commit af2e49a16f23c6ce0b15325bcd148179718b68b0
Author: d3fault <>
Date:   Sun May 28 12:00:14 2017 -0700

    QuickDirtyAutoBackupHalper3 Commit @28 May 2017 12:00:11 -0700

diff --git a/.lastModifiedTimestamps b/.lastModifiedTimestamps
index 82f429c..7228c87 100644
--- a/.lastModifiedTimestamps
+++ b/.lastModifiedTimestamps
@@ -44,7 +44,7 @@ Documents/minddump/2016/4/1459968855-LhX846.txt:1459969203
@@ -61,6 +61,9 @@ Documents/minddump/2017/5/1495743760-MTJ814.txt:1495743877
@@ -3699,7 +3702,7 @@ Projects/IcePick/src/lib/:1431941696
@@ -3745,6 +3748,7 @@ Projects/Ideas/abc/
@@ -5903,19 +5907,19 @@ Projects/libAvGraphicsItem3/src/main.cpp:1327003410
@@ -5924,7 +5928,7 @@ Projects/wasdf/src/lib/wasdfarduino.cpp:1495656263
diff --git a/Documents/minddump/2017/5/1495995924-MTJ784.txt b/Documents/minddump/2017/5/1495995924-MTJ784.txt
new file mode 100644
index 0000000..9094c4c
--- /dev/null
+++ b/Documents/minddump/2017/5/1495995924-MTJ784.txt
@@ -0,0 +1,3 @@
Philosophers and physicists both try to explain the world, but they take completely different approaches. Philosophers tackle the problem from a more "top down" perspective, physicists from a more "bottom up". Philosophers try to whip up succinct explainations using just their brain, whereas physicists go around measuring everything and trying to figure out the complex interplay of the various aspects of nature. Physicists and philosophers seek the same thing: truth/understanding. Philosophy factors in the constant (for now) stream of new information that physicists pump out, but the opposite isn't true: physicists don't give a flying fuck about what the philosophers have to say (unless they are themselves part-time philosophers).

All that being said, I don't know which approach will "discover" the "truth" first.
diff --git a/Documents/minddump/2017/5/1495996366-LhX784.txt b/Documents/minddump/2017/5/1495996366-LhX784.txt
new file mode 100644
index 0000000..7bc53cb
--- /dev/null
+++ b/Documents/minddump/2017/5/1495996366-LhX784.txt
@@ -0,0 +1,13 @@
I think I have the [human] right to release [most of] my "copyright iffy" archive. This chain of thought came to me while imagining/preparing-for a court case that would [maybe/probably] arise out of my releasing it.

Given: to hold information private can give power to a person who acertains that information

