Commit: e4ffde5ab28397c3154a60d930bb15bed5cda2a3 - xinput_calibrator (git)

A generic touchscreen calibration program for X.Org

Commit MetaInfo

• Révision: e4ffde5ab28397c3154a60d930bb15bed5cda2a3 (tree)
• l'heure: 2011-04-20 19:24:48
• Auteur: Antoine Hue <antoine@peti...>
• Commiter: Tias Guns

Message de Log

Managing correctly X/Y swap and X or Y inversion: - detect swap and inversion modification - take into account for inversion in calibration computation since Evdev is doing inversion after calibration. - Mainly tested for Evdev based driver. To be tested for USB.

Sorting outputs to stdout in such a way to only get calibration commands at output => scriptable.

Change Summary

• modified: src/calibrator.cpp
• modified: src/calibrator.hh
• modified: src/calibrator/Evdev.cpp
• modified: src/calibrator/Evdev.hpp
• modified: src/calibrator/Usbtouchscreen.cpp
• modified: src/calibrator/Usbtouchscreen.hpp
• modified: src/calibrator/XorgPrint.cpp
• modified: src/calibrator/XorgPrint.hpp
• modified: src/main_common.cpp

Modification

--- a/src/calibrator.cpp
+++ b/src/calibrator.cpp
@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2009 Tias Guns
  * Copyright (c) 2009 Soren Hauberg
+ * Copyright (c) 2011 Antoine Hue
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -26,46 +27,37 @@
 #include <iostream>
 #include <fstream>
 #include <cstring>
+#include <stdarg.h>
 
 #include "calibrator.hh"
 
-Calibrator::Calibrator(const char* const device_name0, const XYinfo& axys0,
-    const bool verbose0, const int thr_misclick, const int thr_doubleclick, const OutputType output_type0, const char* geometry0)
-  : device_name(device_name0), old_axys(axys0), verbose(verbose0), num_clicks(0), threshold_doubleclick(thr_doubleclick), threshold_misclick(thr_misclick), output_type(output_type0), geometry(geometry0)
-{
-}
+// static instance
+bool Calibrator::verbose = false;
 
-void Calibrator::set_threshold_doubleclick(int t)
-{
-    threshold_doubleclick = t;
-}
-
-void Calibrator::set_threshold_misclick(int t)
-{
-    threshold_misclick = t;
-}
-
-int Calibrator::get_numclicks()
+Calibrator::Calibrator(const char* const device_name0, const XYinfo& axys0,
+    const int thr_misclick, const int thr_doubleclick, const OutputType output_type0, const char* geometry0)
+: device_name(device_name0),
+    threshold_doubleclick(thr_doubleclick), threshold_misclick(thr_misclick),
+    output_type(output_type0), geometry(geometry0)
 {
-    return num_clicks;
-}
+    old_axys = axys0;
 
