Commit: cc54f8ec926ac223c685ff4d8adfd87f10a0cafa - xinput_calibrator (git)

A generic touchscreen calibration program for X.Org

Commit MetaInfo

• Revision: cc54f8ec926ac223c685ff4d8adfd87f10a0cafa (tree)
• Time: 2010-01-08 08:07:46
• Author: Tias Guns <tias@ulys...>
• Commiter: Tias Guns

Log Message

Rewrite: split the one-huge-file into clean components

Change Summary

• modified: Makefile
• add: calibrator.cpp
• add: calibrator.hh
• add: calibrators/calibratorEvdev.cpp
• add: calibrators/calibratorUsbtouchscreen.cpp
• add: calibrators/calibratorXorgPrint.cpp
• add: gui_gtkmm.cpp
• add: main_common.hpp
• add: main_gtkmm.cpp

Incremental Difference

--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,7 @@
-all: xinput_calibrator
+all: xinput_calibrator.old xinput_calibrator.gtkmm
 
-xinput_calibrator: xinput_calibrator.cc
-	g++ -Wall xinput_calibrator.cc `pkg-config --cflags --libs gtkmm-2.4` -o xinput_calibrator
+xinput_calibrator.old: xinput_calibrator.cc
+	g++ -Wall xinput_calibrator.cc `pkg-config --cflags --libs gtkmm-2.4` -o xinput_calibrator.old
+
+xinput_calibrator.gtkmm: main_gtkmm.cpp gui_gtkmm.cpp
+	g++ -Wall main_gtkmm.cpp `pkg-config --cflags --libs gtkmm-2.4` -o xinput_calibrator.gtkmm

--- /dev/null
+++ b/calibrator.cpp
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2009 Tias Guns
+ * Copyright (c) 2009 Soren Hauberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <algorithm>
+#include "calibrator.hh"
+
+Calibrator::Calibrator(const char* const drivername0, const XYinfo& axys0)
+  : drivername(drivername0), old_axys(axys0), num_clicks(0)
+{
+}
+
+int Calibrator::get_numclicks()
+{
+    return num_clicks;
+}
+
+bool Calibrator::add_click(double x, double y)
+{
+    // Check that we don't click the same point twice
+    if (num_clicks > 0 && click_threshold > 0
+     && abs (x - clicked_x[num_clicks-1]) < click_threshold
+     && abs (y - clicked_y[num_clicks-1]) < click_threshold)
+        return false;
+
+    clicked_x[num_clicks] = x;
+    clicked_y[num_clicks] = y;
+    num_clicks ++;
+
+    return true;
+}
+
+void Calibrator::finish(int width, int height)
+{
+    // Should x and y be swapped?
+    const bool swap_xy = (abs (clicked_x [UL] - clicked_x [UR]) < abs (clicked_y [UL] - clicked_y [UR]));
+    if (swap_xy) {
+        std::swap(clicked_x[LL], clicked_x[UR]);
+        std::swap(clicked_y[LL], clicked_y[UR]);
+    }
+
+    // Compute min/max coordinates.
+    XYinfo axys;
+    // These are scaled using the values of old_axys
+    const float scale_x = (old_axys.x_max - old_axys.x_min)/(float)width;
+    axys.x_min = ((clicked_x[UL] + clicked_x[LL]) * scale_x/2) + old_axys.x_min;
+    axys.x_max = ((clicked_x[UR] + clicked_x[LR]) * scale_x/2) + old_axys.x_min;
+    const float scale_y = (old_axys.y_max - old_axys.y_min)/(float)height;
+    axys.y_min = ((clicked_y[UL] + clicked_y[UR]) * scale_y/2) + old_axys.y_min;
+    axys.y_max = ((clicked_y[LL] + clicked_y[LR]) * scale_y/2) + old_axys.y_min;
+
+    // Add/subtract the offset that comes from not having the points in the
+    // corners (using the same coordinate system they are currently in)
+    const int delta_x = (axys.x_max - axys.x_min) / (float)(num_blocks - 2);
+    axys.x_min -= delta_x;
+    axys.x_max += delta_x;
+    const int delta_y = (axys.y_max - axys.y_min) / (float)(num_blocks - 2);
+    axys.y_min -= delta_y;
+    axys.y_max += delta_y;
+
+
+    // If x and y has to be swapped we also have to swap the parameters
+    if (swap_xy) {
+        std::swap(axys.x_min, axys.y_max);
+        std::swap(axys.y_min, axys.x_max);
+    }
+
+    // finish the data, driver specific
+    finish_data(axys, swap_xy);
+}

--- /dev/null
+++ b/calibrator.hh
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2009 Tias Guns
+ * Copyright (c) 2009 Soren Hauberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef _calibrator_hh
+#define _calibrator_hh
+
+// Abstract base class for calculating new calibration parameters
+class Calibrator
+{
+public:
+    Calibrator(const char* const drivername, const XYinfo& axys);
+    ~Calibrator() {}
+
+    int get_numclicks();
+    bool add_click(double x, double y);
+    void finish(int width, int height);
+
+protected:
+    virtual void finish_data(const XYinfo new_axys, int swap_xy) =0;
+
+    const char* const drivername;
+    XYinfo old_axys;
+    int num_clicks;
+    double clicked_x[4], clicked_y[4];
+};
+
+#endif

