logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

engine.c (12424B)

    

  1. /*  This is a stripped down version of the Georgi engine meant for use with
  2.  *  Ginni. As such serial-Steno features are disabled, chords are 16bits and
  3.  *  crap is removed where possible
  4.  *
  5.  *  Do not use this on anything other then Ginny if you want to be sane
  6.  */
  7. #include "engine.h"
  9. // Chord state
  10. C_SIZE cChord     = 0;  // Current Chord
  11. int    chordIndex = 0;  // Keys in previousachord
  12. C_SIZE pressed    = 0;  // number of held keys
  13. C_SIZE chordState[32];  // Full Chord history
  14. #define QWERBUF 24      // Size of chords to buffer for output
  16. bool   repeatFlag  = false;  // Should we repeat?
  17. C_SIZE pChord      = 0;      // Previous Chord
  18. C_SIZE stickyBits  = 0;      // Or'd with every incoming press
  19. int    pChordIndex = 0;      // Keys in previousachord
  20. C_SIZE pChordState[32];      // Previous chord sate
  22. // Key Dicts
  23. extern const struct keyEntry     keyDict[];
  24. extern const struct comboEntry   cmbDict[];
  25. extern const struct funcEntry    funDict[];
  26. extern const struct stringEntry  strDict[];
  27. extern const struct specialEntry spcDict[];
  28. extern size_t                    specialLen;
  29. extern size_t                    stringLen;
  30. extern size_t                    funcsLen;
  31. extern size_t                    keyLen;
  32. extern size_t                    comboLen;
  34. // Mode state
  35. enum MODE { STENO = 0, QWERTY, COMMAND };
  36. enum MODE pMode;
  37. enum MODE cMode = QWERTY;
  39. // Command State
  40. #define MAX_CMD_BUF 20
  41. uint8_t CMDLEN = 0;
  42. uint8_t CMDBUF[MAX_CMD_BUF];
  44. // Key Repeat state
  45. bool     inChord    = false;
  46. bool     repEngaged = false;
  47. uint16_t repTimer   = 0;
  48. #define REP_INIT_DELAY 750
  49. #define REP_DELAY 25
  51. // Mousekeys state
  52. bool   inMouse = false;
  53. int8_t mousePress;
  55. // All processing done at chordUp goes through here
  56. void processKeysUp(void) {
  57.     // Check for mousekeys, this is release
  58. #ifdef MOUSEKEY_ENABLE
  59.     if (inMouse) {
  60.         inMouse = false;
  61.         mousekey_off(mousePress);
  62.         mousekey_send();
  63.     }
  64. #endif
  66.     // handle command mode
  67. #ifdef COMMAND_MODE
  68.     if (cChord == COMMAND_MODE) {
  69. #    ifndef NO_DEBUG
  70.         uprintf("COMMAND Toggle\n");
  71. #    endif
  72.         if (cMode != COMMAND) {  // Entering Command Mode
  73.             CMDLEN = 0;
  74.             pMode  = cMode;
  75.             cMode  = COMMAND;
  76.         } else {  // Exiting Command Mode
  77.             cMode = pMode;
  79.             // Press all and release all
  80.             for (int i = 0; i < CMDLEN; i++) {
  81.                 register_code(CMDBUF[i]);
  82.             }
  83.             clear_keyboard();
  84.         }
  85.     }
  86. #endif
  88.     // Process and reset state
  89.     processChord();
  90.     cChord     = pressed;
  91.     inChord    = false;
  92.     chordIndex = 0;
  93.     clear_keyboard();
  94.     repEngaged = false;
  95.     for (int i = 0; i < 32; i++) chordState[i] = 0xFFFF;
  96. }
  98. // Update Chord State
  99. bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
  100.     // Check if we should run at all
  101.     if (process_engine_pre(cChord, keycode, record) == false) return true;
  103.     // Everything happens in here when steno keys come in.
  104.     // Bail on keyup
  106.     // Update key repeat timers
  107.     repTimer = timer_read();
  108.     bool pr  = record->event.pressed;
  109.     // Switch on the press adding to chord
  110.     switch (keycode) {
  111.         ENGINE_CONFIG
  112.         default:
  113.             return true;
  114.     }
  116.     // Handle any postprocessing
  118.     // All keys up, send it!
  119.     if (inChord && !pr && (pressed & IN_CHORD_MASK) == 0) {
  120.         processKeysUp();
  121.         return false;
  122.     }
  123.     if (pressed == 0 && !pr) {
  124.         processKeysUp();
  125.         return false;
  126.     }
  128.     cChord |= pressed;
  129.     cChord  = process_engine_post(cChord, keycode, record);
  130.     inChord = (cChord & IN_CHORD_MASK) != 0;
  132.     // Store previous state for fastQWER
  133.     if (pr) {
  134.         chordState[chordIndex] = cChord;
  135.         chordIndex++;
  136.     }
  138. #ifndef NO_DEBUG
  139.     uprintf("Chord: %u\n", cChord);
  140. #endif
  141.     return false;
  142. }
  143. void matrix_scan_user(void) {
  144.     // We abuse this for early sending of key
  145.     // Key repeat only on QWER/SYMB layers
  146.     if (cMode != QWERTY || !inChord) return;
  148.         // Check timers
  149. #ifndef NO_HOLD
  150.     if (!repEngaged && timer_elapsed(repTimer) > REP_INIT_DELAY) {
  151.         // Process Key for report
  152.         processChord();
  154.         // Send report to host
  155.         send_keyboard_report();
  156.         repEngaged = true;
  157.     }
  158. #endif
  159. };
  161. // Try and match cChord
  162. C_SIZE mapKeys(C_SIZE chord, bool lookup) {
  163.     lookup = lookup || repEngaged;
  164. #ifndef NO_DEBUG
  165.     if (!lookup) uprint("SENT!\n");
  166. #endif
  167.     // Single key chords
  168.     for (int i = 0; i < keyLen; i++) {
  169.         if (keyDict[i].chord == chord) {
  170.             if (!lookup) SEND(keyDict[i].key);
  171.             return chord;
  172.         }
  173.     }
  175.     // strings
  176.     for (int i = 0; i < stringLen; i++) {
  177.         struct stringEntry fromPgm;
  178.         memcpy_P(&fromPgm, &strDict[i], sizeof(stringEntry_t));
  179.         if (fromPgm.chord == chord) {
  180.             if (!lookup) {
  181.                 if (get_mods() & (MOD_LSFT | MOD_RSFT)) {
  182.                     set_mods(get_mods() & ~(MOD_LSFT | MOD_RSFT));
  183.                     set_oneshot_mods(MOD_LSFT);
  184.                 }
  185.                 send_string_P((PGM_P)(fromPgm.str));
  186.             }
  187.             return chord;
  188.         }
  189.     }
  191.     // combos
  192.     for (int i = 0; i < comboLen; i++) {
  193.         struct comboEntry fromPgm;
  194.         memcpy_P(&fromPgm, &cmbDict[i], sizeof(comboEntry_t));
  195.         if (fromPgm.chord == chord) {
  196. #ifndef NO_DEBUG
  197.             uprintf("%d found combo\n", i);
  198. #endif
  200.             if (!lookup) {
  201.                 uint8_t comboKeys[COMBO_MAX];
  202.                 memcpy_P(&comboKeys, fromPgm.keys, sizeof(uint8_t) * COMBO_MAX);
  203.                 for (int j = 0; j < COMBO_MAX; j++)
  204. #ifndef NO_DEBUG
  205.                     uprintf("Combo [%u]: %u\n", j, comboKeys[j]);
  206. #endif
  208.                 for (int j = 0; (j < COMBO_MAX) && (comboKeys[j] != COMBO_END); j++) {
  209. #ifndef NO_DEBUG
  210.                     uprintf("Combo [%u]: %u\n", j, comboKeys[j]);
  211. #endif
  212.                     SEND(comboKeys[j]);
  213.                 }
  214.             }
  215.             return chord;
  216.         }
  217.     }
  219.     // functions
  220.     for (int i = 0; i < funcsLen; i++) {
  221.         if (funDict[i].chord == chord) {
  222.             if (!lookup) funDict[i].act();
  223.             return chord;
  224.         }
  225.     }
  227.     // Special handling
  228.     for (int i = 0; i < specialLen; i++) {
  229.         if (spcDict[i].chord == chord) {
  230.             if (!lookup) {
  231.                 uint16_t arg = spcDict[i].arg;
  232.                 switch (spcDict[i].action) {
  233.                     case SPEC_STICKY:
  234.                         SET_STICKY(arg);
  235.                         break;
  236.                     case SPEC_REPEAT:
  237.                         REPEAT();
  238.                         break;
  239.                     case SPEC_CLICK:
  240.                         CLICK_MOUSE((uint8_t)arg);
  241.                         break;
  242.                     case SPEC_SWITCH:
  243.                         SWITCH_LAYER(arg);
  244.                         break;
  245.                     default:
  246.                         SEND_STRING("Invalid Special in Keymap");
  247.                 }
  248.             }
  249.             return chord;
  250.         }
  251.     }
  253.     if ((chord & IN_CHORD_MASK) && (chord & IN_CHORD_MASK) != chord && mapKeys((chord & IN_CHORD_MASK), true) == (chord & IN_CHORD_MASK)) {
  254. #ifndef NO_DEBUG
  255.         uprintf("Try with ignore mask:%u\n", (chord & IN_CHORD_MASK));
  256. #endif
  257.         mapKeys((chord & ~IN_CHORD_MASK), lookup);
  258.         mapKeys((chord & IN_CHORD_MASK), lookup);
  259.         return chord;
  260.     }
  261. #ifndef NO_DEBUG
  262.     uprintf("Reached end\n");
  263. #endif
  264.     return 0;
  265. }
  266. // Traverse the chord history to a given point
  267. // Returns the mask to use
  268. void processChord(void) {
  269.     // Save the clean chord state
  270.     C_SIZE savedChord = cChord;
  272.     // Apply Stick Bits if needed
  273.     if (stickyBits != 0) {
  274.         cChord |= stickyBits;
  275.         for (int i = 0; i <= chordIndex; i++) chordState[i] |= stickyBits;
  276.     }
  278.     // First we test if a whole chord was passsed
  279.     // If so we just run it handling repeat logic
  280.     if (mapKeys(cChord, true) == cChord) {
  281.         mapKeys(cChord, false);
  282.         // Repeat logic
  283.         if (repeatFlag) {
  284. #ifndef NO_DEBUG
  285.             uprintf("repeating?\n");
  286. #endif
  287.             restoreState();
  288.             repeatFlag = false;
  289.             processChord();
  290.         } else {
  291.             saveState(cChord);
  292.         }
  293.         return;
  294.     }
  296.     C_SIZE next = process_chord_getnext(cChord);
  297.     if (next && next != cChord) {
  298. #ifndef NO_DEBUG
  299.         uprintf("Trying next candidate: %u\n", next);
  300. #endif
  301.         if (mapKeys(next, true) == next) {
  302.             mapKeys(next, false);
  303.             // Repeat logic
  304.             if (repeatFlag) {
  305. #ifndef NO_DEBUG
  306.                 uprintf("repeating?\n");
  307. #endif
  308.                 restoreState();
  309.                 repeatFlag = false;
  310.                 processChord();
  311.             } else {
  312.                 saveState(cChord);
  313.             }
  314.             return;
  315.         }
  316.     }
  318. #ifndef NO_DEBUG
  319.     uprintf("made it past the maw\n");
  320. #endif
  322.     // Iterate through chord picking out the individual
  323.     // and longest chords
  324.     C_SIZE bufChords[QWERBUF];
  325.     int    bufLen = 0;
  326.     C_SIZE mask   = 0;
  328.     // We iterate over it multiple times to catch the longest
  329.     // chord. Then that gets addded to the mask and re run.
  330.     while (savedChord != mask) {
  331.         C_SIZE test         = 0;
  332.         C_SIZE longestChord = 0;
  334.         for (int i = 0; i <= chordIndex; i++) {
  335.             cChord = chordState[i] & ~mask;
  336.             if (cChord == 0) continue;
  338.             test = mapKeys(cChord, true);
  339.             if (test != 0) {
  340.                 longestChord = test;
  341.             }
  342.         }
  344.         mask |= longestChord;
  345.         bufChords[bufLen] = longestChord;
  346.         bufLen++;
  348.         // That's a loop of sorts, halt processing
  349.         if (bufLen >= QWERBUF) {
  350. #ifndef NO_DEBUG
  351.             uprintf("looped. exiting");
  352. #endif
  353.             return;
  354.         }
  355.     }
  357.     // Now that the buffer is populated, we run it
  358.     for (int i = 0; i < bufLen; i++) {
  359.         cChord = bufChords[i];
  360. #ifndef NO_DEBUG
  361.         uprintf("sending: %u\n", cChord);
  362. #endif
  363.         mapKeys(cChord, false);
  364.     }
  366.     // Save state in case of repeat
  367.     if (!repeatFlag) {
  368.         saveState(savedChord);
  369.     }
  371.     // Restore cChord for held repeat
  372.     cChord = savedChord;
  373.     return;
  374. }
  375. void saveState(C_SIZE cleanChord) {
  376.     pChord      = cleanChord;
  377.     pChordIndex = chordIndex;
  378.     for (int i = 0; i < 32; i++) pChordState[i] = chordState[i];
  379. }
  380. void restoreState(void) {
  381.     cChord     = pChord;
  382.     chordIndex = pChordIndex;
  383.     for (int i = 0; i < 32; i++) chordState[i] = pChordState[i];
  384. }
  386. // Macros for calling from keymap.c
  387. void SEND(uint8_t kc) {
  388.     // Send Keycode, Does not work for Quantum Codes
  389.     if (cMode == COMMAND && CMDLEN < MAX_CMD_BUF) {
  390. #ifndef NO_DEBUG
  391.         uprintf("CMD LEN: %d BUF: %d\n", CMDLEN, MAX_CMD_BUF);
  392. #endif
  393.         CMDBUF[CMDLEN] = kc;
  394.         CMDLEN++;
  395.     }
  397.     if (cMode != COMMAND) register_code(kc);
  398.     return;
  399. }
  400. void REPEAT(void) {
  401.     if (cMode != QWERTY) return;
  403.     repeatFlag = true;
  404.     return;
  405. }
  406. void SET_STICKY(C_SIZE stick) {
  407.     stickyBits ^= stick;
  408.     return;
  409. }
  410. void CLICK_MOUSE(uint8_t kc) {
  411. #ifdef MOUSEKEY_ENABLE
  412.     mousekey_on(kc);
  413.     mousekey_send();
  415.     // Store state for later use
  416.     inMouse    = true;
  417.     mousePress = kc;
  418. #endif
  419. }
  420. void SWITCH_LAYER(int layer) {
  421. #ifndef NO_ACTION_LAYER
  422.     if (keymapsCount >= layer) {
  423.         layer_clear();
  424.         layer_on(layer);
  425.     }
  426. #endif
  427. }
  428. uint8_t bitpop_v(C_SIZE val) {
  429. #if C_SIZE == uint8_t
  430.     return bitpop(val);
  431. #elif C_SIZE == uint16_t
  432.     return bitpop16(val);
  433. #elif C_SIZE == uint32_t
  434.     return bitpop32(val);
  435. #elif C_SIZE == uint64_t
  436.     uint8_t n = 0;
  437.     if (bits >> 32) {
  438.         bits >>= 32;
  439.         n += 32;
  440.     }
  441.     if (bits >> 16) {
  442.         bits >>= 16;
  443.         n += 16;
  444.     }
  445.     if (bits >> 8) {
  446.         bits >>= 8;
  447.         n += 8;
  448.     }
  449.     if (bits >> 4) {
  450.         bits >>= 4;
  451.         n += 4;
  452.     }
  453.     if (bits >> 2) {
  454.         bits >>= 2;
  455.         n += 2;
  456.     }
  457.     if (bits >> 1) {
  458.         bits >>= 1;
  459.         n += 1;
  460.     }
  461.     return n;
  462. #else
  463. #    error unsupported C_SIZE
  464. #endif
  465. }
  467. // See engine.h for what these hooks do
  468. __attribute__((weak)) C_SIZE process_engine_post(C_SIZE cur_chord, uint16_t keycode, keyrecord_t *record) { return cur_chord; }
  469. __attribute__((weak)) C_SIZE process_engine_pre(C_SIZE cur_chord, uint16_t keycode, keyrecord_t *record) { return true; }
  470. __attribute__((weak)) C_SIZE process_chord_getnext(C_SIZE cur_chord) { return 0; }