Pointer glide idea for Synaptics driver

[Dylan McCall]

Here's a little experiment I threw together.

First of all, sorry about the huge quantity of babbling. In short, you
can jump to the bottom, apply the patch and say what you think.

In long (with chapters :P):

                      The background (rationale?):

The mouse is a successful input technique because the physical device
makes sense. It "feels" like the mouse pointer on the screen and obeys
the laws of physics if someone throws it (not that anyone would do
that). The important part is that the user controls the pointer directly
and those motions translate accurately on screen. In the real world, the
interaction here would be understandable with any similarly sized object
floating through whatever surface the mouse is being used on.

The touchpad (trackpad) is often accused of being a difficult input
device with severe ergonomics issues. With a touchpad, everything is an
indirect type of motion without any physical feedback (which is perhaps
why it has been, until now, widely despised). The touchpad doesn't move;
it just acts as a window through which the pointer is nudged. At the
moment the pointer is a difficult object to nudge. A bit like pushing it
through syrupy goo. It just doesn't move unless the user PUSHES it at
all times. It doesn't make as much sense and it doesn't feel like it
applies to the real world, no matter what paper-like texture the
manufacturer puts over the touchpad. (They should really be using a
sticky goo texture if they want it to feel consistent).

I believe this can all be fixed in software, so I tried!

                                My idea:

My idea is to give the pointer a more believable, and at the same time
more comfortable presence when using the touchpad. Since the device
itself doesn't provide any kind of feedback, we have to assume "the
pointer" is fairly light, with a small amount of friction so it can be
pushed easily. This way the user can interact more naturally. Silly, but
I'm sure this can all be linked to some pseudo-scientific psychology
babble.

It's actually a really simple hack, too. If you haven't guessed it, this
is all achieved through ridiculously primitive physics; essentially that
kinetic scrolling stuff everyone loves. If the finger is lifted while
moving (a flicking motion), the pointer keeps moving along its path,
gradually slowed by friction.

Normal pointer movement still works fine since people generally stop at
the end of a movement while still touching the pad, and if not are
likely to click it again in a moment. Correct me if wrong, but I have
seen a few instances (counting myself :P) where people unconsciously
flick the touchpad and expect the pointer to be flicked... but it is
not!

                               The patch:

I attached a patch. My patch is unobtrusive, mainly adding code to
synaptics.c (as well as some little configuration variables elsewhere).
The heavy calculations are only carried out if PointerGlide is set to 1
(enabled). By default, PointerGlide is set to 0. Maths are proof of
concept stage; not optimized. (Matt Helsley on the xorg list gave me
some great suggestions to make those faster).

synclient has been adjusted, adding support for the new configuration
variables PointerGlide, PointerGlideFriction and PointerGlideMaxSpeed.

To test, you will need to apply the (attached) patch to
xf86-input-synaptics, then build both the patched driver and synclient.
The patch is based on the driver from xorg's Git repository on
freedesktop.org, but it should work in the apt-source copy as well.
(Easy enough to do it manually, too; it isn't much code). The
configuration can be done via xorg.conf, but synclient makes it much
more pleasant.

To enable this, run "synclient PointerGlide=1".

The default friction and max speed is the same as right now on my
computer (biggish touchpad, 14" screen with 1280x800 resolution). The
other PointerGlide options are listed if you run synclient -l and can be
played with at any time.

                               The rest:

I originally submitted this as an upstream feature request + patch, but
the folks there convinced me that it was a bit too crazy (and untested)
of an idea for them, though it may make sense somewhere closer to a
desktop... So I am posting here to explore the idea. Two things:

      * What do you think? (Should I just accept that this is a
        ridiculous concept and move on, or could it be useful? :P). Is it comfortable?
        Confusing? Handy? Did you need to play with the settings?
      * Any suggestions for how this can be done outside of the driver?
        It creeped me out while working on this that my insignificant
        modifications to a little input driver could bring down the
        entire session in the event of a crash. I imagine it's a major
        pain to maintain... so are there examples of this type of stuff
        being implemented at a higher level?

Personally, I think this does awesome things for ergonomics and probably
is saving me from developing RSI when I am without a mouse I have asked a few
other people to play with it, bringing positive results as well.
However, I'd love to hear from anyone else on the topic :)



Bye,
Dylan
-------------- next part --------------
A non-text attachment was scrubbed...
Name: synaptics-pointer-glide.diff
Type: text/x-patch
Size: 8394 bytes
Desc: 
URL: <https://lists.ubuntu.com/archives/ubuntu-devel-discuss/attachments/20090209/3fea40a7/attachment.bin>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 197 bytes
Desc: This is a digitally signed message part
URL: <https://lists.ubuntu.com/archives/ubuntu-devel-discuss/attachments/20090209/3fea40a7/attachment.sig>