Indent consistently

x-indent-all.sh from xorg/util/modular as of
c2d630fab65dbe3409af3947f6f442782ddb026f

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
Reviewed-by: Chase Douglas <chase.douglas@canonical.com>

2 files changed, 732 insertions, 662 deletions

diff --git a/tools/synclient.c b/tools/synclient.c
index 6c8ee7a..6ff3aa6 100644
--- a/tools/synclient.c
+++ b/tools/synclient.c
@@ -51,12 +51,11 @@
 #define XATOM_FLOAT "FLOAT"
 #endif
 
-union flong { /* Xlibs 64-bit property handling madness */
+union flong {                   /* Xlibs 64-bit property handling madness */
     long l;
     float f;
 };
 
-
 enum ParaType {
     PT_INT,
     PT_BOOL,
@@ -64,155 +63,201 @@ enum ParaType {
 };
 
 struct Parameter {
-    char *name;				    /* Name of parameter */
-    enum ParaType type;			    /* Type of parameter */
-    double min_val;			    /* Minimum allowed value */
-    double max_val;			    /* Maximum allowed value */
-    char *prop_name;			    /* Property name */
-    int prop_format;			    /* Property format (0 for floats) */
-    int prop_offset;			    /* Offset inside property */
+    char *name;                 /* Name of parameter */
+    enum ParaType type;         /* Type of parameter */
+    double min_val;             /* Minimum allowed value */
+    double max_val;             /* Maximum allowed value */
+    char *prop_name;            /* Property name */
+    int prop_format;            /* Property format (0 for floats) */
+    int prop_offset;            /* Offset inside property */
 };
 
 static struct Parameter params[] = {
-    {"LeftEdge",              PT_INT,    0, 10000, SYNAPTICS_PROP_EDGES,	32,	0},
-    {"RightEdge",             PT_INT,    0, 10000, SYNAPTICS_PROP_EDGES,	32,	1},
-    {"TopEdge",               PT_INT,    0, 10000, SYNAPTICS_PROP_EDGES,	32,	2},
-    {"BottomEdge",            PT_INT,    0, 10000, SYNAPTICS_PROP_EDGES,	32,	3},
-    {"FingerLow",             PT_INT,    0, 255,   SYNAPTICS_PROP_FINGER,	32,	0},
-    {"FingerHigh",            PT_INT,    0, 255,   SYNAPTICS_PROP_FINGER,	32,	1},
-    {"FingerPress",           PT_INT,    0, 256,   SYNAPTICS_PROP_FINGER,	32,	2},
-    {"MaxTapTime",            PT_INT,    0, 1000,  SYNAPTICS_PROP_TAP_TIME,	32,	0},
-    {"MaxTapMove",            PT_INT,    0, 2000,  SYNAPTICS_PROP_TAP_MOVE,	32,	0},
-    {"MaxDoubleTapTime",      PT_INT,    0, 1000,  SYNAPTICS_PROP_TAP_DURATIONS,32,	1},
-    {"SingleTapTimeout",      PT_INT,    0, 1000,  SYNAPTICS_PROP_TAP_DURATIONS,32,	0},
-    {"ClickTime",             PT_INT,    0, 1000,  SYNAPTICS_PROP_TAP_DURATIONS,32,	2},
-    {"FastTaps",              PT_BOOL,   0, 1,     SYNAPTICS_PROP_TAP_FAST,	8,	0},
-    {"EmulateMidButtonTime",  PT_INT,    0, 1000,  SYNAPTICS_PROP_MIDDLE_TIMEOUT,32,	0},
-    {"EmulateTwoFingerMinZ",  PT_INT,    0, 1000,  SYNAPTICS_PROP_TWOFINGER_PRESSURE,	32,	0},
-    {"EmulateTwoFingerMinW",  PT_INT,    0, 15,    SYNAPTICS_PROP_TWOFINGER_WIDTH,	32,	0},
-    {"VertScrollDelta",       PT_INT,    -1000, 1000,  SYNAPTICS_PROP_SCROLL_DISTANCE,	32,	0},
-    {"HorizScrollDelta",      PT_INT,    -1000, 1000,  SYNAPTICS_PROP_SCROLL_DISTANCE,	32,	1},
-    {"VertEdgeScroll",        PT_BOOL,   0, 1,     SYNAPTICS_PROP_SCROLL_EDGE,	8,	0},
-    {"HorizEdgeScroll",       PT_BOOL,   0, 1,     SYNAPTICS_PROP_SCROLL_EDGE,	8,	1},
-    {"CornerCoasting",        PT_BOOL,   0, 1,     SYNAPTICS_PROP_SCROLL_EDGE,	8,	2},
-    {"VertTwoFingerScroll",   PT_BOOL,   0, 1,     SYNAPTICS_PROP_SCROLL_TWOFINGER,	8,	0},
-    {"HorizTwoFingerScroll",  PT_BOOL,   0, 1,     SYNAPTICS_PROP_SCROLL_TWOFINGER,	8,	1},
-    {"MinSpeed",              PT_DOUBLE, 0, 255.0,   SYNAPTICS_PROP_SPEED,	0, /*float */	0},
-    {"MaxSpeed",              PT_DOUBLE, 0, 255.0,   SYNAPTICS_PROP_SPEED,	0, /*float */	1},
-    {"AccelFactor",           PT_DOUBLE, 0, 1.0,   SYNAPTICS_PROP_SPEED,	0, /*float */	2},
-    {"TrackstickSpeed",       PT_DOUBLE, 0, 200.0, SYNAPTICS_PROP_SPEED,	0, /*float */ 3},
-    {"EdgeMotionMinZ",        PT_INT,    1, 255,   SYNAPTICS_PROP_EDGEMOTION_PRESSURE,  32,	0},
-    {"EdgeMotionMaxZ",        PT_INT,    1, 255,   SYNAPTICS_PROP_EDGEMOTION_PRESSURE,  32,	1},
-    {"EdgeMotionMinSpeed",    PT_INT,    0, 1000,  SYNAPTICS_PROP_EDGEMOTION_SPEED,     32,	0},
-    {"EdgeMotionMaxSpeed",    PT_INT,    0, 1000,  SYNAPTICS_PROP_EDGEMOTION_SPEED,     32,	1},
-    {"EdgeMotionUseAlways",   PT_BOOL,   0, 1,     SYNAPTICS_PROP_EDGEMOTION,   8,	0},
-    {"UpDownScrolling",       PT_BOOL,   0, 1,     SYNAPTICS_PROP_BUTTONSCROLLING,  8,	0},
-    {"LeftRightScrolling",    PT_BOOL,   0, 1,     SYNAPTICS_PROP_BUTTONSCROLLING,  8,	1},
-    {"UpDownScrollRepeat",    PT_BOOL,   0, 1,     SYNAPTICS_PROP_BUTTONSCROLLING_REPEAT,   8,	0},
-    {"LeftRightScrollRepeat", PT_BOOL,   0, 1,     SYNAPTICS_PROP_BUTTONSCROLLING_REPEAT,   8,	1},
-    {"ScrollButtonRepeat",    PT_INT,    SBR_MIN , SBR_MAX, SYNAPTICS_PROP_BUTTONSCROLLING_TIME, 32,	0},
-    {"TouchpadOff",           PT_INT,    0, 2,     SYNAPTICS_PROP_OFF,		8,	0},
-    {"LockedDrags",           PT_BOOL,   0, 1,     SYNAPTICS_PROP_LOCKED_DRAGS,	8,	0},
-    {"LockedDragTimeout",     PT_INT,    0, 30000, SYNAPTICS_PROP_LOCKED_DRAGS_TIMEOUT,	32,	0},
-    {"RTCornerButton",        PT_INT,    0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION,	8,	0},
-    {"RBCornerButton",        PT_INT,    0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION,	8,	1},
-    {"LTCornerButton",        PT_INT,    0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION,	8,	2},
-    {"LBCornerButton",        PT_INT,    0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION,	8,	3},
-    {"TapButton1",            PT_INT,    0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION,	8,	4},
-    {"TapButton2",            PT_INT,    0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION,	8,	5},
-    {"TapButton3",            PT_INT,    0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION,	8,	6},
-    {"ClickFinger1",          PT_INT,    0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_CLICK_ACTION,	8,	0},
-    {"ClickFinger2",          PT_INT,    0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_CLICK_ACTION,	8,	1},
-    {"ClickFinger3",          PT_INT,    0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_CLICK_ACTION,	8,	2},
-    {"CircularScrolling",     PT_BOOL,   0, 1,     SYNAPTICS_PROP_CIRCULAR_SCROLLING,	8,	0},
-    {"CircScrollDelta",       PT_DOUBLE, .01, 3,   SYNAPTICS_PROP_CIRCULAR_SCROLLING_DIST,	0 /* float */,	0},
-    {"CircScrollTrigger",     PT_INT,    0, 8,     SYNAPTICS_PROP_CIRCULAR_SCROLLING_TRIGGER,	8,	0},
-    {"CircularPad",           PT_BOOL,   0, 1,     SYNAPTICS_PROP_CIRCULAR_PAD,	8,	0},
-    {"PalmDetect",            PT_BOOL,   0, 1,     SYNAPTICS_PROP_PALM_DETECT,	8,	0},
-    {"PalmMinWidth",          PT_INT,    0, 15,    SYNAPTICS_PROP_PALM_DIMENSIONS,	32,	0},
-    {"PalmMinZ",              PT_INT,    0, 255,   SYNAPTICS_PROP_PALM_DIMENSIONS,	32,	1},
-    {"CoastingSpeed",         PT_DOUBLE, 0, 20,    SYNAPTICS_PROP_COASTING_SPEED,	0 /* float*/,	0},
-    {"CoastingFriction",      PT_DOUBLE, 0, 255,   SYNAPTICS_PROP_COASTING_SPEED,	0 /* float*/,	1},
-    {"PressureMotionMinZ",    PT_INT,    1, 255,   SYNAPTICS_PROP_PRESSURE_MOTION,	32,	0},
-    {"PressureMotionMaxZ",    PT_INT,    1, 255,   SYNAPTICS_PROP_PRESSURE_MOTION,	32,	1},
-    {"PressureMotionMinFactor", PT_DOUBLE, 0, 10.0,SYNAPTICS_PROP_PRESSURE_MOTION_FACTOR,	0 /*float*/,	0},
-    {"PressureMotionMaxFactor", PT_DOUBLE, 0, 10.0,SYNAPTICS_PROP_PRESSURE_MOTION_FACTOR,	0 /*float*/,	1},
-    {"GrabEventDevice",       PT_BOOL,   0, 1,     SYNAPTICS_PROP_GRAB,	8,	0},
-    {"TapAndDragGesture",     PT_BOOL,   0, 1,     SYNAPTICS_PROP_GESTURES,	8,	0},
-    {"AreaLeftEdge",          PT_INT,    0, 10000, SYNAPTICS_PROP_AREA,	32,	0},
-    {"AreaRightEdge",         PT_INT,    0, 10000, SYNAPTICS_PROP_AREA,	32,	1},
-    {"AreaTopEdge",           PT_INT,    0, 10000, SYNAPTICS_PROP_AREA,	32,	2},
-    {"AreaBottomEdge",        PT_INT,    0, 10000, SYNAPTICS_PROP_AREA,	32,	3},
-    {"HorizHysteresis",       PT_INT,    0, 10000, SYNAPTICS_PROP_NOISE_CANCELLATION, 32,	0},
-    {"VertHysteresis",        PT_INT,    0, 10000, SYNAPTICS_PROP_NOISE_CANCELLATION, 32,	1},
-    {"ClickPad",              PT_BOOL,   0, 1,     SYNAPTICS_PROP_CLICKPAD,	8,	0},
-    {"RightButtonAreaLeft",   PT_INT, INT_MIN, INT_MAX, SYNAPTICS_PROP_SOFTBUTTON_AREAS,	32,	0},
-    {"RightButtonAreaRight",  PT_INT, INT_MIN, INT_MAX, SYNAPTICS_PROP_SOFTBUTTON_AREAS,	32,	1},
-    {"RightButtonAreaTop",    PT_INT, INT_MIN, INT_MAX, SYNAPTICS_PROP_SOFTBUTTON_AREAS,	32,	2},
-    {"RightButtonAreaBottom", PT_INT, INT_MIN, INT_MAX, SYNAPTICS_PROP_SOFTBUTTON_AREAS,	32,	3},
-    {"MiddleButtonAreaLeft",  PT_INT, INT_MIN, INT_MAX, SYNAPTICS_PROP_SOFTBUTTON_AREAS,	32,	4},
-    {"MiddleButtonAreaRight", PT_INT, INT_MIN, INT_MAX, SYNAPTICS_PROP_SOFTBUTTON_AREAS,	32,	5},
-    {"MiddleButtonAreaTop",   PT_INT, INT_MIN, INT_MAX, SYNAPTICS_PROP_SOFTBUTTON_AREAS,	32,	6},
-    {"MiddleButtonAreaBottom", PT_INT, INT_MIN, INT_MAX, SYNAPTICS_PROP_SOFTBUTTON_AREAS,	32,	7},
-    { NULL, 0, 0, 0, 0 }
+    {"LeftEdge", PT_INT, 0, 10000, SYNAPTICS_PROP_EDGES, 32, 0},
+    {"RightEdge", PT_INT, 0, 10000, SYNAPTICS_PROP_EDGES, 32, 1},
+    {"TopEdge", PT_INT, 0, 10000, SYNAPTICS_PROP_EDGES, 32, 2},
+    {"BottomEdge", PT_INT, 0, 10000, SYNAPTICS_PROP_EDGES, 32, 3},
+    {"FingerLow", PT_INT, 0, 255, SYNAPTICS_PROP_FINGER, 32, 0},
+    {"FingerHigh", PT_INT, 0, 255, SYNAPTICS_PROP_FINGER, 32, 1},
+    {"FingerPress", PT_INT, 0, 256, SYNAPTICS_PROP_FINGER, 32, 2},
+    {"MaxTapTime", PT_INT, 0, 1000, SYNAPTICS_PROP_TAP_TIME, 32, 0},
+    {"MaxTapMove", PT_INT, 0, 2000, SYNAPTICS_PROP_TAP_MOVE, 32, 0},
+    {"MaxDoubleTapTime", PT_INT, 0, 1000, SYNAPTICS_PROP_TAP_DURATIONS, 32, 1},
+    {"SingleTapTimeout", PT_INT, 0, 1000, SYNAPTICS_PROP_TAP_DURATIONS, 32, 0},
+    {"ClickTime", PT_INT, 0, 1000, SYNAPTICS_PROP_TAP_DURATIONS, 32, 2},
+    {"FastTaps", PT_BOOL, 0, 1, SYNAPTICS_PROP_TAP_FAST, 8, 0},
+    {"EmulateMidButtonTime", PT_INT, 0, 1000, SYNAPTICS_PROP_MIDDLE_TIMEOUT, 32,
+     0},
+    {"EmulateTwoFingerMinZ", PT_INT, 0, 1000, SYNAPTICS_PROP_TWOFINGER_PRESSURE,
+     32, 0},
+    {"EmulateTwoFingerMinW", PT_INT, 0, 15, SYNAPTICS_PROP_TWOFINGER_WIDTH, 32,
+     0},
+    {"VertScrollDelta", PT_INT, -1000, 1000, SYNAPTICS_PROP_SCROLL_DISTANCE, 32,
+     0},
+    {"HorizScrollDelta", PT_INT, -1000, 1000, SYNAPTICS_PROP_SCROLL_DISTANCE,
+     32, 1},
+    {"VertEdgeScroll", PT_BOOL, 0, 1, SYNAPTICS_PROP_SCROLL_EDGE, 8, 0},
+    {"HorizEdgeScroll", PT_BOOL, 0, 1, SYNAPTICS_PROP_SCROLL_EDGE, 8, 1},
+    {"CornerCoasting", PT_BOOL, 0, 1, SYNAPTICS_PROP_SCROLL_EDGE, 8, 2},
+    {"VertTwoFingerScroll", PT_BOOL, 0, 1, SYNAPTICS_PROP_SCROLL_TWOFINGER, 8,
+     0},
+    {"HorizTwoFingerScroll", PT_BOOL, 0, 1, SYNAPTICS_PROP_SCROLL_TWOFINGER, 8,
+     1},
+    {"MinSpeed", PT_DOUBLE, 0, 255.0, SYNAPTICS_PROP_SPEED, 0, /*float */ 0},
+    {"MaxSpeed", PT_DOUBLE, 0, 255.0, SYNAPTICS_PROP_SPEED, 0, /*float */ 1},
+    {"AccelFactor", PT_DOUBLE, 0, 1.0, SYNAPTICS_PROP_SPEED, 0, /*float */ 2},
+    {"TrackstickSpeed", PT_DOUBLE, 0, 200.0, SYNAPTICS_PROP_SPEED, 0, /*float */
+     3},
+    {"EdgeMotionMinZ", PT_INT, 1, 255, SYNAPTICS_PROP_EDGEMOTION_PRESSURE, 32,
+     0},
+    {"EdgeMotionMaxZ", PT_INT, 1, 255, SYNAPTICS_PROP_EDGEMOTION_PRESSURE, 32,
+     1},
+    {"EdgeMotionMinSpeed", PT_INT, 0, 1000, SYNAPTICS_PROP_EDGEMOTION_SPEED, 32,
+     0},
+    {"EdgeMotionMaxSpeed", PT_INT, 0, 1000, SYNAPTICS_PROP_EDGEMOTION_SPEED, 32,
+     1},
+    {"EdgeMotionUseAlways", PT_BOOL, 0, 1, SYNAPTICS_PROP_EDGEMOTION, 8, 0},
+    {"UpDownScrolling", PT_BOOL, 0, 1, SYNAPTICS_PROP_BUTTONSCROLLING, 8, 0},
+    {"LeftRightScrolling", PT_BOOL, 0, 1, SYNAPTICS_PROP_BUTTONSCROLLING, 8, 1},
+    {"UpDownScrollRepeat", PT_BOOL, 0, 1, SYNAPTICS_PROP_BUTTONSCROLLING_REPEAT,
+     8, 0},
+    {"LeftRightScrollRepeat", PT_BOOL, 0, 1,
+     SYNAPTICS_PROP_BUTTONSCROLLING_REPEAT, 8, 1},
+    {"ScrollButtonRepeat", PT_INT, SBR_MIN, SBR_MAX,
+     SYNAPTICS_PROP_BUTTONSCROLLING_TIME, 32, 0},
+    {"TouchpadOff", PT_INT, 0, 2, SYNAPTICS_PROP_OFF, 8, 0},
+    {"LockedDrags", PT_BOOL, 0, 1, SYNAPTICS_PROP_LOCKED_DRAGS, 8, 0},
+    {"LockedDragTimeout", PT_INT, 0, 30000, SYNAPTICS_PROP_LOCKED_DRAGS_TIMEOUT,
+     32, 0},
+    {"RTCornerButton", PT_INT, 0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION, 8,
+     0},
+    {"RBCornerButton", PT_INT, 0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION, 8,
+     1},
+    {"LTCornerButton", PT_INT, 0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION, 8,
+     2},
+    {"LBCornerButton", PT_INT, 0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION, 8,
+     3},
+    {"TapButton1", PT_INT, 0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION, 8, 4},
+    {"TapButton2", PT_INT, 0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION, 8, 5},
+    {"TapButton3", PT_INT, 0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_TAP_ACTION, 8, 6},
+    {"ClickFinger1", PT_INT, 0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_CLICK_ACTION, 8,
+     0},
+    {"ClickFinger2", PT_INT, 0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_CLICK_ACTION, 8,
+     1},
+    {"ClickFinger3", PT_INT, 0, SYN_MAX_BUTTONS, SYNAPTICS_PROP_CLICK_ACTION, 8,
+     2},
+    {"CircularScrolling", PT_BOOL, 0, 1, SYNAPTICS_PROP_CIRCULAR_SCROLLING, 8,
+     0},
+    {"CircScrollDelta", PT_DOUBLE, .01, 3,
+     SYNAPTICS_PROP_CIRCULAR_SCROLLING_DIST, 0 /* float */ , 0},
+    {"CircScrollTrigger", PT_INT, 0, 8,
+     SYNAPTICS_PROP_CIRCULAR_SCROLLING_TRIGGER, 8, 0},
+    {"CircularPad", PT_BOOL, 0, 1, SYNAPTICS_PROP_CIRCULAR_PAD, 8, 0},
+    {"PalmDetect", PT_BOOL, 0, 1, SYNAPTICS_PROP_PALM_DETECT, 8, 0},
+    {"PalmMinWidth", PT_INT, 0, 15, SYNAPTICS_PROP_PALM_DIMENSIONS, 32, 0},
+    {"PalmMinZ", PT_INT, 0, 255, SYNAPTICS_PROP_PALM_DIMENSIONS, 32, 1},
+    {"CoastingSpeed", PT_DOUBLE, 0, 20, SYNAPTICS_PROP_COASTING_SPEED,
+     0 /* float */ , 0},
+    {"CoastingFriction", PT_DOUBLE, 0, 255, SYNAPTICS_PROP_COASTING_SPEED,
+     0 /* float */ , 1},
+    {"PressureMotionMinZ", PT_INT, 1, 255, SYNAPTICS_PROP_PRESSURE_MOTION, 32,
+     0},
+    {"PressureMotionMaxZ", PT_INT, 1, 255, SYNAPTICS_PROP_PRESSURE_MOTION, 32,
+     1},
+    {"PressureMotionMinFactor", PT_DOUBLE, 0, 10.0,
+     SYNAPTICS_PROP_PRESSURE_MOTION_FACTOR, 0 /*float */ , 0},
+    {"PressureMotionMaxFactor", PT_DOUBLE, 0, 10.0,
+     SYNAPTICS_PROP_PRESSURE_MOTION_FACTOR, 0 /*float */ , 1},
+    {"GrabEventDevice", PT_BOOL, 0, 1, SYNAPTICS_PROP_GRAB, 8, 0},
+    {"TapAndDragGesture", PT_BOOL, 0, 1, SYNAPTICS_PROP_GESTURES, 8, 0},
+    {"AreaLeftEdge", PT_INT, 0, 10000, SYNAPTICS_PROP_AREA, 32, 0},
+    {"AreaRightEdge", PT_INT, 0, 10000, SYNAPTICS_PROP_AREA, 32, 1},
+    {"AreaTopEdge", PT_INT, 0, 10000, SYNAPTICS_PROP_AREA, 32, 2},
+    {"AreaBottomEdge", PT_INT, 0, 10000, SYNAPTICS_PROP_AREA, 32, 3},
+    {"HorizHysteresis", PT_INT, 0, 10000, SYNAPTICS_PROP_NOISE_CANCELLATION, 32,
+     0},
+    {"VertHysteresis", PT_INT, 0, 10000, SYNAPTICS_PROP_NOISE_CANCELLATION, 32,
+     1},
+    {"ClickPad", PT_BOOL, 0, 1, SYNAPTICS_PROP_CLICKPAD, 8, 0},
+    {"RightButtonAreaLeft", PT_INT, INT_MIN, INT_MAX,
+     SYNAPTICS_PROP_SOFTBUTTON_AREAS, 32, 0},
+    {"RightButtonAreaRight", PT_INT, INT_MIN, INT_MAX,
+     SYNAPTICS_PROP_SOFTBUTTON_AREAS, 32, 1},
+    {"RightButtonAreaTop", PT_INT, INT_MIN, INT_MAX,
+     SYNAPTICS_PROP_SOFTBUTTON_AREAS, 32, 2},
+    {"RightButtonAreaBottom", PT_INT, INT_MIN, INT_MAX,
+     SYNAPTICS_PROP_SOFTBUTTON_AREAS, 32, 3},
+    {"MiddleButtonAreaLeft", PT_INT, INT_MIN, INT_MAX,
+     SYNAPTICS_PROP_SOFTBUTTON_AREAS, 32, 4},
+    {"MiddleButtonAreaRight", PT_INT, INT_MIN, INT_MAX,
+     SYNAPTICS_PROP_SOFTBUTTON_AREAS, 32, 5},
+    {"MiddleButtonAreaTop", PT_INT, INT_MIN, INT_MAX,
+     SYNAPTICS_PROP_SOFTBUTTON_AREAS, 32, 6},
+    {"MiddleButtonAreaBottom", PT_INT, INT_MIN, INT_MAX,
+     SYNAPTICS_PROP_SOFTBUTTON_AREAS, 32, 7},
+    {NULL, 0, 0, 0, 0}
 };
 
 static double
-parse_cmd(char* cmd, struct Parameter** par)
+parse_cmd(char *cmd, struct Parameter **par)
 {
     char *eqp = strchr(cmd, '=');
+
     *par = NULL;
 
     if (eqp) {
-	int j;
-	int found = 0;
-	*eqp = 0;
-	for (j = 0; params[j].name; j++) {
-	    if (strcasecmp(cmd, params[j].name) == 0) {
-		found = 1;
-		break;
-	    }
-	}
-	if (found) {
-	    double val = atof(&eqp[1]);
-	    *par = &params[j];
-
-	    if (val < (*par)->min_val)
-		val = (*par)->min_val;
-	    if (val > (*par)->max_val)
-		val = (*par)->max_val;
-
-	    return val;
-	} else {
-	    printf("Unknown parameter %s\n", cmd);
-	}
-    } else {
-	printf("Invalid command: %s\n", cmd);
+        int j;
+        int found = 0;
+
+        *eqp = 0;
+        for (j = 0; params[j].name; j++) {
+            if (strcasecmp(cmd, params[j].name) == 0) {
+                found = 1;
+                break;
+            }
+        }
+        if (found) {
+            double val = atof(&eqp[1]);
+
+            *par = &params[j];
+
+            if (val < (*par)->min_val)
+                val = (*par)->min_val;
+            if (val > (*par)->max_val)
+                val = (*par)->max_val;
+
+            return val;
+        }
+        else {
+            printf("Unknown parameter %s\n", cmd);
+        }
+    }
+    else {
+        printf("Invalid command: %s\n", cmd);
     }
 
     return 0;
 }
 
 static int
-is_equal(SynapticsSHM *s1, SynapticsSHM *s2)
+is_equal(SynapticsSHM * s1, SynapticsSHM * s2)
 {
     int i;
 
-    if ((s1->x           != s2->x) ||
-	(s1->y           != s2->y) ||
-	(s1->z           != s2->z) ||
-	(s1->numFingers  != s2->numFingers) ||
-	(s1->fingerWidth != s2->fingerWidth) ||
-	(s1->left        != s2->left) ||
-	(s1->right       != s2->right) ||
-	(s1->up          != s2->up) ||
-	(s1->down        != s2->down) ||
-	(s1->middle      != s2->middle))
-	return 0;
+    if ((s1->x != s2->x) ||
+        (s1->y != s2->y) ||
+        (s1->z != s2->z) ||
+        (s1->numFingers != s2->numFingers) ||
+        (s1->fingerWidth != s2->fingerWidth) ||
+        (s1->left != s2->left) ||
+        (s1->right != s2->right) ||
+        (s1->up != s2->up) ||
+        (s1->down != s2->down) || (s1->middle != s2->middle))
+        return 0;
 
     for (i = 0; i < 8; i++)
-	if (s1->multi[i] != s2->multi[i])
-	    return 0;
+        if (s1->multi[i] != s2->multi[i])
+            return 0;
 
     return 1;
 }
@@ -221,58 +266,64 @@ static double
 get_time(void)
 {
     struct timeval tv;
+
     gettimeofday(&tv, NULL);
     return tv.tv_sec + tv.tv_usec / 1000000.0;
 }
 
 static void
-shm_monitor(SynapticsSHM *synshm, int delay)
+shm_monitor(SynapticsSHM * synshm, int delay)
 {
     int header = 0;
     SynapticsSHM old;
     double t0 = get_time();
 
     memset(&old, 0, sizeof(SynapticsSHM));
-    old.x = -1;				    /* Force first equality test to fail */
+    old.x = -1;                 /* Force first equality test to fail */
 
     while (1) {
-	SynapticsSHM cur = *synshm;
-	if (!is_equal(&old, &cur)) {
-	    if (!header) {
-		printf("%8s  %4s %4s %3s %s %2s %2s %s %s %s %s  %8s  "
-		       "%2s %2s %2s %3s %3s\n",
-		       "time", "x", "y", "z", "f", "w", "l", "r", "u", "d", "m",
-		       "multi", "gl", "gm", "gr", "gdx", "gdy");
-		header = 20;
-	    }
-	    header--;
-	    printf("%8.3f  %4d %4d %3d %d %2d %2d %d %d %d %d  %d%d%d%d%d%d%d%d\n",
-		   get_time() - t0,
-		   cur.x, cur.y, cur.z, cur.numFingers, cur.fingerWidth,
-		   cur.left, cur.right, cur.up, cur.down, cur.middle,
-		   cur.multi[0], cur.multi[1], cur.multi[2], cur.multi[3],
-		   cur.multi[4], cur.multi[5], cur.multi[6], cur.multi[7]);
-	    fflush(stdout);
-	    old = cur;
-	}
-	usleep(delay * 1000);
+        SynapticsSHM cur = *synshm;
+
+        if (!is_equal(&old, &cur)) {
+            if (!header) {
+                printf("%8s  %4s %4s %3s %s %2s %2s %s %s %s %s  %8s  "
+                       "%2s %2s %2s %3s %3s\n",
+                       "time", "x", "y", "z", "f", "w", "l", "r", "u", "d", "m",
+                       "multi", "gl", "gm", "gr", "gdx", "gdy");
+                header = 20;
+            }
+            header--;
+            printf
+                ("%8.3f  %4d %4d %3d %d %2d %2d %d %d %d %d  %d%d%d%d%d%d%d%d\n",
+                 get_time() - t0, cur.x, cur.y, cur.z, cur.numFingers,
+                 cur.fingerWidth, cur.left, cur.right, cur.up, cur.down,
+                 cur.middle, cur.multi[0], cur.multi[1], cur.multi[2],
+                 cur.multi[3], cur.multi[4], cur.multi[5], cur.multi[6],
+                 cur.multi[7]);
+            fflush(stdout);
+            old = cur;
+        }
+        usleep(delay * 1000);
     }
 }
 
 /** Init and return SHM area or NULL on error */
-static  SynapticsSHM*
+static SynapticsSHM *
 shm_init()
 {
     SynapticsSHM *synshm = NULL;
     int shmid = 0;
 
     if ((shmid = shmget(SHM_SYNAPTICS, sizeof(SynapticsSHM), 0)) == -1) {
-	if ((shmid = shmget(SHM_SYNAPTICS, 0, 0)) == -1)
-	    fprintf(stderr, "Can't access shared memory area. SHMConfig disabled?\n");
-	else
-	    fprintf(stderr, "Incorrect size of shared memory area. Incompatible driver version?\n");
-    } else if ((synshm = (SynapticsSHM*) shmat(shmid, NULL, SHM_RDONLY)) == NULL)
-	perror("shmat");
+        if ((shmid = shmget(SHM_SYNAPTICS, 0, 0)) == -1)
+            fprintf(stderr,
+                    "Can't access shared memory area. SHMConfig disabled?\n");
+        else
+            fprintf(stderr,
+                    "Incorrect size of shared memory area. Incompatible driver version?\n");
+    }
+    else if ((synshm = (SynapticsSHM *) shmat(shmid, NULL, SHM_RDONLY)) == NULL)
+        perror("shmat");
 
     return synshm;
 }
@@ -291,134 +342,130 @@ shm_process_commands(int do_monitor, int delay)
 }
 
 /** Init display connection or NULL on error */