--- /dev/null
+++ b/calibrators/calibratorEvdev.cpp
@@ -0,0 +1,399 @@
+/*
+ * Copyright (c) 2009 Tias Guns
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <ctype.h>
+
+#include <X11/Xlib.h>
+#include <X11/extensions/XInput.h>
+#include <X11/Xatom.h>
+//#include <X11/Xutil.h>
+
+#ifndef EXIT_SUCCESS
+#define EXIT_SUCCESS 1
+#endif
+#ifndef EXIT_FAILURE
+#define EXIT_FAILURE 0
+#endif
+
+/***************************************
+ * Class for dynamic evdev calibration
+ * uses xinput "Evdev Axis Calibration"
+ ***************************************/
+class CalibratorEvdev: public Calibrator
+{
+private:
+    Display     *display;
+    XDeviceInfo *info;
+    XDevice     *dev;
+public:
+    CalibratorEvdev(const char* const drivername, const XYinfo& axys);
+    ~CalibratorEvdev();
+
+    virtual void finish_data(const XYinfo new_axys, int swap_xy);
+
+    static Bool check_driver(const char* const name);
+
+    // xinput functions (from the xinput source)
+    static Atom parse_atom(Display *display, const char* name);
+    static XDeviceInfo* find_device_info(Display *display, const char* name, Bool only_extended);
+    int do_set_prop(Display *display, Atom type, int format, int argc, char* argv[]);
+};
+
+CalibratorEvdev::CalibratorEvdev(const char* const drivername0, const XYinfo& axys0)
+  : Calibrator(drivername0, axys0)
+{
+    printf("Calibrating EVDEV driver for \"%s\"\n", drivername);
+
+    // init
+    display = XOpenDisplay(NULL);
+    if (display == NULL) {
+        fprintf(stderr, "Unable to connect to X server\n");
+        return;
+    }
+
+    info = find_device_info(display, drivername, False);
+    if (!info) {
+        fprintf(stderr, "unable to find device %s\n", drivername);
+        return;
+    }
+
+    dev = XOpenDevice(display, info->id);
+    if (!dev) {
+        fprintf(stderr, "unable to open device '%s'\n", info->name);
+        return;
+    }
+
+    // get "Evdev Axis Calibration" property
+    Atom            property = parse_atom(display, "Evdev Axis Calibration");
+    Atom            act_type;
+    int             act_format;
+    unsigned long   nitems, bytes_after;
+    unsigned char   *data, *ptr;
+    if (XGetDeviceProperty(display, dev, property, 0, 1000, False,
+                           AnyPropertyType, &act_type, &act_format,
+                           &nitems, &bytes_after, &data) == Success)
+    {
+        if (act_format != 32 || act_type != XA_INTEGER) {
+            fprintf(stderr, "Error: unexpected format or type from \"Evdev Axis Calibration\" property.\n");
+        }
+
+        if (nitems != 0) {
+            ptr = data;
+
+            old_axys.x_min = *((long*)ptr);
+            ptr += sizeof(long);
+            old_axys.x_max = *((long*)ptr);
+            ptr += sizeof(long);
+            old_axys.y_min = *((long*)ptr);
+            ptr += sizeof(long);
+            old_axys.y_max = *((long*)ptr);
+            ptr += sizeof(long);
+
+            printf("Read current calibration data from XInput: min_x=%d, max_x=%d and min_y=%d, max_y=%d\n",
+                old_axys.x_min, old_axys.x_max, old_axys.y_min, old_axys.y_max);
+        }
+
+        XFree(data);
+    } else
+        printf("\tFetch failure for 'Evdev Axis Calibration', continuing nonetheless\n");
+}
+
+CalibratorEvdev::~CalibratorEvdev () {
+    XCloseDevice(display, dev);
+    XCloseDisplay(display);
+}
+
+void CalibratorEvdev::finish_data(const XYinfo new_axys, int swap_xy)
+{
+    printf("\nTo make the settings permanent, create add a startup script for your window manager with the following command(s):\n");
+    if (swap_xy)
+        printf(" xinput set-int-prop \"%s\" \"Evdev Axes Swap\" 8 %d\n", drivername, swap_xy);
+    printf(" xinput set-int-prop \"%s\" \"Evdev Axis Calibration\" 32 %d %d %d %d\n", drivername, new_axys.x_min, new_axys.x_max, new_axys.y_min, new_axys.y_max);
+
+    printf("\nDoing dynamic recalibration:\n");
+    // Evdev Axes Swap
+    if (swap_xy) {
+        printf("\tSwapping X and Y axis...\n");
+        // xinput set-int-prop "divername" "Evdev Axes Swap" 8 0
+        char* arr_cmd[3];
+        //arr_cmd[0] = "";
+        char str_prop[50];
+        sprintf(str_prop, "Evdev Axes Swap");
+        arr_cmd[1] = str_prop;
+        char str_swap_xy[20];
+        sprintf(str_swap_xy, "%d", swap_xy);
+        arr_cmd[2] = str_swap_xy;
+
+        do_set_prop(display, XA_INTEGER, 8, 3, arr_cmd);
+    }
+
+    // Evdev Axis Calibration
+    printf("\tSetting new calibration data: %d, %d, %d, %d\n", new_axys.x_min, new_axys.x_max, new_axys.y_min, new_axys.y_max);
+    // xinput set-int-prop 4 223 32 5 500 8 300
+    char* arr_cmd[6];
+    //arr_cmd[0] = "";
+    char str_prop[50];
+    sprintf(str_prop, "Evdev Axis Calibration");
+    arr_cmd[1] = str_prop;
+    char str_min_x[20];
+    sprintf(str_min_x, "%d", new_axys.x_min);
+    arr_cmd[2] = str_min_x;
+    char str_max_x[20];
+    sprintf(str_max_x, "%d", new_axys.x_max);
+    arr_cmd[3] = str_max_x;
+    char str_min_y[20];
+    sprintf(str_min_y, "%d", new_axys.y_min);
+    arr_cmd[4] = str_min_y;
+    char str_max_y[20];
+    sprintf(str_max_y, "%d", new_axys.y_max);
+    arr_cmd[5] = str_max_y;
+
+    do_set_prop(display, XA_INTEGER, 32, 6, arr_cmd);
+
+    // close
+    XSync(display, False);
+}
+
+Bool CalibratorEvdev::check_driver(const char *name) {
+    Display     *display;
+    XDeviceInfo *info;
+    XDevice     *dev;
+    int         nprops;
+    Atom        *props;
+    Bool        found = False;
+
+    display = XOpenDisplay(NULL);
+    if (display == NULL) {
+        //fprintf(stderr, "Unable to connect to X server");
+        return false;
+    }
+
+    info = find_device_info(display, name, False);
+    if (!info)
+    {
+        XCloseDisplay(display);
+        //fprintf(stderr, "unable to find device %s\n", name);
+        return false;
+    }
+
+    dev = XOpenDevice(display, info->id);
+    if (!dev)
+    {
+        XCloseDisplay(display);
+        //fprintf(stderr, "unable to open device '%s'\n", info->name);
+        return false;
+    }
+
+    props = XListDeviceProperties(display, dev, &nprops);
+    if (!nprops)
+    {
+        XCloseDevice(display, dev);
+        XCloseDisplay(display);
+        //printf("Device '%s' does not report any properties.\n", info->name);
+        return false;
+    }
+
+    // check if "Evdev Axis Calibration" exists, then its an evdev driver
+    while(nprops--)
+    {
+        if (strcmp(XGetAtomName(display, props[nprops]),
+                   "Evdev Axis Calibration") == 0) {
+            found = True;
+            break;
+        }
+    }
+
+    XFree(props);
+    XCloseDevice(display, dev);
+    XCloseDisplay(display);
+
+    return found;
+}
+
+Atom CalibratorEvdev::parse_atom(Display *display, const char *name) {
+    Bool is_atom = True;
+    int i;
+
+    for (i = 0; name[i] != '\0'; i++) {
+        if (!isdigit(name[i])) {
+            is_atom = False;
+            break;
+        }
+    }
+
+    if (is_atom)
+        return atoi(name);
+    else
+        return XInternAtom(display, name, False);
+}
+
+XDeviceInfo* CalibratorEvdev::find_device_info(
+Display *display, const char *name, Bool only_extended)
+{
+    XDeviceInfo	*devices;
+    XDeviceInfo *found = NULL;
+    int		loop;
+    int		num_devices;
+    int		len = strlen(name);
+    Bool	is_id = True;
+    XID		id = (XID)-1;
+
+    for (loop=0; loop<len; loop++) {
+        if (!isdigit(name[loop])) {
+	        is_id = False;
+	        break;
+        }
+    }
+
+    if (is_id) {
+	    id = atoi(name);
+    }
+
+    devices = XListInputDevices(display, &num_devices);
+
+    for (loop=0; loop<num_devices; loop++) {
+        if ((!only_extended || (devices[loop].use >= IsXExtensionDevice)) &&
+	        ((!is_id && strcmp(devices[loop].name, name) == 0) ||
+	         (is_id && devices[loop].id == id))) {
+            if (found) {
+                fprintf(stderr,
+	                    "Warning: There are multiple devices named \"%s\".\n"
+	                    "To ensure the correct one is selected, please use "
+	                    "the device ID instead.\n\n", name);
+                return NULL;
+            } else {
+                found = &devices[loop];
+            }
+        }
+    }
+
+    return found;
+}
+
+int CalibratorEvdev::do_set_prop(
+Display *display, Atom type, int format, int argc, char **argv)
+{
+    Atom          prop;
+    Atom          old_type;
+    char         *name;
+    int           i;
+    Atom          float_atom;
+    int           old_format, nelements = 0;
+    unsigned long act_nitems, bytes_after;
+    char         *endptr;
+    union {
+        unsigned char *c;
+        short *s;
+        long *l;
+        Atom *a;
+    } data;
+
+    if (argc < 3)
+    {
+        fprintf(stderr, "Wrong usage of do_set_prop, need at least 3 arguments\n");
+        return EXIT_FAILURE;
+    }
+
+    name = argv[1];
+
+    prop = parse_atom(display, name);
+
+    if (prop == None) {
+        fprintf(stderr, "invalid property %s\n", name);
+        return EXIT_FAILURE;
+    }
+
+    float_atom = XInternAtom(display, "FLOAT", False);
+
+    nelements = argc - 2;
+    if (type == None || format == 0) {
+        if (XGetDeviceProperty(display, dev, prop, 0, 0, False, AnyPropertyType,
+                               &old_type, &old_format, &act_nitems,
+                               &bytes_after, &data.c) != Success) {
+            fprintf(stderr, "failed to get property type and format for %s\n",
+                    name);
+            return EXIT_FAILURE;
+        } else {
+            if (type == None)
+                type = old_type;
+            if (format == 0)
+                format = old_format;
+        }
+
+        XFree(data.c);
+    }
+
+    if (type == None) {
+        fprintf(stderr, "property %s doesn't exist, you need to specify "
+                "its type and format\n", name);
+        return EXIT_FAILURE;
+    }
+
+    data.c = (unsigned char*)calloc(nelements, sizeof(long));
+
+    for (i = 0; i < nelements; i++)
+    {
+        if (type == XA_INTEGER) {
+            switch (format)
+            {
+                case 8:
+                    data.c[i] = atoi(argv[2 + i]);
+                    break;
+                case 16:
+                    data.s[i] = atoi(argv[2 + i]);
+                    break;
+                case 32:
+                    data.l[i] = atoi(argv[2 + i]);
+                    break;
+                default:
+                    fprintf(stderr, "unexpected size for property %s", name);
+                    return EXIT_FAILURE;
+            }
+        } else if (type == float_atom) {
+            if (format != 32) {
+                fprintf(stderr, "unexpected format %d for property %s\n",
+                        format, name);
+                return EXIT_FAILURE;
+            }
+            *(float *)(data.l + i) = strtod(argv[2 + i], &endptr);
+            if (endptr == argv[2 + i]) {
+                fprintf(stderr, "argument %s could not be parsed\n", argv[2 + i]);
+                return EXIT_FAILURE;
+            }
+        } else if (type == XA_ATOM) {
+            if (format != 32) {
+                fprintf(stderr, "unexpected format %d for property %s\n",
+                        format, name);
+                return EXIT_FAILURE;
+            }
+            data.a[i] = parse_atom(display, argv[2 + i]);
+        } else {
+            fprintf(stderr, "unexpected type for property %s\n", name);
+            return EXIT_FAILURE;
+        }
+    }
+
+    XChangeDeviceProperty(display, dev, prop, type, format, PropModeReplace,
+                          data.c, nelements);
+    free(data.c);
+    XCloseDevice(display, dev);
+    return EXIT_SUCCESS;
+}

