croptool

croptool.c (27730B)

---

 /*
  * Copyright (c) 2021-2026 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 <stdlib.h>
 #include <unistd.h>
 
 #include <X11/X.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/keysym.h>
 #include <X11/cursorfont.h>
 
 #include <Imlib2.h>
 
 #include "common.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;
 };
 
 /* Note that the ordering of the points in the rectangles is
    used to store which side is being dragged when resizing
    a selection. This means that the points need to be sorted
    using sort_coordinates if they need to be in a canonical
    form such that x0 <= x1 and y0 <= y1. */
 struct Selection {
 	/* scaled_rect can always be calculated from real_rect,
 	   but it's convenient to have it stored separately for
 	   functions like set_cursor_for_selection that use it a lot */
 	struct Rect real_rect;
 	struct Rect scaled_rect;
 	ImageSize sz;
 	char rect_valid;
 	/* sz_valid should be implied for the current selection
 	   by state.ctx.cur_image being valid, but this makes it
 	   a bit more explicit */
 	char sz_valid;
 };
 
 static struct {
 	GraphicsContext ctx;
 
 	struct Selection *selections;
 	char **filenames;
 	int cur_selection;
 	int num_files;
 	int cursor_x;
 	int cursor_y;
 	struct Point move_handle;
 	XColor col1;
 	XColor col2;
 	int cur_col;
 	struct {
 		struct Rect rect;
 		char valid;
 		char scaled;
 	} copied_selection;
 	char moving;
 	char resizing;
 	char lock_x;
 	char lock_y;
 	char print_on_exit;
 } 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 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 scale_selection_rect(double scale, struct Rect rect, struct Rect *rect_ret);
 static void set_scaled_selection_rect(struct Selection *sel, struct Rect rect);
 static void set_real_selection_rect(struct Selection *sel, struct Rect rect);
 static void copy_selection(int scaled);
 static void paste_selection(void);
 static void select_all(void);
 static void clear_selection(void);
 static void queue_update(int x, int y, int w, int h);
 static void queue_rectangle_redraw(int x0, int y0, int x1, int y1);
 static void set_cursor(struct Rect rect);
 static void reset_cursor(void);
 static void set_cursor_for_selection(struct Selection *sel);
 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
 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();
 
 	if (state.print_on_exit) {
 		for (int i = 0; i < argc; i++) {
 			if (state.selections[i].rect_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.ctx.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.ctx.wm_delete_msg)
 					running = 0;
 			default:
 				break;
 			}
 		} while (XPending(state.ctx.dpy));
 
 		redraw();
 	}
 }
 
 static void
 setup(int argc, char *argv[]) {
 	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.cursor_x = 0;
 	state.cursor_y = 0;
 	state.cur_col = 1;
 	state.print_on_exit = 0;
 	state.copied_selection.valid = 0;
 
 	for (int i = 0; i < argc; i++) {
 		state.selections[i].rect_valid = 0;
 		state.selections[i].sz_valid = 0;
 	}
 
 	setup_x(&state.ctx, 500, 500, LINE_WIDTH, CACHE_SIZE);
 
         if (!XParseColor(state.ctx.dpy, state.ctx.cm, SELECTION_COLOR1, &state.col1)) {
 		fprintf(stderr, "Primary color invalid.\n");
 		exit(1);
 	}
         XAllocColor(state.ctx.dpy, state.ctx.cm, &state.col1);
         if (!XParseColor(state.ctx.dpy, state.ctx.cm, SELECTION_COLOR2, &state.col2)) {
 		fprintf(stderr, "Secondary color invalid.\n");
 		exit(1);
 	}
         XAllocColor(state.ctx.dpy, state.ctx.cm, &state.col2);
 
 	cursors.top = XCreateFontCursor(state.ctx.dpy, XC_top_side);
 	cursors.bottom = XCreateFontCursor(state.ctx.dpy, XC_bottom_side);
 	cursors.left = XCreateFontCursor(state.ctx.dpy, XC_left_side);
 	cursors.right = XCreateFontCursor(state.ctx.dpy, XC_right_side);
 	cursors.topleft = XCreateFontCursor(state.ctx.dpy, XC_top_left_corner);
 	cursors.topright = XCreateFontCursor(state.ctx.dpy, XC_top_right_corner);
 	cursors.bottomleft = XCreateFontCursor(state.ctx.dpy, XC_bottom_left_corner);
 	cursors.bottomright = XCreateFontCursor(state.ctx.dpy, XC_bottom_right_corner);
 	cursors.grab = XCreateFontCursor(state.ctx.dpy, XC_fleur);
 
 	next_picture(state.cur_selection, state.filenames, state.num_files, 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.ctx.dpy, state.ctx.win);
 	redraw();
 }
 
 void
 cleanup(void) {
 	free(state.selections);
 	cleanup_x(&state.ctx);
 }
 
 /* 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;
 	/* FIXME: just use putc instead of this complex printf dance */
 	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");
 	}
 }
 
 static void
 redraw(void) {
 	if (!state.ctx.dirty)
 		return;
 	if (!state.ctx.cur_image || state.cur_selection < 0) {
 		clear_screen(&state.ctx);
 		swap_buffers(&state.ctx);
 		return;
 	}
 
 	/* draw the parts of the image that need to be redrawn */
 	struct Selection *sel = &state.selections[state.cur_selection];
 	/* Should never be invalid at this point, but just check anyways */
 	if (sel->sz_valid) {
 		draw_image_updates(&state.ctx, &sel->sz);
 		wipe_around_image(&state.ctx, &sel->sz);
 	}
 
 	/* draw the rectangle */
 	if (sel->rect_valid) {
 		struct Rect rect = sel->scaled_rect;
 		XColor col = state.cur_col == 1 ? state.col1 : state.col2;
 		XSetForeground(state.ctx.dpy, state.ctx.gc, col.pixel);
 		sort_coordinates(&rect.x0, &rect.y0, &rect.x1, &rect.y1);
 		XDrawRectangle(
 		    state.ctx.dpy, state.ctx.drawable, state.ctx.gc,
 		    rect.x0, rect.y0, rect.x1 - rect.x0, rect.y1 - rect.y0
 		);
 	}
 	swap_buffers(&state.ctx);
 }
 
 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) {
 	if (!sel->rect_valid)
 		return;
 	int x0 = sel->real_rect.x0;
 	int y0 = sel->real_rect.y0;
 	int x1 = sel->real_rect.x1;
 	int y1 = sel->real_rect.y1;
 	sort_coordinates(&x0, &y0, &x1, &y1);
 	/* The box is completely outside of the picture. */
 	if (x0 >= sel->sz.orig_w || y0 >= sel->sz.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->sz.orig_w ? sel->sz.orig_w : x1;
 	y1 = y1 > sel->sz.orig_h ? sel->sz.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].sz_valid)
 		return;
 	struct Selection *sel = &state.selections[state.cur_selection];
 	struct Rect *rect = &sel->scaled_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;
 	/* if old rect was invalid, just set it to something
 	   that will definitely not collide with the mouse position */
 	if (!sel->rect_valid) {
 		x0 = y0 = x1 = y1 = -200;
 	} else {
 		/* erase old rectangle */
 		queue_rectangle_redraw(x0, y0, x1, y1);
 	}
 	if (collide_point(x, y, x0, y0)) {
 		*rect = (struct Rect){x1, y1, x, 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, (struct Rect){x0, y0, x1, y1})) {
 		state.moving = 1;
 		state.move_handle.x = x;
 		state.move_handle.y = y;
 	} else {
 		*rect = (struct Rect){x, y, x, y};
 	}
 	state.resizing = 1;
 	set_scaled_selection_rect(sel, *rect);
 }
 
 static void
 queue_update(int x, int y, int w, int h) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].sz_valid)
 		return;
 	struct Selection *sel = &state.selections[state.cur_selection];
 	queue_area_update(&state.ctx, &sel->sz, x, y, w, h);
 }
 
 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.ctx.window_w, state.ctx.window_h);
 }
 
 static void
 resize_window(int w, int h) {
 	int actual_w, actual_h;
 	struct Selection *sel;
 	state.ctx.window_w = w;
 	state.ctx.window_h = h;
 
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].sz_valid)
 		return;
 	sel = &state.selections[state.cur_selection];
 	get_scaled_size(&state.ctx, sel->sz.orig_w, sel->sz.orig_h, &actual_w, &actual_h);
 	if (actual_w != sel->sz.scaled_w || actual_h != sel->sz.scaled_h) {
 		sel->sz.scaled_w = actual_w;
 		sel->sz.scaled_h = actual_h;
 		if (sel->rect_valid)
 			set_real_selection_rect(sel, sel->real_rect);
 		queue_update(0, 0, sel->sz.scaled_w, sel->sz.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);
 	/* this has to be set manually here in case the entire
 	   rectangle is outside the image area, as that will
 	   cause queue_area_update (called by queue_update) to
 	   return immediately without setting the flag, but
 	   redraw() still needs to know that the area outside
 	   the image needs to be redrawn */
 	state.ctx.dirty = 1;
 }
 
 /* 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.ctx.dpy, state.ctx.win, c);
 }
 
 static void
 reset_cursor(void) {
 	XDefineCursor(state.ctx.dpy, state.ctx.win, None);
 }
 
 static void
 set_cursor_for_selection(struct Selection *sel) {
 	if (sel->rect_valid)
 		set_cursor(sel->scaled_rect);
 	else
 		reset_cursor();
 }
 
 static void
 drag_motion(XEvent event) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].rect_valid)
 		return;
 	struct Selection *sel = &state.selections[state.cur_selection];
 	struct Rect *rect = &sel->scaled_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_for_selection(sel);
 		/* return directly to skip the redraw */
 		return;
 	}
 	set_scaled_selection_rect(sel, *rect);
 	set_cursor_for_selection(sel);
 
 	/* redraw the new rectangle */
 	if (SELECTION_REDRAW)
 		queue_rectangle_redraw(rect->x0, rect->y0, rect->x1, rect->y1);
 }
 
 static void
 scale_selection_rect(double scale, struct Rect rect, struct Rect *rect_ret) {
 	sort_coordinates(&rect.x0, &rect.y0, &rect.x1, &rect.y1);
 	rect.x0 = round(rect.x0 * scale);
 	rect.y0 = round(rect.y0 * scale);
 	rect.x1 = round(rect.x1 * scale);
 	rect.y1 = round(rect.y1 * scale);
 	*rect_ret = rect;
 }
 
 /* Only the width is taken into account for the scaling functions since the
    aspect ratio should have been preserved anyways. Of course, this could
    lead to tiny inaccuracies since the scaled width and height are truncated
    to integers. */
 static void
 set_scaled_selection_rect(struct Selection *sel, struct Rect rect) {
 	sel->scaled_rect = rect;
 	scale_selection_rect(
 		(double)sel->sz.orig_w / sel->sz.scaled_w, rect, &sel->real_rect
 	);
 	sel->rect_valid = 1;
 }
 
 static void
 set_real_selection_rect(struct Selection *sel, struct Rect rect) {
 	sel->real_rect = rect;
 	scale_selection_rect(
 		(double)sel->sz.scaled_w / sel->sz.orig_w, rect, &sel->scaled_rect
 	);
 	sel->rect_valid = 1;
 }
 
 static void
 copy_selection(int scaled) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].rect_valid)
 		return;
 	if (scaled) {
 		state.copied_selection.rect = state.selections[state.cur_selection].scaled_rect;
 		state.copied_selection.scaled = 1;
 	} else {
 		state.copied_selection.rect = state.selections[state.cur_selection].real_rect;
 		state.copied_selection.scaled = 0;
 	}
 	state.copied_selection.valid = 1;
 }
 
 static void
 paste_selection(void) {
 	if (!state.copied_selection.valid || state.cur_selection < 0 ||
 	    !state.selections[state.cur_selection].sz_valid) {
 		return;
 	}
 	struct Selection *sel = &state.selections[state.cur_selection];
 	/* clear the old rectangle */
 	struct Rect *rect = &sel->scaled_rect;
 	if (sel->rect_valid)
 		queue_rectangle_redraw(rect->x0, rect->y0, rect->x1, rect->y1);
 	if (state.copied_selection.scaled)
 		set_scaled_selection_rect(sel, state.copied_selection.rect);
 	else
 		set_real_selection_rect(sel, state.copied_selection.rect);
 	queue_rectangle_redraw(rect->x0, rect->y0, rect->x1, rect->y1);
 }
 
 static void
 select_all(void) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].sz_valid)
 		return;
 	struct Selection *sel = &state.selections[state.cur_selection];
 	struct Rect *rect = &sel->scaled_rect;
 	if (sel->rect_valid)
 		queue_rectangle_redraw(rect->x0, rect->y0, rect->x1, rect->y1);
 	set_real_selection_rect(sel, (struct Rect){0, 0, sel->sz.orig_w, sel->sz.orig_h});
 	queue_rectangle_redraw(rect->x0, rect->y0, rect->x1, rect->y1);
 }
 
 /* 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) */
 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.ctx.dpy, state.ctx.win,
 	    state.filenames[new_selection],
 	    NULL, None, NULL, 0, NULL
 	);
 	if (state.ctx.cur_image) {
 		imlib_context_set_image(state.ctx.cur_image);
 		imlib_free_image();
 	}
 	state.ctx.cur_image = new_image;
 	imlib_context_set_image(state.ctx.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(&state.ctx, orig_w, orig_h, &actual_w, &actual_h);
 
 	struct Selection *sel = &state.selections[state.cur_selection];
 	if (sel->sz_valid && (sel->sz.orig_w != orig_w || sel->sz.orig_h != orig_h)) {
 		fprintf(
 			stderr,
 			"WARNING: Image '%s' changed its size since it was previously opened.\n",
 			state.filenames[state.cur_selection]
 		);
 	}
 	sel->sz = (ImageSize){orig_w, orig_h, actual_w, actual_h};
 	sel->sz_valid = 1;
 	if (copy_box && old_selection >= 0 && old_selection < state.num_files) {
 		struct Selection *old = &state.selections[old_selection];
 		if (old->rect_valid) {
 			set_scaled_selection_rect(sel, old->scaled_rect);
 			sel->rect_valid = 1;
 		} else {
 			/* FIXME: an alternative would be to just leave the
 			   selection alone instead of clearing it if copy_box
 			   is true and the previous selection was not valid */
 			sel->rect_valid = 0;
 		}
 	} else if (sel->rect_valid) {
 		/* Always recalculate scaled selection in case the image scale
 		   changed (i.e. the window was resized) */
 		set_real_selection_rect(sel, sel->real_rect);
 	}
 	queue_update(0, 0, sel->sz.scaled_w, sel->sz.scaled_h);
 
 	/* set the cursor since the cropping rectangle may have changed */
 	set_cursor_for_selection(sel);
 }
 
 static void
 clear_selection(void) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].rect_valid)
 		return;
 	struct Selection *sel = &state.selections[state.cur_selection];
 	struct Rect *rect = &sel->scaled_rect;
 	if (sel->rect_valid)
 		queue_rectangle_redraw(rect->x0, rect->y0, rect->x1, rect->y1);
 	sel->rect_valid = 0;
 	set_cursor_for_selection(sel);
 }
 
 static void
 switch_color(void) {
 	if (state.cur_selection < 0 || !state.selections[state.cur_selection].rect_valid)
 		return;
 	state.cur_col = state.cur_col == 1 ? 2 : 1;
 	struct Selection *sel = &state.selections[state.cur_selection];
 	struct Rect *rect = &sel->scaled_rect;
 	if (sel->rect_valid)
 		queue_rectangle_redraw(rect->x0, rect->y0, rect->x1, rect->y1);
 }
 
 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(state.cur_selection, state.filenames, 0);
 		break;
 	case XK_Right:
 		next_picture(state.cur_selection, state.filenames, state.num_files, 0);
 		break;
 	case XK_Return:
 		if (event.xkey.state & ShiftMask)
 			last_picture(state.cur_selection, state.filenames, 1);
 		else
 			next_picture(state.cur_selection, state.filenames, state.num_files, 1);
 		break;
 	case XK_Delete:
 		clear_selection();
 		break;
 	case XK_Tab:
 		switch_color();
 		break;
 	case XK_space:
 		XGetWindowAttributes(state.ctx.dpy, state.ctx.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.ctx.window_w, state.ctx.window_h);
 		break;
 	case XK_q:
 		state.print_on_exit = 1;
 		return 0;
 	case XK_y:
 		copy_selection(1);
 		break;
 	case XK_p:
 		paste_selection();
 		break;
 	case XK_Y:
 		copy_selection(0);
 		break;
 	case XK_a:
 		if (event.xkey.state & ControlMask)
 			select_all();
 		break;
 	default:
 		break;
 	}
 	return 1;
 }