Implementing higher-order clicks

Clairvoyant Interaction | Chui’s counterpoint

Clairvoyant Interaction | Chui’s counterpoint — Sun, 24 Aug 2008 19:41:43 GMT

PingBack from http://www.redmountainsw.com/wordpress/archives/clairvoyant-interaction

Using modular arithmetic to avoid timing overflow problems

The Old New Thing — Tue, 31 May 2005 16:03:24 GMT

Avoiding timing overflows is easier than you think.

re: Implementing higher-order clicks

Joshua Schaeffer — Thu, 11 Nov 2004 23:58:00 GMT

Merle, triple clicks in Word are one of the biggest time savers for me. Sometimes I'm in this utmost lazy chair position where even using right-click is a tiresome expense of a few seconds. Although I personally wouldn't mind a "click chart" like so:

1 - (normal)
2 - word
3 - sentence
4 - paragraph
5 - everything

re: Implementing higher-order clicks

Raymond Chen — Tue, 19 Oct 2004 15:05:00 GMT

You can think of modulo arithmetic as points around a circle. Subtraction gives you the distance along the circumference, which doesn't care where your zero marker is.

Another way of looking at subtraction is to view it as a translation of the circle, which is isometric (distance-preserving).

re: Implementing higher-order clicks

krisztian pinter — Tue, 19 Oct 2004 09:50:00 GMT

thanks, muro!

in my mind, result of substraction was the same as the distance. in a "modulo world", it is not that easy.

re: Implementing higher-order clicks

muro — Tue, 19 Oct 2004 09:10:00 GMT

Overlooked in 32 bit part:
GetDoubleClickTime() = 10: would mean, the first 32bit example is also single click (as time difference is 15), but I hope you get the idea.

re: Implementing higher-order clicks

muro — Tue, 19 Oct 2004 09:07:00 GMT

To clarify: consider, the difference calculation is correct:
tmClick - g_tmLastClick really calculates the time difference between the clicks correctly for our purpose, even when an overflow happens.

First, lets show the overflow calculations with 8bits. GetDoubleClickTime() = 0x10:
0x01 - 0xff = 0x01 + ~(0xff) = 0x01 + (0x100 - 0xff) = 0x01 + 0x01 = 0x02 -> double click
0x21 - 0xff = 0x21 + ~(0xff) = 0x21 + (0x100 - 0xff) = 0x21 + 0x01 = 0x22 -> single click

Then the same for 32bit:
GetDoubleClickTime() = 10:
g_tmLastClick == 4bil = e.g.: 2^32 - 10
tmClick == 5:
5 - 4bil = 5 + ~(4bil) = 5 + (2^32 - 10) = 5 + 10 = 15 -> double click

tmClick == 60000 (click one minute later):
60000 - 4bil = 60000 + ~(4bil) = 60000 + (2^32 - 10) = 60000 + 10 = 60010 -> single click

Sometimes it helps to think in lower precision. Makes all the scary big numbers go away :-). And off course - remember that subtraction is addition of complement. Makes it even less scary.

re: Implementing higher-order clicks

krisztian pinter — Tue, 19 Oct 2004 07:30:00 GMT

i still not get that DoubleClickTime trick

say
g_tmLastClick == ~4bil
tmClick == 10

now 10 - ~4bil is a large number because of the overflow. it will treated as a double. OK.

but

g_tmLastClick == ~4bil
tmClick == 60000 (click one minute later)

60000 - ~4bil is still a large number, so it will also be treated as double, however it is clearly a single.

can someone explain this to me?

re: Implementing higher-order clicks

Cyrus Najmabadi — Tue, 19 Oct 2004 07:06:00 GMT

Ugh, you had to write the code for this now after i spent a good half day getting this working right in some code i was writing. What's worse is that you're the one who told me how to do it, but you weren't willing to take the time to write this up :-P

Oh, and to those of you who are interested this was to add a feature in C# where as you click more and more we start selecting more and more of the C# code you've written based on the parse tree.

So we'll start by selecting the expression, then the statement, the then method, then the class, namespace, etc. Basically each successive click selects one higher level in the parse tree.

it's a feature you grow to love :-)

re: Implementing higher-order clicks

Raymond Chen — Tue, 19 Oct 2004 05:40:00 GMT

Oh, you're right. I forgot what I wrote. (I wrote it so long ago.)