javelin-script.javelin-script

Pinchord · pinchord.git · Tickets · Changelog

Branches > v28.3.2 > b3d8d95 > files / javelin-script.javelin-script

// Pinchord's javelin script
// Copyright Grahp under https://grahp.dev/pinchord.git/LICENSE


// 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 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
>];

// 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 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;

// 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;
}
func should_caps(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);
}

// TODO document...
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);
}

func release(key) {
  current_keys &= ~mask(key);
  // No keys are pressed down
  if (current_keys == 0) {
    printValue("GRAHP pressed_keys", pressed_keys);

    if (should_suppress(pressed_keys)) {
      // {^}
      pressStenoKey(2);
      releaseStenoKey(2);
    } else {
      // TODO yeah :p
      // {}
      pressStenoKey(2);
      pressStenoKey(10);
      pressStenoKey(14);
      pressStenoKey(15);
      pressStenoKey(16);
      releaseStenoKey(2);
      releaseStenoKey(10);
      releaseStenoKey(14);
      releaseStenoKey(15);
      releaseStenoKey(16);
    }

    if (should_caps(pressed_keys)) {
      // {-|}
      pressStenoKey(1);
      releaseStenoKey(1);
    } else {
      // {>}
      pressStenoKey(1);
      pressStenoKey(10);
      pressStenoKey(14);
      pressStenoKey(15);
      pressStenoKey(16);
      releaseStenoKey(1);
      releaseStenoKey(10);
      releaseStenoKey(14);
      releaseStenoKey(15);
      releaseStenoKey(16);
    }


    // And emulate caps here

    simulate_steno_stroke(pressed_keys);

    // Not sure what to do about these...
    // if (should_suffix_e(pressed_keys)) {
    //   sendText("e");
    // }
    // if (should_suffix_s(pressed_keys)) {
    //   sendText("s");
    // }
    pressed_keys = 0;
  }
}