Merge lp:~mtdev-team/mtview/trunk.v1.1.3 into lp:mtview

[Henrik Rydberg]

v1.0.2: Reworked mtview with optional XI2.1 support and the ability to draw in multiple windows simultaneously.

v1.0.3: Adjusted api to latest version (February 2011).

[Chase Douglas (chasedouglas)]

Looks fine except that configure.ac needs to be fixed up the same way as utouch-frame was fixed.

review: Needs Fixing

[Henrik Rydberg (rydberg)]

Like this? (new branch pushed)

[lp:~mtdev-team/mtview/trunk.v1.1.3]

17. By Henrik Rydberg on 2011-02-22

Simplify XInput package test

The XI2.1 support is present in sufficiently recent xinput packages,
so simplify the testing accordingly.

18. By Henrik Rydberg on 2011-02-22

Bump to version 1.1.3

Unmerged revisions

=== modified file 'configure.ac'
--- configure.ac	2011-01-03 18:56:34 +0000
+++ configure.ac	2011-02-21 12:34:52 +0000
@@ -1,7 +1,7 @@
 # Initialize Autoconf
 AC_PREREQ([2.60])
 AC_INIT([Multitouch Viewer],
-        [1.1.1],
+        [1.1.3],
         [],
         [mtview])
 AC_CONFIG_SRCDIR([Makefile.am])
@@ -27,6 +27,15 @@
 PKG_CHECK_MODULES([FRAME], [utouch-frame >= 1.0])
 PKG_CHECK_MODULES([X11], [x11])
 
+AC_ARG_WITH([xi], AS_HELP_STRING([--with-xi], [Build with XI2.1 support]))
+AM_CONDITIONAL([HAVE_XI], [test "x$with_xi" != "x"])
+
+AS_IF([test "x$with_xi" = "xyes"], [
+	PKG_CHECK_MODULES(XINPUT, x11 xext [xi >= 1.2] [inputproto >= 1.5])
+	PKG_CHECK_MODULES(XI2_1, [xi >= 1.4.99.1] [inputproto >= 2.0.99.1])
+	AC_DEFINE([HAVE_XI], [1], [XI2.1 support])
+])
+
 AC_CONFIG_FILES([Makefile
                  tools/Makefile
                  mtview.pc])

=== modified file 'tools/Makefile.am'
--- tools/Makefile.am	2011-01-02 13:26:14 +0000
+++ tools/Makefile.am	2011-02-21 12:34:52 +0000
@@ -4,3 +4,11 @@
 
 mtview_SOURCES = mtview.c
 mtview_LDFLAGS = -lX11 -lutouch-frame -lutouch-evemu -lmtdev -lm
+
+if HAVE_XI
+
+AM_CFLAGS = $(XINPUT_CFLAGS)
+
+mtview_LDFLAGS += $(XINPUT_LIBS)
+
+endif

=== modified file 'tools/mtview.c'
--- tools/mtview.c	2011-01-02 13:26:14 +0000
+++ tools/mtview.c	2011-02-21 12:34:52 +0000
@@ -1,22 +1,29 @@
+#include "config.h"
 #include <X11/Xlib.h>
 #include <stdio.h>
 #include <fcntl.h>
 #include <utouch/frame-mtdev.h>
+#if HAVE_XI
+#include <utouch/frame-xi2.h>
+#endif
+#include <stdlib.h>
+#include <unistd.h>
 #include <string.h>
 #include <math.h>
 
-#define XMARG 16
-#define YMARG 16
 #define DEF_FRAC 0.15
 #define DEF_WIDTH 0.05
 
 #define DIM_TOUCH 32
 
+static int opcode;
+
 struct windata {
 	Display *dsp;
-	Window root, win;
+	Window win;
 	GC gc;
-	int screen, width, height;
+	int screen;
+	float off_x, off_y;
 	unsigned long white, black;
 	unsigned long color[DIM_TOUCH];
 	int id[DIM_TOUCH];
@@ -32,26 +39,28 @@
 	return lrand48() & 0xffffff;
 }
 
