git.y1.nz

draw.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/extensions/Xrandr.h>

#include "config.h"
#include "draw.h"

void
setup_draw(DrawContext * ctx, X11 * x11)
{
	unsigned long mask = 0;
	XSetWindowAttributes window_attributes;

	XColor color;
	int color_alloc_ret = XAllocNamedColor(
		x11->display,
		DefaultColormap(
			x11->display,
			DefaultScreen(x11->display)
		),
		line_color_name,
		(XColor []) {0},
		&color
	);
	if (!color_alloc_ret)
		fatal("failed to allocate color.");

	window_attributes.override_redirect = True;
	mask |= CWOverrideRedirect;
	window_attributes.background_pixel = color.pixel;
	mask |= CWBackPixel;

	window_attributes.event_mask = StructureNotifyMask;
	mask |= CWEventMask;

	for (int i = 0; i < WINDOW_COUNT; i++) {
		x11->window[i] = XCreateWindow(
			x11->display,
			x11->root.window,
			x11->root.x, x11->root.y,
			x11->root.w, x11->root.h,
			0,
			CopyFromParent,
			InputOutput,
			CopyFromParent,
			mask,
			&window_attributes
		);
		char name[] = "selx0";
		name[ARRLEN(name) - 2] += i;
		XClassHint classhint = { name, "selx" };
		XSetClassHint(x11->display, x11->window[i], &classhint);
	}
}

void
setup_keyboard(X11 * x11)
{
	/* when launched via dwm keybinding, it fails the grab since
	 * dwm has it grabbed already. listen for FocusChangeMask and
	 * keep retrying. */
	int keyboard_grab_result;
	XSelectInput(x11->display, x11->root.window, FocusChangeMask);
	do {
		keyboard_grab_result = XGrabKeyboard(
			x11->display, x11->root.window, 0,
			GrabModeAsync, GrabModeAsync, CurrentTime
		);
		XEvent junk;
		XNextEvent(x11->display, &junk);
	} while (keyboard_grab_result == AlreadyGrabbed);
	XSelectInput(x11->display, x11->root.window, 0x0);

	if (keyboard_grab_result != GrabSuccess)
		fatal("failed to grab keyboard");
}

void
setup_display(X11 * x11)
{
	x11->display = XOpenDisplay(NULL);
	if (x11->display == NULL)
		fatal("failed to open X display");

	XWindowAttributes attributes;
	x11->root.window = DefaultRootWindow(x11->display);

	int get_attributes_ret = XGetWindowAttributes(
		x11->display,
		x11->root.window,
		&attributes
	);
	if (get_attributes_ret == 0)
		fatal("XGetWindowAttributes() failed");

	x11->root.x = attributes.x;
	x11->root.y = attributes.y;
	x11->root.w = attributes.width;
	x11->root.h = attributes.height;
}

void
select_window(DrawContext * ctx, X11 * x11, XEvent event)
{
	XWindowAttributes window_attributes;
	int b;

	ctx->target.window = event.xkey.subwindow;
	if (ctx->target.window == None)
		ctx->target.window = event.xkey.root;

	{
		int get_attributes_result = XGetWindowAttributes(
			x11->display,
			ctx->target.window,
			&window_attributes
		);

		if (get_attributes_result == 0)
			fatal("XGetWindowAttributes() failed");
	}

	b = window_attributes.border_width;
	ctx->start.x = window_attributes.x + b;
	ctx->start.y = window_attributes.y + b;
	ctx->end.x = ctx->start.x + window_attributes.width;
	ctx->end.y = ctx->start.y + window_attributes.height;
}

void
select_monitor(DrawContext * ctx, X11 * x11)
{
	ctx->target.monitor = -64;

	int nmonitors;
	XRRMonitorInfo *monitors = XRRGetMonitors(
		x11->display, x11->root.window, True, &nmonitors
	);

	if (monitors == NULL)
		fatal("XRRGetMonitors() failed");

	Point * cur = &ctx->end;
	for (SIZE_T i = 0; i < nmonitors; ++i) {
		XRRMonitorInfo * m = monitors + i;
		if (
			cur->x >= m->x &&
			cur->y >= m->y &&
			cur->x < (m->x + m->width) &&
			cur->y < (m->y + m->height)
		) {
			ctx->target.monitor = i;
			break;
		}
	}

	if (ctx->target.monitor >= nmonitors)
		fatal("no such monitor" "\n"); 

	XRRMonitorInfo * m = monitors + ctx->target.monitor;
	ctx->start.x = m->x;
	ctx->start.y = m->y;
	ctx->end.x = ctx->start.x + m->width;
	ctx->end.y = ctx->start.y + m->height;
}

