layouts/community/ergodox/ishigoya-jp/keymap.c

   1 #include QMK_KEYBOARD_H
   2 #include "debug.h"
   3 #include "action_layer.h"
   4 #include "keymap_jp.h"
   5
   6 static uint16_t start;
   7
   8 #define BASE 0 // EN layer
   9 #define JP 1 // Japanese
  10 #define JPXON 2 // JP + Fn
  11 #define JPKAZARI 3 // JP + KAZARI
  12 #define JPTOPROW 4 // JP + TOPROW
  13 #define JPTRKZ 5 // JP + TOPROW + KAZARI
  14 #define NUM 6 // Numbers
  15
  16 #define CTLSHFT 1
  17 #define CUTCOPY 2
  18
  19 //kana macro definitions start here
  20
  21 #define JPVU 4
  22 #define JPNU 6
  23 #define JPKO 7
  24 #define JPSA 8
  25 #define JPKE 9
  26 #define JPHE 10
  27 #define JPSHI 11
  28 #define JPKA 12
  29 #define JPKI 13
  30 #define JPSU 14
  31 #define JPSO 15
  32 #define JPHI 16
  33 #define JPCHI 17
  34 #define JPFU 18
  35 #define JPSE 19
  36 #define JPTSU 20
  37 #define JPKU 21
  38 #define JPTE 22
  39 #define JPTA 23
  40 #define JPTO 24
  41 #define JPHA 25
  42 #define JPHO 26
  43 #define JPXKE 27
  44 #define JPXU 28
  45 #define JPXKA 29
  46 #define JPXA 30
  47 #define JPXO 31
  48 #define JPGO 32
  49 #define JPZA 33
  50 #define JPGE 34
  51 #define JPBE 35
  52 #define JPYU 36
  53 #define JPJI 37
  54 #define JPGA 38
  55 #define JPGI 39
  56 #define JPZU 40
  57 #define JPZO 41
  58 #define JPBI 42
  59 #define JPDI 43
  60 #define JPZE 44
  61 #define JPDU 45
  62 #define JPGU 46
  63 #define JPYA 47
  64 #define JPYO 48
  65 #define JPDE 49
  66 #define JPDA 50
  67 #define JPDO 51
  68 #define JPBA 52
  69 #define JPBO 53
  70 #define JPRI 54
  71 #define JPRE 55
  72 #define JPRA 56
  73 #define JPNA 57
  74 #define JPNO 58
  75 #define JPMI 59
  76 #define JPMU 60
  77 #define JPME 61
  78 #define JPNE 62
  79 #define JPMA 63
  80 #define JPXTU 64
  81 #define JPWA 65
  82 #define JPRU 66
  83 #define JPWO 67
  84 #define JPNI 68
  85 #define JPNN 69
  86 #define JPMO 70
  87 #define JPRO 71
  88 #define JPXE 72
  89 #define JPXI 73
  90 #define JPXYU 74
  91 #define JPXYA 75
  92 #define JPXYO 76
  93 #define JPPE 77
  94 #define JPPU 78
  95 #define JPPI 79
  96 #define JPPA 80
  97 #define JPPO 81
  98 #define JPBU 82
  99
 100 // kana macro definitions end here
 101
 102 #define SHIFT 86
 103 #define KAZARI 87
 104 #define JPFN 88 //shifts to JPXON layer
 105 #define TOJPLOUT 89
 106 #define TOENL 90
 107 #define TOJPL 91
 108
 109 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 110 /* Keymap 0: Basic layer
 111  *
 112  *
 113  * ,----------------------------------------------------.           ,--------------------------------------------------.
 114  * | En / 和  |      |   ^  |   %  |      |      |Selall|           | Undo |      |   $  |   @  |   LT |  UP  |   RT   |
 115  * |----------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
 116  * | Tab      |   Q  |   D  |   R  |   W  |   B  | Cut  |           | PgUP |   J  |   F  |   U  |   P  |  DN  |   \    |
 117  * |----------+------+------+------+------+------| Copy |           |      |------+------+------+------+------+--------|
 118  * |   /      |   A  |   S  |   H  |   T  |   G  |------|           |------|   Y  |   N  |   E  |   O  |   I  |   ,    |
 119  * |----------+------+------+------+------+------|Paste |           | PgDN |------+------+------+------+------+--------|
 120  * | Ctl+Shft |   Z  |   X  |   M  |   C  |   V  |      |           |      | .    |   L  |   K  |  '   |   ?  | tmux   |
 121  * `----------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
 122  *   | LCtrl  | LGui |   Alt|   _  | Esc  |                                       |MouseL|MouseR|   -  |  ~   | Ctrl |
 123  *   `------------------------------------'                                       `----------------------------------'
 124  *                                        ,-------------.       ,-------------.
 125  *                                        |MidMs | Del  |       | VolUp| Mute |
 126  *                                 ,------|------|------|       |------+--------+------.
 127  *                                 |      |      |      |       | VolDn|        |      |
 128  *                                 | Space| Shift|------|       |------| Backsp |Enter |
 129  *                                 |      |      | Num  |       |  Esc |        |      |
 130  *                                 `--------------------'       `----------------------'
 131  *
 132  *
 133  * tmux prefix set to C-b
 134  *
 135  */
 136 // If it accepts an argument (i.e, is a function), it doesn't need KC_.
 137 // Otherwise, it needs KC_*
 138 [BASE] = LAYOUT_ergodox(  // layer 0 : default
 139         // left hand
 140         M(TOJPLOUT),   KC_NO,   KC_EQL, LSFT(KC_5), KC_NO,   KC_NO,   LCTL(KC_A),
 141         KC_TAB,        KC_Q,         KC_D,   KC_R,   KC_W,   KC_B,   M(CUTCOPY),
 142         KC_SLSH,       KC_A,         KC_S,   KC_H,   KC_T,   KC_G,
 143         M(CTLSHFT),    KC_Z,         KC_X,   KC_M,   KC_C,   KC_V,   LCTL(KC_V),
 144         KC_RCTL,       KC_LGUI,      KC_LALT,JP_UNDS,KC_LCTL,
 145                                               KC_BTN3,  KC_DEL,
 146                                                               KC_NO,
 147                                                KC_SPC,KC_LSFT,F(1),
 148         // right hand
 149              LCTL(KC_Z), KC_NO, LSFT(KC_4),      JP_AT,   KC_LEFT,       KC_UP,   KC_RIGHT,
 150              KC_PGUP,    KC_J,       KC_F,       KC_U,       KC_P,       KC_DOWN, LSFT(KC_3),
 151                          KC_Y,       KC_N,       KC_E,       KC_O,       KC_I,    KC_COMMA,
 152              KC_PGDN, KC_DOT,     KC_L,       KC_K,       LSFT(KC_7), KC_QUES,   LCTL(KC_B),
 153                                   KC_BTN1,  KC_BTN2,KC_MINS,JP_TILD,          KC_RCTL,
 154              KC_VOLU,        KC_MUTE,
 155              KC_VOLD,
 156              KC_SPC,KC_BSLS, KC_ENT
 157     ),
 158 /* Keymap 1: Japanese
 159  *
 160  * ,--------------------------------------------------.           ,--------------------------------------------------.
 161  * | En / 和|      |      |      |      |      |      |           |      |      |      |      |      |      |        |
 162  * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
 163  * |        | 　 nu |  ko  |   sa |  he  |  ke  |      |           |      |  fu  |  se  | tsu  | ku   |      |        |
 164  * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
 165  * |        |   to |  shi |  ka  |  ki  |  su  |------|           |------|  a   |  ha  | te   | ta   |  u   |        |
 166  * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
 167  * |        |   mu |  so  |  hi  |  chi |  me  |      |           |      |      |  ma  |  ho  |  i   |      |        |
 168  * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
 169  *   |      |      |      |      |      |                                       |      |      |      |      |      |
 170  *   `----------------------------------'                                       `----------------------------------'
 171  *                                        ,-------------.       ,-------------.
 172  *                                        |      |      |       |      |      |
 173  *                                 ,------|------|------|       |------+------+------.
 174  *                                 |      |      |      |       |      |      |      |
 175  *                                 | shift|  fn  |------|       |------|      |kazari|
 176  *                                 |      |      | Num  |       |      |      |      |
 177  *                                 `--------------------'       `--------------------'
 178  *
 179  *
 180  *
 181  */
 182 [JP] = LAYOUT_ergodox(
 183        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
 184        KC_TRNS, M(JPNU), M(JPKO), M(JPSA), M(JPHE), M(JPKE), KC_TRNS,
 185        KC_TRNS, M(JPTO), M(JPSHI), M(JPKA), M(JPKI), M(JPSU),
 186        KC_TRNS, M(JPMU), M(JPSO), M(JPHI), M(JPCHI), M(JPME), KC_TRNS,
 187        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
 188                                            KC_TRNS, KC_TRNS,
 189                                                     KC_NO,
 190                                   M(SHIFT), M(JPFN), F(1),
 191     // right hand
 192        KC_TRNS,  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
 193        KC_TRNS,  M(JPFU), M(JPSE), M(JPTSU), M(JPKU), KC_TRNS, KC_TRNS,
 194                  KC_A, M(JPHA), M(JPTE), M(JPTA), KC_U, KC_TRNS,
 195        KC_TRNS,  KC_TRNS, M(JPMA), M(JPHO), KC_I, KC_TRNS, KC_TRNS,
 196                           KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
 197              KC_TRNS,        KC_TRNS,
 198              KC_TRNS,
 199              KC_TRNS,KC_TRNS,M(KAZARI)
 200 ),
 201 /* Keymap 2: Japanese with Fn
 202  *
 203  * ,--------------------------------------------------.           ,--------------------------------------------------.
 204  * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
 205  * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
 206  * |        | 　    |  xe  |      |      |  xke |      |           |      |  xya |      | xtsu |  xo  |      |        |
 207  * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
 208  * |        |      |      |  xka |      |      |------|           |------|  xa  | xyo  |      |      |  xu  |        |
 209  * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
 210  * |        |      |      |      |      |      |      |           |      |      |      |      |  xi  |      |        |
 211  * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
 212  *   |      |      |      |      |      |                                       |      |      |      |      |      |
 213  *   `----------------------------------'                                       `----------------------------------'
 214  *                                        ,-------------.       ,-------------.
 215  *                                        |      |      |       |      |      |
 216  *                                 ,------|------|------|       |------+------+------.
 217  *                                 |      |      |      |       |      |      |      |
 218  *                                 |      |      |------|       |------|      |      |
 219  *                                 |      |      |      |       |      |      |      |
 220  *                                 `--------------------'       `--------------------'
 221  *
 222  *
 223  *
 224  */
 225 [JPXON] = LAYOUT_ergodox(
 226            KC_NO, KC_NO,    KC_NO,        KC_NO,    KC_NO, KC_NO, KC_NO,
 227            KC_NO, KC_NO,    M(JPXE),        KC_NO,    M(JPXKE),   KC_NO, KC_NO,
 228        KC_NO, KC_NO,    KC_NO,          M(JPXKA),      KC_NO, KC_NO,
 229        KC_NO, KC_NO,    KC_NO,        KC_NO,    KC_NO, KC_NO, KC_NO,
 230        KC_TRNS, KC_NO,    KC_NO,        KC_NO,    KC_NO,
 231                                            KC_NO, KC_NO,
 232                                                     KC_NO,
 233                                   KC_NO, KC_TRNS, KC_TRNS,
 234     // right hand
 235            KC_NO,  KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
 236        KC_NO,  M(JPXYA), KC_NO, M(JPXTU), M(JPXO), KC_NO, KC_NO,
 237                  M(JPXA), M(JPXYO), M(JPXYU), KC_NO, M(JPXU), KC_NO,
 238        KC_NO,  KC_NO,KC_NO, KC_NO, M(JPXI), KC_NO, KC_NO,
 239                           KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
 240        KC_NO, KC_NO,
 241        KC_NO,
 242        KC_NO, KC_NO, KC_NO
 243 ),
 244 /* Keymap 3: Japanese with kazari
 245  *
 246  * ,--------------------------------------------------.           ,--------------------------------------------------.
 247  * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
 248  * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
 249  * |        | 　    |  go  |  za  |  be  |  ge  |      |           |      |  bu  |  ze  |  du  |  gu  |      |        |
 250  * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
 251  * |        |  do  |  ji  |  ga  |  gi  |  zu  |------|           |------|      |  ba  |  de  |  da  |  vu  |        |
 252  * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
 253  * |        |      |  zo  |  bi  |  di  |      |      |           |      |      |      |  bo  |      |      |        |
 254  * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
 255  *   |      |      |      |      |      |                                       |      |      |      |      |      |
 256  *   `----------------------------------'                                       `----------------------------------'
 257  *                                        ,-------------.       ,-------------.
 258  *                                        |      |      |       |      |      |
 259  *                                 ,------|------|------|       |------+------+------.
 260  *                                 |      |      |      |       |      |      |      |
 261  *                                 |      |      |------|       |------|      |      |
 262  *                                 |      |      |      |       |      |      |      |
 263  *                                 `--------------------'       `--------------------'
 264  *
 265  *
 266  *
 267  */
 268 [JPKAZARI] = LAYOUT_ergodox(
 269            KC_NO, KC_NO,    KC_NO,        KC_NO,    KC_NO, KC_NO, KC_NO,
 270            KC_NO, KC_NO,    M(JPGO),        M(JPZA),    M(JPBE), M(JPGE), KC_NO,
 271        KC_NO, M(JPDO),    M(JPJI),        M(JPGA),    M(JPGI), M(JPZU),
 272        KC_NO, KC_NO,    M(JPZO),        M(JPBI),    M(JPDI), KC_NO, KC_NO,
 273        KC_TRNS, KC_NO,    KC_NO,        KC_NO,    KC_NO,
 274                                            KC_NO, KC_NO,
 275                                                     KC_NO,
 276                                   M(SHIFT), KC_NO, KC_TRNS,
 277     // right hand
 278            KC_NO,  KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
 279        KC_NO,  M(JPBU), M(JPZE), M(JPDU), M(JPGU), KC_NO, KC_NO,
 280                  KC_NO, M(JPBA), M(JPDE), M(JPDA), M(JPVU), KC_NO,
 281        KC_NO,  KC_NO, KC_NO, M(JPBO), KC_NO, KC_NO, KC_NO,
 282                           KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
 283        KC_NO, KC_NO,
 284        KC_NO,
 285        KC_NO, KC_NO, KC_TRNS
 286 ),
 287 /* Keymap 4: Japanese with Toprow
 288  *
 289  * ,--------------------------------------------------.           ,--------------------------------------------------.
 290  * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
 291  * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
 292  * |        | 　    |  e   |  -   | re   |      |      |           |      |  ya  | ne   |  ru  | o    |      |        |
 293  * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
 294  * |        | ra   |  ri  | na   | no   | mi   |------|           |------| wa   |  yo  | yu   | ni   | nn   |        |
 295  * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
 296  * |        |      |      |      |      |      |      |           |      |      | mo   | ro   |  wo  |      |        |
 297  * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
 298  *   |      |      |      |      |      |                                       |      |      |      |      |      |
 299  *   `----------------------------------'                                       `----------------------------------'
 300  *                                        ,-------------.       ,-------------.
 301  *                                        |      |      |       |      |      |
 302  *                                 ,------|------|------|       |------+------+------.
 303  *                                 |      |      |      |       |      |      |      |
 304  *                                 |      |      |------|       |------|      |      |
 305  *                                 |      |      |      |       |      |      |      |
 306  *                                 `--------------------'       `--------------------'
 307  *
 308  *
 309  *
 310  */
 311 [JPTOPROW] = LAYOUT_ergodox(
 312            KC_NO, KC_NO,    KC_NO,        KC_NO,    KC_NO,   KC_NO, KC_NO,
 313            KC_NO, KC_NO,    KC_E,       KC_MINS,  M(JPRE), KC_NO, KC_NO,
 314        KC_NO, M(JPRA),  M(JPRI),       M(JPNA),  M(JPNO), M(JPMI),
 315        KC_NO, KC_NO, KC_NO,    KC_NO,  KC_NO, KC_NO, KC_NO,
 316        KC_TRNS, KC_NO,    KC_NO,        KC_NO,    KC_NO,
 317                                            KC_NO, KC_NO,
 318                                                     KC_NO,
 319                                   KC_TRNS, KC_NO, KC_NO,
 320     // right hand
 321            KC_NO,  KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
 322        KC_NO,  M(JPYA), M(JPNE), M(JPRU), KC_O, KC_NO, KC_NO,
 323                  M(JPWA), M(JPYO), M(JPYU), M(JPNI), M(JPNN), KC_NO,
 324        KC_NO,  KC_NO, M(JPMO), M(JPRO), M(JPWO), KC_NO, KC_NO,
 325                           KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
 326        KC_NO, KC_NO,
 327        KC_NO,
 328        KC_NO, KC_NO, M(KAZARI)
 329 ),
 330
 331 /* Keymap 5: Japanese with Toprow and Kazari
 332  *
 333  * ,--------------------------------------------------.           ,--------------------------------------------------.
 334  * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
 335  * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
 336  * |        | 　    |      |      |  pe  |      |      |           |      |  pu  |      |      |      |      |        |
 337  * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
 338  * |        |      |      |      |      |      |------|           |------|      |  pa  |      |      |      |        |
 339  * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
 340  * |        |      |      |  pi  |      |      |      |           |      |      |      |  po  |      |      |        |
 341  * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
 342  *   |      |      |      |      |      |                                       |      |      |      |      |      |
 343  *   `----------------------------------'                                       `----------------------------------'
 344  *                                        ,-------------.       ,-------------.
 345  *                                        |      |      |       |      |      |
 346  *                                 ,------|------|------|       |------+------+------.
 347  *                                 |      |      |      |       |      |      |      |
 348  *                                 |      |      |------|       |------|      |      |
 349  *                                 |      |      |      |       |      |      |      |
 350  *                                 `--------------------'       `--------------------'
 351  *
 352  *
 353  *
 354  */
 355 [JPTRKZ] = LAYOUT_ergodox(
 356            KC_NO, KC_NO,    KC_NO,        KC_NO,    KC_NO, KC_NO, KC_NO,
 357            KC_NO, KC_NO,    KC_NO,        KC_NO,    M(JPPE),KC_NO,  KC_NO,
 358        KC_NO, KC_NO,    KC_NO,        KC_NO,    KC_NO, KC_NO,
 359        KC_NO, KC_NO,    KC_NO,        M(JPPI),    KC_NO, KC_NO, KC_NO,
 360        KC_TRNS, KC_NO,    KC_NO,        KC_NO,    KC_NO,
 361                                            KC_NO, KC_NO,
 362                                                     KC_NO,
 363                                   KC_TRNS, KC_NO, KC_NO,
 364     // right hand
 365            KC_NO,  KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
 366        KC_NO,  M(JPPU), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
 367                  KC_NO, M(JPPA), KC_NO, KC_NO, KC_NO, KC_NO,
 368        KC_NO,  KC_NO, KC_NO, M(JPPO), KC_NO, KC_NO, KC_NO,
 369                           KC_NO, KC_NO, KC_NO, KC_NO, KC_NO,
 370        KC_NO, KC_NO,
 371        KC_NO,
 372        KC_NO, KC_NO, KC_TRNS
 373 ),
 374 /* Keymap 6: Number Layer
 375  *
 376  * ,--------------------------------------------------.           ,--------------------------------------------------.
 377  * |        |  F1  |  F2  |  F3  |  F4  |  F5  |      |           |      |  F6  |  F7  |  F8  |  F9  |  F10 |   F11  |
 378  * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
 379  * |        |      |      |   "  |   [  |   ]  |      |           |   |  |   %  |   7  |   8  |   9  |      |   F12  |
 380  * |--------+------+------+------+------+------|   ;  |           |      |------+------+------+------+------+--------|
 381  * |        |      |   /  |   +  |   {  |   }  |------|           |------|   !  |   4  |   5  |   6  |   0  |   ,    |
 382  * |--------+------+------+------+------+------|   :  |           |   &  |------+------+------+------+------+--------|
 383  * |        |      |   *  |   -  |   (  |   )  |      |           |      |   .  |   1  |   2  |   3  |   ?  |        |
 384  * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
 385  *   |      |      |      |      |   #  |                                       |   <  |   =  |   >  |      |      |
 386  *   `----------------------------------'                                       `----------------------------------'
 387  *                                        ,-------------.       ,-------------.
 388  *                                        |      |      |       |      |      |
 389  *                                 ,------|------|------|       |------+------+------.
 390  *                                 |      |      |      |       |      |      |      |
 391  *                                 |      |      |------|       |------| Back |  Ent |
 392  *                                 |      |      |      |       |      |      |      |
 393  *                                 `--------------------'       `--------------------'
 394  */
 395 // Numbers
 396 [NUM] = LAYOUT_ergodox(
 397        // left hand
 398            KC_NO, KC_F1,      KC_F2,          KC_F3,      KC_F4,   KC_F5,   KC_NO,
 399            KC_NO, KC_NO,    KC_NO,        JP_DQT,    KC_RBRACKET,   KC_BSPC, KC_SCLN,
 400        KC_NO, KC_NO,    KC_SLSH,        JP_PLUS,    LSFT(KC_RBRACKET),   JP_RCBR,
 401        KC_NO, KC_NO,    JP_ASTR,        KC_MINS,    LSFT(KC_8), LSFT(KC_9), JP_COLN,
 402        KC_TRNS, KC_NO,    KC_NO,        KC_NO,    KC_HASH,
 403                                            KC_NO, KC_NO,
 404                                                     KC_NO,
 405                                   KC_NO, KC_NO, KC_TRNS,
 406        // right hand
 407        KC_NO, KC_F6,   KC_F7,  KC_F8,   KC_F9,   KC_F10,  KC_F11,
 408        LSFT(KC_JYEN), KC_PERC,   KC_7,   KC_8,    KC_9,    KC_NO, KC_F12,
 409                 KC_EXLM, KC_4,   KC_5,    KC_6,    KC_0, KC_COMM,
 410        LSFT(KC_6), KC_DOT, KC_1,   KC_2,    KC_3,    KC_QUES, KC_NO,
 411                          KC_LT,JP_EQL,  KC_GT,    KC_NO,  KC_NO,
 412        KC_NO, KC_NO,
 413        KC_NO,
 414        KC_SPC, KC_BSLS, KC_DOT
 415 ),
 416 };
 417
 418 const uint16_t PROGMEM fn_actions[] = {
 419     [1] = ACTION_LAYER_MOMENTARY(NUM)                // FN1 - Momentary Layer 6 (Numbers)
 420 };
 421
 422 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 423 {
 424
 425   // MACRO only works in this function
 426         switch(id) {
 427                 case 0:
 428                         if (record->event.pressed) {
 429                                 register_code(KC_RSFT);
 430                         } else {
 431                                 unregister_code(KC_RSFT);
 432                         }
 433                         break;
 434                 case CTLSHFT:
 435                         if (record->event.pressed) {
 436                                 return MACRO( D(LSFT), D(LCTL), END);
 437                         } else {
 438                                 return MACRO( U(LSFT), U(LCTL), END);
 439                         }
 440                         break;
 441                 case CUTCOPY:
 442                         if (record->event.pressed) {
 443                                 start = timer_read();
 444                         } else {
 445                                 if (timer_elapsed(start) > 150) {
 446                                         return MACRO( D(LCTL), T(X), U(LCTL), END);
 447                                 } else {
 448                                         return MACRO( D(LCTL), T(C), U(LCTL), END);
 449                                 }
 450                         }
 451                         break;
 452
 453                 // kana macros start here
 454
 455                 case JPVU:
 456                         if (record->event.pressed) {
 457                                 return MACRO( I(1), T(V), T(U), END);
 458                         }
 459                         break;
 460                 case JPNU:
 461                         if (record->event.pressed) {
 462                                 return MACRO( I(1), T(N), T(U), END);
 463                         }
 464                         break;
 465                 case JPKO:
 466                         if (record->event.pressed) {
 467                                 return MACRO( I(1), T(K), T(O), END);
 468                         }
 469                         break;
 470                 case JPSA:
 471                         if (record->event.pressed) {
 472                                 return MACRO( I(1), T(S), T(A), END);
 473                         }
 474                         break;
 475                 case JPKE:
 476                         if (record->event.pressed) {
 477                                 return MACRO( I(1), T(K), T(E), END);
 478                         }
 479                         break;
 480                 case JPHE:
 481                         if (record->event.pressed) {
 482                                 return MACRO( I(1), T(H), T(E), END);
 483                         }
 484                         break;
 485                 case JPSHI:
 486                         if (record->event.pressed) {
 487                                 return MACRO( I(1), T(S), T(I), END);
 488                         }
 489                         break;
 490                         case JPKA:
 491                         if (record->event.pressed) {
 492                                 return MACRO( I(1), T(K), T(A), END);
 493                         }
 494                         break;
 495                 case JPKI:
 496                         if (record->event.pressed) {
 497                                 return MACRO( I(1), T(K), T(I), END);
 498                         }
 499                         break;
 500                 case JPSU:
 501                         if (record->event.pressed) {
 502                                 return MACRO( I(1), T(S), T(U), END);
 503                         }
 504                         break;
 505                 case JPSO:
 506                         if (record->event.pressed) {
 507                                 return MACRO( I(1), T(S), T(O), END);
 508                         }
 509                         break;
 510                 case JPHI:
 511                         if (record->event.pressed) {
 512                                 return MACRO( I(1), T(H), T(I), END);
 513                         }
 514                         break;
 515                 case JPCHI:
 516                         if (record->event.pressed) {
 517                                 return MACRO( I(1), T(T), T(I), END);
 518                         }
 519                         break;
 520                 case JPFU:
 521                         if (record->event.pressed) {
 522                                 return MACRO( I(1), T(F), T(U), END);
 523                         }
 524                         break;
 525                 case JPSE:
 526                         if (record->event.pressed) {
 527                                 return MACRO( I(1), T(S), T(E), END);
 528                         }
 529                         break;
 530                 case JPTSU:
 531                         if (record->event.pressed) {
 532                                 return MACRO( I(1), T(T), T(U), END);
 533                         }
 534                         break;
 535                 case JPKU:
 536                         if (record->event.pressed) {
 537                                 return MACRO( I(1), T(K), T(U), END);
 538                         }
 539                         break;
 540                 case JPTE:
 541                         if (record->event.pressed) {
 542                                 return MACRO( I(1), T(T), T(E), END);
 543                         }
 544                         break;
 545                 case JPTA:
 546                         if (record->event.pressed) {
 547                                 return MACRO( I(1), T(T), T(A), END);
 548                         }
 549                         break;
 550                 case JPTO:
 551                         if (record->event.pressed) {
 552                                 return MACRO( I(1), T(T), T(O), END);
 553                         }
 554                         break;
 555                 case JPHA:
 556                         if (record->event.pressed) {
 557                                 return MACRO( I(1), T(H), T(A), END);
 558                         }
 559                         break;
 560                 case JPHO:
 561                         if (record->event.pressed) {
 562                                 return MACRO( I(1), T(H), T(O), END);
 563                         }
 564                         break;
 565                 case JPXKE:
 566                         if (record->event.pressed) {
 567                                 return MACRO( I(1), T(X), T(K), T(E), END);
 568                         }
 569                         break;
 570                 case JPXU:
 571                         if (record->event.pressed) {
 572                                 return MACRO( I(1), T(X), T(U), END);
 573                         }
 574                         break;
 575                 case JPXKA:
 576                         if (record->event.pressed) {
 577                                 return MACRO( I(1), T(X), T(K), T(A), END);
 578                         }
 579                         break;
 580                 case JPXA:
 581                         if (record->event.pressed) {
 582                                 return MACRO( I(1), T(X), T(A), END);
 583                         }
 584                         break;
 585                 case JPXO:
 586                         if (record->event.pressed) {
 587                                 return MACRO( I(1), T(X), T(O), END);
 588                         }
 589                         break;
 590                 case JPGO:
 591                         if (record->event.pressed) {
 592                                 return MACRO( I(1), T(G), T(O), END);
 593                         }
 594                         break;
 595                 case JPZA:
 596                         if (record->event.pressed) {
 597                                 return MACRO( I(1), T(Z), T(A), END);
 598                         }
 599                         break;
 600                 case JPGE:
 601                         if (record->event.pressed) {
 602                                 return MACRO( I(1), T(G), T(E), END);
 603                         }
 604                         break;
 605                 case JPBE:
 606                         if (record->event.pressed) {
 607                                 return MACRO( I(1), T(B), T(E), END);
 608                         }
 609                         break;
 610                 case JPYU:
 611                         if (record->event.pressed) {
 612                                 return MACRO( I(1), T(Y), T(U), END);
 613                         }
 614                         break;
 615                 case JPJI:
 616                         if (record->event.pressed) {
 617                                 return MACRO( I(1), T(J), T(I), END);
 618                         }
 619                         break;
 620                 case JPGA:
 621                         if (record->event.pressed) {
 622                                 return MACRO( I(1), T(G), T(A), END);
 623                         }
 624                         break;
 625                 case JPGI:
 626                         if (record->event.pressed) {
 627                                 return MACRO( I(1), T(G), T(I), END);
 628                         }
 629                         break;
 630                 case JPZU:
 631                         if (record->event.pressed) {
 632                                 return MACRO( I(1), T(Z), T(U), END);
 633                         }
 634                         break;
 635                 case JPZO:
 636                         if (record->event.pressed) {
 637                                 return MACRO( I(1), T(Z), T(O), END);
 638                         }
 639                         break;
 640                 case JPBI:
 641                         if (record->event.pressed) {
 642                                 return MACRO( I(1), T(B), T(I), END);
 643                         }
 644                         break;
 645                 case JPDI:
 646                         if (record->event.pressed) {
 647                                 return MACRO( I(1), T(D), T(I), END);
 648                         }
 649                         break;
 650                 case JPZE:
 651                         if (record->event.pressed) {
 652                                 return MACRO( I(1), T(Z), T(E), END);
 653                         }
 654                         break;
 655                 case JPDU:
 656                         if (record->event.pressed) {
 657                                 return MACRO( I(1), T(D), T(U), END);
 658                         }
 659                         break;
 660                 case JPGU:
 661                         if (record->event.pressed) {
 662                                 return MACRO( I(1), T(G), T(U), END);
 663                         }
 664                         break;
 665                 case JPYA:
 666                         if (record->event.pressed) {
 667                                 return MACRO( I(1), T(Y), T(A), END);
 668                         }
 669                         break;
 670                 case JPYO:
 671                         if (record->event.pressed) {
 672                                 return MACRO( I(1), T(Y), T(O), END);
 673                         }
 674                         break;
 675                 case JPDE:
 676                         if (record->event.pressed) {
 677                                 return MACRO( I(1), T(D), T(E), END);
 678                         }
 679                         break;
 680                 case JPDA:
 681                         if (record->event.pressed) {
 682                                 return MACRO( I(1), T(D), T(A), END);
 683                         }
 684                         break;
 685                 case JPDO:
 686                         if (record->event.pressed) {
 687                                 return MACRO( I(1), T(D), T(O), END);
 688                         }
 689                         break;
 690                 case JPBA:
 691                         if (record->event.pressed) {
 692                                 return MACRO( I(1), T(B), T(A), END);
 693                         }
 694                         break;
 695                 case JPBO:
 696                         if (record->event.pressed) {
 697                                 return MACRO( I(1), T(B), T(O), END);
 698                         }
 699                         break;
 700                 case JPRI:
 701                         if (record->event.pressed) {
 702                                 return MACRO( I(1), T(R), T(I), END);
 703                         }
 704                         break;
 705                 case JPRE:
 706                         if (record->event.pressed) {
 707                                 return MACRO( I(1), T(R), T(E), END);
 708                         }
 709                         break;
 710                 case JPRA:
 711                         if (record->event.pressed) {
 712                                 return MACRO( I(1), T(R), T(A), END);
 713                         }
 714                         break;
 715                 case JPNA:
 716                         if (record->event.pressed) {
 717                                 return MACRO( I(1), T(N), T(A), END);
 718                         }
 719                         break;
 720                 case JPNO:
 721                         if (record->event.pressed) {
 722                                 return MACRO( I(1), T(N), T(O), END);
 723                         }
 724                         break;
 725                 case JPMI:
 726                         if (record->event.pressed) {
 727                                 return MACRO( I(1), T(M), T(I), END);
 728                         }
 729                         break;
 730                 case JPMU:
 731                         if (record->event.pressed) {
 732                                 return MACRO( I(1), T(M), T(U), END);
 733                         }
 734                         break;
 735                 case JPME:
 736                         if (record->event.pressed) {
 737                                 return MACRO( I(1), T(M), T(E), END);
 738                         }
 739                         break;
 740                 case JPNE:
 741                         if (record->event.pressed) {
 742                                 return MACRO( I(1), T(N), T(E), END);
 743                         }
 744                         break;
 745                 case JPMA:
 746                         if (record->event.pressed) {
 747                                 return MACRO( I(1), T(M), T(A), END);
 748                         }
 749                         break;
 750                 case JPXTU:
 751                         if (record->event.pressed) {
 752                                 return MACRO( I(1), T(X), T(T), T(U), END);
 753                         }
 754                         break;
 755                 case JPWA:
 756                         if (record->event.pressed) {
 757                                 return MACRO( I(1), T(W), T(A), END);
 758                         }
 759                         break;
 760                 case JPRU:
 761                         if (record->event.pressed) {
 762                                 return MACRO( I(1), T(R), T(U), END);
 763                         }
 764                         break;
 765                 case JPWO:
 766                         if (record->event.pressed) {
 767                                 return MACRO( I(1), T(W), T(O), END);
 768                         }
 769                         break;
 770                 case JPNI:
 771                         if (record->event.pressed) {
 772                                 return MACRO( I(1), T(N), T(I), END);
 773                         }
 774                         break;
 775                 case JPNN:
 776                         if (record->event.pressed) {
 777                                 return MACRO( I(1), T(N), T(N), END);
 778                         }
 779                         break;
 780                 case JPMO:
 781                         if (record->event.pressed) {
 782                                 return MACRO( I(1), T(M), T(O), END);
 783                         }
 784                         break;
 785                 case JPRO:
 786                         if (record->event.pressed) {
 787                                 return MACRO( I(1), T(R), T(O), END);
 788                         }
 789                         break;
 790                 case JPXE:
 791                         if (record->event.pressed) {
 792                                 return MACRO( I(1), T(X), T(E), END);
 793                         }
 794                         break;
 795                 case JPXI:
 796                         if (record->event.pressed) {
 797                                 return MACRO( I(1), T(X), T(I), END);
 798                         }
 799                         break;
 800                 case JPXYU:
 801                         if (record->event.pressed) {
 802                                 return MACRO( I(1), T(X), T(Y), T(U), END);
 803                         }
 804                         break;
 805                 case JPXYA:
 806                         if (record->event.pressed) {
 807                                 return MACRO( I(1), T(X), T(Y), T(A), END);
 808                         }
 809                         break;
 810                 case JPXYO:
 811                         if (record->event.pressed) {
 812                                 return MACRO( I(1), T(X), T(Y), T(O), END);
 813                         }
 814                         break;
 815                 case JPPE:
 816                         if (record->event.pressed) {
 817                                 return MACRO( I(1), T(P), T(E), END);
 818                         }
 819                         break;
 820                 case JPPU:
 821                         if (record->event.pressed) {
 822                                 return MACRO( I(1), T(P), T(U), END);
 823                         }
 824                         break;
 825                 case JPPI:
 826                         if (record->event.pressed) {
 827                                 return MACRO( I(1), T(P), T(I), END);
 828                         }
 829                         break;
 830                 case JPPA:
 831                         if (record->event.pressed) {
 832                                 return MACRO( I(1), T(P), T(A), END);
 833                         }
 834                         break;
 835                 case JPPO:
 836                         if (record->event.pressed) {
 837                                 return MACRO( I(1), T(P), T(O), END);
 838                         }
 839                         break;
 840                 case JPBU:
 841                         if (record->event.pressed) {
 842                                 return MACRO( I(1), T(B), T(U), END);
 843                         }
 844                         break;
 845
 846                         // kana macros end here
 847
 848                         break;
 849                 case SHIFT:
 850                 if (record->event.pressed) {
 851                         start = timer_read();
 852                         if (layer_state == (1<<JPKAZARI)) {
 853                                 layer_state = (1<<JPTOPROW)| (1<<JPTRKZ);
 854                         } else {
 855                                 layer_state = (1<<JPTOPROW);
 856                         }
 857       } else {
 858                         layer_state = (0<<JPTOPROW);
 859                         clear_keyboard_but_mods();
 860                         if (timer_elapsed(start) < 100) {
 861                                 return MACRO( I(1), T(SPC), END);
 862                         }
 863       }
 864       break;
 865                 case KAZARI:
 866                 if (record->event.pressed) {
 867                         start = timer_read();
 868                         if (layer_state == (1<<JPTOPROW)) {
 869                                 layer_state = (1<<JPKAZARI)| (1<<JPTRKZ);
 870                         } else {
 871                                 layer_state = (1<<JPKAZARI);
 872                         }
 873                         break;
 874       } else {
 875                         layer_state = (0<<JPKAZARI);
 876                         layer_state = (0<<JPTRKZ);
 877                 if (timer_elapsed(start) < 100) {
 878           return MACRO( T(ENTER), END);
 879         }
 880       }
 881       break;
 882                 case JPFN:
 883                         if (record->event.pressed) {
 884                                 start = timer_read();
 885                                 layer_state = (1<<JPXON);
 886                         } else {
 887                                 layer_state = (0<<JPXON);
 888                                 if (timer_elapsed(start) < 100) {
 889                                         return MACRO( T(F7), END);
 890                                 }
 891                         }
 892       break;
 893                 case TOJPLOUT:
 894                         if (record->event.pressed) {
 895                                 if (default_layer_state == (1<<JP)) {
 896                                         default_layer_state = (0<<JP);
 897                                 } else {
 898                                         default_layer_state = (1<<JP);
 899                                 }
 900                                 return MACRO( T(ZKHK), END);
 901                         }
 902                         break;
 903 /*
 904                 // TOJPL and TOENL switch keyboard language.
 905                 // The Ctrl+[] commands here load the appropriate ibus-anthy input engine via a WM shortcut
 906                 // The first key pressed in the new engine is missed, thus the space key
 907                 // TOJPLOUT works in the same way but is used for switching engines on external systems.
 908                 case TOJPL:
 909                         if (record->event.pressed) {
 910                                 default_layer_state = (1<<JP);
 911                                 return MACRO( D(LCTL), T(END), U(LCTL), END);
 912                                 //return MACRO( D(LCTL), T(END), U(LCTL), W(250), W(250), W(250), T(SPACE), END);
 913                         }
 914                         break;
 915                 case TOENL:
 916                         if (record->event.pressed) {
 917                                 default_layer_state = (1<<BASE);
 918                                 return MACRO( D(LCTL), T(HOME), U(LCTL), END);
 919                         //return MACRO( D(LCTL), T(HOME), U(LCTL), W(250), W(250), W(250), T(SPACE), END);
 920                         }
 921                         break;
 922 */
 923                 }
 924     return MACRO_NONE;
 925 };
 926
 927 // Runs just one time when the keyboard initializes.
 928 void matrix_init_user(void) {
 929 };
 930
 931 // Runs constantly in the background, in a loop.
 932 void matrix_scan_user(void) {
 933
 934         uint8_t layer = biton32(layer_state);
 935    uint8_t deflayer = biton32(default_layer_state);
 936
 937         ergodox_board_led_off();
 938         ergodox_right_led_1_off();
 939         ergodox_right_led_2_off();
 940         ergodox_right_led_3_off();
 941
 942
 943         switch (layer) {
 944                 case 0:
 945                         //none
 946                         break;
 947 //              case 1:
 948 //                      ergodox_right_led_2_on();
 949 //                      break;
 950                 case 6:
 951                         ergodox_right_led_3_on();
 952                         break;
 953     }
 954     switch (deflayer) {
 955                  case 0:
 956                  ergodox_right_led_1_off();
 957                  break;
 958                  case 1:
 959                  ergodox_right_led_1_on();
 960                  break;
 961         }
 962 };