-static void clear_screen(struct windata *w)
+static void clear_screen(utouch_frame_handle fh, struct windata *w)
 {
+	const struct utouch_surface *s = utouch_frame_get_surface(fh);
+	int width = s->mapped_max_x - s->mapped_min_x;
+	int height = s->mapped_max_y - s->mapped_min_y;
+
 	XSetForeground(w->dsp, w->gc, w->black);
-	XFillRectangle(w->dsp, w->win, w->gc, 0, 0, w->width, w->height);
+	XFillRectangle(w->dsp, w->win, w->gc, 0, 0, width, height);
 }
 
 static void output_touch(utouch_frame_handle fh, struct windata *w,
 			 const struct utouch_contact *t)
 {
 	const struct utouch_surface *s = utouch_frame_get_surface(fh);
-
-	float x1 = s->min_x, y1 = s->min_y;
-	float x2 = s->max_x, y2 = s->max_y;
-	float dx = x2 - x1, dy = y2 - y1;
+	float dx = s->mapped_max_x - s->mapped_min_x;
+	float dy = s->mapped_max_y - s->mapped_min_y;
+	float x = t->x - w->off_x, y = t->y - w->off_y;
 	float major = 0, minor = 0, angle = 0;
 
 	if (s->use_pressure) {
-		float p = DEF_FRAC / s->max_pressure;
-		major = t->pressure * p * dx;
-		minor = t->pressure * p * dx;
+		major = DEF_FRAC * t->pressure * dy;
+		minor = DEF_FRAC * t->pressure * dx;
 		angle = 0;
 	}
 	if (s->use_touch_major) {
@@ -68,15 +77,6 @@
 	float as = fabs(sin(angle));
 	float mx = max(minor * ac, major * as);
 	float my = max(major * ac, minor * as);
-	float ux = t->x - 0.5 * mx;
-	float uy = t->y - 0.5 * my;
-	float vx = t->x + 0.5 * mx;
-	float vy = t->y + 0.5 * my;
-
-	float px = (ux - x1) / dx * w->width;
-	float py = (uy - y1) / dy * w->height;
-	float qx = (vx - x1) / dx * w->width;
-	float qy = (vy - y1) / dy * w->height;
 
 	if (w->id[t->slot] != t->id) {
 		w->id[t->slot] = t->id;
@@ -84,7 +84,9 @@
 	}
 
 	XSetForeground(w->dsp, w->gc, w->color[t->slot]);
-	XFillArc(w->dsp, w->win, w->gc, px, py, qx - px, qy - py, 0, 360 * 64);
+
+	XFillArc(w->dsp, w->win, w->gc, x - mx / 2, y - my / 2,
+		 mx, my, 0, 360 * 64);
 	XFlush(w->dsp);
 }
 
@@ -98,88 +100,105 @@
 		output_touch(fh, w, frame->active[i]);
 }
 