-const char* Calibrator::get_geometry()
-{
-    return geometry;
+    clicked.num = 0;
+    //clicked.x(NUM_POINTS);
+    //clicked.y(NUM_POINTS);
 }
 
 bool Calibrator::add_click(int x, int y)
 {
     // Double-click detection
-    if (threshold_doubleclick > 0 && num_clicks > 0) {
-        int i = num_clicks-1;
+    if (threshold_doubleclick > 0 && clicked.num > 0) {
+        int i = clicked.num - 1;
         while (i >= 0) {
-            if (abs(x - clicked_x[i]) <= threshold_doubleclick
-                && abs(y - clicked_y[i]) <= threshold_doubleclick) {
+            if (abs(x - clicked.x[i]) <= threshold_doubleclick
+                && abs(y - clicked.y[i]) <= threshold_doubleclick) {
                 if (verbose) {
-                    printf("DEBUG: Not adding click %i (X=%i, Y=%i): within %i pixels of previous click\n",
-                        num_clicks, x, y, threshold_doubleclick);
+                    trace ( "Not adding click %i (X=%i, Y=%i): within %i pixels of previous click\n",
+                         clicked.num, x, y, threshold_doubleclick);
                 }
                 return false;
             }
@@ -74,52 +66,61 @@ bool Calibrator::add_click(int x, int y)
     }
 
     // Mis-click detection
-    if (threshold_misclick > 0 && num_clicks > 0) {
+    if (threshold_misclick > 0 && clicked.num > 0) {
         bool misclick = true;
 
-        if (num_clicks == 1) {
-            // check that along one axis of first point
-            if (along_axis(x,clicked_x[0],clicked_y[0]) ||
-                along_axis(y,clicked_x[0],clicked_y[0]))
-                misclick = false;
-        } else if (num_clicks == 2) {
-            // check that along other axis of first point than second point
-            if ((along_axis(y,clicked_x[0],clicked_y[0]) &&
-                 along_axis(clicked_x[1],clicked_x[0],clicked_y[0])) ||
-                (along_axis(x,clicked_x[0],clicked_y[0]) &&
-                 along_axis(clicked_y[1],clicked_x[0],clicked_y[0])))
-                misclick = false;
-        } else if (num_clicks == 3) {
-            // check that along both axis of second and third point
-            if ((along_axis(x,clicked_x[1],clicked_y[1]) &&
-                 along_axis(y,clicked_x[2],clicked_y[2])) ||
-                (along_axis(y,clicked_x[1],clicked_y[1]) &&
-                 along_axis(x,clicked_x[2],clicked_y[2])))
-                misclick = false;
+        switch (clicked.num) {
+            case 1:
+                // check that along one axis of first point
+                if (along_axis(x,clicked.x[UL],clicked.y[UL]) ||
+                        along_axis(y,clicked.x[UL],clicked.y[UL]))
+                {
+                    misclick = false;
+                } else {
+                    trace ( "Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 0 (X=%i, Y=%i) (threshold=%i)\n",
+                            clicked.num, x, y, clicked.x[UL], clicked.y[UL], threshold_misclick);
+                }
+                break;
+
+            case 2:
+                // check that along other axis of first point than second point
+                if ((along_axis( y, clicked.x[UL], clicked.y[UL])
+                            && along_axis( clicked.x[UR], clicked.x[UL], clicked.y[UL]))
+                        || (along_axis( x, clicked.x[UL], clicked.y[UL])
+                            && along_axis( clicked.y[UR], clicked.x[UL], clicked.y[UL])))
+                {
+                    misclick = false;
+                } else {
+                    trace ( "Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 0 (X=%i, Y=%i) or click 1 (X=%i, Y=%i) (threshold=%i)\n",
+                            clicked.num, x, y, clicked.x[UL], clicked.y[UL], clicked.x[UR], clicked.y[UR], threshold_misclick);
+                }
+                break;
+
+            case 3:
+                // check that along both axis of second and third point
+                if ( ( along_axis( x, clicked.x[UR], clicked.y[UR])
+                            &&   along_axis( y, clicked.x[LL], clicked.y[LL]) )
+                        ||( along_axis( y, clicked.x[UR], clicked.y[UR])
+                            &&  along_axis( x, clicked.x[LL], clicked.y[LL]) ) )
+                {
+                    misclick = false;
+                } else {
+                    trace ( "Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 1 (X=%i, Y=%i) or click 2 (X=%i, Y=%i) (threshold=%i)\n",
+                            clicked.num, x, y, clicked.x[UR], clicked.y[UR], clicked.x[LL], clicked.y[LL], threshold_misclick);
+                }
         }
 
         if (misclick) {
-            if (verbose) {
-                if (num_clicks == 1)
-                    printf("DEBUG: Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 0 (X=%i, Y=%i) (threshold=%i)\n", num_clicks, x, y, clicked_x[0], clicked_y[0], threshold_misclick);
-                else if (num_clicks == 2)
-                    printf("DEBUG: Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 0 (X=%i, Y=%i) or click 1 (X=%i, Y=%i) (threshold=%i)\n", num_clicks, x, y, clicked_x[0], clicked_y[0], clicked_x[1], clicked_y[1], threshold_misclick);
-                else if (num_clicks == 3)
-                    printf("DEBUG: Mis-click detected, click %i (X=%i, Y=%i) not aligned with click 1 (X=%i, Y=%i) or click 2 (X=%i, Y=%i) (threshold=%i)\n", num_clicks, x, y, clicked_x[1], clicked_y[1], clicked_x[2], clicked_y[2], threshold_misclick);
-            }
-
             reset();
             return false;
         }
     }
 
-    clicked_x[num_clicks] = x;
-    clicked_y[num_clicks] = y;
-    num_clicks++;
-
-    if (verbose)
-        printf("DEBUG: Adding click %i (X=%i, Y=%i)\n", num_clicks-1, x, y);
+    clicked.x.push_back(x);
+    clicked.y.push_back(y);
+    clicked.num++;
 
+    trace("Adding click %i (X=%i, Y=%i)\n", clicked.num-1, x, y);
     return true;
 }
 
@@ -129,47 +130,86 @@ inline bool Calibrator::along_axis(int xy, int x0, int y0)
             (abs(xy - y0) <= threshold_misclick));
 }
 
+/// Compute calibration on 1 axis
+/// (all +0.5 for float to int rounding)
+void Calibrator::process_axys( int screen_dim, const AxisInfo &previous, std::vector<int> &clicked, AxisInfo &updated )
+{
+    // These are scaled using the values of old_axys
+    const float old_scale = (previous.max - previous.min)/(float)screen_dim;
+
+    // Sort to get lowest two and highest two whatever is the orientation
+    std::sort( clicked.begin(), clicked.end());
+    // If inverted, must undo inversion since calibration is before in evdev driver.
+    if ( previous.invert ) {
+        updated.min = ( (2*screen_dim - clicked[2] - clicked[3]) * old_scale/2 ) + previous.min + 0.5;
+        updated.max = ( (2*screen_dim - clicked[0] - clicked[1]) * old_scale/2 ) + previous.min + 0.5;
+    } else {
+        updated.min = ( (clicked[0] + clicked[1]) * old_scale/2 ) + previous.min + 0.5;
+        updated.max = ( (clicked[2] + clicked[3]) * old_scale/2 ) + previous.min + 0.5;
+    }
+
+    // Add/subtract the offset that comes from not having the points in the
+    // corners (using the new scale, assumed better than previous)
+    const int new_delta = (updated.max - updated.min) / (float)(num_blocks - 2) + 0.5;
+    updated.min -= new_delta;
+    updated.max += new_delta;
+}
+
+// Compute calibration and correct orientation from captured coordinates
 bool Calibrator::finish(int width, int height)
 {
-    if (get_numclicks() != 4) {
+    if (get_numclicks() != NUM_POINTS) {
         return false;
     }
 
-    // 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]);
+    trace ( "Screen size=%dx%d\n", width, height );
+    trace ( "Expected screen coordinates, x.min=%d, x.max=%d, y.min=%d, y.max=%d\n",
+            width/num_blocks, width-width/num_blocks,
+            height/num_blocks, height - height/num_blocks);
+
+    // Evdev v2.3.2 order to compute coordinates from peripheral to screen:
+    // - swap xy axis
+    // - calibration (offset and scale)
+    // - invert x, invert y axis
+
+    trace ( "Previous orientation: swap_xy=%d, invert_x=%d, invert_y=%d\n", old_axys.swap_xy, old_axys.x.invert, old_axys.y.invert );
+
+    // Compute orientation modifications from existing (if orientation is already corrected, no change)
+    // Start reverse order vs. evdev: from screen to peripheral
+
+    // Check if axes are inverted ?
+    bool invert_x = false, invert_y = false;
+    if ( clicked.x[UL] > clicked.x[LR] ) {
+        invert_x = true;
     }
 
-    // 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;
+    if ( clicked.y[UL] > clicked.y[LR] ) {
+        invert_y = true;
+    }
 
-    // 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;
+    XYinfo new_axys; // new axys origin and scaling
 
+    // Should x and y be swapped
+    const bool swap_xy = (abs (clicked.x [UL] - clicked.x [UR]) < abs (clicked.y [UL] - clicked.y [UR]));
+    trace ( "Orientation modifications: swap_xy=%d, invert_x=%d, invert_y=%d\n", swap_xy, invert_x, invert_y);
 
-    // If x and y has to be swapped we also have to swap the parameters
+    /// Compute calibration
     if (swap_xy) {
-        std::swap(axys.x_min, axys.y_max);
-        std::swap(axys.y_min, axys.x_max);
+        process_axys( height, old_axys.x, clicked.y, new_axys.x );
+        process_axys( width, old_axys.y, clicked.x, new_axys.y );
+    } else {
+        process_axys( width, old_axys.x, clicked.x, new_axys.x );
+        process_axys( height, old_axys.y, clicked.y, new_axys.y );
     }
 
+    new_axys.swap_xy = old_axys.swap_xy ^ swap_xy;
+    new_axys.x.invert = old_axys.x.invert ^ invert_x;
+    new_axys.y.invert = old_axys.y.invert ^ invert_y;
+
+    trace ( "New orientation: swap_xy=%d, invert_x=%d, invert_y=%d\n", new_axys.swap_xy, new_axys.x.invert, new_axys.y.invert );
+
     // finish the data, driver/calibrator specific
-    return finish_data(axys, swap_xy);
+    return finish_data(new_axys);
 }
 
 const char* Calibrator::get_sysfs_name()
@@ -202,8 +242,7 @@ bool Calibrator::is_sysfs_name(const char* name) {
                     std::string devname;
                     std::getline(ifile, devname);
                     if (devname == name) {
-                        if (verbose)
-                            printf("DEBUG: Found that '%s' is a sysfs name.\n", name);
+                        trace("Found that '%s' is a sysfs name.\n", name);
                         return true;
                     }
                 }
@@ -213,9 +252,8 @@ bool Calibrator::is_sysfs_name(const char* name) {
     }
     (void) closedir(dp);
 
-    if (verbose)
-        printf("DEBUG: Name '%s' does not match any in '%s/event*/%s'\n",
-                    name, SYSFS_INPUT, SYSFS_DEVNAME);
+    trace ("Name '%s' does not match any in '%s/event*/%s'\n",
+            name, SYSFS_INPUT, SYSFS_DEVNAME);
     return false;
 }
 
@@ -227,7 +265,7 @@ bool Calibrator::has_xorgconfd_support(Display* dpy) {
         display = XOpenDisplay(NULL);
 
     if (display == NULL) {
-        fprintf(stderr, "Unable to connect to X server\n");
+        error ( "Unable to connect to X server\n");
         exit(1);
     }
 
@@ -241,3 +279,46 @@ bool Calibrator::has_xorgconfd_support(Display* dpy) {
 
     return has_support;
 }
+
+/// Write calibration output (to stdout)
+void Calibrator::output ( const char *format, ... )
+{
+    va_list vl;
+    va_start ( vl, format );
+    vprintf ( format, vl );
+    va_end ( vl );
+}
+
+/// Dump debug information if verbose activated
+void Calibrator::trace ( const char *format, ...)
+{
+    if ( verbose == true ) {
+        printf ( "DEBUG: ");
+        va_list vl;
+        va_start ( vl, format );
+        vprintf ( format, vl );
+        va_end ( vl );
+    }
+}
+
+/// Information to user, if verbose mode activated
+void Calibrator::info ( const char *format, ... )
+{
+    if ( verbose == true ) {
+        printf ( "INFO: ");
+        va_list vl;
+        va_start ( vl, format );
+        vprintf ( format, vl );
+        va_end ( vl );
+    }
+}
+
+/// Error (non fatal)
+void Calibrator::error ( const char *format, ...)
+{
+    fprintf ( stderr, "ERROR: ");
+    va_list vl;
+    va_start ( vl, format );
+    vprintf ( format, vl );
+    va_end ( vl );
+}

--- a/src/calibrator.hh
+++ b/src/calibrator.hh
@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2009 Tias Guns
  * Copyright (c) 2009 Soren Hauberg
+ * Copyright (c) 2011 Antoine Hue
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -26,6 +27,7 @@
 
 #include <stdexcept>
 #include <X11/Xlib.h>
+#include <vector>
 
 /*
  * Number of blocks. We partition the screen into 'num_blocks' x 'num_blocks'
@@ -55,15 +57,23 @@
  */
 const int num_blocks = 8;
 
+struct AxisInfo {
+    int min, max;
+    bool invert;
+    AxisInfo() : min(-1), max(-1), invert(false) { }
+};
+
 /// 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) {}
+    /// Axis swapped
+    bool swap_xy;
+    /// X, Y axis
+    AxisInfo x, y;
+
+    XYinfo() : swap_xy(false) {}
+
+    XYinfo(int xmi, int xma, int ymi, int yma, bool swap_xy_ = false):
+        swap_xy(swap_xy_) {  x.min = xmi; x.max = xma; y.min = ymi; y.max = yma;}
 };
 
 /// Names of the points
@@ -102,7 +112,6 @@ public:
     /// if the touchscreen is not of the type it supports
     Calibrator(const char* const device_name,
                const XYinfo& axys,
-               const bool verbose,
                const int thr_misclick=0,
                const int thr_doubleclick=0,
                const OutputType output_type=OUTYPE_AUTO,
@@ -111,21 +120,24 @@ public:
     ~Calibrator() {}
 
     /// set the doubleclick treshold
-    void set_threshold_doubleclick(int t);
+    void set_threshold_doubleclick(int t)
+    { threshold_doubleclick = t; }
 
     /// set the misclick treshold
-    void set_threshold_misclick(int t);
+    void set_threshold_misclick(int t)
+    { threshold_misclick = t; }
 
     /// get the number of clicks already registered
-    int get_numclicks();
+    int get_numclicks() const
+    { return clicked.num; }
 
     /// return geometry string or NULL
-    const char* get_geometry();
+    const char* get_geometry() const
+    { return geometry; }
 
     /// reset clicks
-    void reset() {
-        num_clicks = 0;
-    }
+    void reset()
+    {  clicked.num = 0; clicked.x.clear(); clicked.y.clear();}
 
     /// add a click with the given coordinates
     bool add_click(int x, int y);
@@ -136,22 +148,54 @@ public:
     const char* get_sysfs_name();
 
 protected:
-    // check whether the coordinates are along the respective axis
+    /// check whether the coordinates are along the respective axis
     bool along_axis(int xy, int x0, int y0);
 
-    // overloaded function that applies the new calibration
-    virtual bool finish_data(const XYinfo new_axys, int swap_xy) =0;
+    /// Apply new calibration, implementation dependent
+    ///\param[in] swap_xy if true, X and Y axes are swapped
+    ///\param[in] invert_x if true, X axis is inverted
+    ///\param[in] invert_y if true, Y axis is inverted
+    virtual bool finish_data(const XYinfo new_axys ) =0;
+
+    /// Compute calibration on 1 axis
+    void process_axys( int screen_dim, const AxisInfo &previous, std::vector<int> &clicked, AxisInfo &updated );
+
+    /// Check whether the given name is a sysfs device name
+    bool is_sysfs_name(const char* name);
+
+    /// Check whether the X server has xorg.conf.d support
+    bool has_xorgconfd_support(Display* display=NULL);
+
+    /// Write output calibration (to stdout)
+    void output ( const char *format, ... );
+
+    /// Write information to user, if verbose mode activated
+    static void info ( const char *format, ... );
+
+    /// Trace debug information if verbose activated
+    static void trace ( const char *format, ...);
+
+    /// Write error (non fatal)
+    static void error ( const char *format, ...);
+
+    static int find_device(const char* pre_device, bool list_devices,
+            XID& device_id, const char*& device_name, XYinfo& device_axys);
+protected:
+    // be verbose or not
+    static bool verbose;
 
     // name of the device (driver)
     const char* const device_name;
-    // original axys values
+    /// Original values
     XYinfo old_axys;
-    // be verbose or not
-    bool verbose;
-    // nr of clicks registered
-    int num_clicks;
-    // click coordinates
-    int clicked_x[NUM_POINTS], clicked_y[NUM_POINTS];
+
+    /// Clicked values (screen coordinates)
+    struct {
+        /// actual number of clicks registered
+        int num;
+        /// click coordinates
+        std::vector<int> x, y;
+    } clicked;
 
     // Threshold to keep the same point from being clicked twice.
     // Set to zero if you don't want this check
@@ -162,17 +206,11 @@ protected:
     // Set to zero if you don't want this check
     int threshold_misclick;
 
-    // Type of output
+    /// Format or type of output calibration
     OutputType output_type;
 
-    // manually specified geometry string
+    /// manually specified geometry string for the calibration pattern
     const char* geometry;
-
-    // Check whether the given name is a sysfs device name
-    bool is_sysfs_name(const char* name);
-
-    // Check whether the X server has xorg.conf.d support
-    bool has_xorgconfd_support(Display* display=NULL);
 };
 
 #endif

--- a/src/calibrator/Evdev.cpp
+++ b/src/calibrator/Evdev.cpp
@@ -1,6 +1,7 @@
 /*
  * Copyright (c) 2009 Tias Guns
  * Copyright 2007 Peter Hutterer (xinput_ methods from xinput)
+ * Copyright (c) 2011 Antoine Hue (invertX/Y)
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -25,7 +26,6 @@
 
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
-//#include <X11/Xutil.h>
 #include <ctype.h>
 #include <cstdio>
 #include <cstring>
@@ -38,8 +38,15 @@
 #define EXIT_FAILURE 0
 #endif
 
-CalibratorEvdev::CalibratorEvdev(const char* const device_name0, const XYinfo& axys0, const bool verbose0, XID device_id, const int thr_misclick, const int thr_doubleclick, const OutputType output_type, const char* geometry)
-  : Calibrator(device_name0, axys0, verbose0, thr_misclick, thr_doubleclick, output_type, geometry), old_swap_xy(0)
+// Constructor
+CalibratorEvdev::CalibratorEvdev(const char* const device_name0,
+                                 const XYinfo& axys0,
+                                 XID device_id,
+                                 const int thr_misclick,
+                                 const int thr_doubleclick,
+                                 const OutputType output_type,
+                                 const char* geometry)
+  : Calibrator(device_name0, axys0, thr_misclick, thr_doubleclick, output_type, geometry)
 {
     // init
     display = XOpenDisplay(NULL);
@@ -49,12 +56,12 @@ CalibratorEvdev::CalibratorEvdev(const char* const device_name0, const XYinfo& a
 
     // normaly, we already have the device id
     if (device_id == (XID)-1) {
-        info = xinput_find_device_info(display, device_name, False);
-        if (!info) {
+        devInfo = xinput_find_device_info(display, device_name, False);
+        if (!devInfo) {
             XCloseDisplay(display);
             throw WrongCalibratorException("Evdev: Unable to find device");
         }
-        device_id = info->id;
+        device_id = devInfo->id;
     }
 
     dev = XOpenDevice(display, device_id);
@@ -92,31 +99,29 @@ CalibratorEvdev::CalibratorEvdev(const char* const device_name0, const XYinfo& a
 
         } else if (nitems == 0) {
             if (verbose)
-                printf("DEBUG: Evdev Axis Calibration not set, setting to axis valuators to be sure.\n");
+                trace ( "Evdev Axis Calibration not set, setting to axis valuators to be sure.\n");
 
             // No axis calibration set, set it to the default one
             // QUIRK: when my machine resumes from a sleep,
-            // the calibration property is no longer exported thourgh xinput, but still active
+            // the calibration property is no longer exported through xinput, but still active
             // not setting the values here would result in a wrong first calibration
             bool ok = set_calibration(old_axys);
 
-            if (verbose) {
-                if (ok)
-                    printf("DEBUG: Successfully applied axis calibration.\n");
-                else
-                    printf("DEBUG: Failed to apply axis calibration.\n");
-            }
+            if (ok)
+                trace("Successfully applied axis calibration.\n");
+            else
+                trace("Failed to apply axis calibration.\n");
 
         } else if (nitems > 0) {
             ptr = data;
 
-            old_axys.x_min = *((long*)ptr);
+            old_axys.x.min = *((long*)ptr);
             ptr += sizeof(long);
-            old_axys.x_max = *((long*)ptr);
+            old_axys.x.max = *((long*)ptr);
             ptr += sizeof(long);
-            old_axys.y_min = *((long*)ptr);
+            old_axys.y.min = *((long*)ptr);
             ptr += sizeof(long);
-            old_axys.y_max = *((long*)ptr);
+            old_axys.y.max = *((long*)ptr);
             ptr += sizeof(long);
         }
 
@@ -130,87 +135,86 @@ CalibratorEvdev::CalibratorEvdev(const char* const device_name0, const XYinfo& a
                            &nitems, &bytes_after, &data) == Success)
     {
         if (act_format == 8 && act_type == XA_INTEGER && nitems == 1) {
-            old_swap_xy = *((char*)data);
+            old_axys.swap_xy = *((char*)data);
 
-            if (verbose)
-                printf("DEBUG: Read axes swap value of %i.\n", old_swap_xy);
+            trace("Read axes swap value of %i.\n", old_axys.swap_xy);
+        }
+    }
+
+    // get "Evdev Axes Inversion" property
+    property = xinput_parse_atom(display, "Evdev Axis Inversion");
+    if (XGetDeviceProperty(display, dev, property, 0, 1000, False,
+                AnyPropertyType, &act_type, &act_format,
+                &nitems, &bytes_after, &data) == Success) {
+        if (act_format == 8 && act_type == XA_INTEGER && nitems == 2) {
+            old_axys.x.invert = *((char*)data++);
+            old_axys.y.invert = *((char*)data);
+
+            trace("Read InvertX=%i, InvertY=%i.\n", old_axys.x.invert, old_axys.y.invert);
         }
     }
+
     // TODO? evdev < 2.3.2 with swap_xy had a bug which calibrated before swapping (eg X calib on Y axis)
     // see http://cgit.freedesktop.org/xorg/driver/xf86-input-evdev/commit/?h=evdev-2.3-branch&id=3772676fd65065b43a94234127537ab5030b09f8
 
-    printf("Calibrating EVDEV driver for \"%s\" id=%i\n", device_name, (int)device_id);
-    printf("\tcurrent calibration values (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);
+    trace("Calibrating EVDEV driver for \"%s\" id=%i\n", device_name, (int)device_id);
+    trace("\tcurrent calibration values (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);
 #endif // HAVE_XI_PROP
 
 }
 
+// Destructor
 CalibratorEvdev::~CalibratorEvdev () {
     XCloseDevice(display, dev);
     XCloseDisplay(display);
 }
 
-bool CalibratorEvdev::finish_data(const XYinfo new_axys, int swap_xy)
+// Activate calibrated data or write it
+bool CalibratorEvdev::finish_data(const XYinfo new_axys)
 {
     bool success = true;
 
     // swap x and y axis, indicated by swap_xy
     // new value is old value (could have been 0 or 1) swapped:
-    int new_swap_xy = 1 - old_swap_xy;
+    int new_swap_xy = (new_axys.swap_xy)?1:0;
+    int new_invert_x = (new_axys.x.invert)?1:0;
+    int new_invert_y = (new_axys.y.invert)?1:0;
 
-    printf("\nDoing dynamic recalibration:\n");
-    // Evdev Axes Swap
-    if (swap_xy) {
-        printf("\tSwapping X and Y axis...\n");
-        bool ok = set_swapxy(new_swap_xy);
-        success &= ok;
+    trace("--- Doing dynamic recalibration:\n");
 
-        if (verbose) {
-            if (ok)
-                printf("DEBUG: Successfully swapped X and Y axis.\n");
-            else
-                printf("DEBUG: Failed to swap X and Y axis.\n");
-        }
-    }
+    // Evdev Axes Swap
+    success &= set_swapxy(new_swap_xy);
+    success &= set_invert_xy(true, new_invert_x, new_invert_y);
 
     // 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);
-    bool ok = set_calibration(new_axys);
-    success &= ok;
-
-    if (verbose) {
-        if (ok)
-            printf("DEBUG: Successfully applied axis calibration.\n");
-        else
-            printf("DEBUG: Failed to apply axis calibration.\n");
-    }
+    trace("\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);
+    success &= set_calibration(new_axys);
+
     // close
     XSync(display, False);
 
-
-
-    printf("\n\n--> Making the calibration permanent <--\n");
+    trace("\t--> Making the calibration permanent <--\n");
     switch (output_type) {
         case OUTYPE_AUTO:
             // xorg.conf.d or alternatively xinput commands
             if (has_xorgconfd_support()) {
-                success &= output_xorgconfd(new_axys, swap_xy, new_swap_xy);
+              success &= output_xorgconfd(new_axys, new_swap_xy, new_invert_x, new_invert_y);
             } else {
-                success &= output_xinput(new_axys, swap_xy, new_swap_xy);
+              success &= output_xinput(new_axys, new_swap_xy, new_invert_x, new_invert_y);
             }
             break;
         case OUTYPE_XORGCONFD:
-            success &= output_xorgconfd(new_axys, swap_xy, new_swap_xy);
+          success &= output_xorgconfd(new_axys, new_swap_xy, new_invert_x, new_invert_y);
             break;
         case OUTYPE_HAL:
-            success &= output_hal(new_axys, swap_xy, new_swap_xy);
+          success &= output_hal(new_axys, new_swap_xy, new_invert_x, new_invert_y);
             break;
         case OUTYPE_XINPUT:
-            success &= output_xinput(new_axys, swap_xy, new_swap_xy);
+          success &= output_xinput(new_axys, new_swap_xy, new_invert_x, new_invert_y);
             break;
         default:
-            fprintf(stderr, "ERROR: Evdev Calibrator does not support the supplied --output-type\n");
+            error ( "ERROR: Evdev Calibrator does not support the supplied --output-type\n");
             success = false;
     }
 
@@ -220,49 +224,77 @@ bool CalibratorEvdev::finish_data(const XYinfo new_axys, int swap_xy)
 bool CalibratorEvdev::set_swapxy(const int swap_xy)
 {
     // xinput set-int-prop "divername" "Evdev Axes Swap" 8 0
-    char* arr_cmd[3];
+    const char* arr_cmd[3];
     //arr_cmd[0] = "";
-    char str_prop[50];
-    sprintf(str_prop, "Evdev Axes Swap");
-    arr_cmd[1] = str_prop;
+    arr_cmd[1] = "Evdev Axes Swap";
     char str_swap_xy[20];
-    sprintf(str_swap_xy, "%d", swap_xy);
+    snprintf(str_swap_xy, 20, "%d", swap_xy);
     arr_cmd[2] = str_swap_xy;
 
     int ret = xinput_do_set_prop(display, XA_INTEGER, 8, 3, arr_cmd);
+
+    if (ret == EXIT_SUCCESS)
+        trace("Successfully set swapped X and Y axes = %d.\n", swap_xy);
+    else
+        trace("Failed to set swap X and Y axes.\n");
+
+    return (ret == EXIT_SUCCESS);
+}
+
+bool CalibratorEvdev::set_invert_xy(bool axisX, const int invert_x, const int invert_y)
+{
+    // xinput set-int-prop "divername" "Evdev Axes Swap" 8 0
+    const char* arr_cmd[3];
+    //arr_cmd[0] = "";
+    arr_cmd[1] =  "Evdev Axis Inversion";
+    char str_val[20];
+    snprintf(str_val, 20, "%d %d", invert_x, invert_y);
+    arr_cmd[2] = str_val;
+
+    int ret = xinput_do_set_prop(display, XA_INTEGER, 8, 3, arr_cmd);
+
+    if (ret == EXIT_SUCCESS)
+        trace("Successfully set invert axis X=%d, Y=%d.\n", invert_x, invert_y);
+    else
+        trace("Failed to set axis inversion.\n");
+
     return (ret == EXIT_SUCCESS);
 }
 
 bool CalibratorEvdev::set_calibration(const XYinfo new_axys)
 {
     // xinput set-int-prop 4 223 32 5 500 8 300
-    char* arr_cmd[6];
+    const char* arr_cmd[6];
     //arr_cmd[0] = "";
-    char str_prop[50];
-    sprintf(str_prop, "Evdev Axis Calibration");
-    arr_cmd[1] = str_prop;
+    arr_cmd[1] = "Evdev Axis Calibration";
     char str_min_x[20];
-    sprintf(str_min_x, "%d", new_axys.x_min);
+    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);
+    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);
+    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);
+    sprintf(str_max_y, "%d", new_axys.y.max);
     arr_cmd[5] = str_max_y;
 
     int ret = xinput_do_set_prop(display, XA_INTEGER, 32, 6, arr_cmd);
+
+    if (ret == EXIT_SUCCESS)
+        trace("Successfully applied axis calibration.\n");
+    else
+        trace("Failed to apply axis calibration.\n");
+
     return (ret == EXIT_SUCCESS);
 }
 
-Atom CalibratorEvdev::xinput_parse_atom(Display *display, const char *name) {
+Atom CalibratorEvdev::xinput_parse_atom(Display *display, const char *name)
+{
     Bool is_atom = True;
-    int i;
 
-    for (i = 0; name[i] != '\0'; i++) {
+    for (int i = 0; name[i] != '\0'; i++) {
         if (!isdigit(name[i])) {
             is_atom = False;
             break;
@@ -280,13 +312,12 @@ 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++) {
+    for (int loop=0; loop<len; loop++) {
         if (!isdigit(name[loop])) {
 	        is_id = False;
 	        break;
@@ -299,15 +330,14 @@ Display *display, const char *name, Bool only_extended)
 
     devices = XListInputDevices(display, &num_devices);
 
-    for (loop=0; loop<num_devices; loop++) {
+    for (int 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);
+          error (  "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];
@@ -318,8 +348,7 @@ Display *display, const char *name, Bool only_extended)
     return found;
 }
 
-int CalibratorEvdev::xinput_do_set_prop(
-Display *display, Atom type, int format, int argc, char **argv)
+int CalibratorEvdev::xinput_do_set_prop(Display *display, Atom type, int format, int argc, const char **argv)
 {
 #ifndef HAVE_XI_PROP
     return EXIT_FAILURE;
@@ -327,7 +356,7 @@ Display *display, Atom type, int format, int argc, char **argv)
 
     Atom          prop;
     Atom          old_type;
-    char         *name;
+    const char    *name;
     int           i;
     Atom          float_atom;
     int           old_format, nelements = 0;
@@ -342,7 +371,7 @@ Display *display, Atom type, int format, int argc, char **argv)
 
     if (argc < 3)
     {
-        fprintf(stderr, "Wrong usage of xinput_do_set_prop, need at least 3 arguments\n");
+        error ( "Wrong usage of xinput_do_set_prop, need at least 3 arguments\n");
         return EXIT_FAILURE;
     }
 
@@ -351,7 +380,7 @@ Display *display, Atom type, int format, int argc, char **argv)
     prop = xinput_parse_atom(display, name);
 
     if (prop == None) {
-        fprintf(stderr, "invalid property %s\n", name);
+        error ( "invalid property %s\n", name);
         return EXIT_FAILURE;
     }
 
@@ -362,7 +391,7 @@ Display *display, Atom type, int format, int argc, char **argv)
         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",
+            error ( "failed to get property type and format for %s\n",
                     name);
             return EXIT_FAILURE;
         } else {
@@ -376,7 +405,7 @@ Display *display, Atom type, int format, int argc, char **argv)
     }
 
     if (type == None) {
-        fprintf(stderr, "property %s doesn't exist, you need to specify "
+      error ( "property %s doesn't exist, you need to specify "
                 "its type and format\n", name);
         return EXIT_FAILURE;
     }
@@ -398,29 +427,29 @@ Display *display, Atom type, int format, int argc, char **argv)
                     data.l[i] = atoi(argv[2 + i]);
                     break;
                 default:
-                    fprintf(stderr, "unexpected size for property %s", name);
+                  error (  "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",
+                error (  "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]);
+                error (  "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",
+                error (  "unexpected format %d for property %s\n",
                         format, name);
                 return EXIT_FAILURE;
             }
             data.a[i] = xinput_parse_atom(display, argv[2 + i]);
         } else {
-            fprintf(stderr, "unexpected type for property %s\n", name);
+            error (  "unexpected type for property %s\n", name);
             return EXIT_FAILURE;
         }
     }
@@ -433,7 +462,7 @@ Display *display, Atom type, int format, int argc, char **argv)
 
 }
 
-bool CalibratorEvdev::output_xorgconfd(const XYinfo new_axys, int swap_xy, int new_swap_xy)
+bool CalibratorEvdev::output_xorgconfd(const XYinfo new_axys, int new_swap_xy, int new_invert_x, int new_invert_y)
 {
     const char* sysfs_name = get_sysfs_name();
     bool not_sysfs_name = (sysfs_name == NULL);
@@ -441,23 +470,24 @@ bool CalibratorEvdev::output_xorgconfd(const XYinfo new_axys, int swap_xy, int n
         sysfs_name = "!!Name_Of_TouchScreen!!";
 
     // xorg.conf.d snippet
-    printf("  copy the snippet below into '/etc/X11/xorg.conf.d/99-calibration.conf'\n");
-    printf("Section \"InputClass\"\n");
-    printf("	Identifier	\"calibration\"\n");
-    printf("	MatchProduct	\"%s\"\n", sysfs_name);
-    printf("	Option	\"Calibration\"	\"%d %d %d %d\"\n",
-                new_axys.x_min, new_axys.x_max, new_axys.y_min, new_axys.y_max);
-    if (swap_xy != 0)
-        printf("	Option	\"SwapAxes\"	\"%d\"\n", new_swap_xy);
-    printf("EndSection\n");
+    info ("  copy the snippet below into '/etc/X11/xorg.conf.d/99-calibration.conf'\n");
+    output("Section \"InputClass\"\n");
+    output("	Identifier	\"calibration\"\n");
+    output("	MatchProduct	\"%s\"\n", sysfs_name);
+    output("	Option	\"Calibration\"	\"%d %d %d %d\"\n",
+                new_axys.x.min, new_axys.x.max, new_axys.y.min, new_axys.y.max);
+    output ("	Option	\"SwapAxes\"	\"%d\"\n", new_swap_xy);
+    output ("	Option	\"InvertX\"	\"%d\"\n", new_invert_x);
+    output ("	Option	\"InvertY\"	\"%d\"\n", new_invert_y);
+    output("EndSection\n");
 
     if (not_sysfs_name)
-        printf("\nChange '%s' to your device's name in the snippet above.\n", sysfs_name);
+        info ("\nChange '%s' to your device's name in the snippet above.\n", sysfs_name);
 
     return true;
 }
 
-bool CalibratorEvdev::output_hal(const XYinfo new_axys, int swap_xy, int new_swap_xy)
+bool CalibratorEvdev::output_hal(const XYinfo new_axys, int new_swap_xy, int new_invert_x, int new_invert_y)
 {
     const char* sysfs_name = get_sysfs_name();
     bool not_sysfs_name = (sysfs_name == NULL);
@@ -465,27 +495,28 @@ bool CalibratorEvdev::output_hal(const XYinfo new_axys, int swap_xy, int new_swa
         sysfs_name = "!!Name_Of_TouchScreen!!";
 
     // HAL policy output
-    printf("  copy the policy below into '/etc/hal/fdi/policy/touchscreen.fdi'\n\
-<match key=\"info.product\" contains=\"%s\">\n\
-  <merge key=\"input.x11_options.calibration\" type=\"string\">%d %d %d %d</merge>\n"
-     , sysfs_name, 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.swapaxes\" type=\"string\">%d</merge>\n", new_swap_xy);
-    printf("</match>\n");
+    info ("  copy the policy below into '/etc/hal/fdi/policy/touchscreen.fdi'\n");
+    output ( "<match key=\"info.product\" contains=\"%s\">\n\
+    <merge key=\"input.x11_options.calibration\" type=\"string\">%d %d %d %d</merge>\n",
+             sysfs_name, new_axys.x.min, new_axys.x.max, new_axys.y.min, new_axys.y.max);
+    output("  <merge key=\"input.x11_options.swapaxes\" type=\"string\">%d</merge>\n", new_swap_xy);
+    output("  <merge key=\"input.x11_options.invertx\" type=\"string\">%d</merge>\n", new_invert_x);
+    output("  <merge key=\"input.x11_options.inverty\" type=\"string\">%d</merge>\n", new_invert_y);
+    output("</match>\n");
 
     if (not_sysfs_name)
-        printf("\nChange '%s' to your device's name in the config above.\n", sysfs_name);
+        info ("\nChange '%s' to your device's name in the config above.\n", sysfs_name);
 
     return true;
 }
 
-bool CalibratorEvdev::output_xinput(const XYinfo new_axys, int swap_xy, int new_swap_xy)
+bool CalibratorEvdev::output_xinput(const XYinfo new_axys, int new_swap_xy, int new_invert_x, int new_invert_y)
 {
     // create startup script
-    printf("  Install the 'xinput' tool and copy the command(s) below in a script that starts with your X session\n");
-    printf("    xinput set-int-prop \"%s\" \"Evdev Axis Calibration\" 32 %d %d %d %d\n", device_name, new_axys.x_min, new_axys.x_max, new_axys.y_min, new_axys.y_max);
-    if (swap_xy)
-        printf("    xinput set-int-prop \"%s\" \"Evdev Axes Swap\" 8 %d\n", device_name, new_swap_xy);
+    info ("  Install the 'xinput' tool and copy the command(s) below in a script that starts with your X session\n");
+    output ("    xinput set-prop \"%s\" \"Evdev Axis Calibration\" %d %d %d %d\n", device_name, new_axys.x.min, new_axys.x.max, new_axys.y.min, new_axys.y.max);
 
+    output ("    xinput set-prop \"%s\" \"Evdev Axes Swap\" %d\n", device_name, new_swap_xy);
+    output ("    xinput set-prop \"%s\" \"Evdev Axis Inversion\" %d %d\n", device_name, new_invert_x, new_invert_y);
     return true;
 }

--- a/src/calibrator/Evdev.hpp
+++ b/src/calibrator/Evdev.hpp
@@ -35,29 +35,29 @@ class CalibratorEvdev: public Calibrator
 {
 private:
     Display     *display;
-    XDeviceInfo *info;
+    XDeviceInfo *devInfo;
     XDevice     *dev;
 
-    int old_swap_xy;
 public:
-    CalibratorEvdev(const char* const device_name, const XYinfo& axys, const bool verbose,
+    CalibratorEvdev(const char* const device_name, const XYinfo& axys,
         XID device_id=(XID)-1, const int thr_misclick=0, const int thr_doubleclick=0,
         const OutputType output_type=OUTYPE_AUTO, const char* geometry=0);
     ~CalibratorEvdev();
 
-    virtual bool finish_data(const XYinfo new_axys, int swap_xy);
+    virtual bool finish_data(const XYinfo new_axys);
 
     bool set_swapxy(const int swap_xy);
+    bool set_invert_xy(bool axisX, const int invert_x, const int invert_y );
     bool set_calibration(const XYinfo new_axys);
 
     // xinput_ functions (from the xinput project)
     Atom xinput_parse_atom(Display *display, const char* name);
     XDeviceInfo* xinput_find_device_info(Display *display, const char* name, Bool only_extended);
-    int xinput_do_set_prop(Display *display, Atom type, int format, int argc, char* argv[]);
+    int xinput_do_set_prop(Display *display, Atom type, int format, int argc, const char** argv);
 protected:
-    bool output_xorgconfd(const XYinfo new_axys, int swap_xy, int new_swap_xy);
-    bool output_hal(const XYinfo new_axys, int swap_xy, int new_swap_xy);
-    bool output_xinput(const XYinfo new_axys, int swap_xy, int new_swap_xy);
+    bool output_xorgconfd(const XYinfo new_axys, int new_swap_xy, int new_invert_x, int new_invert_y);
+    bool output_hal(const XYinfo new_axys, int new_swap_xy, int new_invert_x, int new_invert_y);
+    bool output_xinput(const XYinfo new_axys, int new_swap_xy, int new_invert_x, int new_invert_y);
 };
 
 #endif

--- a/src/calibrator/Usbtouchscreen.cpp
+++ b/src/calibrator/Usbtouchscreen.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2009 Soren Hauberg
+ * Copyright (c) 2011 Antoine Hue
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -48,67 +49,67 @@ static const char *p_flip_x = "flip_x";
 static const char *p_flip_y = "flip_y";
 static const char *p_swap_xy = "swap_xy";
 
-CalibratorUsbtouchscreen::CalibratorUsbtouchscreen(const char* const device_name0, const XYinfo& axys0, const bool verbose0, const int thr_misclick, const int thr_doubleclick, const OutputType output_type, const char* geometry)
-  : Calibrator(device_name0, axys0, verbose0, thr_misclick, thr_doubleclick, output_type, geometry)
+CalibratorUsbtouchscreen::CalibratorUsbtouchscreen(const char* const device_name0, const XYinfo& axys0, const int thr_misclick, const int thr_doubleclick, const OutputType output_type, const char* geometry)
+  : Calibrator(device_name0, axys0, thr_misclick, thr_doubleclick, output_type, geometry)
 {
     if (strcmp(device_name, "Usbtouchscreen") != 0)
         throw WrongCalibratorException("Not a usbtouchscreen device");
 
     // 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);
+    read_bool_parameter(p_flip_x, old_axys.x.invert);
+    read_bool_parameter(p_flip_y, old_axys.y.invert);
+    read_bool_parameter(p_swap_xy, old_axys.swap_xy);
 
+#if 0 // do not modify current
     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);
-
-    printf("Calibrating Usbtouchscreen, through the kernel module\n");
+#endif
+    info ("Calibrating Usbtouchscreen, through the kernel module\n");
 }
 
 CalibratorUsbtouchscreen::~CalibratorUsbtouchscreen()
 {
+#if 0 // do not modify current
     // 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);
+#endif
 }
 
-bool CalibratorUsbtouchscreen::finish_data(const XYinfo new_axys, int swap_xy)
+bool CalibratorUsbtouchscreen::finish_data(const XYinfo new_axys)
 {
     if (output_type != OUTYPE_AUTO) {
-        fprintf(stderr, "ERROR: Usbtouchscreen Calibrator does not support the supplied --output-type\n");
+        error ("Usbtouchscreen Calibrator does not support the supplied --output-type\n");
         return false;
     }
 
     // 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);
+    const int range_x = (new_axys.x.max - new_axys.x.min);
+    const int range_y = (new_axys.y.max - new_axys.y.min);
 
     // 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_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);
+    write_bool_parameter(p_flip_x, new_axys.x.invert);
+    write_bool_parameter(p_flip_y, new_axys.y.invert);
+    write_bool_parameter(p_swap_xy, new_axys.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 necessary rights\n", modprobe_conf_local);
-        fprintf(stderr, "New calibration data NOT saved\n");
+        error ( "Can't open '%s' for reading. Make sure you have the necessary rights\n", modprobe_conf_local);
+        error ( "\tNew calibration data NOT saved\n");
         return false;
     }
 
@@ -129,16 +130,16 @@ bool CalibratorUsbtouchscreen::finish_data(const XYinfo new_axys, int swap_xy)
     char *new_opt = new char[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));
+         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(new_axys.x.invert),
+         p_flip_y, yesno(new_axys.y.invert), p_swap_xy, yesno(new_axys.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 necessary rights\n", modprobe_conf_local);
-        fprintf(stderr, "New calibration data NOT saved\n");
+        error ( "Can't open '%s' for writing. Make sure you have the necessary rights\n", modprobe_conf_local);
+        error ( "\tNew calibration data NOT saved\n");
         return false;
     }
     fprintf(fid, "%s", new_contents.c_str ());
@@ -154,7 +155,7 @@ void CalibratorUsbtouchscreen::read_int_parameter(const char *param, int &value)
         sprintf(filename, "%s/%s", module_prefix, param);
         FILE *fid = fopen(filename, "r");
         if (fid == NULL) {
-            fprintf(stderr, "Could not read parameter '%s'\n", param);
+            error ( "Could not read parameter '%s'\n", param);
             return;
         }
 
@@ -169,7 +170,7 @@ void CalibratorUsbtouchscreen::read_int_parameter(const char *param, int &value)
         sprintf(filename, "%s/%s", module_prefix, param);
         FILE *fid = fopen(filename, "r");
         if (fid == NULL) {
-            fprintf(stderr, "Could not read parameter '%s'\n", param);
+            error ( "Could not read parameter '%s'\n", param);
             return;
         }
 
@@ -186,7 +187,7 @@ void CalibratorUsbtouchscreen::read_int_parameter(const char *param, int &value)
         sprintf(filename, "%s/%s", module_prefix, param);
         FILE *fid = fopen(filename, "w");
         if (fid == NULL) {
-            fprintf(stderr, "Could not save parameter '%s'\n", param);
+            error ( "Could not save parameter '%s'\n", param);
             return;
         }
 
@@ -200,7 +201,7 @@ void CalibratorUsbtouchscreen::write_bool_parameter(const char *param, const boo
         sprintf(filename, "%s/%s", module_prefix, param);
         FILE *fid = fopen(filename, "w");
         if (fid == NULL) {
-            fprintf(stderr, "Could not save parameter '%s'\n", param);
+            error ("Could not save parameter '%s'\n", param);
             return;
         }
 

--- a/src/calibrator/Usbtouchscreen.hpp
+++ b/src/calibrator/Usbtouchscreen.hpp
@@ -33,19 +33,19 @@ class CalibratorUsbtouchscreen: public Calibrator
 {
 public:
     CalibratorUsbtouchscreen(const char* const device_name, const XYinfo& axys,
-        const bool verbose, const int thr_misclick=0, const int thr_doubleclick=0,
+         const int thr_misclick=0, const int thr_doubleclick=0,
         const OutputType output_type=OUTYPE_AUTO, const char* geometry=0);
     ~CalibratorUsbtouchscreen();
 
-    virtual bool finish_data(const XYinfo new_axys, int swap_xy);
+    virtual bool finish_data(const XYinfo new_axys);
 
 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;
+    bool val_transform_xy;
 
     // Helper functions
-    char yesno(const bool value)
+    inline char yesno(const bool value)
     {
         if (value)
             return 'Y';

--- a/src/calibrator/XorgPrint.cpp
+++ b/src/calibrator/XorgPrint.cpp
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2009 Tias Guns
+ * Copyright (c) 2011 Antoine Hue
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,48 +25,50 @@
 
 #include <cstdio>
 
-CalibratorXorgPrint::CalibratorXorgPrint(const char* const device_name0, const XYinfo& axys0, const bool verbose0, const int thr_misclick, const int thr_doubleclick, const OutputType output_type, const char* geometry)
-  : Calibrator(device_name0, axys0, verbose0, thr_misclick, thr_doubleclick, output_type, geometry)
+CalibratorXorgPrint::CalibratorXorgPrint(const char* const device_name0, const XYinfo& axys0, const int thr_misclick, const int thr_doubleclick, const OutputType output_type, const char* geometry)
+  : Calibrator(device_name0, axys0, thr_misclick, thr_doubleclick, output_type, geometry)
 {
-    printf("Calibrating standard Xorg driver \"%s\"\n", device_name);
-    printf("\tcurrent calibration values: 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);
-    printf("\tIf these values are estimated wrong, either supply it manually with the --precalib option, or run the 'get_precalib.sh' script to automatically get it (through HAL).\n");
+    trace("Calibrating standard Xorg driver \"%s\"\n", device_name);
+    trace("\tcurrent calibration values: 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);
+    trace("\tIf these values are estimated wrong, either supply it manually with the --precalib option, or run the 'get_precalib.sh' script to automatically get it (through HAL).\n");
 }
 
-bool CalibratorXorgPrint::finish_data(const XYinfo new_axys, int swap_xy)
+bool CalibratorXorgPrint::finish_data(const XYinfo new_axys)
 {
     bool success = true;
 
-    // we suppose the previous 'swap_xy' value was 0
+    // we suppose the previous 'swap_xy', 'invert_x', 'invert_y' value was 0
     // (unfortunately there is no way to verify this (yet))
-    int new_swap_xy = swap_xy;
+    int new_swap_xy = (new_axys.swap_xy)? 1: 0;
+    int new_invert_x = (new_axys.x.invert)? 1: 0;
+    int new_invert_y = (new_axys.y.invert)? 1: 0;
 
-    printf("\n\n--> Making the calibration permanent <--\n");
+    info ("\t--> Making the calibration permanent <--\n");
     switch (output_type) {
         case OUTYPE_AUTO:
             // xorg.conf.d or alternatively hal config
             if (has_xorgconfd_support()) {
-                success &= output_xorgconfd(new_axys, swap_xy, new_swap_xy);
+                success &= output_xorgconfd(new_axys, new_swap_xy, new_invert_x, new_invert_y);
             } else {
-                success &= output_hal(new_axys, swap_xy, new_swap_xy);
+                success &= output_hal(new_axys, new_swap_xy, new_invert_x, new_invert_y);
             }
             break;
         case OUTYPE_XORGCONFD:
-            success &= output_xorgconfd(new_axys, swap_xy, new_swap_xy);
+            success &= output_xorgconfd(new_axys, new_swap_xy, new_invert_x, new_invert_y);
             break;
         case OUTYPE_HAL:
-            success &= output_hal(new_axys, swap_xy, new_swap_xy);
+            success &= output_hal(new_axys, new_swap_xy, new_invert_x, new_invert_y);
             break;
         default:
-            fprintf(stderr, "ERROR: XorgPrint Calibrator does not support the supplied --output-type\n");
+            error ( "XorgPrint Calibrator does not support the supplied --output-type\n");
             success = false;
     }
 
     return success;
 }
 
-bool CalibratorXorgPrint::output_xorgconfd(const XYinfo new_axys, int swap_xy, int new_swap_xy)
+bool CalibratorXorgPrint::output_xorgconfd(const XYinfo new_axys, int new_swap_xy, int new_invert_x, int new_invert_y)
 {
     const char* sysfs_name = get_sysfs_name();
     bool not_sysfs_name = (sysfs_name == NULL);
@@ -73,25 +76,26 @@ bool CalibratorXorgPrint::output_xorgconfd(const XYinfo new_axys, int swap_xy, i
         sysfs_name = "!!Name_Of_TouchScreen!!";
 
     // xorg.conf.d snippet
-    printf("  copy the snippet below into '/etc/X11/xorg.conf.d/99-calibration.conf'\n");
-    printf("Section \"InputClass\"\n");
-    printf("	Identifier	\"calibration\"\n");
-    printf("	MatchProduct	\"%s\"\n", sysfs_name);
-    printf("	Option	\"MinX\"	\"%d\"\n", new_axys.x_min);
-    printf("	Option	\"MaxX\"	\"%d\"\n", new_axys.x_max);
-    printf("	Option	\"MinY\"	\"%d\"\n", new_axys.y_min);
-    printf("	Option	\"MaxY\"	\"%d\"\n", new_axys.y_max);
-    if (swap_xy != 0)
-        printf("	Option	\"SwapXY\"	\"%d\" # unless it was already set to 1\n", new_swap_xy);
-    printf("EndSection\n");
+    info ("  copy the snippet below into '/etc/X11/xorg.conf.d/99-calibration.conf'\n");
+    output("Section \"InputClass\"\n");
+    output("	Identifier	 \"calibration\"\n");
+    output("	MatchProduct	\"%s\"\n", sysfs_name);
+    output("	Option	\"MinX\"	\"%d\"\n", new_axys.x.min);
+    output("	Option	\"MaxX\"	\"%d\"\n", new_axys.x.max);
+    output("	Option	\"MinY\"	\"%d\"\n", new_axys.y.min);
+    output("	Option	\"MaxY\"	\"%d\"\n", new_axys.y.max);
+    output("	Option	\"SwapXY\"	\"%d\" # unless it was already set\n", new_swap_xy);
+    output("	Option	\"InvertX\"	\"%d\"  # unless it was already set\n", new_invert_x);
+    output("	Option	\"InvertY\"	\"%d\"  # unless it was already set\n", new_invert_y);
+    output("EndSection\n");
 
     if (not_sysfs_name)
-        printf("\nChange '%s' to your device's name in the config above.\n", sysfs_name);
+        trace("Change '%s' to your device's name in the config above.\n", sysfs_name);
 
     return true;
 }
 
-bool CalibratorXorgPrint::output_hal(const XYinfo new_axys, int swap_xy, int new_swap_xy)
+bool CalibratorXorgPrint::output_hal(const XYinfo new_axys, int new_swap_xy, int new_invert_x, int new_invert_y)
 {
     const char* sysfs_name = get_sysfs_name();
     bool not_sysfs_name = (sysfs_name == NULL);
@@ -99,19 +103,21 @@ bool CalibratorXorgPrint::output_hal(const XYinfo new_axys, int swap_xy, int new
         sysfs_name = "!!Name_Of_TouchScreen!!";
 
     // HAL policy output
-    printf("  copy the policy below into '/etc/hal/fdi/policy/touchscreen.fdi'\n\
-<match key=\"info.product\" contains=\"%s\">\n\
-  <merge key=\"input.x11_options.minx\" type=\"string\">%d</merge>\n\
-  <merge key=\"input.x11_options.maxx\" type=\"string\">%d</merge>\n\
-  <merge key=\"input.x11_options.miny\" type=\"string\">%d</merge>\n\
-  <merge key=\"input.x11_options.maxy\" type=\"string\">%d</merge>\n"
-     , sysfs_name, 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", new_swap_xy);
-    printf("</match>\n");
+    info ("  copy the policy below into '/etc/hal/fdi/policy/touchscreen.fdi'\n");
+    output ( "<match key=\"info.product\" contains=\"%s\">\n\
+    <merge key=\"input.x11_options.minx\" type=\"string\">%d</merge>\n\
+    <merge key=\"input.x11_options.maxx\" type=\"string\">%d</merge>\n\
+    <merge key=\"input.x11_options.miny\" type=\"string\">%d</merge>\n\
+    <merge key=\"input.x11_options.maxy\" type=\"string\">%d</merge>\n"
+    , sysfs_name, new_axys.x.min, new_axys.x.max, new_axys.y.min, new_axys.y.max);
+
+    output("  <merge key=\"input.x11_options.swapxy\" type=\"string\">%d</merge>\n", new_swap_xy);
+    output("  <merge key=\"input.x11_options.invertx\" type=\"string\">%d</merge>\n", new_invert_x);
+    output("  <merge key=\"input.x11_options.inverty\" type=\"string\">%d</merge>\n", new_invert_y);
+    output("</match>\n");
 
     if (not_sysfs_name)
-        printf("\nChange '%s' to your device's name in the config above.\n", sysfs_name);
+        info("\nChange '%s' to your device's name in the config above.\n", sysfs_name);
 
     return true;
 }

--- a/src/calibrator/XorgPrint.hpp
+++ b/src/calibrator/XorgPrint.hpp
@@ -33,13 +33,14 @@ class CalibratorXorgPrint: public Calibrator
 {
 public:
     CalibratorXorgPrint(const char* const device_name, const XYinfo& axys,
-        const bool verbose, const int thr_misclick=0, const int thr_doubleclick=0,
+        const int thr_misclick=0, const int thr_doubleclick=0,
         const OutputType output_type=OUTYPE_AUTO, const char* geometry=0);
 
-    virtual bool finish_data(const XYinfo new_axys, int swap_xy);
+    virtual bool finish_data(const XYinfo new_axys);
+
 protected:
-    bool output_xorgconfd(const XYinfo new_axys, int swap_xy, int new_swap_xy);
-    bool output_hal(const XYinfo new_axys, int swap_xy, int new_swap_xy);
+    bool output_xorgconfd(const XYinfo new_axys, int new_swap_xy, int new_invert_x, int new_invert_y);
+    bool output_hal(const XYinfo new_axys, int new_swap_xy, int new_invert_x, int new_invert_y);
 };
 
 #endif

--- a/src/main_common.cpp
+++ b/src/main_common.cpp
@@ -54,7 +54,7 @@ static char* my_strdup(const char* s) {
  * retuns number of devices found,
  * the data of the device is returned in the last 3 function parameters
  */
-static int find_device(const char* pre_device, bool verbose, bool list_devices,
+int Calibrator::find_device(const char* pre_device, bool list_devices,
         XID& device_id, const char*& device_name, XYinfo& device_axys)
 {
     bool pre_device_is_id = true;
@@ -62,13 +62,13 @@ static int find_device(const char* pre_device, bool verbose, bool list_devices,
 
     Display* display = XOpenDisplay(NULL);
     if (display == NULL) {
-        fprintf(stderr, "Unable to connect to X server\n");
+        error ( "Unable to connect to X server\n");
         exit(1);
     }
 
-    int xi_opcode, event, error;
-    if (!XQueryExtension(display, "XInputExtension", &xi_opcode, &event, &error)) {
-        fprintf(stderr, "X Input extension not available.\n");
+    int xi_opcode, event, err;
+    if (!XQueryExtension(display, "XInputExtension", &xi_opcode, &event, &err)) {
+        error ( "X Input extension not available.\n");
         exit(1);
     }
 
@@ -77,7 +77,7 @@ static int find_device(const char* pre_device, bool verbose, bool list_devices,
         XExtensionVersion *version = XGetExtensionVersion(display, INAME);
 
         if (version && (version != (XExtensionVersion*) NoSuchExtension)) {
-            printf("DEBUG: %s version is %i.%i\n",
+            trace ("%s version is %i.%i\n",
                 INAME, version->major_version, version->minor_version);
             XFree(version);
         }
@@ -94,9 +94,7 @@ static int find_device(const char* pre_device, bool verbose, bool list_devices,
         }
     }
 
-
-    if (verbose)
-        printf("DEBUG: Skipping virtual master devices and devices without axis valuators.\n");
+    trace ("Skipping virtual master devices and devices without axis valuators.\n");
     int ndevices;
     XDeviceInfoPtr list, slist;
     slist=list=(XDeviceInfoPtr) XListInputDevices (display, &ndevices);
@@ -126,27 +124,25 @@ static int find_device(const char* pre_device, bool verbose, bool list_devices,
                 XAxisInfoPtr ax = (XAxisInfoPtr) V->axes;
 
                 if (V->mode != Absolute) {
-                    if (verbose)
-                        printf("DEBUG: Skipping device '%s' id=%i, does not report Absolute events.\n",
+                    trace ( "Skipping device '%s' id=%i, does not report Absolute events.\n",
                             list->name, (int)list->id);
                 } else 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)) {
-                    if (verbose)
-                        printf("DEBUG: Skipping device '%s' id=%i, does not have two calibratable axes.\n",
+                    trace ( "Skipping device '%s' id=%i, does not have two calibratable axes.\n",
                             list->name, (int)list->id);
                 } else {
                     /* a calibratable device (has 2 axis valuators) */
                     found++;
                     device_id = list->id;
                     device_name = my_strdup(list->name);
-                    device_axys.x_min = ax[0].min_value;
-                    device_axys.x_max = ax[0].max_value;
-                    device_axys.y_min = ax[1].min_value;
-                    device_axys.y_max = ax[1].max_value;
+                    device_axys.x.min = ax[0].min_value;
+                    device_axys.x.max = ax[0].max_value;
+                    device_axys.y.min = ax[1].min_value;
+                    device_axys.y.max = ax[1].max_value;
 
                     if (list_devices)
-                        printf("Device \"%s\" id=%i\n", device_name, (int)device_id);
+                        info ("Device \"%s\" id=%i\n", device_name, (int)device_id);
                 }
 
             }
@@ -183,7 +179,6 @@ static void usage(char* cmd, unsigned thr_misclick)
 
 Calibrator* Calibrator::make_calibrator(int argc, char** argv)
 {
-    bool verbose = false;
     bool list_devices = false;
     bool fake = false;
     bool precalib = false;
@@ -200,7 +195,7 @@ Calibrator* Calibrator::make_calibrator(int argc, char** argv)
             // Display help ?
             if (strcmp("-h", argv[i]) == 0 ||
                 strcmp("--help", argv[i]) == 0) {
-                fprintf(stderr, "xinput_calibrator, v%s\n\n", VERSION);
+                error ( "xinput_calibrator, v%s\n\n", VERSION);
                 usage(argv[0], thr_misclick);
                 exit(0);
             } else
@@ -221,7 +216,7 @@ Calibrator* Calibrator::make_calibrator(int argc, char** argv)
                 if (argc > i+1)
                     pre_device = argv[++i];
                 else {
-                    fprintf(stderr, "Error: --device needs a device name or id as argument; use --list to list the calibratable input devices.\n\n");
+                    error( "--device needs a device name or id as argument; use --list to list the calibratable input devices.\n\n");
                     usage(argv[0], thr_misclick);
                     exit(1);
                 }
@@ -231,13 +226,13 @@ Calibrator* Calibrator::make_calibrator(int argc, char** argv)
             if (strcmp("--precalib", argv[i]) == 0) {
                 precalib = true;
                 if (argc > i+1)
-                    pre_axys.x_min = atoi(argv[++i]);
+                    pre_axys.x.min = atoi(argv[++i]);
                 if (argc > i+1)
-                    pre_axys.x_max = atoi(argv[++i]);
+                    pre_axys.x.max = atoi(argv[++i]);
                 if (argc > i+1)
-                    pre_axys.y_min = atoi(argv[++i]);
+                    pre_axys.y.min = atoi(argv[++i]);
                 if (argc > i+1)
-                    pre_axys.y_max = atoi(argv[++i]);
+                    pre_axys.y.max = atoi(argv[++i]);
             } else
 
             // Get mis-click threshold ?
@@ -245,7 +240,7 @@ Calibrator* Calibrator::make_calibrator(int argc, char** argv)
                 if (argc > i+1)
                     thr_misclick = atoi(argv[++i]);
                 else {
-                    fprintf(stderr, "Error: --misclick needs a number (the pixel threshold) as argument. Set to 0 to disable mis-click detection.\n\n");
+                    error ( "--misclick needs a number (the pixel threshold) as argument. Set to 0 to disable mis-click detection.\n\n");
                     usage(argv[0], thr_misclick);
                     exit(1);
                 }
@@ -264,12 +259,12 @@ Calibrator* Calibrator::make_calibrator(int argc, char** argv)
                     else if (strcmp("xinput", argv[i]) == 0)
                         output_type = OUTYPE_XINPUT;
                     else {
-                        fprintf(stderr, "Error: --output-type needs one of auto|xorg.conf.d|hal|xinput.\n\n");
+                        error ( "--output-type needs one of auto|xorg.conf.d|hal|xinput.\n\n");
                         usage(argv[0], thr_misclick);
                         exit(1);
                     }
                 } else {
-                    fprintf(stderr, "Error: --output-type needs one argument.\n\n");
+                    error ( "--output-type needs one argument.\n\n");
                     usage(argv[0], thr_misclick);
                     exit(1);
                 }
@@ -304,18 +299,16 @@ Calibrator* Calibrator::make_calibrator(int argc, char** argv)
         device_name = "Fake_device";
         device_axys = XYinfo(0,1000,0,1000);
 
-        if (verbose) {
-            printf("DEBUG: Faking device: %s\n", device_name);
-        }
+        trace ("Faking device: %s\n", device_name);
     } else {
         // Find the right device
-        int nr_found = find_device(pre_device, verbose, list_devices, device_id, device_name, device_axys);
+        int nr_found = find_device(pre_device, list_devices, device_id, device_name, device_axys);
 
         if (list_devices) {
             // printed the list in find_device
             if (nr_found == 0)
                 printf("No calibratable devices found.\n");
-            exit(0);
+            exit(2);
         }
 
         if (nr_found == 0) {
@@ -326,30 +319,26 @@ Calibrator* Calibrator::make_calibrator(int argc, char** argv)
             exit(1);
 
         } else if (nr_found > 1) {
-            printf ("Warning: multiple calibratable devices found, calibrating last one (%s)\n\tuse --device to select another one.\n", device_name);
+            info ("Warning: multiple calibratable devices found, calibrating last one (%s)\n\tuse --device to select another one.\n", device_name);
         }
 
-        if (verbose) {
-            printf("DEBUG: Selected device: %s\n", device_name);
-        }
+        trace ("Selected device: %s\n", device_name);
     }
 
     // override min/max XY from command line ?
     if (precalib) {
-        if (pre_axys.x_min != -1)
-            device_axys.x_min = pre_axys.x_min;
-        if (pre_axys.x_max != -1)
-            device_axys.x_max = pre_axys.x_max;
-        if (pre_axys.y_min != -1)
-            device_axys.y_min = pre_axys.y_min;
-        if (pre_axys.y_max != -1)
-            device_axys.y_max = pre_axys.y_max;
-
-        if (verbose) {
-            printf("DEBUG: Setting precalibration: %i, %i, %i, %i\n",
-                device_axys.x_min, device_axys.x_max,
-                device_axys.y_min, device_axys.y_max);
-        }
+        if (pre_axys.x.min != -1)
+            device_axys.x.min = pre_axys.x.min;
+        if (pre_axys.x.max != -1)
+            device_axys.x.max = pre_axys.x.max;
+        if (pre_axys.y.min != -1)
+            device_axys.y.min = pre_axys.y.min;
+        if (pre_axys.y.max != -1)
+            device_axys.y.max = pre_axys.y.max;
+
+        trace ( "Setting precalibration: %i, %i, %i, %i\n",
+                device_axys.x.min, device_axys.x.max,
+                device_axys.y.min, device_axys.y.max);
     }
 
 
@@ -357,24 +346,22 @@ Calibrator* Calibrator::make_calibrator(int argc, char** argv)
     try {
         // try Usbtouchscreen driver
         return new CalibratorUsbtouchscreen(device_name, device_axys,
-            verbose, thr_misclick, thr_doubleclick, output_type, geometry);
+             thr_misclick, thr_doubleclick, output_type, geometry);
 
     } catch(WrongCalibratorException& x) {
-        if (verbose)
-            printf("DEBUG: Not usbtouchscreen calibrator: %s\n", x.what());
+        trace("Not usbtouchscreen calibrator: %s\n", x.what());
     }
 
     try {
         // next, try Evdev driver (with XID)
-        return new CalibratorEvdev(device_name, device_axys, verbose, device_id,
+        return new CalibratorEvdev(device_name, device_axys, device_id,
             thr_misclick, thr_doubleclick, output_type, geometry);
 
     } catch(WrongCalibratorException& x) {
-        if (verbose)
-            printf("DEBUG: Not evdev calibrator: %s\n", x.what());
+        trace ("Not evdev calibrator: %s\n", x.what());
     }
 
     // lastly, presume a standard Xorg driver (evtouch, mutouch, ...)
     return new CalibratorXorgPrint(device_name, device_axys,
-            verbose, thr_misclick, thr_doubleclick, output_type, geometry);
+            thr_misclick, thr_doubleclick, output_type, geometry);
 }