javelin-script.javelin-script
Pinchord · pinchord.git · Tickets · Changelog
Branches > v27.0 > bb4c3ac > files / javelin-script.javelin-script
// Pinchord's javelin script
// Uhh put a copyright notice here probably.
// TODO:
// - Put configurable things first
// - try to figure out the story of changing the layout?
// - Fallback lookup with # and + and friends
// Bitset of keys pressed in the last stroke
// Reset after the stroke has been sent
var pressed_keys;
// Bitset of the current keys pressed down
// Changes every time a key is pressed/released
var current_keys;
const undo_stack_underflow = 234890; // Random number that couldn't be a byte idk :p
const regular_steno_undo = 423908;
const undo_stack_size = 256;
var undo_stack = createBuffer(undo_stack_size * 2); // Each entry is 16 bits or 2 bytes
var undo_ptr = 0;
var undo_size = 0;
const key_masks = [[
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00
// X1 through X26
01 02 03 04 05 06 07 08 09 0a 0b 0c
0d 0e 0f 10 11 12 13 14 15 16
17 18 19 1a
]];
// Aaaagh
// How do the bits in the bitmask map to these keys?
// What are the bits in the bit mask
const mappings_to_steno_keys_to_emulate = [<
//00,
26, 1, 3, 5, 7, 9, 17, 18, 20, 22, 24, 38,
26, 2, 4, 6, 8, 19, 21, 23, 25, 38,
10, 14, 15, 16
>];
const INVALID_CHORD = 0;
// Could these be made into array maps for easier editing?
// Uhhh, how can I automate making these?
const starter_bits = [[03 0f 04 10 05 11 06 ff]];
const starters = [<
"", "t", "s", "st", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127"
>];
const vowel_bits = [[17 18 19 1a 07 ff]];
const vowels = [<
"", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", INVALID_CHORD, "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", INVALID_CHORD
>];
const final_bits = [[08 12 09 13 0a 14 0b 15 ff]];
const finals = [<
"", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199", "200", "201", "202", "203", "204", "205", "206", "207", "208", "209", "210", "211", "212", "213", "214", "215", "216", "217", "218", "219", "220", "221", "222", "223", "224", "225", "226", "227", "228", "229", "230", "231", "232", "233", "234", "235", "236", "237", "238", "239", "240", "241", "242", "243", "244", "245", "246", "247", "248", "249", "250", "251", "252", "253", "254", "255
>];
// These are stripped from lookup!
const affix_bits = [[01 0d 02 0e 0c 16 ff]];
// Baked into logic idk smiesmie
const affixes = [<
"s", "s", "#", "+", "e", "e"
>];
// Another bank of special (affix) keys to be stripped from lookup?
func mask(key) var {
return 1 << key_masks[key];
}
// const keys = [<
// "-s", "#-", "T-", "P-", "W-", "&-", "^", "-L", "-P", "-F", "-T", "-e",
// "-s", "+-", "S-", "W-", "R-", "-R", "-K", "-S", "-*", "-e",
// "A", "O", "I", "U"
// >];
func strlen(string) var {
var i = 0;
while (string[i] != 0) {
i += 1;
}
return i;
}
func undo_push(count) {
undo_stack[<undo_ptr>] = count;
undo_ptr = (undo_ptr + 1) % undo_stack_size;
if (undo_size < undo_stack_size) {
undo_size += 1;
}
}
// Returns a number, or the 2 special undo cases
func undo_pop() var {
// TODO this accounts for the size rolling over right?
if (undo_size > 0) {
// why would you add something and then mod it?
undo_ptr = (undo_ptr - 1 + undo_stack_size) % undo_stack_size;
undo_size -= 1;
return undo_stack[<undo_ptr>];
} else {
return undo_stack_underflow;
}
}
const SC_BACKSPACE = 0x2a;
func backspace(n) {
var i = 0;
while (i < n) {
tapScanCode(SC_BACKSPACE);
i += 1;
}
}
func undo() {
var count = undo_pop();
printValue("count is", count);
if (count == regular_steno_undo) {
sendText("Emulate a regular steno undo... Eventually")
}
else if (count != undo_stack_underflow) {
backspace(count);
}
}
func strip_affixes(keys) var {
var i = 0;
while (affix_bits[i] != 0xff) {
// Is this right?
keys &= ~(1 << (affix_bits[i] - 1));
i += 1;
}
return keys;
}
// The X1-X26 keys begin at stenoKey 38 and end at 63, so just add 37 to the index to get the steno key code.
const X_key_offset = 37;
func pressAllKeys(keys) {
// Start at 1?
var bit = 0;
while (bit < 26) {
if (keys & (1 << bit)) {
pressStenoKey(mappings_to_steno_keys_to_emulate[<bit>]);
}
bit += 1;
}
bit = 0;
while (bit < 26) {
if (keys & (1 << bit)) {
releaseStenoKey(mappings_to_steno_keys_to_emulate[<bit>]);
}
bit += 1;
}
}
func simulate_steno_stroke(keys) {
// Strip # + e etc. from keys
// Get the affixes and send {^}, {-|}, and ^e for each
var lookup_keys = strip_affixes(keys);
pressAllKeys(lookup_keys);
}
// Probably shouldn't be hard coded
func should_suffix_e(keys) var {
var i = 0;
while (affix_bits[i] != 0xff) {
if (affixes[<i>] == "e") {
if (keys & (1 << (affix_bits[i] - 1))) {
return 1;
}
}
i += 1;
}
return 0;
}
func should_suffix_s(keys) var {
var i = 0;
while (affix_bits[i] != 0xff) {
if (affixes[<i>] == "s") {
if (keys & (1 << (affix_bits[i] - 1))) {
return 1;
}
}
i += 1;
}
return 0;
}
func should_suppress(keys) var {
var i = 0;
while (affix_bits[i] != 0xff) {
if (affixes[<i>] == "+") {
if (keys & (1 << (affix_bits[i] - 1))) {
return 1;
}
}
i += 1;
}
return 0;
}
// Key is an index, I guess from gemini?
func press(key) {
pressed_keys |= mask(key);
current_keys |= mask(key);
}
func release(key) {
current_keys &= ~mask(key);
// No keys are pressed down
if (current_keys == 0) {
printValue("GRAHP pressed_keys", pressed_keys);
var starter_letters = get_from_bank(starter_bits, pressed_keys, starters);
var vowel_letters = get_from_bank(vowel_bits, pressed_keys, vowels);
var final_letters = get_from_bank(final_bits, pressed_keys, finals);
// Check for undo and call undo()?
// How can you even get the text count, ugh.
if (starter_letters && vowel_letters && final_letters) {
// Eventually don't hard code this obviously :p
// Make it into a stroke check however that would work
if (starter_letters == "" && vowel_letters == "" && final_letters == "3") {
undo();
} else {
var extra_size = 0;
if (!should_suppress(pressed_keys)) {
sendText(" ");
extra_size += 1;
}
// Caps somehow :p
sendText(starter_letters);
sendText(vowel_letters);
sendText(final_letters);
if (should_suffix_e(pressed_keys)) {
sendText("e");
extra_size += 1;
}
if (should_suffix_s(pressed_keys)) {
sendText("s");
extra_size += 1;
}
undo_push(strlen(starter_letters) + strlen(vowel_letters) + strlen(final_letters) + extra_size);
}
} else {
// Need to add a special value here and emulate a regular steno undo plus padding for suffixes probably?
simulate_steno_stroke(pressed_keys);
if (should_suffix_e(pressed_keys)) {
sendText("e");
// extra_size += 1;
}
if (should_suffix_s(pressed_keys)) {
sendText("s");
// extra_size += 1;
}
}
pressed_keys = 0;
}
}
// Returns 0 if the list is not properly terminated with '0xff'
func get_from_bank(bits, pressed_keys, bank) var {
var bank_index = 0;
var i = 0;
while (i < 32) {
while (bits[i] != 0xff) {
// TODO yeah I don't really know why this is -1 but it seems to work?
if (pressed_keys & (1 << bits[i] - 1)) {
bank_index |= (1 << i);
}
i += 1;
}
return bank[<bank_index>];
}
return 0;
}