-static void event_loop(utouch_frame_handle fh,
-		       struct mtdev *dev, int fd,
-		       struct windata *w)
+static int init_window(struct windata *w)
+{
+	int event, err;
+	int i;
+
+	memset(w, 0, sizeof(w));
+	for (i = 0; i < DIM_TOUCH; i++)
+		w->id[i] = -1;
+
+	w->dsp = XOpenDisplay(NULL);
+	if (!w->dsp)
+		return -1;
+	if (!XQueryExtension(w->dsp, "XInputExtension", &opcode, &event, &err))
+		return -1;
+
+	w->screen = DefaultScreen(w->dsp);
+	w->white = WhitePixel(w->dsp, w->screen);
+	w->black = BlackPixel(w->dsp, w->screen);
+
+	w->win = XCreateSimpleWindow(w->dsp, XDefaultRootWindow(w->dsp),
+				     0, 0, 200, 200, 0, w->black, w->white);
+	w->gc = DefaultGC(w->dsp, w->screen);
+
+	XMapWindow(w->dsp, w->win);
+	XFlush(w->dsp);
+
+	return 0;
+}
+
+static void term_window(struct windata *w)
+{
+	XDestroyWindow(w->dsp, w->win);
+	XCloseDisplay(w->dsp);
+}
+
+static void set_screen_size_mtdev(utouch_frame_handle fh,
+				  struct windata *w,
+				  XEvent *xev)
+{
+	struct utouch_surface *s = utouch_frame_get_surface(fh);
+	XConfigureEvent *cev = (XConfigureEvent *)xev;
+
+	s->mapped_min_x = 0;
+	s->mapped_min_y = 0;
+	s->mapped_max_x = DisplayWidth(w->dsp, w->screen);
+	s->mapped_max_y = DisplayHeight(w->dsp, w->screen);
+	s->mapped_max_pressure = 1;
+
+	if (cev) {
+		w->off_x = cev->x;
+		w->off_y = cev->y;
+	}
+
+	fprintf(stderr, "map: %f %f %f %f %f %f\n",
+		w->off_x, w->off_y,
+		s->mapped_min_x, s->mapped_min_y,
+		s->mapped_max_x, s->mapped_max_y);
+}
+
+static void run_window_mtdev(utouch_frame_handle fh, struct mtdev *dev, int fd)
 {
 	const struct utouch_frame *frame;
 	struct input_event iev;
+	struct windata w;
 	XEvent xev;
 
-	XSelectInput(w->dsp, w->win,
-		     ButtonPressMask | ButtonReleaseMask |
-		     ExposureMask | StructureNotifyMask);
-
-	clear_screen(w);
+	if (init_window(&w))
+		return;
+
+	clear_screen(fh, &w);
+
+	set_screen_size_mtdev(fh, &w, 0);
+	XSelectInput(w.dsp, w.win, StructureNotifyMask);
+
 	while (1) {
 		while (!mtdev_idle(dev, fd, 100)) {
 			while (mtdev_get(dev, fd, &iev, 1) > 0) {
 				frame = utouch_frame_pump_mtdev(fh, &iev);
 				if (frame)
-					report_frame(fh, frame, w);
+					report_frame(fh, frame, &w);
 			}
 		}
-		while (XPending(w->dsp)) {
-			XNextEvent(w->dsp, &xev);
+		while (XPending(w.dsp)) {
+			XNextEvent(w.dsp, &xev);
+			set_screen_size_mtdev(fh, &w, &xev);
 		}
 	}
-}
-
-static void run_window(utouch_frame_handle fh, struct mtdev *dev, int fd)
-{
-	struct windata w;
-	int i;
-	memset(&w, 0, sizeof(w));
-	for (i = 0; i < DIM_TOUCH; i++)
-		w.id[i] = -1;
-
-	w.dsp = XOpenDisplay(NULL);
-	if (!w.dsp)
-		return;
-
-	w.screen = DefaultScreen(w.dsp);
-	w.white = WhitePixel(w.dsp, w.screen);
-	w.black = BlackPixel(w.dsp, w.screen);
-	w.width = DisplayWidth(w.dsp, w.screen) - XMARG;
-	w.height = DisplayHeight(w.dsp, w.screen) - YMARG;
-
-	w.root = DefaultRootWindow(w.dsp);
-	w.win = XCreateSimpleWindow(w.dsp, w.root,
-				    0, 0, w.width, w.height,
-				    0, w.black, w.white);
-
-	XMapWindow(w.dsp, w.win);
-
-	long eventMask = StructureNotifyMask;
-	XSelectInput(w.dsp, w.win, eventMask);
-
-	XEvent ev;
-	do {
-		XNextEvent(w.dsp, &ev);
-	} while (ev.type != MapNotify);
-
-
-	w.gc = XCreateGC(w.dsp, w.win, 0, NULL);
-
-	event_loop(fh, dev, fd, &w);
-
-	XDestroyWindow(w.dsp, w.win);
-	XCloseDisplay(w.dsp);
-}
-
-int main(int argc, char *argv[])
+
+	term_window(&w);
+}
+
+static int run_mtdev(const char *name)
 {
 	struct evemu_device *evemu;
 	struct mtdev *mtdev;
 	utouch_frame_handle fh;
 	int fd;
 
-	if (argc < 2) {
-		fprintf(stderr, "Usage: %s <device>\n", argv[0]);
-		return -1;
-	}
-
-	fd = open(argv[1], O_RDONLY | O_NONBLOCK);
+	fd = open(name, O_RDONLY | O_NONBLOCK);
 	if (fd < 0) {
 		fprintf(stderr, "error: could not open device\n");
 		return -1;
@@ -209,7 +228,7 @@
 		return -1;
 	}
 
-	run_window(fh, mtdev, fd);
+	run_window_mtdev(fh, mtdev, fd);
 
 	utouch_frame_delete_engine(fh);
 	mtdev_close_delete(mtdev);
@@ -220,3 +239,129 @@
 
 	return 0;
 }
