common/action.h

   1 /*
   2 Copyright 2012,2013 Jun Wako <wakojun@gmail.com>
   3
   4 This program is free software: you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation, either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17 #ifndef ACTION_H
  18 #define ACTION_H
  19
  20 #include "keyboard.h"
  21 #include "keycode.h"
  22 #include "action_macro.h"
  23
  24
  25 /* Struct to record event and tap count  */
  26 typedef struct {
  27     keyevent_t  event;
  28     uint8_t     tap_count;
  29 } keyrecord_t;
  30
  31 /* Action struct.
  32  *
  33  * In avr-gcc bit field seems to be assigned from LSB(bit0) to MSB(bit15).
  34  * AVR looks like a little endian in avr-gcc.
  35  *
  36  * NOTE: not portable across compiler/endianness?
  37  * Byte order and bit order of 0x1234:
  38  * Big endian:     15 ...  8 7 ... 210
  39  *                |  0x12   |  0x34   |
  40  *                 0001 0010 0011 0100
  41  * Little endian:  012 ... 7  8 ... 15
  42  *                |  0x34   |  0x12   |
  43  *                 0010 1100 0100 1000
  44  */
  45 typedef union {
  46     uint16_t code;
  47     struct action_kind {
  48         uint16_t param  :12;
  49         uint8_t  id     :4;
  50     } kind;
  51     struct action_key {
  52         uint8_t  code   :8;
  53         uint8_t  mods   :4;
  54         uint8_t  kind   :4;
  55     } key;
  56     struct action_layer {
  57         uint8_t  code   :8;
  58         uint8_t  val    :4;
  59         uint8_t  kind   :4;
  60     } layer;
  61     struct action_usage {
  62         uint16_t code   :10;
  63         uint8_t  page   :2;
  64         uint8_t  kind   :4;
  65     } usage;
  66     struct action_command {
  67         uint8_t  id     :8;
  68         uint8_t  opt    :4;
  69         uint8_t  kind   :4;
  70     } command;
  71     struct action_function {
  72         uint8_t  id     :8;
  73         uint8_t  opt    :4;
  74         uint8_t  kind   :4;
  75     } func;
  76 } action_t;
  77
  78
  79
  80 /* Execute action per keyevent */
  81 void action_exec(keyevent_t event);
  82
  83 /* action for key */
  84 action_t action_for_key(uint8_t layer, key_t key);
  85
  86 /* macro */
  87 const prog_macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt);
  88
  89 /* user defined special function */
  90 void action_function(keyrecord_t *record, uint8_t id, uint8_t opt);
  91
  92 /*
  93  * Utilities for actions.
  94  */
  95 void register_code(uint8_t code);
  96 void unregister_code(uint8_t code);
  97 void add_mods(uint8_t mods);
  98 void del_mods(uint8_t mods);
  99 void set_mods(uint8_t mods);
 100 void clear_keyboard(void);
 101 void clear_keyboard_but_mods(void);
 102 bool sending_anykey(void);
 103 void layer_switch(uint8_t new_layer);
 104 bool is_tap_key(key_t key);
 105 bool waiting_buffer_has_anykey_pressed(void);
 106
 107
 108
 109 /*
 110  * Action codes
 111  * ============
 112  * 16bit code: action_kind(4bit) + action_parameter(12bit)
 113  *
 114  * Keyboard Keys(00XX)
 115  * -------------------
 116  * ACT_LMODS(0000):
 117  * 0000|0000|000000|00    No action
 118  * 0000|0000|000000|01    Transparent
 119  * 0000|0000| keycode     Key
 120  * 0000|mods|000000|00    Left mods
 121  * 0000|mods| keycode     Key & Left mods
 122  *
 123  * ACT_RMODS(0001):
 124  * 0001|0000|000000|00    No action(not used)
 125  * 0001|0000|000000|01    Transparent(not used)
 126  * 0001|0000| keycode     Key(no used)
 127  * 0001|mods|000000|00    Right mods
 128  * 0001|mods| keycode     Key & Right mods
 129  *
 130  * ACT_LMODS_TAP(0010):
 131  * 0010|mods|000000|00    Left mods OneShot
 132  * 0010|mods|000000|01    (reserved)
 133  * 0010|mods|000000|10    (reserved)
 134  * 0010|mods|000000|11    (reserved)
 135  * 0010|mods| keycode     Left mods + tap Key
 136  *
 137  * ACT_RMODS_TAP(0011):
 138  * 0011|mods|000000|00    Right mods OneShot
 139  * 0011|mods|000000|01    (reserved)
 140  * 0011|mods|000000|10    (reserved)
 141  * 0011|mods|000000|11    (reserved)
 142  * 0011|mods| keycode     Right mods + tap Key
 143  *
 144  *
 145  * Other keys(01XX)
 146  * --------------------
 147  * This action handles other usages than keyboard.
 148  * ACT_USAGE(0100):
 149  * 0100|00| usage(10)     System control(0x80) - General Desktop page(0x01)
 150  * 0100|01| usage(10)     Consumer control(0x01) - Consumer page(0x0C)
 151  * 0100|10| usage(10)     (reserved)
 152  * 0100|11| usage(10)     (reserved)
 153  *
 154  * ACT_MOUSEKEY(0110):
 155  * 0101|XXXX| keycode     Mouse key
 156  *
 157  *
 158  * Layer Actions(10XX)
 159  * -------------------
 160  * ACT_KEYMAP:
 161  * 1000|--xx|0000 0000   Clear keyamp and overlay
 162  * 1000|LLLL|0000 00xx   Reset default layer and clear keymap and overlay
 163  * 1000|LLLL| keycode    Invert with tap key
 164  * 1000|LLLL|1111 0000   Invert with tap toggle
 165  * 1000|LLLL|1111 00xx   Invert[^=  1<<L]
 166  * 1000|LLLL|1111 0100   On/Off
 167  * 1000|LLLL|1111 01xx   On[|= 1<<L]
 168  * 1000|LLLL|1111 1000   Off/On
 169  * 1000|LLLL|1111 10xx   Off[&= ~(1<<L)]
 170  * 1000|LLLL|1111 1100   Set/Clear
 171  * 1000|LLLL|1111 11xx   Set[= 1<<L]
 172  * default layer: 0-15(4bit)
 173  * xx: On {00:for special use, 01:press, 10:release, 11:both}
 174  *
 175  * ACT_OVERLAY:
 176  * 1011|0000|0000 0000   Clear overlay
 177  * 1011|LLLL|0000 00ss   Invert 4-bit chunk [^= L<<(4*ss)]
 178  * 1011|LLLL| keycode    Invert with tap key
 179  * 1011|LLLL|1111 0000   Invert with tap toggle
 180  * 1011|LLLL|1111 00xx   Invert[^= 1<<L]
 181  * 1011|LLLL|1111 0100   On/Off(momentary)
 182  * 1011|LLLL|1111 01xx   On[|= 1<<L]
 183  * 1011|LLLL|1111 1000   Off/On
 184  * 1011|LLLL|1111 10xx   Off[&= ~(1<<L)]
 185  * 1011|LLLL|1111 1100   Set/Clear
 186  * 1011|LLLL|1111 11xx   Set[= 1<<L]
 187  * overlays: 16-layer on/off status(16bit)
 188  * xx: On {00:for special use, 01:press, 10:release, 11:both}
 189  *
 190  *
 191  * Extensions(11XX)
 192  * ----------------
 193  * ACT_MACRO(1100):
 194  * 1100|opt | id(8)      Macro play?
 195  * 1100|1111| id(8)      Macro record?
 196  *
 197  * ACT_COMMAND(1110):
 198  * 1110|opt | id(8)      Built-in Command exec
 199  *
 200  * ACT_FUNCTION(1111):
 201  * 1111| address(12)     Function?
 202  * 1111|opt | id(8)      Function?
 203  *
 204  */
 205 enum action_kind_id {
 206     ACT_LMODS           = 0b0000,
 207     ACT_RMODS           = 0b0001,
 208     ACT_LMODS_TAP       = 0b0010,
 209     ACT_RMODS_TAP       = 0b0011,
 210
 211     ACT_USAGE           = 0b0100,
 212     ACT_MOUSEKEY        = 0b0101,
 213
 214     ACT_KEYMAP          = 0b1000,
 215     ACT_OVERLAY         = 0b1001,
 216
 217     ACT_MACRO           = 0b1100,
 218     ACT_COMMAND         = 0b1110,
 219     ACT_FUNCTION        = 0b1111
 220 };
 221
 222
 223 /* action utility */
 224 #define ACTION_NO                       0
 225 #define ACTION_TRANSPARENT              1
 226 #define ACTION(kind, param)             ((kind)<<12 | (param))
 227 #define MODS4(mods)                     (((mods)>>4 | (mods)) & 0x0F)
 228
 229 /*
 230  * Key
 231  */
 232 #define ACTION_KEY(key)                 ACTION(ACT_LMODS,    key)
 233 /* Mods & key */
 234 #define ACTION_LMODS(mods)              ACTION(ACT_LMODS,    MODS4(mods)<<8 | 0x00)
 235 #define ACTION_LMODS_KEY(mods, key)     ACTION(ACT_LMODS,    MODS4(mods)<<8 | (key))
 236 #define ACTION_RMODS(mods)              ACTION(ACT_RMODS,    MODS4(mods)<<8 | 0x00)
 237 #define ACTION_RMODS_KEY(mods, key)     ACTION(ACT_RMODS,    MODS4(mods)<<8 | (key))
 238 #define ACTION_LMOD(mod)                ACTION(ACT_LMODS,    MODS4(MOD_BIT(mod))<<8 | 0x00)
 239 #define ACTION_LMOD_KEY(mod, key)       ACTION(ACT_LMODS,    MODS4(MOD_BIT(mod))<<8 | (key))
 240 #define ACTION_RMOD(mod)                ACTION(ACT_RMODS,    MODS4(MOD_BIT(mod))<<8 | 0x00)
 241 #define ACTION_RMOD_KEY(mod, key)       ACTION(ACT_RMODS,    MODS4(MOD_BIT(mod))<<8 | (key))
 242 /* Tap key */
 243 enum mods_codes {
 244     MODS_ONESHOT           = 0x00,
 245 };
 246 #define ACTION_LMODS_TAP_KEY(mods, key) ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | (key))
 247 #define ACTION_LMODS_ONESHOT(mods)      ACTION(ACT_LMODS_TAP, MODS4(mods)<<8 | MODS_ONESHOT)
 248 #define ACTION_RMODS_TAP_KEY(mods, key) ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | (key))
 249 #define ACTION_RMODS_ONESHOT(mods)      ACTION(ACT_RMODS_TAP, MODS4(mods)<<8 | MODS_ONESHOT)
 250 #define ACTION_LMOD_TAP_KEY(mod, key)   ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key))
 251 #define ACTION_LMOD_ONESHOT(mod)        ACTION(ACT_LMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT)
 252 #define ACTION_RMOD_TAP_KEY(mod, key)   ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | (key))
 253 #define ACTION_RMOD_ONESHOT(mod)        ACTION(ACT_RMODS_TAP, MODS4(MOD_BIT(mod))<<8 | MODS_ONESHOT)
 254
 255 /* HID Usage */
 256 enum usage_pages {
 257     PAGE_SYSTEM,
 258     PAGE_CONSUMER
 259 };
 260 #define ACTION_USAGE_SYSTEM(id)         ACTION(ACT_USAGE, PAGE_SYSTEM<<10 | (id))
 261 #define ACTION_USAGE_CONSUMER(id)       ACTION(ACT_USAGE, PAGE_CONSUMER<<10 | (id))
 262
 263 /* Mousekey */
 264 #define ACTION_MOUSEKEY(key)            ACTION(ACT_MOUSEKEY, key)
 265
 266
 267
 268 /* Layer Actions:
 269  *      Invert  layer ^= (1<<layer)
 270  *      On      layer |= (1<<layer)
 271  *      Off     layer &= ~(1<<layer)
 272  *      Set     layer = (1<<layer)
 273  *      Clear   layer = 0
 274  */
 275 enum layer_params {
 276     ON_PRESS    = 1,
 277     ON_RELEASE  = 2,
 278     ON_BOTH     = 3,
 279
 280     OP_RESET  = 0x00,
 281     OP_INV4  = 0x00,
 282     OP_INV   = 0xF0,
 283     OP_ON    = 0xF4,
 284     OP_OFF   = 0xF8,
 285     OP_SET   = 0xFC,
 286 };
 287
 288 /*
 289  * Default Layer
 290  */
 291 #define ACTION_DEFAULT_LAYER                      ACTION(ACT_KEYMAP, 0<<8 | OP_RESET | 0)
 292 #define ACTION_SET_DEFAULT_LAYER(layer)           ACTION_KEYMAP_RESET(layer)
 293 #define ACTION_SET_DEFAULT_LAYER_P(layer)         ACTION_KEYMAP_RESET_P(layer)
 294 #define ACTION_SET_DEFAULT_LAYER_R(layer)         ACTION_KEYMAP_RESET_R(layer)
 295 #define ACTION_SET_DEFAULT_LAYER_B(layer)         ACTION_KEYMAP_RESET_B(layer)
 296 /*
 297  * Keymap Layer
 298  */
 299 #define ACTION_KEYMAP(layer)                     ACTION_KEYMAP_MOMENTARY(layer)
 300 #define ACTION_KEYMAP_MOMENTARY(layer)           ACTION_KEYMAP_ON_OFF(layer)
 301 #define ACTION_KEYMAP_TOGGLE(layer)              ACTION_KEYMAP_INV_R(layer)
 302 /* Keymap Set and clear overaly */
 303 #define ACTION_KEYMAP_RESET(layer)               ACTION_KEYMAP_RESET_R(layer)
 304 #define ACTION_KEYMAP_RESET_P(layer)             ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | ON_PRESS)
 305 #define ACTION_KEYMAP_RESET_R(layer)             ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | ON_RELEASE)
 306 #define ACTION_KEYMAP_RESET_B(layer)             ACTION(ACT_KEYMAP, (layer)<<8 | OP_RESET | ON_BOTH)
 307 /* Keymap Invert */
 308 #define ACTION_KEYMAP_INV(layer)                 ACTION_KEYMAP_INV_B(layer)
 309 #define ACTION_KEYMAP_TAP_TOGGLE(layer)          ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | 0)
 310 #define ACTION_KEYMAP_INV_P(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | ON_PRESS)
 311 #define ACTION_KEYMAP_INV_R(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | ON_RELEASE)
 312 #define ACTION_KEYMAP_INV_B(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_INV | ON_BOTH)
 313 /* Keymap On */
 314 #define ACTION_KEYMAP_ON(layer)                  ACTION_KEYMAP_ON_OFF(layer)
 315 #define ACTION_KEYMAP_ON_OFF(layer)              ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON  | 0)
 316 #define ACTION_KEYMAP_ON_P(layer)                ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON  | ON_PRESS)
 317 #define ACTION_KEYMAP_ON_R(layer)                ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON  | ON_RELEASE)
 318 #define ACTION_KEYMAP_ON_B(layer)                ACTION(ACT_KEYMAP, (layer)<<8 | OP_ON  | ON_BOTH)
 319 /* Keymap Off */
 320 #define ACTION_KEYMAP_OFF(layer)                 ACTION_KEYMAP_OFF_ON(layer)
 321 #define ACTION_KEYMAP_OFF_ON(layer)              ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | 0)
 322 #define ACTION_KEYMAP_OFF_P(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | ON_PRESS)
 323 #define ACTION_KEYMAP_OFF_R(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | ON_RELEASE)
 324 #define ACTION_KEYMAP_OFF_B(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_OFF | ON_BOTH)
 325 /* Keymap Set */
 326 #define ACTION_KEYMAP_SET(layer)                 ACTION_KEYMAP_SET_CLEAR(layer)
 327 #define ACTION_KEYMAP_SET_CLEAR(layer)           ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | 0)
 328 #define ACTION_KEYMAP_SET_P(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | ON_PRESS)
 329 #define ACTION_KEYMAP_SET_R(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | ON_RELEASE)
 330 #define ACTION_KEYMAP_SET_B(layer)               ACTION(ACT_KEYMAP, (layer)<<8 | OP_SET | ON_BOTH)
 331 /* Keymap Invert with tap key */
 332 #define ACTION_KEYMAP_TAP_KEY(layer, key)        ACTION(ACT_KEYMAP, (layer)<<8 | (key))
 333
 334 /*
 335  * Overlay Layer
 336  */
 337 #define ACTION_OVERLAY(layer)                     ACTION_OVERLAY_MOMENTARY(layer)
 338 #define ACTION_OVERLAY_MOMENTARY(layer)           ACTION_OVERLAY_ON_OFF(layer)
 339 #define ACTION_OVERLAY_TOGGLE(layer)              ACTION_OVERLAY_INV_R(layer)
 340 /* Overlay Clear */
 341 #define ACTION_OVERLAY_CLEAR                      ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | 0)
 342 #define ACTION_OVERLAY_CLEAR_P                    ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | ON_PRESS)
 343 #define ACTION_OVERLAY_CLEAR_R                    ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | ON_RELEASE)
 344 #define ACTION_OVERLAY_CLEAR_B                    ACTION(ACT_OVERLAY, 0<<8 | OP_INV4 | ON_BOTH)
 345 /* Overlay Invert 4-bit chunk */
 346 #define ACTION_OVERLAY_INV4(bits, shift)          ACTION(ACT_OVERLAY, (bits)<<8 | OP_INV4 | shift)
 347 /* Overlay Invert */
 348 #define ACTION_OVERLAY_INV(layer)                 ACTION_OVERLAY_INV_B(layer)
 349 #define ACTION_OVERLAY_TAP_TOGGLE(layer)          ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | 0)
 350 #define ACTION_OVERLAY_INV_P(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | ON_PRESS)
 351 #define ACTION_OVERLAY_INV_R(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | ON_RELEASE)
 352 #define ACTION_OVERLAY_INV_B(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_INV | ON_BOTH)
 353 /* Overlay On */
 354 #define ACTION_OVERLAY_ON(layer)                  ACTION_OVERLAY_ON_OFF(layer)
 355 #define ACTION_OVERLAY_ON_OFF(layer)              ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON  | 0)
 356 #define ACTION_OVERLAY_ON_P(layer)                ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON  | ON_PRESS)
 357 #define ACTION_OVERLAY_ON_R(layer)                ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON  | ON_RELEASE)
 358 #define ACTION_OVERLAY_ON_B(layer)                ACTION(ACT_OVERLAY, (layer)<<8 | OP_ON  | ON_BOTH)
 359 /* Overlay Off */
 360 #define ACTION_OVERLAY_OFF(layer)                 ACTION_OVERLAY_OFF_ON(layer)
 361 #define ACTION_OVERLAY_OFF_ON(layer)              ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | 0)
 362 #define ACTION_OVERLAY_OFF_P(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | ON_PRESS)
 363 #define ACTION_OVERLAY_OFF_R(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | ON_RELEASE)
 364 #define ACTION_OVERLAY_OFF_B(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_OFF | ON_BOTH)
 365 /* Overlay Set */
 366 #define ACTION_OVERLAY_SET(layer)                 ACTION_OVERLAY_SET_CLEAR(layer)
 367 #define ACTION_OVERLAY_SET_CLEAR(layer)           ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | 0)
 368 #define ACTION_OVERLAY_SET_P(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_PRESS)
 369 #define ACTION_OVERLAY_SET_R(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_RELEASE)
 370 #define ACTION_OVERLAY_SET_B(layer)               ACTION(ACT_OVERLAY, (layer)<<8 | OP_SET | ON_BOTH)
 371 /* Overlay Invert with tap key */
 372 #define ACTION_OVERLAY_TAP_KEY(layer, key)        ACTION(ACT_OVERLAY, (layer)<<8 | (key))
 373
 374
 375 /*
 376  * Extensions
 377  */
 378 /* Macro */
 379 #define ACTION_MACRO(id)                ACTION(ACT_MACRO, (id))
 380 #define ACTION_MACRO_OPT(id, opt)       ACTION(ACT_MACRO, (opt)<<8 | (id))
 381
 382 /* Command */
 383 #define ACTION_COMMAND(id, opt)         ACTION(ACT_COMMAND,  (opt)<<8 | (addr))
 384
 385 /* Function */
 386 enum function_opts {
 387     FUNC_TAP        = 0x8,      /* indciates function is tappable */
 388 };
 389 #define ACTION_FUNCTION(id, opt)        ACTION(ACT_FUNCTION, (opt)<<8 | id)
 390 #define ACTION_FUNCTION_TAP(id)         ACTION(ACT_FUNCTION, FUNC_TAP<<8 | id)
 391
 392 #endif  /* ACTION_H */