--- /dev/null
+++ b/calibrators/calibratorUsbtouchscreen.cpp
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2009 Soren Hauberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <string>
+
+/*************************
+ * Variables for usbtouchscreen specifically
+ *************************/
+// The file to which the calibration parameters are saved.
+// (XXX: is this distribution dependend?)
+const char *modprobe_conf_local = "/etc/modprobe.conf.local";
+
+// Prefix to the kernel path where we can set the parameters
+const char *module_prefix = "/sys/module/usbtouchscreen/parameters";
+
+// Names of kernel parameters
+const char *p_range_x = "range_x";
+const char *p_range_y = "range_y";
+const char *p_min_x = "min_x";
+const char *p_min_y = "min_y";
+const char *p_max_x = "max_x";
+const char *p_max_y = "max_y";
+const char *p_transform_xy = "transform_xy";
+const char *p_flip_x = "flip_x";
+const char *p_flip_y = "flip_y";
+const char *p_swap_xy = "swap_xy";
+
+
+/**********************************
+ * Class for usbtouchscreen driver,
+ * writes output parameters to running kernel and to modprobe.conf
+ **********************************/
+class CalibratorUsbtouchscreen: public Calibrator
+{
+public:
+    CalibratorUsbtouchscreen(const char* const drivername, const XYinfo& axys);
+    ~CalibratorUsbtouchscreen();
+
+    virtual void finish_data(const XYinfo new_axys, int swap_xy);
+
+protected:
+    // Globals for kernel parameters from startup.
+    // We revert to these if the program aborts
+    bool val_transform_xy, val_flip_x, val_flip_y, val_swap_xy;
+
+    // Helper functions
+    char yesno(const bool value)
+    {
+        if (value)
+            return 'Y';
+        else
+            return 'N';
+    }
+
+    void read_int_parameter(const char *param, int &value)
+    {
+        char filename[100];
+        sprintf(filename, "%s/%s", module_prefix, param);
+        FILE *fid = fopen(filename, "r");
+        if (fid == NULL) {
+            fprintf(stderr, "Could not read parameter '%s'\n", param);
+            return;
+        }
+
+        fscanf(fid, "%d", &value);
+        fclose(fid);
+    }
+
+    void read_bool_parameter(const char *param, bool &value)
+    {
+        char filename[100];
+        sprintf(filename, "%s/%s", module_prefix, param);
+        FILE *fid = fopen(filename, "r");
+        if (fid == NULL) {
+            fprintf(stderr, "Could not read parameter '%s'\n", param);
+            return;
+        }
+
+        char val[3];
+        fgets(val, 2, fid);
+        fclose(fid);
+
+        value = (val[0] == yesno(true));
+    }
+
+    void write_int_parameter(const char *param, const int value)
+    {
+        char filename[100];
+        sprintf(filename, "%s/%s", module_prefix, param);
+        FILE *fid = fopen(filename, "w");
+        if (fid == NULL) { 
+            fprintf(stderr, "Could not save parameter '%s'\n", param);
+            return;
+        }
+
+        fprintf(fid, "%d", value);
+        fclose(fid);
+    }
+
+    void write_bool_parameter(const char *param, const bool value)
+    {
+        char filename[100];
+        sprintf(filename, "%s/%s", module_prefix, param);
+        FILE *fid = fopen(filename, "w");
+        if (fid == NULL) {
+            fprintf(stderr, "Could not save parameter '%s'\n", param);
+            return;
+        }
+
+        fprintf(fid, "%c", yesno (value));
+        fclose(fid);
+    }
+};
+
+CalibratorUsbtouchscreen::CalibratorUsbtouchscreen(const char* const drivername0, const XYinfo& axys0)
+  : Calibrator(drivername0, axys0)
+{
+    // Reset the currently running kernel
+    read_bool_parameter(p_transform_xy, val_transform_xy);
+    read_bool_parameter(p_flip_x, val_flip_x);
+    read_bool_parameter(p_flip_y, val_flip_y);
+    read_bool_parameter(p_swap_xy, val_swap_xy);
+
+    write_bool_parameter(p_transform_xy, false);
+    write_bool_parameter(p_flip_x, false);
+    write_bool_parameter(p_flip_y, false);
+    write_bool_parameter(p_swap_xy, false);
+}
+
+CalibratorUsbtouchscreen::~CalibratorUsbtouchscreen()
+{
+    // Dirty exit, so we restore the parameters of the running kernel
+    write_bool_parameter (p_transform_xy, val_transform_xy);
+    write_bool_parameter (p_flip_x, val_flip_x);
+    write_bool_parameter (p_flip_y, val_flip_y);
+    write_bool_parameter (p_swap_xy, val_swap_xy);
+}
+
+void CalibratorUsbtouchscreen::finish_data(const XYinfo new_axys, int swap_xy)
+{
+    // New ranges
+    const int range_x = (new_axys.x_max - new_axys.x_min);
+    const int range_y = (new_axys.y_max - new_axys.y_min);
+    // Should x and y be flipped ?
+    const bool flip_x = (new_axys.x_min > new_axys.x_max);
+    const bool flip_y = (new_axys.y_min > new_axys.y_max);
+
+    // Send the estimated parameters to the currently running kernel
+    write_int_parameter(p_range_x, range_x);
+    write_int_parameter(p_range_y, range_y);
+    write_int_parameter(p_min_x, new_axys.x_min);
+    write_int_parameter(p_max_x, new_axys.x_max);
+    write_int_parameter(p_min_y, new_axys.y_min);
+    write_int_parameter(p_max_y, new_axys.y_max);
+    write_bool_parameter(p_transform_xy, true);
+    write_bool_parameter(p_flip_x, flip_x);
+    write_bool_parameter(p_flip_y, flip_y);
+    write_bool_parameter(p_swap_xy, swap_xy);
+
+    // Read, then write calibration parameters to modprobe_conf_local,
+    // to keep the for the next boot
+    FILE *fid = fopen(modprobe_conf_local, "r");
+    if (fid == NULL) {
+        fprintf(stderr, "Error: Can't open '%s' for reading. Make sure you have the necesary rights\n", modprobe_conf_local);
+        fprintf(stderr, "New calibration data NOT saved\n");
+        return;
+    }
+
+    std::string new_contents;
+    const int len = 1024; // XXX: we currently don't handle lines that are longer than this
+    char line[len];
+    const char *opt = "options usbtouchscreen";
+    const int opt_len = strlen(opt);
+    while (fgets(line, len, fid)) {
+        if (strncmp(line, opt, opt_len) == 0) {
+            // This is the line we want to remove
+            continue;
+        }
+        new_contents += line;
+    }
+    fclose(fid);
+
+    char new_opt[opt_len];
+    sprintf(new_opt, "%s %s=%d %s=%d %s=%d %s=%d %s=%d %s=%d %s=%c %s=%c %s=%c %s=%c\n",
+         opt, p_range_x, range_x, p_range_y, range_y,
+         p_min_x, new_axys.x_min, p_min_y, new_axys.y_min,
+         p_max_x, new_axys.x_max, p_max_y, new_axys.y_max,
+         p_transform_xy, yesno(true), p_flip_x, yesno(flip_x),
+         p_flip_y, yesno(flip_y), p_swap_xy, yesno(swap_xy));
+    new_contents += new_opt;
+
+    fid = fopen(modprobe_conf_local, "w");
+    if (fid == NULL) {
+        fprintf(stderr, "Error: Can't open '%s' for writing. Make sure you have the necesary rights\n", modprobe_conf_local);
+        fprintf(stderr, "New calibration data NOT saved\n");
+        return;
+    }
+    fprintf(fid, "%s", new_contents.c_str ());
+    fclose(fid);
+}