+
+#if HAVE_XI
+static void handle_event_xi2(struct windata *w,
+			     utouch_frame_handle fh,
+			     XEvent *ev)
+{
+	XConfigureEvent *cev = (XConfigureEvent *)ev;
+	XGenericEventCookie *gev = &ev->xcookie;
+	const struct utouch_frame *frame;
+
+	switch(ev->type) {
+	case ConfigureNotify:
+		if (cev->window == XDefaultRootWindow(cev->display)) {
+			utouch_frame_configure_xi2(fh, cev);
+		} else {
+			w->off_x = cev->x;
+			w->off_y = cev->y;
+		}
+		break;
+	case GenericEvent:
+		if (!XGetEventData(w->dsp, gev))
+			break;
+		if (gev->type == GenericEvent && gev->extension == opcode) {
+			frame = utouch_frame_pump_xi2(fh, gev->data);
+			if (frame)
+				report_frame(fh, frame, w);
+		}
+		XFreeEventData(w->dsp, gev);
+		break;
+	}
+}
+
+static void run_window_xi2(struct windata *w,
+			   utouch_frame_handle fh,
+			   XIDeviceInfo *dev)
+{
+	const struct utouch_frame *frame;
+	XIEventMask mask;
+
+	fprintf(stderr, "xi2 running\n");
+
+	XSelectInput(w->dsp, w->win, StructureNotifyMask);
+	XSelectInput(w->dsp, XDefaultRootWindow(w->dsp), StructureNotifyMask);
+
+	mask.deviceid = dev->deviceid;
+	mask.mask_len = XIMaskLen(XI_LASTEVENT);
+	mask.mask = calloc(mask.mask_len, sizeof(char));
+
+	XISetMask(mask.mask, XI_PropertyEvent);
+	XISetMask(mask.mask, XI_TouchBegin);
+	XISetMask(mask.mask, XI_TouchUpdate);
+	XISetMask(mask.mask, XI_TouchEnd);
+	XISelectEvents(w->dsp, w->win, &mask, 1);
+
+	while (1) {
+		XEvent ev;
+		XNextEvent(w->dsp, &ev);
+		handle_event_xi2(w, fh, &ev);
+	}
+}
+
+static int run_xi2(int id)
+{
+	struct windata w;
+	XIDeviceInfo *info, *dev;
+	utouch_frame_handle fh;
+	int ndevice;
+	int i;
+
+	if (init_window(&w)) {
+		fprintf(stderr, "error: could not init window\n");
+		return -1;
+	}
+
+	info = XIQueryDevice(w.dsp, XIAllDevices, &ndevice);
+	dev = 0;
+	for (i = 0; i < ndevice; i++)
+		if (info[i].deviceid == id)
+			dev = &info[i];
+	if (!dev)
+		return -1;
+
+	if (!utouch_frame_is_supported_xi2(w.dsp, dev)) {
+		fprintf(stderr, "error: unsupported device\n");
+		return -1;
+	}
+
+	fh = utouch_frame_new_engine(100, 32, 100);
+	if (!fh || utouch_frame_init_xi2(fh, w.dsp, dev)) {
+		fprintf(stderr, "error: could not init frame\n");
+		return -1;
+	}
+
+	run_window_xi2(&w, fh, dev);
+
+	utouch_frame_delete_engine(fh);
+	XIFreeDeviceInfo(info);
+	term_window(&w);
+
+	return 0;
+}
+#else
+static int run_xi2(int id)
+{
+	fprintf(stderr, "XI2.1 not supported\n");
+	return 0;
+}
+#endif
+
+int main(int argc, char *argv[])
+{
+	int id, ret;
+
+	if (argc < 2) {
+		fprintf(stderr, "Usage: %s <device>\n", argv[0]);
+		return -1;
+	}
+
+	id = atoi(argv[1]);
+	if (id)
+		ret = run_xi2(id);
+	else
+		ret = run_mtdev(argv[1]);
+
+	return ret;
+}