X-Git-Url: https://git.subgeniuskitty.com/xmenu/.git/blobdiff_plain/a3a73837401ad9dcc0e4ba513972dc55e1e24a8a..15362de42b2b4603f928873aaaf31174381b97a9:/xmenu.c

diff --git a/xmenu.c b/xmenu.c
index 8a7d511..6305a13 100644
--- a/xmenu.c
+++ b/xmenu.c
@@ -1,7 +1,10 @@
+#include <ctype.h>
 #include <err.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <limits.h>
 #include <time.h>
 #include <unistd.h>
 #include <X11/Xlib.h>
@@ -17,11 +20,15 @@
  * Function declarations
  */
 
+/* argument parser */
+static void parseposition(const char *optarg);
+
 /* initializers, and their helper routines */
+static void parsefonts(const char *s);
 static void ealloccolor(const char *s, XftColor *color);
 static void initresources(void);
 static void initdc(void);
-static void initscreengeom(void);
+static void initconfig(void);
 static void initatoms(void);
 
 /* structure builders, and their helper routines */
@@ -31,10 +38,17 @@ static struct Menu *buildmenutree(unsigned level, const char *label, const char
 static struct Menu *parsestdin(void);
 
 /* image loader */
-static Imlib_Image loadicon(const char *file, int size);
+static Imlib_Image loadicon(const char *file);
+
+/* utf8 utils */
+static FcChar32 getnextutf8char(const char *s, const char **end_ret);
+
+/* pixmap drawers */
+static int drawtext(XftDraw *draw, XftColor *color, int x, int y, unsigned h, const char *text);
+static void drawitems(struct Menu *menu);
 
 /* structure setters, and their helper routines */
-static void setupmenusize(struct Menu *menu);
+static void setupitems(struct Menu *menu);
 static void setupmenupos(struct Menu *menu);
 static void setupmenu(struct Menu *menu, XClassHint *classh);
 
@@ -44,14 +58,16 @@ static void grabkeyboard(void);
 
 /* window drawers and mappers */
 static void mapmenu(struct Menu *currmenu);
-static void drawseparator(struct Menu *menu, struct Item *item);
-static void drawitem(struct Menu *menu, struct Item *item, XftColor *color);
-static void drawmenu(struct Menu *currmenu);
+static void copypixmaps(struct Menu *currmenu);
 
-/* main event loop, and its helper routines */
+/* getters */
 static struct Menu *getmenu(struct Menu *currmenu, Window win);
 static struct Item *getitem(struct Menu *menu, int y);
+
+/* cycle through items */
 static struct Item *itemcycle(struct Menu *currmenu, int direction);
+
+/* main event loop */
 static void run(struct Menu *currmenu);
 
 /* cleaners */
@@ -78,6 +94,8 @@ static Atom wmdelete;
 static Atom netatom[NetLast];
 
 /* flags */
+static int iflag = 0;   /* whether to disable icons */
+static int pflag = 0;   /* whether the user specified a position */
 static int wflag = 0;   /* whether to let the window manager control XMenu */
 
 /* include config variable */
@@ -96,8 +114,15 @@ main(int argc, char *argv[])
 	XClassHint classh;
 	int ch;
 
-	while ((ch = getopt(argc, argv, "w")) != -1) {
+	while ((ch = getopt(argc, argv, "ip:w")) != -1) {
 		switch (ch) {
+		case 'i':
+			iflag = 1;
+			break;
+		case 'p':
+			pflag = 1;
+			parseposition(optarg);
+			break;
 		case 'w':
 			wflag = 1;
 			break;
@@ -121,16 +146,18 @@ main(int argc, char *argv[])
 	colormap = DefaultColormap(dpy, screen);
 
 	/* imlib2 stuff */
-	imlib_set_cache_size(2048 * 1024);
-	imlib_context_set_dither(1);
-	imlib_context_set_display(dpy);
-	imlib_context_set_visual(visual);
-	imlib_context_set_colormap(colormap);
+	if (!iflag) {
+		imlib_set_cache_size(2048 * 1024);
+		imlib_context_set_dither(1);
+		imlib_context_set_display(dpy);
+		imlib_context_set_visual(visual);
+		imlib_context_set_colormap(colormap);
+	}
 
 	/* initializers */
 	initresources();
 	initdc();
-	initscreengeom();
+	initconfig();
 	initatoms();
 
 	/* set window class */
@@ -162,6 +189,64 @@ main(int argc, char *argv[])
 	return 0;
 }
 
+/* parse position string from -p, put results on config.x and config.y */
+static void
+parseposition(const char *optarg)
+{
+	long n;
+	const char *s = optarg;
+	char *endp;
+
+	n = strtol(s, &endp, 10);
+	if (errno == ERANGE || n > INT_MAX || n < 0 || endp == s || *endp != 'x')
+		goto error;
+	config.posx = n;
+	s = endp+1;
+	n = strtol(s, &endp, 10);
+	if (errno == ERANGE || n > INT_MAX || n < 0 || endp == s || *endp != '\0')
+		goto error;
+	config.posy = n;
+
+	return;
+
+error:
+	errx(1, "improper position: %s", optarg);
+}
+
+/* parse color string */
+static void
+parsefonts(const char *s)
+{
+	const char *p;
+	char buf[1024];
+	size_t nfont = 0;
+
+	dc.nfonts = 1;
+	for (p = s; *p; p++)
+		if (*p == ',')
+			dc.nfonts++;
+
+	if ((dc.fonts = calloc(dc.nfonts, sizeof *dc.fonts)) == NULL)
+		err(1, "calloc");
+
+	p = s;
+	while (*p != '\0') {
+		size_t i;
+
+		i = 0;
+		while (isspace(*p))
+			p++;
+		while (*p != '\0' && *p != ',') {
+			buf[i++] = *p++;
+		}
+		if (*p == ',')
+			p++;
+		buf[i] = '\0';
+		if ((dc.fonts[nfont++] = XftFontOpenName(dpy, screen, buf)) == NULL)
+			errx(1, "cannot load font");
+	}
+}
+
 /* get color from color string */
 static void
 ealloccolor(const char *s, XftColor *color)
@@ -198,6 +283,9 @@ initresources(void)
 	if (XrmGetResource(xdb, "xmenu.width", "*", &type, &xval) == True)
 		if ((n = strtol(xval.addr, NULL, 10)) > 0)
 			config.width_pixels = n;
+	if (XrmGetResource(xdb, "xmenu.gap", "*", &type, &xval) == True)
+		if ((n = strtol(xval.addr, NULL, 10)) > 0)
+			config.gap_pixels = n;
 	if (XrmGetResource(xdb, "xmenu.background", "*", &type, &xval) == True)
 		config.background_color = strdup(xval.addr);
 	if (XrmGetResource(xdb, "xmenu.foreground", "*", &type, &xval) == True)
@@ -228,25 +316,26 @@ initdc(void)
 	ealloccolor(config.separator_color,     &dc.separator);
 	ealloccolor(config.border_color,        &dc.border);
 
-	/* try to get font */
-	if ((dc.font = XftFontOpenName(dpy, screen, config.font)) == NULL)
-		errx(1, "cannot load font");
+	/* parse fonts */
+	parsefonts(config.font);
 
 	/* create common GC */
 	dc.gc = XCreateGC(dpy, rootwin, 0, NULL);
 }
 
-/* calculate screen geometry */
+/* calculate configuration values that are not set manually */
 static void
-initscreengeom(void)
+initconfig(void)
 {
 	Window dw;   /* dummy variable */
 	int di;      /* dummy variable */
 	unsigned du; /* dummy variable */
 
-	XQueryPointer(dpy, rootwin, &dw, &dw, &config.cursx, &config.cursy, &di, &di, &du);
+	if (!pflag)  /* if the user haven't specified a position, use cursor position*/
+		XQueryPointer(dpy, rootwin, &dw, &dw, &config.posx, &config.posy, &di, &di, &du);
 	config.screenw = DisplayWidth(dpy, screen);
 	config.screenh = DisplayHeight(dpy, screen);
+	config.iconsize = config.height_pixels - config.iconpadding * 2;
 }
 
 /* intern atoms */
@@ -438,7 +527,7 @@ parsestdin(void)
 
 /* load and scale icon */
 static Imlib_Image
-loadicon(const char *file, int size)
+loadicon(const char *file)
 {
 	Imlib_Image icon;
 	int width;
@@ -455,21 +544,200 @@ loadicon(const char *file, int size)
 	height = imlib_image_get_height();
 	imgsize = MIN(width, height);
 
-	icon = imlib_create_cropped_scaled_image(0, 0, imgsize, imgsize, size, size);
+	icon = imlib_create_cropped_scaled_image(0, 0, imgsize, imgsize,
+	                                         config.iconsize,
+	                                         config.iconsize);
 
 	return icon;
 }
 
-/* setup the size of a menu and the position of its items */
+/* get next utf8 char from s return its codepoint and set next_ret to pointer to next character */
+static FcChar32
+getnextutf8char(const char *s, const char **next_ret)
+{
+	/* */
+	static const unsigned char utfbyte[] = {0x80, 0x00, 0xC0, 0xE0, 0xF0};
+	/* */
+	static const unsigned char utfmask[] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
+	/* 0xFFFD is the replacement character, used to represent unknown characters */
+	static const FcChar32 utfmin[] = {0, 0x00,  0x80,  0x800,  0x10000};
+	static const FcChar32 utfmax[] = {0, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
+	static const FcChar32 unknown = 0xFFFD;
+	FcChar32 ucode;         /* FcChar32 type holds 32 bits */
+	size_t usize = 0;       /* n' of bytes of the utf8 character */
+	size_t i;
+
+	*next_ret = s+1;
+
+	/* get code of first byte of utf8 character */
+	for (i = 0; i < sizeof utfmask; i++) {
+		if (((unsigned char)*s & utfmask[i]) == utfbyte[i]) {
+			usize = i;
+			ucode = (unsigned char)*s & ~utfmask[i];
+			break;
+		}
+	}
+
+	/* if first byte is a continuation byte or is not allowed, return unknown */
+	if (i == sizeof utfmask || usize == 0)
+		return unknown;
+
+	/* check the other usize-1 bytes */
+	s++;
+	for (i = 1; i < usize; i++) {
+		*next_ret = s+1;
+		/* if byte is EOS or is not a continuation byte, return unknown */
+		if (*s == '\0' || ((unsigned char)*s & utfmask[0]) != utfbyte[0])
+			return unknown;
+		/* 6 is the number of relevant bits in the continuation byte */
+		ucode = (ucode << 6) | ((unsigned char)*s & ~utfmask[0]);
+		s++;
+	}
+
+	/* check if ucode is invalid or in utf-16 surrogate halves */
+	if (!BETWEEN(ucode, utfmin[usize], utfmax[usize])
+	    || BETWEEN (ucode, 0xD800, 0xDFFF))
+		return unknown;
+
+	return ucode;
+}
+
+/* draw text into XftDraw */
+static int
+drawtext(XftDraw *draw, XftColor *color, int x, int y, unsigned h, const char *text)
+{
+	const char *s, *nexts;
+	FcChar32 ucode;
+	XftFont *currfont;
+	int textlen = 0;
+
+	s = text;
+	while (*s) {
+		XGlyphInfo ext;
+		int charexists;
+		size_t len;
+		size_t i;
+
+		charexists = 0;
+		ucode = getnextutf8char(s, &nexts);
+		for (i = 0; i < dc.nfonts; i++) {
+			charexists = XftCharExists(dpy, dc.fonts[i], ucode);
+			if (charexists)
+				break;
+		}
+		if (charexists)
+			currfont = dc.fonts[i];
+
+		len = nexts - s;
+
+		XftTextExtentsUtf8(dpy, currfont, (XftChar8 *)s,
+		                   len, &ext);
+		textlen += ext.xOff;
+
+		if (draw) {
+			int texty;
+
+			texty = y + (h + currfont->ascent) / 2;
+			XftDrawStringUtf8(draw, color, currfont, x, texty,
+			                  (XftChar8 *)s, len);
+			x += ext.xOff;
+		}
+
+		s = nexts;
+	}
+
+	return textlen;
+}
+
+/* draw pixmap for the selected and unselected version of each item on menu */
 static void
-setupmenusize(struct Menu *menu)
+drawitems(struct Menu *menu)
+{
+	struct Item *item;
+
+	for (item = menu->list; item != NULL; item = item->next) {
+		XftDraw *dsel, *dunsel;
+		int x, y;
+
+		item->unsel = XCreatePixmap(dpy, menu->win, menu->w, item->h,
+		                          DefaultDepth(dpy, screen));
+
+		XSetForeground(dpy, dc.gc, dc.normal[ColorBG].pixel);
+		XFillRectangle(dpy, item->unsel, dc.gc, 0, 0, menu->w, item->h);
+
+		if (item->label == NULL) { /* item is separator */
+			y = item->h/2;
+			XSetForeground(dpy, dc.gc, dc.separator.pixel);
+			XDrawLine(dpy, item->unsel, dc.gc, config.horzpadding, y,
+			          menu->w - config.horzpadding, y);
+
+			item->sel = item->unsel;
+		} else {
+
+			item->sel = XCreatePixmap(dpy, menu->win, menu->w, item->h,
+			                          DefaultDepth(dpy, screen));
+			XSetForeground(dpy, dc.gc, dc.selected[ColorBG].pixel);
+			XFillRectangle(dpy, item->sel, dc.gc, 0, 0, menu->w, item->h);
+
+			/* draw text */
+			x = config.horzpadding;
+			x += (iflag) ? 0 : config.horzpadding + config.iconsize;
+			dsel = XftDrawCreate(dpy, item->sel, visual, colormap);
+			dunsel = XftDrawCreate(dpy, item->unsel, visual, colormap);
+			XSetForeground(dpy, dc.gc, dc.selected[ColorFG].pixel);
+			drawtext(dsel, &dc.selected[ColorFG], x, 0, item->h, item->label);
+			XSetForeground(dpy, dc.gc, dc.normal[ColorFG].pixel);
+			drawtext(dunsel, &dc.normal[ColorFG], x, 0, item->h, item->label);
+			XftDrawDestroy(dsel);
+			XftDrawDestroy(dunsel);
+
+			/* draw triangle */
+			if (item->submenu != NULL) {
+				x = menu->w - config.triangle_width - config.horzpadding;
+				y = (item->h - config.triangle_height + 1) / 2;
+
+				XPoint triangle[] = {
+					{x, y},
+					{x + config.triangle_width, y + config.triangle_height/2},
+					{x, y + config.triangle_height},
+					{x, y}
+				};
+
+				XSetForeground(dpy, dc.gc, dc.selected[ColorFG].pixel);
+				XFillPolygon(dpy, item->sel, dc.gc, triangle, LEN(triangle),
+				             Convex, CoordModeOrigin);
+				XSetForeground(dpy, dc.gc, dc.normal[ColorFG].pixel);
+				XFillPolygon(dpy, item->unsel, dc.gc, triangle, LEN(triangle),
+				             Convex, CoordModeOrigin);
+			}
+
+			/* draw icon */
+			if (item->file != NULL && !iflag) {
+				item->icon = loadicon(item->file);
+
+				imlib_context_set_drawable(item->sel);
+				imlib_context_set_image(item->icon);
+				imlib_render_image_on_drawable(config.horzpadding, config.iconpadding);
+
+				imlib_context_set_drawable(item->unsel);
+				imlib_context_set_image(item->icon);
+				imlib_render_image_on_drawable(config.horzpadding, config.iconpadding);
+			}
+		}
+	}
+}
+
+/* setup the height, width and icon of the items of a menu */
+static void
+setupitems(struct Menu *menu)
 {
-	XGlyphInfo ext;
 	struct Item *item;
-	int labelwidth;
 
 	menu->w = config.width_pixels;
 	for (item = menu->list; item != NULL; item = item->next) {
+		int itemwidth;
+		int textwidth;
+
 		item->y = menu->h;
 
 		if (item->label == NULL)   /* height for separator item */
@@ -478,17 +746,26 @@ setupmenusize(struct Menu *menu)
 			item->h = config.height_pixels;
 		menu->h += item->h;
 
-		/* get length of item->label rendered in the font */
-		XftTextExtentsUtf8(dpy, dc.font, (XftChar8 *)item->label,
-		                   item->labellen, &ext);
-
-		/* set menu width */
-		labelwidth = ext.xOff + item->h * 2;
-		menu->w = MAX(menu->w, labelwidth);
-
-		/* create icon */
-		if (item->file != NULL)
-			item->icon = loadicon(item->file, item->h - config.iconpadding * 2);
+		if (item->label)
+			textwidth = drawtext(NULL, NULL, 0, 0, item->h, item->label);
+		else
+			textwidth = 0;
+
+		/*
+		 * set menu width
+		 *
+		 * the item width depends on the size of its label (textwidth),
+		 * and it is only used to calculate the width of the menu (which
+		 * is equal to the width of the largest item).
+		 *
+		 * the horizontal padding appears 4 times through the width of a
+		 * item: before and after its icon, and before and after its triangle.
+		 * if the iflag is set (icons are disabled) then the horizontal
+		 * padding appears 3 times: before the label and around the triangle.
+		 */
+		itemwidth = textwidth + config.triangle_width + config.horzpadding * 3;
+		itemwidth += (iflag) ? 0 : config.iconsize + config.horzpadding;
+		menu->w = MAX(menu->w, itemwidth);
 	}
 }
 
@@ -501,13 +778,13 @@ setupmenupos(struct Menu *menu)
 	width = menu->w + config.border_pixels * 2;
 	height = menu->h + config.border_pixels * 2;
 	if (menu->parent == NULL) { /* if root menu, calculate in respect to cursor */
-		if (config.screenw - config.cursx >= menu->w)
-			menu->x = config.cursx;
-		else if (config.cursx > width)
-			menu->x = config.cursx - width;
+		if (pflag || config.screenw - config.posx >= menu->w)
+			menu->x = config.posx;
+		else if (config.posx > width)
+			menu->x = config.posx - width;
 
-		if (config.screenh - config.cursy >= height)
-			menu->y = config.cursy;
+		if (pflag || config.screenh - config.posy >= height)
+			menu->y = config.posy;
 		else if (config.screenh > height)
 			menu->y = config.screenh - height;
 	} else {                    /* else, calculate in respect to parent menu */
@@ -536,7 +813,8 @@ setupmenu(struct Menu *menu, XClassHint *classh)
 	XTextProperty wintitle;
 
 	/* setup size and position of menus */
-	setupmenusize(menu);
+	setupitems(menu);
+	drawitems(menu);
 	setupmenupos(menu);
 
 	/* update menu geometry */
@@ -561,11 +839,6 @@ setupmenu(struct Menu *menu, XClassHint *classh)
 	sizeh.min_height = sizeh.max_height = menu->h;
 	XSetWMProperties(dpy, menu->win, &wintitle, NULL, NULL, 0, &sizeh, NULL, classh);
 
-	/* create pixmap and XftDraw */
-	menu->pixmap = XCreatePixmap(dpy, menu->win, menu->w, menu->h,
-	                             DefaultDepth(dpy, screen));
-	menu->draw = XftDrawCreate(dpy, menu->pixmap, visual, colormap);
-
 	/* set WM protocols and ewmh window properties */
 	XSetWMProtocols(dpy, menu->win, &wmdelete, 1);
 	XChangeProperty(dpy, menu->win, netatom[NetWMName], utf8string, 8,
@@ -673,86 +946,22 @@ mapmenu(struct Menu *currmenu)
 	prevmenu = currmenu;
 }
 
-/* draw separator item */
+/* copy pixmaps of items of the current menu and of its ancestors into menu window */
 static void
-drawseparator(struct Menu *menu, struct Item *item)
-{
-	int y;
-
-	y = item->y + item->h/2;
-
-	XSetForeground(dpy, dc.gc, dc.separator.pixel);
-	XDrawLine(dpy, menu->pixmap, dc.gc, 0, y, menu->w, y);
-}
-
-/* draw regular item */
-static void
-drawitem(struct Menu *menu, struct Item *item, XftColor *color)
-{
-	int x, y;
-
-	x = item->h;
-	y = item->y + (item->h + dc.font->ascent) / 2;
-	XSetForeground(dpy, dc.gc, color[ColorFG].pixel);
-	XftDrawStringUtf8(menu->draw, &color[ColorFG], dc.font,
-                      x, y, (XftChar8 *)item->label, item->labellen);
-
-	/* draw triangle, if item contains a submenu */
-	if (item->submenu != NULL) {
-		x = menu->w - (item->h + config.triangle_width + 1) / 2;
-		y = item->y + (item->h - config.triangle_height + 1) / 2;
-
-		XPoint triangle[] = {
-			{x, y},
-			{x + config.triangle_width, y + config.triangle_height/2},
-			{x, y + config.triangle_height},
-			{x, y}
-		};
-
-		XFillPolygon(dpy, menu->pixmap, dc.gc, triangle, LEN(triangle),
-		             Convex, CoordModeOrigin);
-	}
-
-	/* draw icon */
-	if (item->file != NULL) {
-		x = config.iconpadding;
-		y = item->y + config.iconpadding;
-		imlib_context_set_drawable(menu->pixmap);
-		imlib_context_set_image(item->icon);
-		imlib_render_image_on_drawable(x, y);
-	}
-}
-
-/* draw items of the current menu and of its ancestors */
-static void
-drawmenu(struct Menu *currmenu)
+copypixmaps(struct Menu *currmenu)
 {
 	struct Menu *menu;
 	struct Item *item;
 
 	for (menu = currmenu; menu != NULL; menu = menu->parent) {
 		for (item = menu->list; item != NULL; item = item->next) {
-			XftColor *color;
-
-			/* determine item color */
-			if (item == menu->selected && item->label != NULL)
-				color = dc.selected;
+			if (item == menu->selected)
+				XCopyArea(dpy, item->sel, menu->win, dc.gc, 0, 0,
+				          menu->w, item->h, 0, item->y);
 			else
-				color = dc.normal;
-
-			/* draw item box */
-			XSetForeground(dpy, dc.gc, color[ColorBG].pixel);
-			XFillRectangle(dpy, menu->pixmap, dc.gc, 0, item->y,
-			               menu->w, item->h);
-
-			if (item->label == NULL)  /* item is a separator */
-				drawseparator(menu, item);
-			else                      /* item is a regular item */
-				drawitem(menu, item, color);
+				XCopyArea(dpy, item->unsel, menu->win, dc.gc, 0, 0,
+				          menu->w, item->h, 0, item->y);
 		}
-
-		XCopyArea(dpy, menu->pixmap, menu->win, dc.gc, 0, 0,
-			      menu->w, menu->h, 0, 0);
 	}
 }
 
@@ -842,7 +1051,7 @@ run(struct Menu *currmenu)
 		switch(ev.type) {
 		case Expose:
 			if (ev.xexpose.count == 0)
-				drawmenu(currmenu);
+				copypixmaps(currmenu);
 			break;
 		case MotionNotify:
 			menu = getmenu(currmenu, ev.xbutton.window);
@@ -858,7 +1067,7 @@ run(struct Menu *currmenu)
 				currmenu = menu;
 			}
 			mapmenu(currmenu);
-			drawmenu(currmenu);
+			copypixmaps(currmenu);
 			break;
 		case ButtonRelease:
 			menu = getmenu(currmenu, ev.xbutton.window);
@@ -876,7 +1085,7 @@ selectitem:
 			}
 			mapmenu(currmenu);
 			currmenu->selected = currmenu->list;
-			drawmenu(currmenu);
+			copypixmaps(currmenu);
 			break;
 		case ButtonPress:
 			menu = getmenu(currmenu, ev.xbutton.window);
@@ -912,12 +1121,12 @@ selectitem:
 			} else
 				break;
 			currmenu->selected = item;
-			drawmenu(currmenu);
+			copypixmaps(currmenu);
 			break;
 		case LeaveNotify:
 			previtem = NULL;
 			currmenu->selected = NULL;
-			drawmenu(currmenu);
+			copypixmaps(currmenu);
 			break;
 		case ConfigureNotify:
 			menu = getmenu(currmenu, ev.xconfigure.window);
@@ -952,6 +1161,9 @@ cleanmenu(struct Menu *menu)
 		if (item->submenu != NULL)
 			cleanmenu(item->submenu);
 		tmp = item;
+		XFreePixmap(dpy, item->unsel);
+		if (tmp->label != NULL)
+			XFreePixmap(dpy, item->sel);
 		if (tmp->label != tmp->output)
 			free(tmp->label);
 		free(tmp->output);
@@ -966,8 +1178,6 @@ cleanmenu(struct Menu *menu)
 		free(tmp);
 	}
 
-	XFreePixmap(dpy, menu->pixmap);
-	XftDrawDestroy(menu->draw);
 	XDestroyWindow(dpy, menu->win);
 	free(menu);
 }
@@ -994,6 +1204,6 @@ cleanup(void)
 static void
 usage(void)
 {
-	(void)fprintf(stderr, "usage: xmenu [-w] [title]\n");
+	(void)fprintf(stderr, "usage: xmenu [-iw] [-p position] [title]\n");
 	exit(1);
 }