Perform movement calculations using floats

Using floats made dividing the speed by a factor much easier to
calculate.

Also, as I've used ptrkeys as my primary pointing mechanism the
importance of being able to use it single-handedly has been made obvious
to me, and the changes to the bindings reflect this.

Author: torbiak

command.h

@@ -41,9 +41,9 @@ void move2scroll(const Arg *enable); // enable is treated as a boolean.
 void togglem2s(const Arg *ignored);
 void scrollstart(const Arg *dir);
 void scrollstop(const Arg *dir);
-// n is an unsigned int.
-void multiplyspeed(const Arg *uint);
-void dividespeed(const Arg *uint);
+// factor is a float.
+void multiplyspeed(const Arg *factor);
+void dividespeed(const Arg *factor);
 
 // Clicking:
 // btn can be any value from enum Mouse.

config.def.h

@@ -1,7 +1,7 @@
 // "Frames" or updates per second.
 #define FPS 60
 // Pixels per second.
-#define BASE_SPEED 150
+#define BASE_SPEED 1000.0
 // Events per second.
 #define BASE_SCROLL 10
 
@@ -29,12 +29,12 @@ static Key keys[] = {
 // Scrolling
 {0,          XK_Shift_L,    0,              move2scroll,         {.i=1},           move2scroll,     {.i=0}},
 {0,          XK_f,          0,              togglem2s,           {0},              NULL,            {0}},
-// Accelerate using the right hand.
-{0,          XK_j,          0,              multiplyspeed,       {.i=2},           dividespeed,     {.i=2}},
-{0,          XK_k,          0,              multiplyspeed,       {.i=4},           dividespeed,     {.i=4}},
-{0,          XK_Alt_L,      0,              multiplyspeed,       {.i=6},           dividespeed,     {.i=6}},
-{0,          XK_l,          0,              multiplyspeed,       {.i=8},           dividespeed,     {.i=8}},
-{0,          XK_semicolon,  0,              multiplyspeed,       {.i=64},          dividespeed,     {.i=64}},
+// Speed multiply/divide.
+{0,          XK_Alt_L,      0,              dividespeed,         {.f=8},           multiplyspeed,   {.f=8}},
+{0,          XK_j,          0,              dividespeed,         {.f=8},           multiplyspeed,   {.f=8}},
+{0,          XK_k,          0,              dividespeed,         {.f=2},           multiplyspeed,   {.f=2}},
+{0,          XK_l,          0,              multiplyspeed,       {.f=4},           dividespeed,     {.f=4}},
+{0,          XK_semicolon,  0,              multiplyspeed,       {.f=8},           dividespeed,     {.f=8}},
 // Left-handed clicking.
 {0,          XK_e,          0,              clickpress,          {.ui=BTNRIGHT},   clickrelease,    {.ui=BTNRIGHT}},
 {0,          XK_r,          0,              clickpress,          {.ui=BTNMIDDLE},  clickrelease,    {.ui=BTNMIDDLE}},

debug.h

@@ -0,0 +1,10 @@
+void
+printmovement()
+{
+	Movement *p = &mvptr;
+	tracef("ptr: base=%.3g dir=%u mul=%.3g xc=%d yc=%d",
+			p->basespeed, p->dir, p->mul, p->xcont, p->ycont);
+	Movement *s = &mvscroll;
+	tracef("scroll: base=%.3g dir=%u mul=%.3g xc=%d yc=%d",
+			s->basespeed, s->dir, s->mul, s->xcont, s->ycont);
+}

pk.c

@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <errno.h>
+#include <math.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
@@ -198,42 +199,36 @@ static void
 requestpointermovement(Movement *m, int usec)
 {
 	if (!m->dir) return;
-	// -1, 0, 1
-	int xsign = ((m->dir & RIGHT) ? 1 : 0) - ((m->dir & LEFT) ? 1 : 0);
-	int ysign = ((m->dir & UP) ? 1 : 0) - ((m->dir & DOWN) ? 1 : 0);
-	// x, y units per second
-	int xps = m->basespeed * xsign * m->mul * usec + m->xrem;
-	int yps = m->basespeed * ysign * m->mul * usec + m->yrem;
-	int dx =  xps / 1000000;
-	int dy = - yps / 1000000;
-	// Subunit remainders.
-	m->xrem = xps % 1000000;
-	m->yrem = yps % 1000000;
+	// xsign and ysign can be one of -1, 0, 1.
+	double xsign = ((m->dir & RIGHT) ? 1 : 0) - ((m->dir & LEFT) ? 1 : 0);
+	double ysign = ((m->dir & UP) ? 1 : 0) - ((m->dir & DOWN) ? 1 : 0);
+	double dx = m->basespeed * xsign * m->mul * usec / 1e6 + m->xrem;
+	double dy = - m->basespeed * ysign * m->mul * usec / 1e6 + m->yrem;
+	double dummy;
+	m->xrem = modf(dx, &dummy);
+	m->yrem = modf(dy, &dummy);
 
-	XWarpPointer(dpy, None, None, 0, 0, 0, 0, dx, dy);
+	XWarpPointer(dpy, None, None, 0, 0, 0, 0, (int) dx, (int) dy);
 }
 
 static void
 requestscrolling(Movement *m, int usec)
 {
 	if (!m->dir) return;
-	// -1, 0, 1
-	int xsign = ((m->dir & RIGHT) ? 1 : 0) - ((m->dir & LEFT) ? 1 : 0);
-	int ysign = ((m->dir & UP) ? 1 : 0) - ((m->dir & DOWN) ? 1 : 0);
-	// x, y units per second
-	int xps = m->basespeed * xsign * m->mul * usec + m->xrem;
-	int yps = m->basespeed * ysign * m->mul * usec + m->yrem;
-	int dx =  xps / 1000000;
-	int dy = - yps / 1000000;
-	// Subunit remainders.
-	m->xrem = xps % 1000000;
-	m->yrem = yps % 1000000;
+	// xsign and ysign can be one of -1, 0, 1.
+	double xsign = ((m->dir & RIGHT) ? 1 : 0) - ((m->dir & LEFT) ? 1 : 0);
+	double ysign = ((m->dir & UP) ? 1 : 0) - ((m->dir & DOWN) ? 1 : 0);
+	double dx = m->basespeed * xsign * m->mul * usec / 1e6 + m->xrem;
+	double dy = m->basespeed * ysign * m->mul * usec / 1e6 + m->yrem;
+	double dummy;
+	m->xrem = modf(dx, &dummy);
+	m->yrem = modf(dy, &dummy);
 
 	unsigned int xbutton = (m->dir & LEFT) ? SCROLLLEFT : SCROLLRIGHT;
-	unsigned int ybutton = (m->dir & UP) ? 4 : 5;
+	unsigned int ybutton = (m->dir & UP) ? SCROLLUP : SCROLLDOWN;
 
-	int xevents = abs(dx);
-	int yevents = abs(dy);
+	int xevents = abs((int) dx);
+	int yevents = abs((int) dy);
 	// Scroll immediately after a scroll key is pressed, but adjust the
 	// remainder so the configured number of scroll events occur in the first
 	// second.
@@ -576,10 +571,8 @@ move2scroll(const Arg *enable)
 void
 togglem2s(const Arg *ignored)
 {
-	printmovement();
 	Arg arg = {.i=!ismove2scroll};
 	move2scroll(&arg);
-	printmovement();
 }
 
 void
@@ -597,19 +590,19 @@ scrollstop(const Arg *dir)
 }
 
 void
-multiplyspeed(const Arg *n)
+multiplyspeed(const Arg *factor)
 {
-	if (!n) die("multiplyspeed: NULL arg");
-	mvptr.mul += n->ui;
-	mvscroll.mul += n->ui;
+	if (!factor) die("multiplyspeed: NULL arg");
+	mvptr.mul *= factor->f;
+	mvscroll.mul *= factor->f;
 }
 
 void
-dividespeed(const Arg *n)
+dividespeed(const Arg *factor)
 {
-	if (!n) die("dividespeed: NULL arg");
-	mvptr.mul -= n->ui;
-	mvscroll.mul -= n->ui;
+	if (!factor) die("dividespeed: NULL arg");
+	mvptr.mul /= factor->f;
+	mvscroll.mul /= factor->f;
 }
 
 void

pk.h

@@ -4,18 +4,18 @@
 #include <X11/Xlib.h>
 
 typedef struct {
-	unsigned int basespeed;
+	double basespeed;
 	unsigned int dir;  // Bits from enum Direction.
-	unsigned int mul;
-	int xrem, yrem; // Subunit remainders.
+	double mul;
+	double xrem, yrem; // Subunit remainders.
 	int xcont, ycont; // Continuing a movement?
 } Movement;
 
 typedef union {
 	int i;
 	unsigned int ui;
 	unsigned long ul;
-	float f;
+	double f;
 	const void *v;
 } Arg;