path: root/record.cpp

#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <time.h>
#include <X11/Xlib.h>
#include <X11/extensions/XInput.h>
#ifdef HAVE_XI2
#include <X11/extensions/XInput2.h>
#endif
#include <X11/XKBlib.h>

#include "global.h"
#include "rec.h"

static volatile int done = 0;

static unsigned
get_record_time()
{
	struct timespec ts;

	clock_gettime(CLOCK_MONOTONIC, &ts);
	return ts.tv_sec * 1000u + ts.tv_nsec / 1000000u;
}

static void
sig_end(int sig)
{
	done = 1;
}

namespace {
class DoRecord
{
public:
	DoRecord(Window _win, const char *fn);
	void go();
private:
	void handle_xi_mouse(XIDeviceEvent* ev);
	void handle_xi_keys(XIDeviceEvent* ev);
	void handle_xinput(XGenericEventCookie *cookie);
	void handle_ConfigureNotify(XEvent *event);
	void handle_xev(XEvent *ev);
	void record_move();

	WriteRecordsFile file;
	bool has_focus, inside;
	Window win;
	Rect rc;
};
};

DoRecord::DoRecord(Window _win, const char *fn):
	file(fn), has_focus(false), inside(false), win(_win), rc(get_win_pos(_win))
{
	/* TODO get focus and if mouse inside */

	xev_init(win);
	xinput_init(dpy, win);

	/* mark which window we selected to record */
	Record r(Record::TargetWindow, get_record_time());
	r.set_field(Record::Window, win);
	file.put(r);

	/* fake move to tell where mouse was */
	record_move();
}

void
DoRecord::go()
{
	signal(SIGINT, sig_end);
	signal(SIGTERM, sig_end);

	while (!done) {
		XEvent event;

		XNextEvent (dpy, &event);

		if (is_xinput_event(&event)) {
			XGenericEventCookie *cookie = &event.xcookie;
			if (XGetEventData(dpy, cookie)) {
				handle_xinput(cookie);
				XFreeEventData(dpy, cookie);
			}
		} else {
			handle_xev(&event);
		}
	}

	signal(SIGINT, SIG_DFL);
	signal(SIGTERM, SIG_DFL);
}

void
DoRecord::record_move()
{
	Record r(Record::WindowMove, get_record_time());
	r.set_field(Record::X, rc.x);
	r.set_field(Record::Y, rc.y);
	r.set_field(Record::Width, rc.width);
	r.set_field(Record::Height, rc.height);
	r.set_field(Record::Window, win);
	file.put(r);
}

static Record::RecordType get_record_type(int evtype)
{
	switch (evtype) {
	case XI_KeyPress:
		return Record::KeyDown;
	case XI_KeyRelease:
		return Record::KeyUp;
	case XI_ButtonPress:
		return Record::ButtonDown;
	case XI_ButtonRelease:
		return Record::ButtonUp;
	case XI_Motion:
		return Record::MouseMotion;
	}
	fprintf (stderr, "unhandled event\n");
	exit(EXIT_FAILURE);
}

void
DoRecord::handle_xi_mouse(XIDeviceEvent* ev)
{
	int mouse_x = (int) ev->root_x;
	if (mouse_x < rc.x || mouse_x - rc.x >= rc.width)
		return;

	int mouse_y = (int) ev->root_y;
	if (mouse_y < rc.y || mouse_y - rc.y >= rc.height)
		return;

	if (!inside)
		return;

	Record r(get_record_type(ev->evtype), get_record_time());
	r.set_field(Record::X, mouse_x - rc.x);
	r.set_field(Record::Y, mouse_y - rc.y);
	r.set_field(Record::State, ev->mods.effective);
	r.set_field(Record::Detail, ev->detail);
	r.set_field(Record::Window, win);
	file.put(r);

	if (verbose == 1)
		printf("Mouse moved at (%d,%d)\n", mouse_x, mouse_y);
}

