croptool

croptool.c (31857B)

---

 /*
  * Copyright (c) 2021-2023 lumidify <nobody@lumidify.org>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
 #include <math.h>
 #include <stdio.h>
 #include <errno.h>
 #include <string.h>
 #include <stdlib.h>
 #include <limits.h>
 #include <unistd.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/keysym.h>
 #include <X11/XF86keysym.h>
 #include <X11/cursorfont.h>
 #ifndef NODB
 #include <X11/extensions/Xdbe.h>
 #endif
 #include <Imlib2.h>
 
 /* The number of pixels to check on each side when checking
  * if a corner or edge of the selection box was clicked 
  * (in order to change the size of the box) */
 static int COLLISION_PADDING = 10;
 /* The color of the selection box */
 static const char *SELECTION_COLOR1 = "#000000";
 /* The second selection color - when tab is pressed */
 static const char *SELECTION_COLOR2 = "#FFFFFF";
 /* The width of the selection line */
 static int LINE_WIDTH = 2;
 /* When set to 1, the display is redrawn on window resize */
 static short RESIZE_REDRAW = 1;
 /* When set to 1, the selection is redrawn continually,
    not just when the mouse button is released */
 static short SELECTION_REDRAW = 1;
 /*
   The command printed for each image.
   %w: Width of cropped area.
   %h: Height of cropped area.
   %l: Left side of cropped area.
   %r: Right side of cropped area.
   %t: Top side of cropped area.
   %b: Bottom side of cropped area.
   %f: Filename of image.
 */
 static const char *CMD_FORMAT = "croptool_crop %wx%h+%l+%t '%f'";
 /* Size of Imlib2 in-memory cache in MiB */
 static int CACHE_SIZE = 4;
 
 extern char *optarg;
 extern int optind;
 
 struct Rect {
 	int x0;
 	int y0;
 	int x1;
 	int y1;
 };
 
 struct Point {
 	int x;
 	int y;
 };
 
 struct Selection {
 	struct Rect rect;
 	int orig_w;
 	int orig_h;
 	int scaled_w;
 	int scaled_h;
 	char valid;
 };
 
 static struct {
 	Display *dpy;
 	GC gc;
 	Window win;
 	Visual *vis;
 	Drawable drawable;
 	#ifndef NODB
 	XdbeBackBuffer back_buf;
 	int db_enabled;
 	#endif
 	Colormap cm;
 	int screen;
 	int depth;
 
 	struct Selection *selections;
 	char **filenames;
 	int cur_selection;
 	int num_files;
 	int window_w;
 	int window_h;
 	int cursor_x;
 	int cursor_y;
 	struct Point move_handle;
 	char moving;
 	char resizing;
 	char lock_x;
 	char lock_y;
 	char dirty;
 	XColor col1;
 	XColor col2;
 	int cur_col;
 	Atom wm_delete_msg;
 	Imlib_Image cur_image;
 	Imlib_Updates updates;
 } state;
 
 static struct {
 	Cursor top;
 	Cursor bottom;
 	Cursor left;
 	Cursor right;
 	Cursor topleft;
 	Cursor topright;
 	Cursor bottomleft;
 	Cursor bottomright;
 	Cursor grab;
 } cursors;
 
 static void usage(void);
 static void mainloop(void);
 static void setup(int argc, char *argv[]);
 static void cleanup(void);
 static void sort_coordinates(int *x0, int *y0, int *x1, int *y1);
 static void swap(int *a, int *b);
 static void redraw(void);
 static void print_cmd(const char *filename, int x, int y, int w, int h, int dry_run);
 static void print_selection(struct Selection *sel, const char *filename);
 static int collide_point(int x, int y, int x_point, int y_point);
 static int collide_line(int x, int y, int x0, int y0, int x1, int y1);
 static int collide_rect(int x, int y, struct Rect rect);
 static void switch_color(void);
 static void clear_selection(void);
 static void next_picture(int copy_box);
 static void last_picture(int copy_box);
 static void change_picture(Imlib_Image new_image, int new_selection, int copy_box);
 static void get_scaled_size(int orig_w, int orig_h, int *scaled_w, int *scaled_h);
 static void set_selection(
     struct Selection *sel, int rect_x0, int rect_y0, int rect_x1,
     int rect_y1, int orig_w, int orig_h, int scaled_w, int scaled_h
 );
 static void queue_rectangle_redraw(int x0, int y0, int x1, int y1);
 static void set_cursor(struct Rect rect);
 static void drag_motion(XEvent event);
 static void resize_window(int w, int h);
 static void button_release(void);
 static void button_press(XEvent event);
 static int key_press(XEvent event);
 static void queue_update(int x, int y, int w, int h);
 static int parse_int(const char *str, int min, int max, int *value);
 
 static void
 usage(void) {
 	fprintf(stderr, "USAGE: croptool [-mr] [-f format] "
 	    "[-w width] [-c padding] [-p color] [-s color] "
 	    "[-z size] file ...\n");
 }
 
 int 
 main(int argc, char *argv[]) {
 	char c;
 
 	while ((c = getopt(argc, argv, "f:w:c:mrp:s:z:")) != -1) {
 		switch (c) {
 		case 'f':
 			CMD_FORMAT = optarg;
 			break;
 		case 'm':
 			RESIZE_REDRAW = 0;
 			break;
 		case 'r':
 			SELECTION_REDRAW = 0;
 			break;
 		case 'p':
 			SELECTION_COLOR1 = optarg;
 			break;
 		case 's':
 			SELECTION_COLOR2 = optarg;
 			break;
 		case 'c':
 			if (parse_int(optarg, 1, 99, &COLLISION_PADDING)) {
 				fprintf(stderr, "Invalid collision padding.\n");
 				exit(1);
 			}
 			break;
 		case 'w':
 			if (parse_int(optarg, 1, 99, &LINE_WIDTH)) {
 				fprintf(stderr, "Invalid line width.\n");
 				exit(1);
 			}
 			break;
 		case 'z':
 			if (parse_int(optarg, 0, 1024, &CACHE_SIZE)) {
 				fprintf(stderr, "Invalid cache size.\n");
 				exit(1);
 			}
 			break;
 		default:
 			usage();
 			exit(1);
 			break;
 		}
 	}
 	/* print warning if command format is invalid */
 	print_cmd("", 0, 0, 0, 0, 1);
 
 	argc -= optind;
 	argv += optind;
 	if (argc < 1) {
 		usage();
 		exit(1);
 	}
 	setup(argc, argv);
 
 	mainloop();
 
 	for (int i = 0; i < argc; i++) {
 		if (state.selections[i].valid) {
 			print_selection(&state.selections[i], state.filenames[i]);
 		}
 	}
 
 	cleanup();
 
 	return 0;
 }
 
 static void
 mainloop(void) {
 	XEvent event;
 	int running = 1;
 
 	while (running) {
 		do {
 			XNextEvent(state.dpy, &event);
 			switch (event.type) {
 			case Expose:
 				if (RESIZE_REDRAW)
 					queue_update(event.xexpose.x, event.xexpose.y,
 					    event.xexpose.width, event.xexpose.height);
 				break;
 			case ConfigureNotify:
 				if (RESIZE_REDRAW)
 					resize_window(
 					    event.xconfigure.width,
 					    event.xconfigure.height
 					);
 				break;
 			case ButtonPress:
 				if (event.xbutton.button == Button1)
 					button_press(event);
 				break;
 			case ButtonRelease:
 				if (event.xbutton.button == Button1)
 					button_release();
 				break;
 			case MotionNotify:
 				drag_motion(event);
 				break;
 			case KeyPress:
 				running = key_press(event);
 				break;
 			case ClientMessage:
 				if ((Atom)event.xclient.data.l[0] == state.wm_delete_msg)
 					running = 0;
 			default:
 				break;
 			}
 		} while (XPending(state.dpy));
 
 		redraw();
 	}
 }
 
 static void
 setup(int argc, char *argv[]) {
 	XSetWindowAttributes attrs;
 	XGCValues gcv;
 
 	state.cur_image = NULL;
 	state.selections = malloc(argc * sizeof(struct Selection));
 	if (!state.selections) {
 		fprintf(stderr, "Unable to allocate memory.\n");
 		exit(1);
 	}
 	state.num_files = argc;
 	state.filenames = argv;
 	state.cur_selection = -1;
 	state.moving = 0;
 	state.resizing = 0;
 	state.lock_x = 0;
 	state.lock_y = 0;
 	state.window_w = 500;
 	state.window_h = 500;
 	state.cursor_x = 0;
 	state.cursor_y = 0;
 	state.cur_col = 1;
 
 	for (int i = 0; i < argc; i++) {
 		state.selections[i].valid = 0;
 	}
 
 	state.dpy = XOpenDisplay(NULL);
 	state.screen = DefaultScreen(state.dpy);
 	state.vis = DefaultVisual(state.dpy, state.screen);
 	state.depth = DefaultDepth(state.dpy, state.screen);
 	state.cm = DefaultColormap(state.dpy, state.screen);
 
 	#ifndef NODB
 	state.db_enabled = 0;
 	/* based on http://wili.cc/blog/xdbe.html */
 	int major, minor;
 	if (XdbeQueryExtension(state.dpy, &major, &minor)) {
 		int num_screens = 1;
 		Drawable screens[] = { DefaultRootWindow(state.dpy) };
 		XdbeScreenVisualInfo *info = XdbeGetVisualInfo(
 		    state.dpy, screens, &num_screens
 		);
 		if (!info || num_screens < 1 || info->count < 1) {
 			fprintf(stderr,
 			    "Warning: No visuals support Xdbe, "
 			    "double buffering disabled.\n"
 			);
 		} else {
 			XVisualInfo xvisinfo_templ;
 			xvisinfo_templ.visualid = info->visinfo[0].visual;
 			xvisinfo_templ.screen = 0;
 			xvisinfo_templ.depth = info->visinfo[0].depth;
 			int matches;
 			XVisualInfo *xvisinfo_match = XGetVisualInfo(
 			    state.dpy,
 			    VisualIDMask | VisualScreenMask | VisualDepthMask,
 			    &xvisinfo_templ, &matches
 			);
 			if (!xvisinfo_match || matches < 1) {
 				fprintf(stderr,
 				    "Warning: Couldn't match a Visual with "
 				    "double buffering, double buffering disabled.\n"
 				);
 			} else {
 				state.vis = xvisinfo_match->visual;
 				state.depth = xvisinfo_match->depth;
 				state.db_enabled = 1;
 			}
 			XFree(xvisinfo_match);
 		}
 		XdbeFreeVisualInfo(info);
 	} else {
 		fprintf(stderr, "Warning: No Xdbe support, double buffering disabled.\n");
 	}
 	#endif
 
 	memset(&attrs, 0, sizeof(attrs));
 	attrs.background_pixel = BlackPixel(state.dpy, state.screen);
 	attrs.colormap = state.cm;
 	/* this causes the window contents to be kept
 	 * when it is resized, leading to less flicker */
 	attrs.bit_gravity = NorthWestGravity;
 	state.win = XCreateWindow(state.dpy, DefaultRootWindow(state.dpy), 0, 0,
 	    state.window_w, state.window_h, 0, state.depth,
 	    InputOutput, state.vis, CWBackPixel | CWColormap | CWBitGravity, &attrs);
 
 	#ifndef NODB
 	if (state.db_enabled) {
 		state.back_buf = XdbeAllocateBackBufferName(
 		    state.dpy, state.win, XdbeCopied
 		);
 		state.drawable = state.back_buf;
 	} else {
 		state.drawable = state.win;
 	}
 	#else
 	state.drawable = state.win;
 	#endif
 
 	memset(&gcv, 0, sizeof(gcv));
 	gcv.line_width = LINE_WIDTH;
 	state.gc = XCreateGC(state.dpy, state.win, GCLineWidth, &gcv);
 
         if (!XParseColor(state.dpy, state.cm, SELECTION_COLOR1, &state.col1)) {
 		fprintf(stderr, "Primary color invalid.\n");
 		exit(1);
 	}
         XAllocColor(state.dpy, state.cm, &state.col1);
         if (!XParseColor(state.dpy, state.cm, SELECTION_COLOR2, &state.col2)) {
 		fprintf(stderr, "Secondary color invalid.\n");
 		exit(1);
 	}
         XAllocColor(state.dpy, state.cm, &state.col2);
 
 	XSelectInput(
 	    state.dpy, state.win,
 	    StructureNotifyMask | KeyPressMask | ButtonPressMask |
 	    ButtonReleaseMask | PointerMotionMask | ExposureMask
 	);
 
 	state.wm_delete_msg = XInternAtom(state.dpy, "WM_DELETE_WINDOW", False);
 	XSetWMProtocols(state.dpy, state.win, &state.wm_delete_msg, 1);
 
 	cursors.top = XCreateFontCursor(state.dpy, XC_top_side);
 	cursors.bottom = XCreateFontCursor(state.dpy, XC_bottom_side);
 	cursors.left = XCreateFontCursor(state.dpy, XC_left_side);
 	cursors.right = XCreateFontCursor(state.dpy, XC_right_side);
 	cursors.topleft = XCreateFontCursor(state.dpy, XC_top_left_corner);
 	cursors.topright = XCreateFontCursor(state.dpy, XC_top_right_corner);
 	cursors.bottomleft = XCreateFontCursor(state.dpy, XC_bottom_left_corner);
 	cursors.bottomright = XCreateFontCursor(state.dpy, XC_bottom_right_corner);
 	cursors.grab = XCreateFontCursor(state.dpy, XC_fleur);
 
 	/* note: since CACHE_SIZE is <= 1024, this definitely fits in long */
 	long cs = (long)CACHE_SIZE * 1024 * 1024;
 	if (cs > INT_MAX) {
 		fprintf(stderr, "Cache size would cause integer overflow.\n");
 		exit(1);
 	}
 	imlib_set_cache_size((int)cs);
 	imlib_set_color_usage(128);
 	imlib_context_set_dither(1);
 	imlib_context_set_display(state.dpy);
 	imlib_context_set_visual(state.vis);
 	imlib_context_set_colormap(state.cm);
 	imlib_context_set_drawable(state.drawable);
 	state.updates = imlib_updates_init();
 
 	next_picture(0);
 	/* Only map window here so the program exits immediately if
 	   there are no loadable images, without first opening the
 	   window and closing it again immediately */
 	XMapWindow(state.dpy, state.win);
 	redraw();
 }
 
 static void
 cleanup(void) {
 	if (state.cur_image) {
 		imlib_context_set_image(state.cur_image);
 		imlib_free_image();
 	}
 	free(state.selections);
 	XDestroyWindow(state.dpy, state.win);
 	XCloseDisplay(state.dpy);
 }
 
 /* TODO: Escape filename properly
  * -> But how? Since the format can be set by the user,
  * it isn't really clear *what* needs to be escaped. */
 static void
 print_cmd(const char *filename, int x, int y, int w, int h, int dry_run) {
 	short percent = 0;
 	const char *c;
 	int length = 0;
 	int start_index = 0;
 	for (c = CMD_FORMAT; *c != '\0'; c++) {
 		if (percent)
 			start_index++;
 		if (*c == '%') {
 			if (length) {
 				if (!dry_run)
 					printf("%.*s", length, CMD_FORMAT + start_index);
 				start_index += length;
 				length = 0;
 			}
 			if (percent && !dry_run)
 				printf("%%");
 			percent++;
 			percent %= 2;
 			start_index++;
 		} else if (percent && *c == 'w') {
 			if (!dry_run)
 				printf("%d", w);
 			percent = 0;
 		} else if (percent && *c == 'h') {
 			if (!dry_run)
 				printf("%d", h);
 			percent = 0;
 		} else if (percent && *c == 'l') {
 			if (!dry_run)
 				printf("%d", x);
 			percent = 0;
 		} else if (percent && *c == 't') {
 			if (!dry_run)
 				printf("%d", y);
 			percent = 0;
 		} else if (percent && *c == 'r') {
 			if (!dry_run)
 				printf("%d", x + w);
 			percent = 0;
 		} else if (percent && *c == 'b') {
 			if (!dry_run)
 				printf("%d", y + h);
 			percent = 0;
 		} else if (percent && *c == 'f') {
 			if (!dry_run)
 				printf("%s", filename);
 			percent = 0;
 		} else if (percent) {
 			if (dry_run) {
 				fprintf(stderr,
 				    "Warning: Unknown substitution '%c' "
 				    "in format string.\n", *c
 				);
 			} else {
 				printf("%%%c", *c);
 			}
 			percent = 0;
 		} else {
 			length++;
 		}
 	}
 	if (!dry_run) {
 		if (length)
 			printf("%.*s", length, CMD_FORMAT + start_index);
 		printf("\n");
 	}
 }
 
 /* Parse integer between min and max (inclusive).
    Returns 1 on error, 0 otherwise.
    The result is stored in *value.
    Based on OpenBSD's strtonum. */
 static int
 parse_int(const char *str, int min, int max, int *value) {
 	char *end;
 	long l = strtol(str, &end, 10);
 	if (min > max)
 		return 1;
 	if (str == end || *end != '\0') {
 		return 1; 
 	} else if (l < min || l > max || ((l == LONG_MIN ||
 	    l == LONG_MAX) && errno == ERANGE)) {
 		return 1;
 	}
 	*value = (int)l;
 
 	return 0;
 }
 
 /* queue a part of the image for redrawing */
 static void
 queue_update(int x, int y, int w, int h) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].valid)
 		return;
 	state.dirty = 1;
 	struct Selection *sel = &state.selections[state.cur_selection];
 	if (x > sel->scaled_w || y > sel->scaled_h)
 		return;
 	state.updates = imlib_update_append_rect(
 	    state.updates, x, y,
 	    w + x > sel->scaled_w ? sel->scaled_w - x : w,
 	    h + y > sel->scaled_h ? sel->scaled_h - y : h
 	);
 }
 
 static void
 redraw(void) {
 	Imlib_Image buffer;
 	Imlib_Updates current_update;
 	if (!state.dirty)
 		return;
 	if (!state.cur_image || state.cur_selection < 0) {
 		/* clear the window completely */
 		XSetForeground(state.dpy, state.gc, BlackPixel(state.dpy, state.screen));
 		XFillRectangle(
 		    state.dpy, state.drawable, state.gc,
 		    0, 0, state.window_w, state.window_h
 		);
 		goto swap_buffers;
 	}
 
 	/* draw the parts of the image that need to be redrawn */
 	struct Selection *sel = &state.selections[state.cur_selection];
 	state.updates = imlib_updates_merge_for_rendering(
 	    state.updates, sel->scaled_w, sel->scaled_h
 	);
 	for (current_update = state.updates; current_update;
 	    current_update = imlib_updates_get_next(current_update)) {
 		int up_x, up_y, up_w, up_h;
 		imlib_updates_get_coordinates(current_update, &up_x, &up_y, &up_w, &up_h);
 		buffer = imlib_create_image(up_w, up_h);
 		imlib_context_set_blend(0);
 		imlib_context_set_image(buffer);
 		imlib_blend_image_onto_image(
 		    state.cur_image, 0, 0, 0,
 		    sel->orig_w, sel->orig_h,
 		    -up_x, -up_y,
 		    sel->scaled_w, sel->scaled_h);
 		imlib_render_image_on_drawable(up_x, up_y);
 		imlib_free_image();
 	}
 	if (state.updates)
 		imlib_updates_free(state.updates);
 	state.updates = imlib_updates_init();
 
 	/* wipe the black area around the image */
 	XSetForeground(state.dpy, state.gc, BlackPixel(state.dpy, state.screen));
 	XFillRectangle(
 	    state.dpy, state.drawable, state.gc,
 	    0, sel->scaled_h, sel->scaled_w, state.window_h - sel->scaled_h
 	);
 	XFillRectangle(
 	    state.dpy, state.drawable, state.gc,
 	    sel->scaled_w, 0, state.window_w - sel->scaled_w, state.window_h
 	);
 
 	/* draw the rectangle */
 	struct Rect rect = sel->rect;
 	if (rect.x0 != -200) {
 		XColor col = state.cur_col == 1 ? state.col1 : state.col2;
 		XSetForeground(state.dpy, state.gc, col.pixel);
 		sort_coordinates(&rect.x0, &rect.y0, &rect.x1, &rect.y1);
 		XDrawRectangle(
 		    state.dpy, state.drawable, state.gc,
 		    rect.x0, rect.y0, rect.x1 - rect.x0, rect.y1 - rect.y0
 		);
 	}
 
 swap_buffers:
 	#ifndef NODB
 	if (state.db_enabled) {
 		XdbeSwapInfo swap_info;
 		swap_info.swap_window = state.win;
 		swap_info.swap_action = XdbeCopied;
 
 		if (!XdbeSwapBuffers(state.dpy, &swap_info, 1))
 			fprintf(stderr, "Warning: Unable to swap buffers.\n");
 	}
 	#endif
 	state.dirty = 0;
 }
 
 static void
 swap(int *a, int *b) {
         int tmp = *a;
         *a = *b;
         *b = tmp;
 }
 
 /* sort rectangle coordinates into their canonical
  * form so *x1 - *x0 >= 0 and *y1 - *y0 >= 0 */
 static void
 sort_coordinates(int *x0, int *y0, int *x1, int *y1) {
         if (*x0 > *x1)
                 swap(x0, x1);
         if(*y0 > *y1)
                 swap(y0, y1);
 }
 
 static void
 print_selection(struct Selection *sel, const char *filename) {
 	/* The box was never actually used */
 	if (sel->rect.x0 == -200)
 		return;
 	double scale = (double)sel->orig_w / sel->scaled_w;
 	int x0 = sel->rect.x0, y0 = sel->rect.y0;
 	int x1 = sel->rect.x1, y1 = sel->rect.y1;
 	sort_coordinates(&x0, &y0, &x1, &y1);
 	x0 = round(x0 * scale);
 	y0 = round(y0 * scale);
 	x1 = round(x1 * scale);
 	y1 = round(y1 * scale);
 	/* The box is completely outside of the picture. */
 	if (x0 >= sel->orig_w || y0 >= sel->orig_h)
 		return;
 	/* Cut the bounding box if it goes past the end of the picture. */
 	x0 = x0 < 0 ? 0 : x0;
 	y0 = y0 < 0 ? 0 : y0;
 	x1 = x1 > sel->orig_w ? sel->orig_w : x1;
 	y1 = y1 > sel->orig_h ? sel->orig_h : y1;
 	print_cmd(filename, x0, y0, x1 - x0, y1 - y0, 0);
 }
 
 static int
 collide_point(int x, int y, int x_point, int y_point) {
 	return (abs(x - x_point) <= COLLISION_PADDING) &&
 		(abs(y - y_point) <= COLLISION_PADDING);
 }
 
 static int
 collide_line(int x, int y, int x0, int y0, int x1, int y1) {
 	sort_coordinates(&x0, &y0, &x1, &y1);
 	/* this expects a valid line */
 	if (x0 == x1) {
 		return (abs(x - x0) <= COLLISION_PADDING) &&
 			(y0 <= y) && (y <= y1);
 	} else {
 		return (abs(y - y0) <= COLLISION_PADDING) &&
 			(x0 <= x) && (x <= x1);
 	}
 }
 
 static int
 collide_rect(int x, int y, struct Rect rect) {
 	int x0 = rect.x0, x1 = rect.x1;
 	int y0 = rect.y0, y1 = rect.y1;
 	sort_coordinates(&x0, &y0, &x1, &y1);
 	return (x0 <= x) && (x <= x1) && (y0 <= y) && (y <= y1);
 }
 
 static void
 button_press(XEvent event) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].valid)
 		return;
 	struct Rect *rect = &state.selections[state.cur_selection].rect;
 	int x = event.xbutton.x;
 	int y = event.xbutton.y;
 	int x0 = rect->x0, x1 = rect->x1;
 	int y0 = rect->y0, y1 = rect->y1;
 	/* erase old rectangle */
 	queue_rectangle_redraw(x0, y0, x1, y1);
 	if (collide_point(x, y, x0, y0)) {
 		rect->x0 = x1;
 		rect->y0 = y1;
 		rect->x1 = x;
 		rect->y1 = y;
 	} else if (collide_point(x, y, x1, y1)) {
 		rect->x1 = x;
 		rect->y1 = y;
 	} else if (collide_point(x, y, x0, y1)) {
 		rect->x0 = rect->x1;
 		rect->x1 = x;
 		rect->y1 = y;
 	} else if (collide_point(x, y, x1, y0)) {
 		rect->y0 = y1;
 		rect->x1 = x;
 		rect->y1 = y;
 	} else if (collide_line(x, y, x0, y0, x1, y0)) {
 		state.lock_y = 1;
 		swap(&rect->x0, &rect->x1);
 		rect->y0 = rect->y1;
 		rect->y1 = y;
 	} else if (collide_line(x, y, x0, y0, x0, y1)) {
 		state.lock_x = 1;
 		swap(&rect->y0, &rect->y1);
 		rect->x0 = rect->x1;
 		rect->x1 = x;
 	} else if (collide_line(x, y, x1, y1, x0, y1)) {
 		state.lock_y = 1;
 		rect->y1 = y;
 	} else if (collide_line(x, y, x1, y1, x1, y0)) {
 		state.lock_x = 1;
 		rect->x1 = x;
 	} else if (collide_rect(x, y, *rect)) {
 		state.moving = 1;
 		state.move_handle.x = x;
 		state.move_handle.y = y;
 	} else {
 		rect->x0 = x;
 		rect->y0 = y;
 		rect->x1 = x;
 		rect->y1 = y;
 	}
 	state.resizing = 1;
 }
 
 static void
 button_release(void) {
 	state.moving = 0;
 	state.resizing = 0;
 	state.lock_x = 0;
 	state.lock_y = 0;
 	/* redraw everything if automatic redrawing of the rectangle
 	   is disabled (so it's redrawn when the mouse is released) */
 	if (!SELECTION_REDRAW)
 		queue_update(0, 0, state.window_w, state.window_h);
 }
 
 static void
 resize_window(int w, int h) {
 	int actual_w, actual_h;
 	struct Selection *sel;
 	state.window_w = w;
 	state.window_h = h;
 
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].valid)
 		return;
 	sel = &state.selections[state.cur_selection];
 	get_scaled_size(sel->orig_w, sel->orig_h, &actual_w, &actual_h);
 	if (actual_w != sel->scaled_w) {
 		if (sel->rect.x0 != -200) {
 			/* If there is a selection, we need to convert it to
 			 * the new scale. This only takes width into account
 			 * because the aspect ratio should have been preserved
 			 * anyways */
 			double scale = (double)actual_w / sel->scaled_w;
 			sel->rect.x0 = round(sel->rect.x0 * scale);
 			sel->rect.y0 = round(sel->rect.y0 * scale);
 			sel->rect.x1 = round(sel->rect.x1 * scale);
 			sel->rect.y1 = round(sel->rect.y1 * scale);
 		}
 		sel->scaled_w = actual_w;
 		sel->scaled_h = actual_h;
 		queue_update(0, 0, sel->scaled_w, sel->scaled_h);
 	}
 }
 
 /* queue the redrawing of a rectangular area on the image -
  * this queues four updates, one for each side of the rectangle,
  * with the width or height (depending on which side) of the
  * rectangle being determined by the configured line width */
 static void
 queue_rectangle_redraw(int x0, int y0, int x1, int y1) {
 	sort_coordinates(&x0, &y0, &x1, &y1);
 	queue_update(
 	    x0 - LINE_WIDTH > 0 ? x0 - LINE_WIDTH : 0,
 	    y0 - LINE_WIDTH > 0 ? y0 - LINE_WIDTH : 0,
 	    x1 - x0 + LINE_WIDTH * 2, LINE_WIDTH * 2);
 	queue_update(
 	    x0 - LINE_WIDTH > 0 ? x0 - LINE_WIDTH : 0,
 	    y1 - LINE_WIDTH > 0 ? y1 - LINE_WIDTH : 0,
 	    x1 - x0 + LINE_WIDTH * 2, LINE_WIDTH * 2);
 	queue_update(
 	    x0 - LINE_WIDTH > 0 ? x0 - LINE_WIDTH : 0,
 	    y0 - LINE_WIDTH > 0 ? y0 - LINE_WIDTH : 0,
 	    LINE_WIDTH * 2, y1 - y0 + LINE_WIDTH * 2);
 	queue_update(
 	    x1 - LINE_WIDTH > 0 ? x1 - LINE_WIDTH : 0,
 	    y0 - LINE_WIDTH > 0 ? y0 - LINE_WIDTH : 0,
 	    LINE_WIDTH * 2, y1 - y0 + LINE_WIDTH * 2);
 }
 
 /* set the appropriate cursor based on the
  * current mouse position and a cropping rectangle */
 static void
 set_cursor(struct Rect rect) {
 	Cursor c = None;
 	sort_coordinates(&rect.x0, &rect.y0, &rect.x1, &rect.y1);
 	if (collide_point(
 	    state.cursor_x, state.cursor_y,
 	    rect.x0, rect.y0)) {
 		c = cursors.topleft;
 	} else if (collide_point(
 	    state.cursor_x, state.cursor_y,
 	    rect.x1, rect.y0)) {
 		c = cursors.topright;
 	} else if (collide_point(
 	    state.cursor_x, state.cursor_y,
 	    rect.x0, rect.y1)) {
 		c = cursors.bottomleft;
 	} else if (collide_point(
 	    state.cursor_x, state.cursor_y,
 	    rect.x1, rect.y1)) {
 		c = cursors.bottomright;
 	} else if (collide_line(
 	    state.cursor_x, state.cursor_y,
 	    rect.x0, rect.y0, rect.x1, rect.y0)) {
 		c = cursors.top;
 	} else if (collide_line(
 	    state.cursor_x, state.cursor_y,
 	    rect.x1, rect.y1, rect.x0, rect.y1)) {
 		c = cursors.bottom;
 	} else if (collide_line(
 	    state.cursor_x, state.cursor_y,
 	    rect.x1, rect.y1, rect.x1, rect.y0)) {
 		c = cursors.right;
 	} else if (collide_line(
 	    state.cursor_x, state.cursor_y,
 	    rect.x0, rect.y0, rect.x0, rect.y1)) {
 		c = cursors.left;
 	} else if (collide_rect(state.cursor_x, state.cursor_y, rect)) {
 		c = cursors.grab;
 	}
 	XDefineCursor(state.dpy, state.win, c);
 }
 
 static void
 drag_motion(XEvent event) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].valid)
 		return;
 	struct Selection *sel = &state.selections[state.cur_selection];
 	struct Rect *rect = &sel->rect;
 
 	/* don't allow coordinates to go below 0 */
 	if (event.xbutton.x >= 0)
 		state.cursor_x = event.xbutton.x;
 	else
 		state.cursor_x = 0;
 	if (event.xbutton.y >= 0)
 		state.cursor_y = event.xbutton.y;
 	else
 		state.cursor_y = 0;
 
 	int x0 = rect->x0, x1 = rect->x1;
 	int y0 = rect->y0, y1 = rect->y1;
 	sort_coordinates(&x0, &y0, &x1, &y1);
 	/* redraw the old rectangle */
 	if (SELECTION_REDRAW && (state.moving || state.resizing))
 		queue_rectangle_redraw(x0, y0, x1, y1);
 	if (state.moving) {
 		int x_delta = state.cursor_x - state.move_handle.x;
 		int y_delta = state.cursor_y - state.move_handle.y;
 		/* don't allow coordinates to go below 0 */
 		int x_realdelta = x0 + x_delta >= 0 ? x_delta : -x0;
 		int y_realdelta = y0 + y_delta >= 0 ? y_delta : -y0;
 		rect->x0 += x_realdelta;
 		rect->x1 += x_realdelta;
 		rect->y0 += y_realdelta;
 		rect->y1 += y_realdelta;
 		state.move_handle.x = state.cursor_x;
 		state.move_handle.y = state.cursor_y;
 	} else if (state.resizing) {
 		if (!state.lock_y)
 			rect->x1 = state.cursor_x;
 		if (!state.lock_x)
 			rect->y1 = state.cursor_y;
 	} else {
 		set_cursor(*rect);
 		return;
 	}
 	set_cursor(*rect);
 
 	/* redraw the new rectangle */
 	if (SELECTION_REDRAW)
 		queue_rectangle_redraw(rect->x0, rect->y0, rect->x1, rect->y1);
 }
 
 static void
 set_selection(
 	struct Selection *sel, int rect_x0, int rect_y0, int rect_x1,
 	int rect_y1, int orig_w, int orig_h, int scaled_w, int scaled_h) {
 
 	sel->rect.x0 = rect_x0;
 	sel->rect.y0 = rect_y0;
 	sel->rect.x1 = rect_x1;
 	sel->rect.y1 = rect_y1;
 	sel->orig_w = orig_w;
 	sel->orig_h = orig_h;
 	sel->scaled_w = scaled_w;
 	sel->scaled_h = scaled_h;
 }
 
 /* get the scaled size of an image based on the current window size */
 static void
 get_scaled_size(int orig_w, int orig_h, int *scaled_w, int *scaled_h) {
 	double scale_w, scale_h;
 	scale_w = (double)state.window_w / (double)orig_w;
 	scale_h = (double)state.window_h / (double)orig_h;
 	if (orig_w <= state.window_w && orig_h <= state.window_h) {
 		*scaled_w = orig_w;
 		*scaled_h = orig_h;
 	} else if (scale_w * orig_h > state.window_h) {
 		*scaled_w = (int)(scale_h * orig_w);
 		*scaled_h = state.window_h;
 	} else {
 		*scaled_w = state.window_w;
 		*scaled_h = (int)(scale_w * orig_h);
 	}
 }
 
 /* change the shown image
  * new_selection is the index of the new selection
  * copy_box determines whether the cropping rectangle of the current
  * selection should be copied (i.e. this is a true value when return
  * is pressed) */
 static void
 change_picture(Imlib_Image new_image, int new_selection, int copy_box) {
 	int orig_w, orig_h, actual_w, actual_h;
 	/* set window title to filename */
 	XSetStandardProperties(
 	    state.dpy, state.win,
 	    state.filenames[new_selection],
 	    NULL, None, NULL, 0, NULL
 	);
 	if (state.cur_image) {
 		imlib_context_set_image(state.cur_image);
 		imlib_free_image();
 	}
 	state.cur_image = new_image;
 	imlib_context_set_image(state.cur_image);
 	int old_selection = state.cur_selection;
 	state.cur_selection = new_selection;
 
 	orig_w = imlib_image_get_width();
 	orig_h = imlib_image_get_height();
 	get_scaled_size(orig_w, orig_h, &actual_w, &actual_h);
 
 	struct Selection *sel = &state.selections[state.cur_selection];
 	if (copy_box && old_selection >= 0 && old_selection < state.num_files) {
 		struct Selection *old = &state.selections[old_selection];
 		set_selection(
 		    sel,
 		    old->rect.x0, old->rect.y0, old->rect.x1, old->rect.y1,
 		    orig_w, orig_h, actual_w, actual_h
 		);
 	} else if (!sel->valid) {
 		/* Just fill it with -200 so we can check
 		 * later if it has been used yet */
 		set_selection(
 		    sel,
 		    -200, -200, -200, -200,
 		    orig_w, orig_h, actual_w, actual_h
 		);
 	} else if (sel->rect.x0 != -200 && actual_w != sel->scaled_w) {
 		/* If there is a selection, we need to convert it to the
 		 * new scale. This only takes width into account because
 		 * the aspect ratio should have been preserved anyways */
 		double scale = (double)actual_w / sel->scaled_w;
 		sel->rect.x0 = round(sel->rect.x0 * scale);
 		sel->rect.y0 = round(sel->rect.y0 * scale);
 		sel->rect.x1 = round(sel->rect.x1 * scale);
 		sel->rect.y1 = round(sel->rect.y1 * scale);
 	}
 	sel->scaled_w = actual_w;
 	sel->scaled_h = actual_h;
 	sel->valid = 1;
 	queue_update(0, 0, sel->scaled_w, sel->scaled_h);
 
 	/* set the cursor since the cropping rectangle may have changed */
 	set_cursor(sel->rect);
 }
 
 /* show the next image in the argument list - unloadable files are skipped
  * copy_box determines whether the current selection is copied */
 static void
 next_picture(int copy_box) {
 	if (state.cur_selection + 1 >= state.num_files)
 		return;
 	Imlib_Image tmp_image = NULL;
 	int tmp_cur_selection = state.cur_selection;
 	/* loop until we find a loadable file */
 	while (!tmp_image && tmp_cur_selection + 1 < state.num_files) {
 		tmp_cur_selection++;
 		if (!state.filenames[tmp_cur_selection])
 			continue;
 		tmp_image = imlib_load_image_immediately(
 		    state.filenames[tmp_cur_selection]
 		);
 		if (!tmp_image) {
 			fprintf(stderr, "Warning: Unable to load image '%s'.\n",
 			    state.filenames[tmp_cur_selection]);
 			state.filenames[tmp_cur_selection] = NULL;
 		}
 	}
 	/* immediately exit program if no loadable image is found on startup */
 	if (state.cur_selection < 0 && !tmp_image) {
 		fprintf(stderr, "No loadable images found.\n");
 		cleanup();
 		exit(1);
 	}
 	if (!tmp_image)
 		return;
 
 	change_picture(tmp_image, tmp_cur_selection, copy_box);
 }
 
 /* show the previous image in the argument list - unloadable files are skipped
  * copy_box determines whether the current selection is copied */
 static void
 last_picture(int copy_box) {
 	if (state.cur_selection <= 0)
 		return;
 	Imlib_Image tmp_image = NULL;
 	int tmp_cur_selection = state.cur_selection;
 	/* loop until we find a loadable file */
 	while (!tmp_image && tmp_cur_selection > 0) {
 		tmp_cur_selection--;
 		if (!state.filenames[tmp_cur_selection])
 			continue;
 		tmp_image = imlib_load_image_immediately(
 		    state.filenames[tmp_cur_selection]
 		);
 		if (!tmp_image) {
 			fprintf(stderr, "Warning: Unable to load image '%s'.\n",
 			    state.filenames[tmp_cur_selection]);
 			state.filenames[tmp_cur_selection] = NULL;
 		}
 	}
 
 	if (!tmp_image)
 		return;
 
 	change_picture(tmp_image, tmp_cur_selection, copy_box);
 }
 
 static void
 clear_selection(void) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].valid)
 		return;
 	struct Selection *sel = &state.selections[state.cur_selection];
 	sel->rect.x0 = sel->rect.x1 = sel->rect.y0 = sel->rect.y1 = -200;
 	queue_update(0, 0, sel->scaled_w, sel->scaled_h);
 }
 
 static void
 switch_color(void) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].valid)
 		return;
 	state.cur_col = state.cur_col == 1 ? 2 : 1;
 	queue_update(0, 0, state.window_w, state.window_h);
 }
 
 static int
 key_press(XEvent event) {
 	XWindowAttributes attrs;
 	char buf[32];
 	KeySym sym;
 	XLookupString(&event.xkey, buf, sizeof(buf), &sym, NULL);
 	switch (sym) {
 	case XK_Left:
 		last_picture(0);
 		break;
 	case XK_Right:
 		next_picture(0);
 		break;
 	case XK_Return:
 		if (event.xkey.state & ShiftMask)
 			last_picture(1);
 		else
 			next_picture(1);
 		break;
 	case XK_Delete:
 		clear_selection();
 		break;
 	case XK_Tab:
 		switch_color();
 		break;
 	case XK_space:
 		XGetWindowAttributes(state.dpy, state.win, &attrs);
 		resize_window(attrs.width, attrs.height);
 		/* queue update separately so it also redraws when
 		   size didn't change */
 		queue_update(0, 0, state.window_w, state.window_h);
 		break;
 	case XK_q:
 		return 0;
 	default:
 		break;
 	}
 	return 1;
 }