-static Display*
+static Display *
 dp_init()
 {
-    Display *dpy		= NULL;
-    XExtensionVersion *v	= NULL;
-    Atom touchpad_type		= 0;
-    Atom synaptics_property	= 0;
-    int error			= 0;
+    Display *dpy = NULL;
+    XExtensionVersion *v = NULL;
+    Atom touchpad_type = 0;
+    Atom synaptics_property = 0;
+    int error = 0;
 
     dpy = XOpenDisplay(NULL);
     if (!dpy) {
-	fprintf(stderr, "Failed to connect to X Server.\n");
-	error = 1;
-	goto unwind;
+        fprintf(stderr, "Failed to connect to X Server.\n");
+        error = 1;
+        goto unwind;
     }
 
     v = XGetExtensionVersion(dpy, INAME);
     if (!v->present ||
-	(v->major_version * 1000 + v->minor_version) < (XI_Add_DeviceProperties_Major * 1000
-	    + XI_Add_DeviceProperties_Minor)) {
-	fprintf(stderr, "X server supports X Input %d.%d. I need %d.%d.\n",
-		v->major_version, v->minor_version,
-		XI_Add_DeviceProperties_Major,
-		XI_Add_DeviceProperties_Minor);
-	error = 1;
-	goto unwind;
+        (v->major_version * 1000 + v->minor_version) <
+        (XI_Add_DeviceProperties_Major * 1000 +
+         XI_Add_DeviceProperties_Minor)) {
+        fprintf(stderr, "X server supports X Input %d.%d. I need %d.%d.\n",
+                v->major_version, v->minor_version,
+                XI_Add_DeviceProperties_Major, XI_Add_DeviceProperties_Minor);
+        error = 1;
+        goto unwind;
     }
 
     /* We know synaptics sets XI_TOUCHPAD for all the devices. */
     touchpad_type = XInternAtom(dpy, XI_TOUCHPAD, True);
     if (!touchpad_type) {
-	fprintf(stderr, "XI_TOUCHPAD not initialised.\n");
-	error = 1;
-	goto unwind;
+        fprintf(stderr, "XI_TOUCHPAD not initialised.\n");
+        error = 1;
+        goto unwind;
     }
 
     synaptics_property = XInternAtom(dpy, SYNAPTICS_PROP_EDGES, True);
     if (!synaptics_property) {
-	fprintf(stderr, "Couldn't find synaptics properties. No synaptics "
-		"driver loaded?\n");
-	error = 1;
-	goto unwind;
+        fprintf(stderr, "Couldn't find synaptics properties. No synaptics "
+                "driver loaded?\n");
+        error = 1;
+        goto unwind;
     }
 
-unwind:
+ unwind:
     XFree(v);
-    if (error && dpy)
-    {
-	XCloseDisplay(dpy);
-	dpy = NULL;
+    if (error && dpy) {
+        XCloseDisplay(dpy);
+        dpy = NULL;
     }
     return dpy;
 }
 
 static XDevice *
-dp_get_device(Display *dpy)
+dp_get_device(Display * dpy)
 {
-    XDevice* dev		= NULL;
-    XDeviceInfo *info		= NULL;
-    int ndevices		= 0;
-    Atom touchpad_type		= 0;
-    Atom synaptics_property	= 0;
-    Atom *properties		= NULL;
-    int nprops			= 0;
-    int error			= 0;
+    XDevice *dev = NULL;
+    XDeviceInfo *info = NULL;
+    int ndevices = 0;
+    Atom touchpad_type = 0;
+    Atom synaptics_property = 0;
+    Atom *properties = NULL;
+    int nprops = 0;
+    int error = 0;
 
     touchpad_type = XInternAtom(dpy, XI_TOUCHPAD, True);
     synaptics_property = XInternAtom(dpy, SYNAPTICS_PROP_EDGES, True);
     info = XListInputDevices(dpy, &ndevices);
 
-    while(ndevices--) {
-	if (info[ndevices].type == touchpad_type) {
-	    dev = XOpenDevice(dpy, info[ndevices].id);
-	    if (!dev) {
-		fprintf(stderr, "Failed to open device '%s'.\n",
-			info[ndevices].name);
-		error = 1;
-		goto unwind;
-	    }
-
-	    properties = XListDeviceProperties(dpy, dev, &nprops);
-	    if (!properties || !nprops)
-	    {
-		fprintf(stderr, "No properties on device '%s'.\n",
-			info[ndevices].name);
-		error = 1;
-		goto unwind;
-	    }
-
-	    while(nprops--)
-	    {
-		if (properties[nprops] == synaptics_property)
-		    break;
-	    }
-	    if (!nprops)
-	    {
-		fprintf(stderr, "No synaptics properties on device '%s'.\n",
-			info[ndevices].name);
-		error = 1;
-		goto unwind;
-	    }
-
-	    break; /* Yay, device is suitable */
-	}
+    while (ndevices--) {
+        if (info[ndevices].type == touchpad_type) {
+            dev = XOpenDevice(dpy, info[ndevices].id);
+            if (!dev) {
+                fprintf(stderr, "Failed to open device '%s'.\n",
+                        info[ndevices].name);
+                error = 1;
+                goto unwind;
+            }
+
+            properties = XListDeviceProperties(dpy, dev, &nprops);
+            if (!properties || !nprops) {
+                fprintf(stderr, "No properties on device '%s'.\n",
+                        info[ndevices].name);
+                error = 1;
+                goto unwind;
+            }
+
+            while (nprops--) {
+                if (properties[nprops] == synaptics_property)
+                    break;
+            }
+            if (!nprops) {
+                fprintf(stderr, "No synaptics properties on device '%s'.\n",
+                        info[ndevices].name);
+                error = 1;
+                goto unwind;
+            }
+
+            break;              /* Yay, device is suitable */
+        }
     }
 
-unwind:
+ unwind:
     XFree(properties);
     XFreeDeviceList(info);
     if (!dev)
         fprintf(stderr, "Unable to find a synaptics device.\n");
-    else if (error && dev)
-    {
-	XCloseDevice(dpy, dev);
-	dev = NULL;
+    else if (error && dev) {
+        XCloseDevice(dpy, dev);
+        dev = NULL;
     }
     return dev;
 }
 
 static void
-dp_set_variables(Display *dpy, XDevice* dev, int argc, char *argv[], int first_cmd)
+dp_set_variables(Display * dpy, XDevice * dev, int argc, char *argv[],
+                 int first_cmd)
 {
     int i;
     double val;
     struct Parameter *par;
     Atom prop, type, float_type;
     int format;
-    unsigned char* data;
+    unsigned char *data;
     unsigned long nitems, bytes_after;
 
     union flong *f;
@@ -427,81 +474,78 @@ dp_set_variables(Display *dpy, XDevice* dev, int argc, char *argv[], int first_c
 
     float_type = XInternAtom(dpy, XATOM_FLOAT, True);
     if (!float_type)
-	fprintf(stderr, "Float properties not available.\n");
+        fprintf(stderr, "Float properties not available.\n");
 
     for (i = first_cmd; i < argc; i++) {
-	val = parse_cmd(argv[i], &par);
-	if (!par)
-	    continue;
-
-	prop = XInternAtom(dpy, par->prop_name, True);
-	if (!prop)
-	{
-	    fprintf(stderr, "Property for '%s' not available. Skipping.\n",
-		    par->name);
-	    continue;
-
-	}
-
-	XGetDeviceProperty(dpy, dev, prop, 0, 1000, False, AnyPropertyType,
-				&type, &format, &nitems, &bytes_after, &data);
-
-	if (type == None)
-	{
-	    fprintf(stderr, "Property for '%s' not available. Skipping.\n",
-		    par->name);
-	    continue;
-	}
-
-	switch(par->prop_format)
-	{
-	    case 8:
-		if (format != par->prop_format || type != XA_INTEGER) {
-		    fprintf(stderr, "   %-23s = format mismatch (%d)\n",
-			    par->name, format);
-		    break;
-		}
-		b = (char*)data;
-		b[par->prop_offset] = rint(val);
-		break;
-	    case 32:
-		if (format != par->prop_format ||
-                    (type != XA_INTEGER && type != XA_CARDINAL)) {
-		    fprintf(stderr, "   %-23s = format mismatch (%d)\n",
-			    par->name, format);
-		    break;
-		}
-		n = (long*)data;
-		n[par->prop_offset] = rint(val);
-		break;
-	    case 0: /* float */
-		if (!float_type)
-		    continue;
-		if (format != 32 || type != float_type) {
-		    fprintf(stderr, "   %-23s = format mismatch (%d)\n",
-			    par->name, format);
-		    break;
-		}
-		f = (union flong*)data;
-		f[par->prop_offset].f = val;
-		break;
-	}
-
-	XChangeDeviceProperty(dpy, dev, prop, type, format,
-				PropModeReplace, data, nitems);
-	XFlush(dpy);
+        val = parse_cmd(argv[i], &par);
+        if (!par)
+            continue;
+
+        prop = XInternAtom(dpy, par->prop_name, True);
+        if (!prop) {
+            fprintf(stderr, "Property for '%s' not available. Skipping.\n",
+                    par->name);
+            continue;
+
+        }
+
+        XGetDeviceProperty(dpy, dev, prop, 0, 1000, False, AnyPropertyType,
+                           &type, &format, &nitems, &bytes_after, &data);
+
+        if (type == None) {
+            fprintf(stderr, "Property for '%s' not available. Skipping.\n",
+                    par->name);
+            continue;
+        }
+
+        switch (par->prop_format) {
+        case 8:
+            if (format != par->prop_format || type != XA_INTEGER) {
+                fprintf(stderr, "   %-23s = format mismatch (%d)\n",
+                        par->name, format);
+                break;
+            }
+            b = (char *) data;
+            b[par->prop_offset] = rint(val);
+            break;
+        case 32:
+            if (format != par->prop_format ||
+                (type != XA_INTEGER && type != XA_CARDINAL)) {
+                fprintf(stderr, "   %-23s = format mismatch (%d)\n",
+                        par->name, format);
+                break;
+            }
+            n = (long *) data;
+            n[par->prop_offset] = rint(val);
+            break;
+        case 0:                /* float */
+            if (!float_type)
+                continue;
+            if (format != 32 || type != float_type) {
+                fprintf(stderr, "   %-23s = format mismatch (%d)\n",
+                        par->name, format);
+                break;
+            }
+            f = (union flong *) data;
+            f[par->prop_offset].f = val;
+            break;
+        }
+
+        XChangeDeviceProperty(dpy, dev, prop, type, format,
+                              PropModeReplace, data, nitems);
+        XFlush(dpy);
     }
 }
 
 /* FIXME: horribly inefficient. */
 static void
-dp_show_settings(Display *dpy, XDevice *dev)
+dp_show_settings(Display * dpy, XDevice * dev)
 {
     int j;
     Atom a, type, float_type;
     int format;
     unsigned long nitems, bytes_after;
-    unsigned char* data;
+    unsigned char *data;
     int len;
 
     union flong *f;
@@ -510,69 +554,75 @@ dp_show_settings(Display *dpy, XDevice *dev)
 
     float_type = XInternAtom(dpy, XATOM_FLOAT, True);
     if (!float_type)
-	fprintf(stderr, "Float properties not available.\n");
+        fprintf(stderr, "Float properties not available.\n");
 
     printf("Parameter settings:\n");
     for (j = 0; params[j].name; j++) {
-	struct Parameter *par = &params[j];
-	a = XInternAtom(dpy, par->prop_name, True);
-	if (!a)
-	    continue;
-
-	len = 1 + ((par->prop_offset * (par->prop_format ? par->prop_format : 32)/8))/4;
-
-	XGetDeviceProperty(dpy, dev, a, 0, len, False,
-				AnyPropertyType, &type, &format,
-				&nitems, &bytes_after, &data);
-	if (type == None)
-	    continue;
-
-	switch(par->prop_format) {
-	    case 8:
-		if (format != par->prop_format || type != XA_INTEGER) {
-		    fprintf(stderr, "    %-23s = format mismatch (%d)\n",
-			    par->name, format);
-		    break;
-		}
-
-		b = (char*)data;
-		printf("    %-23s = %d\n", par->name, b[par->prop_offset]);
-		break;
-	    case 32:
-		if (format != par->prop_format ||
-                    (type != XA_INTEGER && type != XA_CARDINAL)) {
-		    fprintf(stderr, "    %-23s = format mismatch (%d)\n",
-			    par->name, format);
-		    break;
-		}
-
-		i = (long*)data;
-		printf("    %-23s = %ld\n", par->name, i[par->prop_offset]);
-		break;
-	    case 0: /* Float */
-		if (!float_type)
-		    continue;
-		if (format != 32 || type != float_type) {
-		    fprintf(stderr, "    %-23s = format mismatch (%d)\n",
-			    par->name, format);
-		    break;
-		}
-
-		f = (union flong*)data;
-		printf("    %-23s = %g\n", par->name, f[par->prop_offset].f);
-		break;
-	}
-
-	XFree(data);
+        struct Parameter *par = &params[j];
+
+        a = XInternAtom(dpy, par->prop_name, True);
+        if (!a)
+            continue;
+
+        len =
+            1 +
+            ((par->prop_offset * (par->prop_format ? par->prop_format : 32) /
+              8)) / 4;
+
+        XGetDeviceProperty(dpy, dev, a, 0, len, False,
+                           AnyPropertyType, &type, &format,
+                           &nitems, &bytes_after, &data);
+        if (type == None)
+            continue;
+
+        switch (par->prop_format) {
+        case 8:
+            if (format != par->prop_format || type != XA_INTEGER) {
+                fprintf(stderr, "    %-23s = format mismatch (%d)\n",
+                        par->name, format);
+                break;
+            }
+
+            b = (char *) data;
+            printf("    %-23s = %d\n", par->name, b[par->prop_offset]);
+            break;
+        case 32:
+            if (format != par->prop_format ||
+                (type != XA_INTEGER && type != XA_CARDINAL)) {
+                fprintf(stderr, "    %-23s = format mismatch (%d)\n",
+                        par->name, format);
+                break;
+            }
+
+            i = (long *) data;
+            printf("    %-23s = %ld\n", par->name, i[par->prop_offset]);
+            break;
+        case 0:                /* Float */
+            if (!float_type)
+                continue;
+            if (format != 32 || type != float_type) {
+                fprintf(stderr, "    %-23s = format mismatch (%d)\n",
+                        par->name, format);
+                break;
+            }
+
+            f = (union flong *) data;
+            printf("    %-23s = %g\n", par->name, f[par->prop_offset].f);
+            break;
+        }
+
+        XFree(data);
     }
 }
 
 static void
 usage(void)
 {
-    fprintf(stderr, "Usage: synclient [-s] [-m interval] [-h] [-l] [-V] [-?] [var1=value1 [var2=value2] ...]\n");
-    fprintf(stderr, "  -m monitor changes to the touchpad state (implies -s)\n"
-	    "     interval specifies how often (in ms) to poll the touchpad state\n");
+    fprintf(stderr,
+            "Usage: synclient [-s] [-m interval] [-h] [-l] [-V] [-?] [var1=value1 [var2=value2] ...]\n");
+    fprintf(stderr,
+            "  -m monitor changes to the touchpad state (implies -s)\n"
+            "     interval specifies how often (in ms) to poll the touchpad state\n");
     fprintf(stderr, "  -l List current user settings\n");
     fprintf(stderr, "  -V Print synclient version string and exit\n");
     fprintf(stderr, "  -? Show this help message\n");
@@ -597,26 +647,26 @@ main(int argc, char *argv[])
 
     /* Parse command line parameters */
     while ((c = getopt(argc, argv, "sm:hlV")) != -1) {
-	switch (c) {
-	case 'm':
-	    do_monitor = 1;
-	    if ((delay = atoi(optarg)) < 0)
-		usage();
-	    break;
-	case 'l':
-	    dump_settings = 1;
-	    break;
-	case 'V':
-	    printf("%s\n", VERSION);
-	    exit(0);
-	default:
-	    usage();
-	}
+        switch (c) {
+        case 'm':
+            do_monitor = 1;
+            if ((delay = atoi(optarg)) < 0)
+                usage();
+            break;
+        case 'l':
+            dump_settings = 1;
+            break;
+        case 'V':
+            printf("%s\n", VERSION);
+            exit(0);
+        default:
+            usage();
+        }
     }
 
     first_cmd = optind;
     if (!do_monitor && !dump_settings && first_cmd == argc)
-	usage();
+        usage();
 
     /* Connect to the shared memory area */
     if (do_monitor)
diff --git a/tools/syndaemon.c b/tools/syndaemon.c
index bead545..5109052 100644
--- a/tools/syndaemon.c
+++ b/tools/syndaemon.c
@@ -34,7 +34,7 @@
 #ifdef HAVE_X11_EXTENSIONS_RECORD_H
 #include <X11/Xproto.h>
 #include <X11/extensions/record.h>
-#endif /* HAVE_X11_EXTENSIONS_RECORD_H */
+#endif                          /* HAVE_X11_EXTENSIONS_RECORD_H */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -54,8 +54,8 @@ typedef enum {
     TappingOff = 2
 } TouchpadState;
 
-
-static Bool pad_disabled /* internal flag, this does not correspond to device state */;
+static Bool pad_disabled
+    /* internal flag, this does not correspond to device state */ ;
 static int ignore_modifier_combos;
 static int ignore_modifier_keys;
 static int background;
@@ -73,15 +73,19 @@ static unsigned char keyboard_mask[KEYMAP_SIZE];
 static void
 usage(void)
 {
-    fprintf(stderr, "Usage: syndaemon [-i idle-time] [-m poll-delay] [-d] [-t] [-k]\n");
-    fprintf(stderr, "  -i How many seconds to wait after the last key press before\n");
+    fprintf(stderr,
+            "Usage: syndaemon [-i idle-time] [-m poll-delay] [-d] [-t] [-k]\n");
+    fprintf(stderr,
+            "  -i How many seconds to wait after the last key press before\n");
     fprintf(stderr, "     enabling the touchpad. (default is 2.0s)\n");
     fprintf(stderr, "  -m How many milli-seconds to wait until next poll.\n");
     fprintf(stderr, "     (default is 200ms)\n");
     fprintf(stderr, "  -d Start as a daemon, i.e. in the background.\n");
     fprintf(stderr, "  -p Create a pid file with the specified name.\n");
-    fprintf(stderr, "  -t Only disable tapping and scrolling, not mouse movements.\n");
-    fprintf(stderr, "  -k Ignore modifier keys when monitoring keyboard activity.\n");
+    fprintf(stderr,
+            "  -t Only disable tapping and scrolling, not mouse movements.\n");
+    fprintf(stderr,
+            "  -k Ignore modifier keys when monitoring keyboard activity.\n");
     fprintf(stderr, "  -K Like -k but also ignore Modifier+Key combos.\n");
     fprintf(stderr, "  -R Use the XRecord extension.\n");
     fprintf(stderr, "  -v Print diagnostic messages.\n");
@@ -96,9 +100,10 @@ store_current_touchpad_state(void)
     unsigned long nitems, bytes_after;
     unsigned char *data;
 
-    if ((XGetDeviceProperty (display, dev, touchpad_off_prop, 0, 1, False,
-                             XA_INTEGER, &real_type, &real_format, &nitems,
-                             &bytes_after, &data) == Success) && (real_type != None)) {
+    if ((XGetDeviceProperty(display, dev, touchpad_off_prop, 0, 1, False,
+                            XA_INTEGER, &real_type, &real_format, &nitems,
+                            &bytes_after, &data) == Success) &&
+        (real_type != None)) {
         previous_state = data[0];
     }
 }
@@ -110,25 +115,27 @@ static void
 toggle_touchpad(Bool enable)
 {
     unsigned char data;
+
     if (pad_disabled && enable) {
         data = previous_state;
         pad_disabled = False;
         if (verbose)
             printf("Enable\n");
-    } else if (!pad_disabled && !enable &&
-               previous_state != disable_state &&
-               previous_state != TouchpadOff) {
+    }
+    else if (!pad_disabled && !enable &&
+             previous_state != disable_state && previous_state != TouchpadOff) {
         store_current_touchpad_state();
         pad_disabled = True;
         data = disable_state;
         if (verbose)
             printf("Disable\n");
-    } else
+    }
+    else
         return;
 
-    /* This potentially overwrites a different client's setting, but ...*/
+    /* This potentially overwrites a different client's setting, but ... */
     XChangeDeviceProperty(display, dev, touchpad_off_prop, XA_INTEGER, 8,
-            PropModeReplace, &data, 1);
+                          PropModeReplace, &data, 1);
     XFlush(display);
 }
 
@@ -138,7 +145,7 @@ signal_handler(int signum)
     toggle_touchpad(True);
 
     if (pid_file)
-	unlink(pid_file);
+        unlink(pid_file);
     kill(getpid(), signum);
 }
 
@@ -146,11 +153,11 @@ static void
 install_signal_handler(void)
 {
     static int signals[] = {
-	SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGTRAP, SIGABRT,
-	SIGBUS, SIGFPE, SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE,
-	SIGALRM, SIGTERM,
+        SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGTRAP, SIGABRT,
+        SIGBUS, SIGFPE, SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE,
+        SIGALRM, SIGTERM,
 #ifdef SIGPWR
-	SIGPWR
+        SIGPWR
 #endif
     };
     int i;
@@ -167,10 +174,10 @@ install_signal_handler(void)
 #endif
 
     for (i = 0; i < sizeof(signals) / sizeof(int); i++) {
-	if (sigaction(signals[i], &act, NULL) == -1) {
-	    perror("sigaction");
-	    exit(2);
-	}
+        if (sigaction(signals[i], &act, NULL) == -1) {
+            perror("sigaction");
+            exit(2);
+        }
     }
 }
 
@@ -178,31 +185,31 @@ install_signal_handler(void)
  * Return non-zero if the keyboard state has changed since the last call.
  */
 static int
-keyboard_activity(Display *display)
+keyboard_activity(Display * display)
 {
     static unsigned char old_key_state[KEYMAP_SIZE];
     unsigned char key_state[KEYMAP_SIZE];
     int i;
     int ret = 0;
 
-    XQueryKeymap(display, (char*)key_state);
+    XQueryKeymap(display, (char *) key_state);
 
     for (i = 0; i < KEYMAP_SIZE; i++) {
-	if ((key_state[i] & ~old_key_state[i]) & keyboard_mask[i]) {
-	    ret = 1;
-	    break;
-	}
+        if ((key_state[i] & ~old_key_state[i]) & keyboard_mask[i]) {
+            ret = 1;
+            break;
+        }
     }
     if (ignore_modifier_combos) {
-	for (i = 0; i < KEYMAP_SIZE; i++) {
-	    if (key_state[i] & ~keyboard_mask[i]) {
-		ret = 0;
-		break;
-	    }
-	}
+        for (i = 0; i < KEYMAP_SIZE; i++) {
+            if (key_state[i] & ~keyboard_mask[i]) {
+                ret = 0;
+                break;
+            }
+        }
     }
     for (i = 0; i < KEYMAP_SIZE; i++)
-	old_key_state[i] = key_state[i];
+        old_key_state[i] = key_state[i];
     return ret;
 }
 
@@ -210,12 +217,13 @@ static double
 get_time(void)
 {
     struct timeval tv;
+
     gettimeofday(&tv, NULL);
     return tv.tv_sec + tv.tv_usec / 1000000.0;
 }
 
 static void
-main_loop(Display *display, double idle_time, int poll_delay)
+main_loop(Display * display, double idle_time, int poll_delay)
 {
     double last_activity = 0.0;
     double current_time;
@@ -223,22 +231,23 @@ main_loop(Display *display, double idle_time, int poll_delay)
     keyboard_activity(display);
 
     for (;;) {
-	current_time = get_time();
-	if (keyboard_activity(display))
-	    last_activity = current_time;
-
-	/* If system times goes backwards, touchpad can get locked. Make
-	 * sure our last activity wasn't in the future and reset if it was. */
-	if (last_activity > current_time)
-	    last_activity = current_time - idle_time - 1;
-
-	if (current_time > last_activity + idle_time) {	/* Enable touchpad */
-	    toggle_touchpad(True);
-	} else {			    /* Disable touchpad */
-	    toggle_touchpad(False);
-	}
-
-	usleep(poll_delay);
+        current_time = get_time();
+        if (keyboard_activity(display))
+            last_activity = current_time;
+
+        /* If system times goes backwards, touchpad can get locked. Make
+         * sure our last activity wasn't in the future and reset if it was. */
+        if (last_activity > current_time)
+            last_activity = current_time - idle_time - 1;
+
+        if (current_time > last_activity + idle_time) { /* Enable touchpad */
+            toggle_touchpad(True);
+        }
+        else {                  /* Disable touchpad */
+            toggle_touchpad(False);
+        }
+
+        usleep(poll_delay);
     }
 }
 
@@ -247,26 +256,28 @@ clear_bit(unsigned char *ptr, int bit)
 {
     int byte_num = bit / 8;
     int bit_num = bit % 8;
+
     ptr[byte_num] &= ~(1 << bit_num);
 }
 
 static void
-setup_keyboard_mask(Display *display, int ignore_modifier_keys)
+setup_keyboard_mask(Display * display, int ignore_modifier_keys)
 {
     XModifierKeymap *modifiers;
     int i;
 
     for (i = 0; i < KEYMAP_SIZE; i++)
-	keyboard_mask[i] = 0xff;
+        keyboard_mask[i] = 0xff;
 
     if (ignore_modifier_keys) {
-	modifiers = XGetModifierMapping(display);
-	for (i = 0; i < 8 * modifiers->max_keypermod; i++) {
-	    KeyCode kc = modifiers->modifiermap[i];
-	    if (kc != 0)
-		clear_bit(keyboard_mask, kc);
-	}
-	XFreeModifiermap(modifiers);
+        modifiers = XGetModifierMapping(display);
+        for (i = 0; i < 8 * modifiers->max_keypermod; i++) {
+            KeyCode kc = modifiers->modifiermap[i];
+
+            if (kc != 0)
+                clear_bit(keyboard_mask, kc);
+        }
+        XFreeModifiermap(modifiers);
     }
 }
 
@@ -284,96 +295,104 @@ struct xrecord_callback_results {
 };
 
 /* test if the xrecord extension is found */
-Bool check_xrecord(Display *display) {
+Bool
+check_xrecord(Display * display)
+{
 
-    Bool   found;
+    Bool found;
     Status status;
-    int    major_opcode, minor_opcode, first_error;
-    int    version[2];
+    int major_opcode, minor_opcode, first_error;
+    int version[2];
 
     found = XQueryExtension(display,
-			    "RECORD",
-			    &major_opcode,
-			    &minor_opcode,
-			    &first_error);
+                            "RECORD",
+                            &major_opcode, &minor_opcode, &first_error);
 
-    status = XRecordQueryVersion(display, version, version+1);
+    status = XRecordQueryVersion(display, version, version + 1);
     if (verbose && status) {
-	printf("X RECORD extension version %d.%d\n", version[0], version[1]);
+        printf("X RECORD extension version %d.%d\n", version[0], version[1]);
     }
     return found;
 }
 
 /* called by XRecordProcessReplies() */
-void xrecord_callback( XPointer closure, XRecordInterceptData* recorded_data) {
+void
+xrecord_callback(XPointer closure, XRecordInterceptData * recorded_data)
+{
 
     struct xrecord_callback_results *cbres;
     xEvent *xev;
     int nxev;
 
-    cbres = (struct xrecord_callback_results *)closure;
+    cbres = (struct xrecord_callback_results *) closure;
 
     if (recorded_data->category != XRecordFromServer) {
-	XRecordFreeData(recorded_data);
-	return;
+        XRecordFreeData(recorded_data);
+        return;
     }
 
     nxev = recorded_data->data_len / 8;
-    xev = (xEvent *)recorded_data->data;
-    while(nxev--) {
-
-	if ( (xev->u.u.type == KeyPress) || (xev->u.u.type == KeyRelease)) {
-	    int i;
-	    int is_modifier = 0;
-
-	    cbres->key_event = 1; /* remember, a key was pressed or released. */
-
-	    /* test if it was a modifier */
-	    for (i = 0; i < 8 * cbres->modifiers->max_keypermod; i++) {
-		KeyCode kc = cbres->modifiers->modifiermap[i];
-
-		if (kc == xev->u.u.detail) {
-		    is_modifier = 1; /* yes, it is a modifier. */
-		    break;
-		}
-	    }
-
-	    if (is_modifier) {
-		if (xev->u.u.type == KeyPress) {
-		    for (i=0; i < MAX_MODIFIERS; ++i)
-			if (!cbres->pressed_modifiers[i]) {
-			    cbres->pressed_modifiers[i] = xev->u.u.detail;
-			    break;
-			}
-		} else { /* KeyRelease */
-		    for (i=0; i < MAX_MODIFIERS; ++i)
-			if (cbres->pressed_modifiers[i] == xev->u.u.detail)
-			    cbres->pressed_modifiers[i] = 0;
-		}
-
-	    } else {
-		/* remember, a non-modifier was pressed. */
-		cbres->non_modifier_event = 1;
-	    }
-	}
-
-	xev++;
+    xev = (xEvent *) recorded_data->data;
+    while (nxev--) {
+
+        if ((xev->u.u.type == KeyPress) || (xev->u.u.type == KeyRelease)) {
+            int i;
+            int is_modifier = 0;
+
+            cbres->key_event = 1;       /* remember, a key was pressed or released. */
+
+            /* test if it was a modifier */
+            for (i = 0; i < 8 * cbres->modifiers->max_keypermod; i++) {
+                KeyCode kc = cbres->modifiers->modifiermap[i];
+
+                if (kc == xev->u.u.detail) {
+                    is_modifier = 1;    /* yes, it is a modifier. */
+                    break;
+                }
+            }
+
+            if (is_modifier) {
+                if (xev->u.u.type == KeyPress) {
+                    for (i = 0; i < MAX_MODIFIERS; ++i)
+                        if (!cbres->pressed_modifiers[i]) {
+                            cbres->pressed_modifiers[i] = xev->u.u.detail;
+                            break;
+                        }
+                }
+                else {          /* KeyRelease */
+                    for (i = 0; i < MAX_MODIFIERS; ++i)
+                        if (cbres->pressed_modifiers[i] == xev->u.u.detail)
+                            cbres->pressed_modifiers[i] = 0;
+                }
+
+            }
+            else {
+                /* remember, a non-modifier was pressed. */
+                cbres->non_modifier_event = 1;
+            }
+        }
+
+        xev++;
     }
 
-    XRecordFreeData(recorded_data); /* cleanup */
+    XRecordFreeData(recorded_data);     /* cleanup */
 }
 
-static int is_modifier_pressed(const struct xrecord_callback_results *cbres) {
+static int
+is_modifier_pressed(const struct xrecord_callback_results *cbres)
+{
     int i;
 
     for (i = 0; i < MAX_MODIFIERS; ++i)
-	if (cbres->pressed_modifiers[i])
-	    return 1;
+        if (cbres->pressed_modifiers[i])
+            return 1;
 
     return 0;
 }
 
-void record_main_loop(Display* display, double idle_time) {
+void
+record_main_loop(Display * display, double idle_time)
+{
 
     struct xrecord_callback_results cbres;
     XRecordContext context;
@@ -382,141 +401,139 @@ void record_main_loop(Display* display, double idle_time) {
     XRecordRange *range;
     int i;
 
-    dpy_data = XOpenDisplay(NULL); /* we need an additional data connection. */
-    range  = XRecordAllocRange();
+    dpy_data = XOpenDisplay(NULL);      /* we need an additional data connection. */
+    range = XRecordAllocRange();
 
     range->device_events.first = KeyPress;
-    range->device_events.last  = KeyRelease;
+    range->device_events.last = KeyRelease;
 
-    context =  XRecordCreateContext(dpy_data, 0,
-				    &cspec,1,
-				    &range, 1);
+    context = XRecordCreateContext(dpy_data, 0, &cspec, 1, &range, 1);
 
-    XRecordEnableContextAsync(dpy_data, context, xrecord_callback, (XPointer)&cbres);
+    XRecordEnableContextAsync(dpy_data, context, xrecord_callback,
+                              (XPointer) & cbres);
 
-    cbres.modifiers  = XGetModifierMapping(display);
+    cbres.modifiers = XGetModifierMapping(display);
     /* clear list of modifiers */
     for (i = 0; i < MAX_MODIFIERS; ++i)
-	cbres.pressed_modifiers[i] = 0;
+        cbres.pressed_modifiers[i] = 0;
 
     while (1) {
 
-	int fd = ConnectionNumber(dpy_data);
-	fd_set read_fds;
-	int ret;
-	int disable_event = 0;
-	struct timeval timeout;
+        int fd = ConnectionNumber(dpy_data);
+        fd_set read_fds;
+        int ret;
+        int disable_event = 0;
+        struct timeval timeout;
+
+        FD_ZERO(&read_fds);
+        FD_SET(fd, &read_fds);
 
-	FD_ZERO(&read_fds);
-	FD_SET(fd, &read_fds);
+        ret = select(fd + 1 /* =(max descriptor in read_fds) + 1 */ ,
+                     &read_fds, NULL, NULL,
+                     pad_disabled ? &timeout : NULL
+                     /* timeout only required for enabling */ );
 
-	ret = select(fd+1 /* =(max descriptor in read_fds) + 1 */,
-		     &read_fds, NULL, NULL,
-		     pad_disabled ? &timeout : NULL /* timeout only required for enabling */ );
+        if (FD_ISSET(fd, &read_fds)) {
 
-	if (FD_ISSET(fd, &read_fds)) {
+            cbres.key_event = 0;
+            cbres.non_modifier_event = 0;
 
-	    cbres.key_event = 0;
-	    cbres.non_modifier_event = 0;
+            XRecordProcessReplies(dpy_data);
 
-	    XRecordProcessReplies(dpy_data);
+            /* If there are any events left over, they are in error. Drain them
+             * from the connection queue so we don't get stuck. */
+            while (XEventsQueued(dpy_data, QueuedAlready) > 0) {
+                XEvent event;
 
-	    /* If there are any events left over, they are in error. Drain them
-	     * from the connection queue so we don't get stuck. */
-	    while (XEventsQueued(dpy_data, QueuedAlready) > 0) {
-	        XEvent event;
-	        XNextEvent(dpy_data, &event);
-	        fprintf(stderr, "bad event received, major opcode %d\n", event.type);
-	    }
+                XNextEvent(dpy_data, &event);
+                fprintf(stderr, "bad event received, major opcode %d\n",
+                        event.type);
+            }
 
-	    if (!ignore_modifier_keys && cbres.key_event) {
-		disable_event = 1;
-	    }
+            if (!ignore_modifier_keys && cbres.key_event) {
+                disable_event = 1;
+            }
 
-	    if (cbres.non_modifier_event &&
-		!(ignore_modifier_combos && is_modifier_pressed(&cbres)) ) {
-		disable_event = 1;
-	    }
-	}
+            if (cbres.non_modifier_event &&
+                !(ignore_modifier_combos && is_modifier_pressed(&cbres))) {
+                disable_event = 1;
+            }
+        }
 
-	if (disable_event) {
-	    /* adjust the enable_time */
-	    timeout.tv_sec  = (int)idle_time;
-	    timeout.tv_usec = (idle_time-(double)timeout.tv_sec) * 1.e6;
+        if (disable_event) {
+            /* adjust the enable_time */
+            timeout.tv_sec = (int) idle_time;
+            timeout.tv_usec = (idle_time - (double) timeout.tv_sec) * 1.e6;
 
-	    toggle_touchpad(False);
-	}
+            toggle_touchpad(False);
+        }
 
-	if (ret == 0 && pad_disabled) { /* timeout => enable event */
-	    toggle_touchpad(True);
-	}
+        if (ret == 0 && pad_disabled) { /* timeout => enable event */
+            toggle_touchpad(True);
+        }
 
-    } /* end while(1) */
+    }                           /* end while(1) */
 
     XFreeModifiermap(cbres.modifiers);
 }
-#endif /* HAVE_X11_EXTENSIONS_RECORD_H */
+#endif                          /* HAVE_X11_EXTENSIONS_RECORD_H */
 
 static XDevice *
-dp_get_device(Display *dpy)
+dp_get_device(Display * dpy)
 {
-    XDevice* dev		= NULL;
-    XDeviceInfo *info		= NULL;
-    int ndevices		= 0;
-    Atom touchpad_type		= 0;
-    Atom *properties		= NULL;
-    int nprops			= 0;
-    int error			= 0;
+    XDevice *dev = NULL;
+    XDeviceInfo *info = NULL;
+    int ndevices = 0;
+    Atom touchpad_type = 0;
+    Atom *properties = NULL;
+    int nprops = 0;
+    int error = 0;
 
     touchpad_type = XInternAtom(dpy, XI_TOUCHPAD, True);
     touchpad_off_prop = XInternAtom(dpy, SYNAPTICS_PROP_OFF, True);
     info = XListInputDevices(dpy, &ndevices);
 
-    while(ndevices--) {
-	if (info[ndevices].type == touchpad_type) {
-	    dev = XOpenDevice(dpy, info[ndevices].id);
-	    if (!dev) {
-		fprintf(stderr, "Failed to open device '%s'.\n",
-			info[ndevices].name);
-		error = 1;
-		goto unwind;
-	    }
-
-	    properties = XListDeviceProperties(dpy, dev, &nprops);
-	    if (!properties || !nprops)
-	    {
-		fprintf(stderr, "No properties on device '%s'.\n",
-			info[ndevices].name);
-		error = 1;
-		goto unwind;
-	    }
-
-	    while(nprops--)
-	    {
-		if (properties[nprops] == touchpad_off_prop)
-		    break;
-	    }
-	    if (nprops < 0)
-	    {
-		fprintf(stderr, "No synaptics properties on device '%s'.\n",
-			info[ndevices].name);
-		error = 1;
-		goto unwind;
-	    }
-
-	    break; /* Yay, device is suitable */
-	}
+    while (ndevices--) {
+        if (info[ndevices].type == touchpad_type) {
+            dev = XOpenDevice(dpy, info[ndevices].id);
+            if (!dev) {
+                fprintf(stderr, "Failed to open device '%s'.\n",
+                        info[ndevices].name);
+                error = 1;
+                goto unwind;
+            }
+
+            properties = XListDeviceProperties(dpy, dev, &nprops);
+            if (!properties || !nprops) {
+                fprintf(stderr, "No properties on device '%s'.\n",
+                        info[ndevices].name);
+                error = 1;
+                goto unwind;
+            }
+
+            while (nprops--) {
+                if (properties[nprops] == touchpad_off_prop)
+                    break;
+            }
+            if (nprops < 0) {
+                fprintf(stderr, "No synaptics properties on device '%s'.\n",
+                        info[ndevices].name);
+                error = 1;
+                goto unwind;
+            }
+
+            break;              /* Yay, device is suitable */
+        }
     }
 
-unwind:
+ unwind:
     XFree(properties);
     XFreeDeviceList(info);
     if (!dev)
-	fprintf(stderr, "Unable to find a synaptics device.\n");
-    else if (error && dev)
-    {
-	XCloseDevice(dpy, dev);
-	dev = NULL;
+        fprintf(stderr, "Unable to find a synaptics device.\n");
+    else if (error && dev) {
+        XCloseDevice(dpy, dev);
+        dev = NULL;
     }
     return dev;
 }
@@ -525,106 +542,109 @@ int
 main(int argc, char *argv[])
 {
     double idle_time = 2.0;
-    int poll_delay = 200000;	    /* 200 ms */
+    int poll_delay = 200000;    /* 200 ms */
     int c;
     int use_xrecord = 0;
 
     /* Parse command line parameters */
     while ((c = getopt(argc, argv, "i:m:dtp:kKR?v")) != EOF) {
-	switch(c) {
-	case 'i':
-	    idle_time = atof(optarg);
-	    break;
-	case 'm':
-	    poll_delay = atoi(optarg) * 1000;
-	    break;
-	case 'd':
-	    background = 1;
-	    break;
-	case 't':
-	    disable_state = TappingOff;
-	    break;
-	case 'p':
-	    pid_file = optarg;
-	    break;
-	case 'k':
-	    ignore_modifier_keys = 1;
-	    break;
-	case 'K':
-	    ignore_modifier_combos = 1;
-	    ignore_modifier_keys = 1;
-	    break;
-	case 'R':
-	    use_xrecord = 1;
-	    break;
-	case 'v':
-	    verbose = 1;
-	    break;
-	default:
-	    usage();
-	    break;
-	}
+        switch (c) {
+        case 'i':
+            idle_time = atof(optarg);
+            break;
+        case 'm':
+            poll_delay = atoi(optarg) * 1000;
+            break;
+        case 'd':
+            background = 1;
+            break;
+        case 't':
+            disable_state = TappingOff;
+            break;
+        case 'p':
+            pid_file = optarg;
+            break;
+        case 'k':
+            ignore_modifier_keys = 1;
+            break;
+        case 'K':
+            ignore_modifier_combos = 1;
+            ignore_modifier_keys = 1;
+            break;
+        case 'R':
+            use_xrecord = 1;
+            break;
+        case 'v':
+            verbose = 1;
+            break;
+        default:
+            usage();
+            break;
+        }
     }
     if (idle_time <= 0.0)
-	usage();
+        usage();
 
     /* Open a connection to the X server */
     display = XOpenDisplay(NULL);
     if (!display) {
-	fprintf(stderr, "Can't open display.\n");
-	exit(2);
+        fprintf(stderr, "Can't open display.\n");
+        exit(2);
     }
 
     if (!(dev = dp_get_device(display)))
-	exit(2);
+        exit(2);
 
     /* Install a signal handler to restore synaptics parameters on exit */
     install_signal_handler();
 
     if (background) {
-	pid_t pid;
-	if ((pid = fork()) < 0) {
-	    perror("fork");
-	    exit(3);
-	} else if (pid != 0)
-	    exit(0);
-
-	/* Child (daemon) is running here */
-	setsid();	/* Become session leader */
-	chdir("/");	/* In case the file system gets unmounted */
-	umask(0);	/* We don't want any surprises */
-	if (pid_file) {
-	    FILE *fd = fopen(pid_file, "w");
-	    if (!fd) {
-		perror("Can't create pid file");
-		exit(3);
-	    }
-	    fprintf(fd, "%d\n", getpid());
-	    fclose(fd);
-	}
+        pid_t pid;
+
+        if ((pid = fork()) < 0) {
+            perror("fork");
+            exit(3);
+        }
+        else if (pid != 0)
+            exit(0);
+
+        /* Child (daemon) is running here */
+        setsid();               /* Become session leader */
+        chdir("/");             /* In case the file system gets unmounted */
+        umask(0);               /* We don't want any surprises */
+        if (pid_file) {
+            FILE *fd = fopen(pid_file, "w");
+
+            if (!fd) {
+                perror("Can't create pid file");
+                exit(3);
+            }
+            fprintf(fd, "%d\n", getpid());
+            fclose(fd);
+        }
     }
 
     pad_disabled = False;
     store_current_touchpad_state();
 
 #ifdef HAVE_X11_EXTENSIONS_RECORD_H
-    if (use_xrecord)
-    {
-	if(check_xrecord(display))
-	    record_main_loop(display, idle_time);
-	else {
-	    fprintf(stderr, "Use of XRecord requested, but failed to "
-		    " initialize.\n");
+    if (use_xrecord) {
+        if (check_xrecord(display))
+            record_main_loop(display, idle_time);
+        else {
+            fprintf(stderr, "Use of XRecord requested, but failed to "
+                    " initialize.\n");
             exit(4);
         }
-    } else
-#endif /* HAVE_X11_EXTENSIONS_RECORD_H */
-      {
-	setup_keyboard_mask(display, ignore_modifier_keys);
-
-	/* Run the main loop */
-	main_loop(display, idle_time, poll_delay);
-      }
+    }
+    else
+#endif                          /* HAVE_X11_EXTENSIONS_RECORD_H */
+    {
+        setup_keyboard_mask(display, ignore_modifier_keys);
+
+        /* Run the main loop */
+        main_loop(display, idle_time, poll_delay);
+    }
     return 0;
 }