layer.c

   1 #include "keymap_skel.h"
   2 #include "usb_keyboard.h"
   3 #include "debug.h"
   4 #include "timer.h"
   5 #include "layer.h"
   6
   7 /*
   8  * Parameters:
   9  *     enter_delay         |=======|
  10  *     send_fn_term        |================|
  11  *
  12  * Fn key processing cases:
  13  * 1. release Fn after send_fn_term.
  14  *     Layer sw         ___________|~~~~~~~~~~~|___
  15  *     Fn press         ___|~~~~~~~~~~~~~~~~~~~|___
  16  *     Fn send          ___________________________
  17  *
  18  * 2. release Fn in send_fn_term.(not layer used)
  19  *     Layer sw         ___________|~~~~~~|________
  20  *     Fn press         ___|~~~~~~~~~~~~~~|________
  21  *     Fn key send      __________________|~|______
  22  *     other key press  ___________________________
  23  *     other key send   ___________________________
  24  *
  25  * 3. release Fn in send_fn_term.(layer used)
  26  *     Layer sw         ___________|~~~~~~|________
  27  *     Fn press         ___|~~~~~~~~~~~~~~|________
  28  *     Fn key send      ___________________________
  29  *     Fn send          ___________________________
  30  *     other key press  _____________|~~|__________
  31  *     other key send   _____________|~~|__________
  32  *
  33  * 4. press other key in ENTER_DELAY.
  34  *     Layer sw         ___________________________
  35  *     Fn key press     ___|~~~~~~~~~|_____________
  36  *     Fn key send      ______|~~~~~~|_____________
  37  *     other key press  ______|~~~|________________
  38  *     other key send   _______|~~|________________
  39  *
  40  * 5. press Fn while press other key.
  41  *     Layer sw         ___________________________
  42  *     Fn key press     ___|~~~~~~~~~|_____________
  43  *     Fn key send      ___|~~~~~~~~~|_____________
  44  *     other key press  ~~~~~~~|___________________
  45  *     other key send   ~~~~~~~|___________________
  46  */
  47
  48 // LAYER_ENTER_DELAY: prevent from moving new layer
  49 #define LAYER_ENTER_DELAY 10
  50
  51 // LAYER_SEND_FN_TERM: send keycode if release key in this term
  52 #define LAYER_SEND_FN_TERM 40
  53
  54
  55 static uint8_t current_layer = 0;
  56 static bool layer_used = false;
  57
  58
  59 uint8_t layer_get_keycode(uint8_t row, uint8_t col)
  60 {
  61     uint8_t code = keymap_get_keycode(current_layer, row, col);
  62     // normal key or mouse key
  63     if ((IS_KEY(code) || IS_MOUSE(code))) {
  64         layer_used = true;
  65     }
  66     return code;
  67 }
  68
  69 void layer_switching(uint8_t fn_bits)
  70 {
  71     // layer switching
  72     static uint8_t new_layer = 0;
  73     static uint8_t last_bits = 0;
  74     static uint8_t last_mods = 0;
  75     static uint16_t last_timer = 0;
  76
  77     if (fn_bits == last_bits) { // Fn key is not changed
  78         if (current_layer != new_layer) {
  79             // not switch layer yet
  80             if (timer_elapsed(last_timer) > LAYER_ENTER_DELAY) {
  81                 debug("Fn case: 1,2,3(switch layer)\n");
  82                 // case: 1,2,3
  83                 // switch layer after LAYER_ENTER_DELAY elapse
  84                 current_layer = new_layer;
  85                 debug("timer_elapsed: "); debug_hex16(timer_elapsed(last_timer)); debug("\n");
  86                 debug("switch layer: "); debug_hex(current_layer); debug("\n");
  87             } else if (usb_keyboard_has_key()) {
  88                 debug("Fn case: 4(send Fn first, then add Fn to report)\n");
  89                 // case: 4
  90                 // send only Fn key first
  91                 usb_keyboard_swap_report();
  92                 usb_keyboard_clear_report();
  93                 usb_keyboard_add_code(keymap_fn_keycode(last_bits));
  94                 usb_keyboard_set_mods(last_mods);
  95                 usb_keyboard_send();
  96                 usb_keyboard_swap_report();
  97                 // add Fn key to send with other keys
  98                 usb_keyboard_add_code(keymap_fn_keycode(last_bits));
  99                 // cancel layer switching
 100                 new_layer = 0;
 101            }
 102         } else {
 103             if (fn_bits && new_layer == 0) {
 104                 // case: 4,5
 105                 // send Fn key
 106                 usb_keyboard_add_code(keymap_fn_keycode(last_bits));
 107             }
 108         }
 109     } else { // Fn key is changed
 110         if (fn_bits == 0) { // Fn key is released(falling edge)
 111             if (!layer_used && timer_elapsed(last_timer) < LAYER_SEND_FN_TERM) {
 112                 debug("Fn case: 2(send Fn)\n");
 113                 // send Fn key (case: 2[no layer used],3)
 114                 usb_keyboard_swap_report();
 115                 usb_keyboard_clear_report();
 116                 usb_keyboard_add_code(keymap_fn_keycode(last_bits));
 117                 usb_keyboard_set_mods(last_mods);
 118                 usb_keyboard_send();
 119                 usb_keyboard_swap_report();
 120             }
 121             debug("Fn case: 1,2,3,4,5(return to default layer)\n");
 122             // return to default layer(case: 1,2,3,4,5)
 123             new_layer = 0;
 124             current_layer = 0;
 125         } else { // Fn Key is pressed(rising edge)
 126             if (!usb_keyboard_has_key()) {
 127                 debug("Fn case: 1,2,3,4(ready for switching layer)\n");
 128                 // ready for switching layer(case: 1,2,3,4)
 129                 new_layer = keymap_fn_layer(fn_bits);
 130             } else {
 131                 debug("Fn case: 5(add Fn to report)\n");
 132                 // add Fn key to send with other keys(case: 5)
 133                 usb_keyboard_add_code(keymap_fn_keycode(fn_bits));
 134             }
 135         }
 136         layer_used = false;
 137         last_bits = fn_bits;
 138         last_mods = usb_keyboard_mods;
 139         last_timer = timer_read();
 140         debug("new_layer: "); debug_hex(new_layer); debug("\n");
 141         debug("last_bits: "); debug_bin(last_bits); debug("\n");
 142         debug("last_mods: "); debug_hex(last_mods); debug("\n");
 143         debug("last_timer: "); debug_hex16(last_timer); debug("\n");
 144     }
 145 }