Rect
get_rectangle(DrawContext * ctx, X11 * x11)
{
	int px[2] = { ctx->start.x, ctx->end.x }, 
	    py[2] = { ctx->start.y, ctx->end.y }; 

	/* ensure positive orientations */
	if (px[1] < px[0]) {
		px[0] = ctx->end.x;
		px[1] = ctx->start.x;
	}
	if (py[1] < py[0]) {
		py[0] = ctx->end.y;
		py[1] = ctx->start.y;
	}

	px[0] = CLAMP(x11->root.x, px[0], x11->root.x+x11->root.w);
	px[1] = CLAMP(x11->root.x, px[1], x11->root.x+x11->root.w);
	py[0] = CLAMP(x11->root.y, py[0], x11->root.y+x11->root.h);
	py[1] = CLAMP(x11->root.y, py[1], x11->root.y+x11->root.h);

	int x = px[0];
	int y = py[0];
	int w = DIFF(px[0], px[1]);
	int h = DIFF(py[0], py[1]);

	return (Rect) { x, y, w, h };
}

int
get_speed(DrawContext * ctx)
{
	int mask = ctx->keys_down_mask;
	if (mask & KEY_SLOW_MASK) return speed_slow;
	if (mask & KEY_FAST_MASK) return speed_fast;
	return speed_normal;
}

int
get_line_thickness(DrawContext * ctx)
{
	int mask = ctx->keys_down_mask;
	if (mask & KEY_SLOW_MASK) return border_thin;
	if (mask & KEY_FAST_MASK) return border_thick;
	return border_normal;
}

void
draw(DrawContext * ctx, X11 * x11)
{
	Rect selection;
	int x, y, w, h, b;
	Rect * rects;
	
	selection = get_rectangle(ctx, x11);
	b = get_line_thickness(ctx);
	x = selection.x;
	y = selection.y;
	w = selection.w;
	h = selection.h;

	if (ctx->mode == MODE_BOTH || ctx->mode == MODE_P1) {
		w = x11->root.w;
		h = x11->root.h;
	}

	rects = (Rect[]) {
		{ x-b, y-b, w+b*2, b }, /* top */
		{ x-b, y-b, b, h+b*2 }, /* left */
		{ x-b, y+h, w+b*2, b }, /* bottom */
		{ x+w, y-b, b, h+b*2 }, /* right */
		{ x+w/2-b, y+h/2-b, b*2, b*2 }, /* center or corner */
	};
	
	/* show the active edges thicker */
	if (ctx->keys_down_mask & KEY_DOWN2_MASK) rects[2].h *= 2;
	if (ctx->keys_down_mask & KEY_RIGHT2_MASK) rects[3].w *= 2;
	if (ctx->keys_down_mask & KEY_LEFT2_MASK) {
		rects[1].w += b; rects[1].x -= b;
	}
	if (ctx->keys_down_mask & KEY_UP2_MASK) {
		rects[0].h += b; rects[0].y -= b;
	}

	for (int window_i = 0; window_i < WINDOW_COUNT; window_i++) {
		int rect_i = window_i;
		if (ctx->mode == MODE_BOTH || ctx->mode == MODE_P1)
			rect_i %= 2;
		Rect * rect = rects + rect_i;
		XMoveResizeWindow(
			x11->display, x11->window[window_i],
			rect->x, rect->y,
			rect->w, rect->h
		);
	}

	XFlush(x11->display);
}

void
init_draw(DrawContext * ctx, X11 * x11) // , Point p)
{
	ctx->start.x = 10;
	ctx->start.y = 10;
	ctx->end.x = 100;
	ctx->end.y = 100;
	ctx->mode = MODE_BOTH;
	ctx->keys_down_mask = 0;

	draw(ctx, x11);

	for (int i = 0; i < ARRLEN(x11->window); i++)
		XMapWindow(x11->display, x11->window[i]);

	XFlush(x11->display);
}

void
set_up(DrawContext * ctx, X11 * x11)
{
	setup_display(x11);
	setup_keyboard(x11);
	setup_draw(ctx, x11);
	init_draw(ctx, x11);	
}

void
clean_up(DrawContext * ctx, X11 * x11)
{
	for (int i = 0; i < ARRLEN(x11->window); ++i)
		XDestroyWindow(x11->display, x11->window[i]);

	int destroyed = 0;
	int unmapped = 0;
	for (XEvent event; !(destroyed == WINDOW_COUNT && unmapped == WINDOW_COUNT);) { 
		XNextEvent(x11->display, &event);
		for (int i = 0; i < ARRLEN(x11->window); i++) {
			if(event.type == DestroyNotify)
				destroyed += (event.xdestroywindow.window == x11->window[i]);
			if(event.type == UnmapNotify)
				unmapped += (event.xunmap.window == x11->window[i]);
		}
	}

	XUngrabPointer(x11->display, CurrentTime);
	XUngrabKeyboard(x11->display, CurrentTime);
}

