The mouse data in this particular code is a pair of integers (x, y) that define the position of the mouse relative to top left corner of the dialog the position is retrieved from. For a dialog of size (X, Y), the top left corner is (0, 0), the bottom right corner is (X, Y).
In this particular case, the dialog is created with a default size so it depends on the desktop resolution and the default system font size, which influences the size of the elements within that dialog (and thus how large Qt is going to create it). Assuming a desktop resolution of 800*600, I believe the dialog could get as small as 300 pixels wide and 150 high. This gives us x E [0, 150] and y E [0, 300], so an average of 16 bits for the pair in some pretty bad conditions.
Timestamps are in the plain old UNIX format, i.e. the amount of time that has passed since Jan 1st 1970. I believe the timestamp is in milliseconds in this case (I would have to double check). The more significant bits of the timestamp won't change at all during this operation, so only the bottom few really matter for consecutive throws. If you take [3-8] seconds per throw and key press that's about 12 bits of entropy per, but assuming I messed up and the timestamps are in seconds, then you are closer to 6~8 bits on the span of 100 throws.
Interesting.
So that I can understand better what's going on, are you able to tell me:
If we do "self.entropyAccum.append" of an integer (for example a cursor location) that has 16 bits of entropy and then later repeat the process again for another cursor location, do we now have an entropy of 32 bits?
In other words, did the first recording of the cursor location fill in this entropy bit sequence:
a1 a2 ... a16 (where each a can be either 0 or 1)
and the second recording of the cursor location fill in additional 16 bits:
a1 a2 ... a16 a17 a18 ... a32 ?
If my understanding in correct, is there a threshold at which it "wraps over"? For instance, after we have filled in 256 bits, will the next "self.entropyAccum.append" start over from bit zero, or will it continue past 256 bits? Is there any such a limit at all?
For example, in my above "screen dividing" example, is there a point at which I would actually stop making a difference in the entropy at some point (say, after throwing the die a million times)?