--- /dev/null
+++ b/calibrators/calibratorXorgPrint.cpp
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2009 Tias Guns
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+/***************************************
+ * Class for generic Xorg driver,
+ * outputs new Xorg.conf and FDI policy, on stdout
+ ***************************************/
+class CalibratorXorgPrint: public Calibrator
+{
+public:
+    CalibratorXorgPrint(const char* const drivername, const XYinfo& axys);
+
+    virtual void finish_data(const XYinfo new_axys, int swap_xy);
+};
+
+CalibratorXorgPrint::CalibratorXorgPrint(const char* const drivername0, const XYinfo& axys0)
+  : Calibrator(drivername0, axys0)
+{
+    printf ("Calibrating Xorg driver \"%s\" (currently having min_x=%d, max_x=%d and min_y=%d, max_y=%d)\n",
+                drivername, old_axys.x_min, old_axys.x_max,
+                old_axys.y_min, old_axys.y_max);
+    printf("\tIf the current calibration data is estimated wrong then either supply it manually with --precalib <minx> <maxx> <miny> <maxy> or run the 'get_precalib.sh' script to automatically get it from your current Xorg configuration (through hal).\n");
+}
+
+void CalibratorXorgPrint::finish_data(const XYinfo new_axys, int swap_xy)
+{
+    // FDI policy output
+    printf("\nNew method for making the calibration permanent: create an FDI policy file like /etc/hal/fdi/policy/touchscreen.fdi with:\n\
+<match key=\"info.product\" contains=\"%%Name_Of_TouchScreen%%\">\n\
+  <merge key=\"input.x11_options.minx\" type=\"string\">%d</merge>\n\
+  <merge key=\"input.x11_options.miny\" type=\"string\">%d</merge>\n\
+  <merge key=\"input.x11_options.maxx\" type=\"string\">%d</merge>\n\
+  <merge key=\"input.x11_options.maxy\" type=\"string\">%d</merge>\n"
+         , new_axys.x_min, new_axys.x_max, new_axys.y_min, new_axys.y_max);
+    if (swap_xy != 0)
+        printf("  <merge key=\"input.x11_options.swapxy\" type=\"string\">%d</merge>\n", swap_xy);
+    printf("</match>\n");
+
+    // Xorg.conf output
+    printf("\nOld method, edit /etc/X11/xorg.conf and add in the 'Section \"Device\"' of your touchscreen device:\n");
+    printf("\tOption\t\"MinX\"\t\t\"%d\"\t# was \"%d\"\n",
+                new_axys.x_min, old_axys.x_min);
+    printf("\tOption\t\"MaxX\"\t\t\"%d\"\t# was \"%d\"\n",
+                new_axys.x_max, old_axys.x_max);
+    printf("\tOption\t\"MinY\"\t\t\"%d\"\t# was \"%d\"\n",
+                new_axys.y_min, old_axys.y_min);
+    printf("\tOption\t\"MaxY\"\t\t\"%d\"\t# was \"%d\"\n",
+                new_axys.y_max, old_axys.y_max);
+    if (swap_xy != 0)
+        printf("\tOption\t\"SwapXY\"\t\"%d\"\n", swap_xy);
+}