int
handle_key_press(DrawContext * ctx, X11 * x11, XEvent event)
{
	KeySym keysym = XKeycodeToKeysym(x11->display, event.xkey.keycode, 0);

	if ((event.xkey.state & ControlMask) && keysym == XK_c)
		fatal("Keyboard Interrupt" "\n");

	switch (keysym) {
	case KEY_MONITOR:
		select_monitor(ctx, x11);
		return STATUS_DONE;
	case KEY_WINDOW:
		select_window(ctx, x11, event);
		return STATUS_DONE;
	case KEY_CONFIRM:
		if (ctx->mode != MODE_BOTH) return STATUS_DONE;
		ctx->mode = MODE_P2;
		break;
	case KEY_CANCEL:
		fatal("Cancelled" "\n");
		break;
	case KEY_SLOW: ctx->keys_down_mask |= KEY_SLOW_MASK; break; 
	case KEY_FAST: ctx->keys_down_mask |= KEY_FAST_MASK; break; 
	case KEY_LEFT: ctx->keys_down_mask |= KEY_LEFT_MASK; break;
	case KEY_RIGHT: ctx->keys_down_mask |= KEY_RIGHT_MASK; break;
	case KEY_UP: ctx->keys_down_mask |= KEY_UP_MASK; break;
	case KEY_DOWN: ctx->keys_down_mask |= KEY_DOWN_MASK; break;
	}

	/* draw to update visual hinting */
	draw(ctx, x11); 
	return STATUS_CONTINUE;
}

void
handle_key_release(DrawContext * ctx, X11 * x11, XEvent event)
{
	KeySym keysym = XKeycodeToKeysym(
		x11->display, event.xkey.keycode, 0
	);
	
	switch (keysym) {
	case KEY_SLOW: ctx->keys_down_mask &= ~KEY_SLOW_MASK; break; 
	case KEY_FAST: ctx->keys_down_mask &= ~KEY_FAST_MASK; break; 
	case KEY_LEFT: ctx->keys_down_mask &= ~KEY_LEFT_MASK; break;
	case KEY_RIGHT: ctx->keys_down_mask &= ~KEY_RIGHT_MASK; break;
	case KEY_DOWN: ctx->keys_down_mask &= ~KEY_DOWN_MASK; break;
	case KEY_UP: ctx->keys_down_mask &= ~KEY_UP_MASK; break;
	}

	/* draw to update visual hinting */
	draw(ctx, x11); 
}
		
int
handle_xevent(DrawContext * ctx, X11 * x11, XEvent event, int * queued)
{
	switch (event.type) {
	case KeyPress:
		return handle_key_press(ctx, x11, event);
	case KeyRelease:
		handle_key_release(ctx, x11, event);
		break;
	case Expose:
		draw(ctx, x11);
		break;
	case DestroyNotify:
		fatal("received DestroyNotify" "\n");
	}
	return STATUS_CONTINUE;
}

void
do_movement(DrawContext * ctx, X11 * x11)
{
	int mask = ctx->keys_down_mask;

	int down = mask & KEY_DOWN_MASK;
	int up = mask & KEY_UP_MASK;
	int left = mask & KEY_LEFT_MASK;
	int right = mask & KEY_RIGHT_MASK;

	int speed = get_speed(ctx);
	int delta_x = speed * ((right != 0) - (left != 0));
	int delta_y = speed * ((down != 0) - (up != 0));

	int min_x = x11->root.x;
	int min_y = x11->root.y;
	int max_x = x11->root.x + x11->root.w;
	int max_y = x11->root.y + x11->root.h;

	if (delta_x == 0 && delta_y == 0)
		return;

	if (ctx->mode == MODE_BOTH || ctx->mode == MODE_P1) {
		ctx->start.x += delta_x;
		ctx->start.y += delta_y;
	}
	if (ctx->mode == MODE_BOTH || ctx->mode == MODE_P2) {
		ctx->end.x += delta_x;
		ctx->end.y += delta_y;
	}

	/* clamp within screen */
	ctx->start.x = CLAMP(min_x, ctx->start.x, max_x);
	ctx->start.y = CLAMP(min_y, ctx->start.y, max_y);
	ctx->end.x = CLAMP(min_x, ctx->end.x, max_x);
	ctx->end.y = CLAMP(min_y, ctx->end.y, max_y);

	draw(ctx, x11);
	ctx->frames_moving++;
}

void
run_draw_loop(DrawContext * ctx, X11 * x11)
{
	int queued = FALSE, event_set;
	int status = STATUS_CONTINUE;
	XEvent event;

	while (status == STATUS_CONTINUE) {
		event_set = XCheckMaskEvent(
			x11->display,
			~0, /* accept all events */
			&event
		);

		if (!event_set) {
			usleep(sleep_ms * 1000);
			if (ctx->keys_down_mask != 0) do_movement(ctx, x11);
			else			      ctx->frames_moving = 0;
			continue;
		}

		status = handle_xevent(ctx, x11, event, &queued);
	}
}

This webpage is intended to be an accessible preview of this repository. To get a fuller picture, clone it and use the git CLI.