void
DoRecord::handle_xi_keys(XIDeviceEvent* ev)
{
	Record r(get_record_type(ev->evtype), get_record_time());
	r.set_field(Record::X, ev->root_x - rc.x);
	r.set_field(Record::Y, ev->root_y - rc.y);
	r.set_field(Record::State, ev->mods.effective);
	r.set_field(Record::Detail, ev->detail);
	r.set_field(Record::Window, win);
	KeySym	key = XkbKeycodeToKeysym(dpy, ev->detail,
		0, ev->mods.effective & ShiftMask ? 1 : 0);
	r.set_field(Record::Keysym, key);
	file.put(r);
}

void
DoRecord::handle_xinput(XGenericEventCookie *cookie)
{
	if (verbose >= 2)
		xinput_dump(dpy, cookie);

	switch (cookie->evtype) {
	case XI_KeyPress:
	case XI_KeyRelease:
		if (has_focus) {
			xinput_dump(dpy, cookie);
			handle_xi_keys((XIDeviceEvent*) cookie->data);
		}
		break;
	case XI_ButtonPress:
	case XI_ButtonRelease:
	case XI_Motion:
		handle_xi_mouse((XIDeviceEvent*) cookie->data);
		break;
	/* don't care about these */
	case XI_RawKeyPress:
	case XI_RawKeyRelease:
	case XI_RawButtonPress:
	case XI_RawButtonRelease:
	case XI_RawTouchBegin:
	case XI_RawTouchUpdate:
	case XI_RawTouchEnd:
	case XI_RawMotion:
		break;
	default:
		if (verbose == 1)
			xinput_dump(dpy, cookie);
		break;
	}
}

void
DoRecord::handle_ConfigureNotify(XEvent *event)
{
	XConfigureEvent *e = &event->xconfigure;

	if (e->window == win) {
		rc.x = e->x;
		rc.y = e->y;
		rc.width = e->width;
		rc.height = e->height;
		record_move();
	}
}

void
DoRecord::handle_xev(XEvent *ev)
{
	if (verbose >= 2)
		xev_dump(ev);

	switch (ev->type) {
	case FocusIn:
		if (ev->xfocus.window == win)
			has_focus = 1;
		break;
	case FocusOut:
		if (ev->xfocus.window == win
		    && ev->xfocus.mode != NotifyWhileGrabbed)
			has_focus = 0;
		break;
	case EnterNotify:
		if (ev->xcrossing.window == win)
			inside = 1;
		break;
	case LeaveNotify:
		if (ev->xcrossing.window == win)
			inside = 0;
		break;
	case DestroyNotify:
		if (ev->xdestroywindow.window == win)
			done = 1;
		break;
	case ConfigureNotify:
		handle_ConfigureNotify(ev);
		break;
	/* don't care */
	case KeyPress:
	case KeyRelease:
	case ButtonPress:
	case ButtonRelease:
	case MotionNotify:
	case ColormapNotify:
		break;
	case KeymapNotify:
	case Expose:
	case GraphicsExpose:
	case NoExpose:
	case VisibilityNotify:
	case CreateNotify:	/* see if our client was created ? */
	case UnmapNotify:
	case MapNotify:
	case MapRequest:
	case ReparentNotify:
	case ConfigureRequest:
	case GravityNotify:
	case ResizeRequest:
	case CirculateNotify:
	case CirculateRequest:
	case PropertyNotify:	/* handle status change (visible/not) ? */
	case SelectionClear:
	case SelectionRequest:
	case SelectionNotify:
	case ClientMessage:
	case MappingNotify:
		if (verbose == 1)
			xev_dump(ev);
		break;
	}
}

void record(const char *fn_out, Window w)
{
	if (w == 0) {
		fprintf (stderr, "record mode require a window to be specified\n");
		exit(EXIT_FAILURE);
	}

	DoRecord action(w, fn_out);

	action.go();
}