--- /dev/null
+++ b/gui_gtkmm.cpp
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2009 Tias Guns
+ * Copyright (c) 2009 Soren Hauberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <gtkmm/main.h>
+#include <gtkmm/window.h>
+#include <gtkmm/drawingarea.h>
+#include <cairomm/context.h>
+
+#include "calibrator.hh"
+
+
+// Timeout parameters
+const int time_step = 100;  // in milliseconds
+const int max_time = 15000; // 5000 = 5 sec
+
+// Clock appereance
+const int clock_radius = 50;
+const int clock_line_width = 10;
+
+// Text printed on screen
+const int font_size = 20;
+const std::string help_text = "Press the point with the stylus";
+
+
+/*******************************************
+ * GTK-mm class for the the calibration GUI
+ *******************************************/
+class CalibrationArea : public Gtk::DrawingArea
+{
+public:
+    CalibrationArea(Calibrator* w);
+
+protected:
+    // Data
+    Calibrator* calibrator;
+    double X[4], Y[4];
+    int display_width, display_height;
+    int time_elapsed;
+
+
+    // Signal handlers
+    bool on_timer_signal();
+    bool on_expose_event(GdkEventExpose *event);
+    bool on_button_press_event(GdkEventButton *event);
+
+    // Helper functions
+    void redraw();
+};
+
+CalibrationArea::CalibrationArea(Calibrator* calibrator0)
+  : calibrator(calibrator0), time_elapsed(0)
+{
+    // Listen for mouse events
+    add_events(Gdk::BUTTON_PRESS_MASK);
+
+    // Compute absolute circle centers
+    const Glib::RefPtr<Gdk::Screen> S = get_screen();
+    display_width = S->get_width();
+    display_height = S->get_height();
+
+    const int delta_x = display_width/num_blocks;
+    const int delta_y = display_height/num_blocks;
+    X[UL] = delta_x;                     Y[UL] = delta_y;
+    X[UR] = display_width - delta_x - 1; Y[UR] = delta_y;
+    X[LL] = delta_x;                     Y[LL] = display_height - delta_y - 1;
+    X[LR] = display_width - delta_x - 1; Y[LR] = display_height - delta_y - 1;
+
+    // Setup timer for animation
+    sigc::slot<bool> slot = sigc::mem_fun(*this, &CalibrationArea::on_timer_signal);
+    Glib::signal_timeout().connect(slot, time_step);
+}
+
+
+bool CalibrationArea::on_expose_event(GdkEventExpose *event)
+{
+    const double radius = 4;
+    Glib::RefPtr<Gdk::Window> window = get_window();
+    if (window) {
+        Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
+        cr->save();
+
+        cr->rectangle(event->area.x, event->area.y, event->area.width, event->area.height);
+        cr->clip();
+
+        // Print the text
+        Cairo::TextExtents extent;
+        cr->set_font_size(font_size);
+        cr->get_text_extents(help_text, extent);
+        cr->move_to((display_width-extent.width)/2, 0.3*display_height);
+        cr->show_text(help_text);
+        cr->stroke();
+
+        // Draw the points
+        int i = 0;
+        for (; i < calibrator->get_numclicks(); i++) {
+            cr->arc(X[i], Y[i], radius, 0.0, 2.0 * M_PI);
+            cr->set_source_rgb(1.0, 1.0, 1.0);
+            cr->fill_preserve();
+            cr->stroke();
+        }
+
+        cr->set_line_width(2);
+        cr->arc(X[i], Y[i], radius, 0.0, 2.0 * M_PI);
+        cr->set_source_rgb(0.8, 0.0, 0.0);
+        //cr->fill_preserve();
+        cr->stroke();
+
+        // Draw the clock background
+        cr->arc(display_width/2, display_height/2, clock_radius/2, 0.0, 2.0 * M_PI);
+        cr->set_source_rgb(0.5, 0.5, 0.5);
+        cr->fill_preserve();
+        cr->stroke();
+
+        cr->set_line_width(clock_line_width);
+        cr->arc(display_width/2, display_height/2, (clock_radius - clock_line_width)/2,
+             0.0, 2.0 * M_PI * (double)time_elapsed/(double)max_time);
+        cr->set_source_rgb(0.0, 0.0, 0.0);
+        cr->stroke();
+
+        cr->restore();
+    }
+
+    return true;
+}
+
+void CalibrationArea::redraw()
+{
+    Glib::RefPtr<Gdk::Window> win = get_window();
+    if (win) {
+        const Gdk::Rectangle rect(0, 0, display_width, display_height);
+        win->invalidate_rect(rect, false);
+    }
+}
+
+bool CalibrationArea::on_timer_signal()
+{
+    time_elapsed += time_step;
+    if (time_elapsed > max_time) {
+        exit(0);
+    }
+
+    // Update clock
+    Glib::RefPtr<Gdk::Window> win = get_window();
+    if (win) {
+        const Gdk::Rectangle rect(display_width/2 - clock_radius - clock_line_width,
+                                 display_height/2 - clock_radius - clock_line_width,
+                                 2 * clock_radius + 1 + 2 * clock_line_width,
+                                 2 * clock_radius + 1 + 2 * clock_line_width);
+        win->invalidate_rect(rect, false);
+    }
+
+    return true;
+}
+
+bool CalibrationArea::on_button_press_event(GdkEventButton *event)
+{
+    // Handle click
+    time_elapsed = 0;
+    calibrator->add_click(event->x_root, event->y_root);
+
+    // Are we done yet?
+    if (calibrator->get_numclicks() >= 4) {
+        // Recalibrate
+        calibrator->finish(display_width, display_height);
+
+        exit(0);
+    }
+
+    // Force a redraw
+    redraw();
+
+    return true;
+}