Anyone who hacks my "copyright iffy" archive (and indeed I made it hackable because I myself want to be able to access it (it's impossible to have one without the other)) will then have power over me: can blackmail me etc etc or just see into my brain further than most others can.

Since society is flooded with copyrighted works (advertisements mostly), it is illogical to expect a human who records their [entire] life to retroactively censor those copyright infringing recordings. Such a human being would either have to detach from society entirely or spend more hours than are available in a given day editting out copyright infringing materials. e.g. if I'm up for 16 hours (recording) and sleeping for 8 hours (also recording, because I try to speak in my sleep), what hours do I have left to go and censor those 24 hours (unless I sacrifice entire days of my life doing it, which means AT LEAST half of my lifetime will be spent censoring previous days (assuming the [waking] recordings are littered with copyright infringing material, and they would be).

This might not apply retroactively but only going forward. I knew back then (though I didn't understand the gravity of it) that my talking while listening to music was probably copyright infringing, so those kinds of infringement are [probably] not justified. But going forward, not myself being the one to initiate the playback of such copyright infringing materials, I can... I _MUST_... be able to record and redistribute those works which, not because of my doing, are contaminated with copyright infringing works.

Let's ignore the fact that I try to stay away from society and it's copyrighted BRAINWASH: whether I like it or not I am forced to enter and interact with society every once in a while.

So since a government obviously can't push it's citizens away from it (society), and since it's illogical to expect/demand a human to censor their own 24/7/365 lifestream, it is therefore unconstitutional in the cases described above to charge a person with copyright infringment. If it is found to be constitutional (by stupid/corrupt lawyers/judges/politicians/etc), then the constitution itself is illogical and I will tear it up and write a new one.
diff --git a/Documents/minddump/2017/5/1495997462-nnS784.txt b/Documents/minddump/2017/5/1495997462-nnS784.txt
new file mode 100644
index 0000000..68aeb4b
--- /dev/null
+++ b/Documents/minddump/2017/5/1495997462-nnS784.txt
@@ -0,0 +1,7 @@
Overall I like Better Call Saul, despite it being rather slow so far (oh and I haven't seen the past 2 eps xD), but I found what I consider to be a rather large plot hole. Or more appropriately, an accurate representation of a typical STUPID human. Bob Odenkirk's _character_ is fucking retarded (like most humans): he's BREAKING BAD because bawww his big brother was mean to him bawwww. W.W. had a good reason to break bad: "I'm 'bout to die and want to leave my family with some money". Odenkirk's though, "boo hoo my brother blocked me from being an attourney at his company, bawww".

The point I'm trying to make is that it's stupid to let your interactions with others have such a large impact on your decision making process (ie, how you live your life).

Fuck your brother, cut him out of your life, but don't let his actions (mean'ness) affect yours!

Basically I don't want to be an asshole just because my father is ;-).
diff --git a/Projects/Ideas/ b/Projects/Ideas/
new file mode 100644
index 0000000..8b4b990
--- /dev/null
+++ b/Projects/Ideas/
@@ -0,0 +1,3 @@
OT (but definitely could implement IN wasdf):  I want a 3 button mouse, using my right ring finger for "left click and hold". I don't like that left click is the same button as the "click and hold" (I mean sure you can right click and hold, but click and holds are USUALLY with the left mouse (if you right click and hold a bunch, a 4 button mouse is 4 u)). I tend to accidentally click and hold my left mouse button when I'm only intending on clicking regularly. This could potentially have disasterous results, and programming around it is a waste of complexity (which us programmers try to minimize).

So basically hack the fucking drivers so that left mouse is always "left mouse down" -> IMMEDIATELY AFTERWARDS "left mouse up". there should be no time in between down/up to process "mouse move" events. The driver or OS needs to be designed a specific way to be able to do that (but if I'm the one synthezising(splol) it, such as the case of wasdf, then I can easily arrange for that to always happen. If you hack (or provide) the usb mouse drivers (assuming you can even find such a mouse, but I'm willing to bet you can), then you can arrange for that to always happen (notice how I didn't say easily. it might be ez af it might be a bitch).
diff --git a/Projects/wasdf/assets/ArduinoSketches/ArduinoWriteChangesOnAnalogPinsToSerial/ArduinoWriteChangesOnAnalogPinsToSerial.ino b/Projects/wasdf/assets/ArduinoSketches/ArduinoWriteChangesOnAnalogPinsToSerial/ArduinoWriteChangesOnAnalogPinsToSerial.ino
index 88dad64..d81fdf0 100644
--- a/Projects/wasdf/assets/ArduinoSketches/ArduinoWriteChangesOnAnalogPinsToSerial/ArduinoWriteChangesOnAnalogPinsToSerial.ino
+++ b/Projects/wasdf/assets/ArduinoSketches/ArduinoWriteChangesOnAnalogPinsToSerial/ArduinoWriteChangesOnAnalogPinsToSerial.ino
@@ -1,5 +1,7 @@
//rewriting the first version of this instead of just removing calibration because I also want to try to not to use pp defines/macros. pure C++ is cleaner and easier to read/modify. aside from that it's just a functionally equivalent rewrite (with the calibration stripped out since that's going to be done on the PC side)

#include <Arduino.h> //for NUM_ANALOG_INPUTS

#error "Your board does not support at least 10 analog inputs" //TODOmb: fail gracefully. but don't simply uncomment this, otherwise we will probably have a memory access violation in this code. namely when we try to pull out the "old" sensor value of finger9, but we only allocated (on the stack) an array of size NUM_ANALOG_INPUTS to hold our old sensor values
@@ -10,6 +12,7 @@ static const int NUM_FINGERS_PER_HAND = 5;
static const int HALF_THRESHOLD_FOR_NOTIFYING_OF_CHANGE = 2; //TODOoptional: this could be determined during 'calibration' (so it'd be received from PC over serial). example instructions to uesr for determining it: "move your right index finger as little as possible until you see on screen that it's registered" or some such (haven't thought this through very much, maybe it's dumb idea)

//TODOmb: when in calibrating mode maybe I should blink pin 13 rapidly, and when normal mode starts I should do 3 long pulses and then disable it (because leaving it on is dumb)
//TODOreq: during testing I noticed that the analog pin values with no sensor connected were "floating". not floating point or whatever, but their values were not zero and they also weren't consistent. they seemed to change WITH the analog pin that had a sensor connected, as it moved (I only tested with 1, but it probably applies with more than 1), but their values didn't match. I need to verify that my "pin detection" stuff is ok/safe to use (it seems to be fine despite that random floating/changing, but maybe I'm only getting lucky). If it isn't, I need to "require" 10 pins always connected, and only do FINGER DETECTION only by using the same code that I do right now for "pin detection to finger mapping", but altered slightly to only do it on  10 pins.  The default analog pins should be 0-9, but there should be a way for the user to pass in pins ("range" parsing is perhaps (but perhaps not after more thinking about it) a GUI thing, the business object wants those pin numbers in a QList<int>). What I need to verify is that the "total accrued distance moved" will always be greater on anlog pins with sensors connected; greater than pins with no sensors connected. but for now I'll just say fuck it (but maybe once 10 are connected it won't work ofc)
bool newSensorValueHasChangedEnoughThatWeWantToReportIt(int oldSensorValue, int newSensorValue)
    /*if(NewSensorValue == OldSensorValue)
diff --git a/Projects/wasdf/design/ b/Projects/wasdf/design/
index a16d756..27940e4 100644
--- a/Projects/wasdf/design/
+++ b/Projects/wasdf/design/
@@ -1 +1,12 @@
I need to realtime replay my serialized wasdf actions (the raw user input stream) on a different computer, then overlay the mouse--- scratch that, compare the sha512 of the screenshots of the computers (every GUI piece must be deterministic (and that's pretty ez tbh)). but anyways the original idea (involving mouse) was that I need to overlay the mouses of the separate computer(s) to make sure they don't get out of sync. like I mean the leonardo/micro "special" (real?) usb channel might get out of sync with my KeyboardAndMouse "dupe" channel that is getting sent over the Serial port. If the different channels of KeyboardAndMouse input [streams] get desynchronized and not corrected (and the differences would likely multiply as time grew), the entire serialized user input becomes useless. The serialization has failed (save for maybe keystrokes. I guess yea this is about mouse. but that's the thing, the mouse controls a TON of actions on the computer [that we want to be replayable FROM that user input stream].

The easiest way to "sync" is to just move your mouse into one of the corners and intentionally "overshoot it" so that the replayed mouse overlay (which is desync'd) lines up with (in that corner) the system mouse.

If I am the one "simulating" (synthesizing is better word for it imo, but the OS hooks usually call it "simulate") the mouse actions to to the OS in the first place (and what I serialize is the same exact thing as what I send to the OS) then there might not be this desync problem in the first place.

My worries pretty much boil down to this:
on the arduino in loop() somewhere I call:
Mouse.move(16, 420); //only works on micro/leonardo
Serial.print(Serialize(MouseMovement(16, 420)));
^yes they are both the same data and sent "at the same time", but they take different USB channels so I have no fucking clue that they'll be "processed" by the "cpu" at the same "time". I need to be able to guarantee that (or use the above desync correction). Being the "synthesizer/simulator" does simplify things quite a bit, and I'm pretty sure making an abstract base class/interface (with "the big 3" implementing that interface) as mostly just a copy/paste job. I could maybe even gift that to Qt (so I don't have to maintain/update it).
diff --git a/Projects/wasdf/src/lib/wasdfcalibrationconfigurationsettingsreaderwriter.cpp b/Projects/wasdf/src/lib/wasdfcalibrationconfigurationsettingsreaderwriter.cpp
index 385dc9f..faf7ce6 100644
--- a/Projects/wasdf/src/lib/wasdfcalibrationconfigurationsettingsreaderwriter.cpp
+++ b/Projects/wasdf/src/lib/wasdfcalibrationconfigurationsettingsreaderwriter.cpp
@@ -5,8 +5,9 @@
#define WasdfCalibrationConfigurationSettingsReaderWriter_FINGERS_ARRAY "fingers"
#define WasdfCalibrationConfigurationSettingsReaderWriter_FINGER_KEY "finger"
#define WasdfCalibrationConfigurationSettingsReaderWriter_KEY_ANALOG_PIN_ON_ARDUINO "analogPin"
#define WasdfCalibrationConfigurationSettingsReaderWriter_KEY_MINVALUEWasdfCalibrationConfigurationSettingsReaderWriter_KEY_MIN_VALUE "minValue"
#define WasdfCalibrationConfigurationSettingsReaderWriter_KEY_MAXVALUEWasdfCalibrationConfigurationSettingsReaderWriter_KEY_MAX_VALUE "maxValue"
#define WasdfCalibrationConfigurationSettingsReaderWriter_KEY_AT_REST_POSITION "atRestPosition"

//TODOreq: "profiles"
void WasdfCalibrationConfigurationSettingsReaderWriter::writeToSettings(QSettings &settings, const WasdfCalibrationConfiguration &wasdfCalibrationConfiguration)
@@ -21,9 +22,9 @@ void WasdfCalibrationConfigurationSettingsReaderWriter::writeToSettings(QSetting

        settings.setValue(WasdfCalibrationConfigurationSettingsReaderWriter_FINGER_KEY, /*fingerEnumToHumanReadableString*/static_cast<int>(it.key())); //I thought (while laying in bed last night) about maybe using this int-converted value in place of "i" for the settings array, but then I'd have to convert the hash to a map before inserting (not hard at all!) and idk it just might lead to problems if for example a "FingerNegative1_InvalidFinger" ever gets introduced. it's also why I changed various static_casts to int instead of uint. you never know what design changes you'll make in the future
        settings.setValue(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_ANALOG_PIN_ON_ARDUINO, it.value().AnalogPinIdOnArduino);
        settings.setValue(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_MINVALUE,settings.setValue(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_MIN_VALUE, it.value().MinValue);
        settings.setValue(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_MAXVALUE,settings.setValue(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_MAX_VALUE, it.value().MaxValue);
        settings.endGroup();settings.setValue(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_AT_REST_POSITION, it.value().AtRestPosition);

@@ -41,8 +42,9 @@ void WasdfCalibrationConfigurationSettingsReaderWriter::readFromSettings(QSettin
        Finger finger = static_cast<Finger>(settings.value(WasdfCalibrationConfigurationSettingsReaderWriter_FINGER_KEY).toInt(/*TODOmb: &convertOk error checking that converted to int was successful. also applies to the next few lines of code*/));
        WasdfCalibrationFingerConfiguration fingerConfigutation;
        fingerConfigutation.AnalogPinIdOnArduino = settings.value(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_ANALOG_PIN_ON_ARDUINO).toInt();
        fingerConfigutation.MinValue = settings.value(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_MINVALUE).toInt();settings.value(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_MIN_VALUE).toInt();
        fingerConfigutation.MaxValue = settings.value(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_MAXVALUE).toInt();settings.value(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_MAX_VALUE).toInt();
        fingerConfigutation.AtRestPosition = settings.value(WasdfCalibrationConfigurationSettingsReaderWriter_KEY_AT_REST_POSITION).toInt();

        *out_wasdfCalibrationConfiguration->insert(finger, fingerConfigutation);