--- /dev/null
+++ b/main_common.hpp
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) 2009 Tias Guns
+ * Copyright (c) 2009 Soren Hauberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <cstring>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <X11/Xlib.h>
+#include <X11/extensions/XInput.h>
+
+/*
+ * Number of blocks. We partition the screen into 'num_blocks' x 'num_blocks'
+ * rectangles of equal size. We then ask the user to press points that are
+ * located at the corner closes to the center of the four blocks in the corners
+ * of the screen. The following ascii art illustrates the situation. We partition
+ * the screen into 8 blocks in each direction. We then let the user press the
+ * points marked with 'O'.
+ *
+ *   +--+--+--+--+--+--+--+--+
+ *   |  |  |  |  |  |  |  |  |
+ *   +--O--+--+--+--+--+--O--+
+ *   |  |  |  |  |  |  |  |  |
+ *   +--+--+--+--+--+--+--+--+
+ *   |  |  |  |  |  |  |  |  |
+ *   +--+--+--+--+--+--+--+--+
+ *   |  |  |  |  |  |  |  |  |
+ *   +--+--+--+--+--+--+--+--+
+ *   |  |  |  |  |  |  |  |  |
+ *   +--+--+--+--+--+--+--+--+
+ *   |  |  |  |  |  |  |  |  |
+ *   +--+--+--+--+--+--+--+--+
+ *   |  |  |  |  |  |  |  |  |
+ *   +--O--+--+--+--+--+--O--+
+ *   |  |  |  |  |  |  |  |  |
+ *   +--+--+--+--+--+--+--+--+
+ */
+const int num_blocks = 8;
+
+// Threshold to keep the same point from being clicked twice.
+// Set to zero if you don't want this check
+const int click_threshold = 7;
+
+// Names of the points
+enum {
+    UL = 0, // Upper-left
+    UR = 1, // Upper-right
+    LL = 2, // Lower-left
+    LR = 3  // Lower-right
+};
+
+// struct to hold min/max info of the X and Y axis
+struct XYinfo {
+    int x_min;
+    int x_max;
+    int y_min;
+    int y_max;
+    XYinfo() : x_min(-1), x_max(-1), y_min(-1), y_max(-1) {}
+    XYinfo(int xmi, int xma, int ymi, int yma) :
+         x_min(xmi), x_max(xma), y_min(ymi), y_max(yma) {}
+};
+
+// all need struct XYinfo, and some the consts too
+#include "calibrator.cpp"
+#include "calibrators/calibratorXorgPrint.cpp"
+#include "calibrators/calibratorEvdev.cpp"
+#include "calibrators/calibratorUsbtouchscreen.cpp"
+
+
+
+// find a calibratable device (using Xinput)
+// retuns number of devices found,
+// data of last driver is returned in the function parameters
+int find_driver(const char* drivername, XYinfo& axys) 
+{
+    int found = 0;
+
+    Display* display = XOpenDisplay(NULL);
+    if (display == NULL) {
+	    fprintf(stderr, "Unable to connect to X server\n");
+        exit(1);
+    }
+
+    int xi_opcode, event, error;
+    if (!XQueryExtension(display, "XInputExtension", &xi_opcode, &event, &error)) {
+        printf("X Input extension not available.\n");
+        exit(1);
+    }
+
+    int ndevices;
+    XDeviceInfoPtr list, slist;
+    slist=list=(XDeviceInfoPtr) XListInputDevices (display, &ndevices);
+    for (int i=0; i<ndevices; i++, list++)
+    {
+        if (list->use == IsXKeyboard || list->use == IsXPointer)
+            continue;
+
+        XAnyClassPtr any = (XAnyClassPtr) (list->inputclassinfo);
+        for (int j=0; j<list->num_classes; j++)
+        {
+
+            if (any->c_class == ValuatorClass)
+            {
+                XValuatorInfoPtr V = (XValuatorInfoPtr) any;
+                XAxisInfoPtr ax = (XAxisInfoPtr) V->axes;
+
+                if (V->num_axes >= 2 &&
+                    !(ax[0].min_value == -1 && ax[0].max_value == -1) &&
+                    !(ax[1].min_value == -1 && ax[1].max_value == -1)) {
+                    /* a calibratable device (no mouse etc) */
+                    found++;
+                    drivername = strdup(list->name);
+                    axys.x_min = ax[0].min_value;
+                    axys.x_max = ax[0].max_value;
+                    axys.y_min = ax[1].min_value;
+                    axys.y_max = ax[1].max_value;
+                }
+
+            }
+
+            /*
+             * Increment 'any' to point to the next item in the linked
+             * list.  The length is in bytes, so 'any' must be cast to
+             * a character pointer before being incremented.
+             */
+            any = (XAnyClassPtr) ((char *) any + any->length);
+        }
+
+    }
+    XFreeDeviceList(slist);
+    XCloseDisplay(display);
+
+    return found;
+}
+
+static void usage(char* cmd)
+{
+    fprintf(stderr, "Usage: %s [-h|--help] [--precalib <minx> <maxx> <miny> <maxy>]\n", cmd);
+    fprintf(stderr, "\t--precalib: manually provide the current calibration setting (eg the values in xorg.conf)\n");
+}
+
+Calibrator* main_common(int argc, char** argv)
+{
+    bool fake = false;
+    bool precalib = false;
+    XYinfo pre_axys;
+
+    // parse input
+    if (argc > 1) {
+        for (int i=1; i!=argc; i++) {
+            // Display help ?
+            if (strcmp("-h", argv[i]) == 0 ||
+                 strcmp("--help", argv[i]) == 0) {
+                usage(argv[0]);
+                exit(0);
+            }
+
+            // Get pre-calibration ?
+            if (strcmp("--precalib", argv[i]) == 0) {
+                precalib = true;
+                if (argc > i+1)
+                    pre_axys.x_min = atoi(argv[i+1]);
+                if (argc > i+2)
+                    pre_axys.x_max = atoi(argv[i+2]);
+                if (argc > i+3)
+                    pre_axys.y_min = atoi(argv[i+3]);
+                if (argc > i+4)
+                    pre_axys.y_max = atoi(argv[i+4]);
+            }
+
+            // Fake calibratable device ?
+            if (strcmp("--fake", argv[i]) == 0) {
+                fake = true;
+            }
+        }
+    }
+    
+    // find driver(s)
+    const char* drivername = NULL;
+    XYinfo axys;
+    int nr_found = find_driver(drivername, axys);
+    if (nr_found == 0) {
+        if (fake) {
+            // Fake a calibratable device
+            drivername = "Fake_device";
+            axys = XYinfo(0,0,0,0);
+        } else {
+            fprintf (stderr, "Error: No calibratable devices found.\n");
+            exit(1);
+        }
+    }
+    if (nr_found > 1) {
+        printf ("Warning: multiple calibratable devices found, calibrating last one (%s)\n", drivername);
+    }
+
+    // override min/max XY from command line ?
+    if (precalib) {
+        if (pre_axys.x_min != -1)
+            axys.x_min = pre_axys.x_min;
+        if (pre_axys.x_max != -1)
+            axys.x_max = pre_axys.x_max;
+        if (pre_axys.y_min != -1)
+            axys.y_min = pre_axys.y_min;
+        if (pre_axys.y_max != -1)
+            axys.y_max = pre_axys.y_max;
+    }
+
+    Calibrator* calibrator;
+    // Different driver, different backend behaviour
+    if (strcmp(drivername, "Usbtouchscreen") == 0)
+        // Usbtouchscreen driver
+        calibrator = new CalibratorUsbtouchscreen(drivername, axys);
+    else {
+        // unable to know device driver from its name alone
+        // either its EVDEV or a normal Xorg touchscreen driver
+        if (CalibratorEvdev::check_driver(drivername)) {
+            // Evdev driver
+            calibrator = new CalibratorEvdev(drivername, axys);
+        } else {
+            // EVTouch is handled as a normal Xorg driver
+            calibrator = new CalibratorXorgPrint(drivername, axys);
+        }
+    }
+    return calibrator;
+}

--- /dev/null
+++ b/main_gtkmm.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2009 Tias Guns
+ * Copyright (c) 2009 Soren Hauberg
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <stdexcept>
+
+// Must be before Xlib stuff
+#include <gtkmm/main.h>
+#include <gtkmm/window.h>
+#include <gtkmm/drawingarea.h>
+#include <cairomm/context.h>
+
+#include "main_common.hpp"
+#include "gui_gtkmm.cpp"
+
+int main(int argc, char** argv)
+{
+    Calibrator* calibrator = main_common(argc, argv);
+
+    // GTK-mm setup
+    Gtk::Main kit(argc, argv);
+
+    Gtk::Window win;
+    win.fullscreen();
+
+    CalibrationArea area(calibrator);
+    win.add(area);
+    area.show();
+
+    Gtk::Main::run(win);
+
+    Gtk::Main::quit();
+    delete calibrator;
+    return 0;
+}