[Keymap] Improvements to Samuel's literate keymap (#5428)

* added my own keymap

* changed thing

* updated keymap Samuel

* updated laypout for better one handed use

* updated stuff I want

* happy with my lagout

* formatting

* Added new literate config

* made everything nice

* cleaned

* fixed spelling and two small bugs in macros

* Made press and lift function for modifiers

* made taps occur on press instead of release

* added oneshot keys and chars cant be negative!

* removed debug message

* Added command and qwerty layers

* fixed bug with oneshot layer

* same bug, different key

2 files changed, 593 insertions, 288 deletions

diff --git a/keyboards/planck/keymaps/samuel/README.org b/keyboards/planck/keymaps/samuel/README.org
index d0750ee03a..3c0f08a9d9 100644
--- a/keyboards/planck/keymaps/samuel/README.org
+++ b/keyboards/planck/keymaps/samuel/README.org
@@ -5,7 +5,7 @@ This is my qmk firmware for my keyboard. I grew tired of organizing the keycode
 array in plain text so I made it a literate .org file. I've never done this
 before, so bear with me.
 
-* Keymap
+* Layers
 
 #+BEGIN_COMMENT
 #+NAME: empty-layer
@@ -19,7 +19,7 @@ before, so bear with me.
 #+END_COMMENT
 
 This is my "pretty" org mode organized table for my main dvorak layer. If you
-don't use org mode, it won't be that exiting, but if you enjoy working in org
+don't use org mode, it won't be that exciting, but if you enjoy working in org
 mode, you can edit this table directly, and this file is tangled to the actual
 keymap. No more organizing spaces or converting to and from comments.
 
@@ -31,23 +31,45 @@ keymap. No more organizing spaces or converting to and from comments.
 | T_LGUI | T_LALT | UP   | DOWN | BSPC | TAB | ENT | SPC | LEFT | RIGHT | T_RALT | T_RGUI |
 |--------+--------+------+------+------+-----+-----+-----+------+-------+--------+--------|
 
+This qwerty layout is just so normal people can try out the board. Tap keys
+would need to be customized I think, more on that later. I also put another
+dvorak key here because I have nightmares of getting trapped in this forsaken
+layout.
+
+#+NAME: qwerty-layer
+|--------+--------+----+------+------+-----+-----+-----+------+-------+--------+--------|
+| T_LRSE | Q      | W  | E    | R    | T   | Y   | U   | I    | O     | P      | T_RRSE |
+| T_LSFT | A      | S  | D    | F    | G   | H   | J   | K    | L     | SCLN   | T_RSFT |
+| T_LCTL | Z      | X  | C    | V    | B   | N   | M   | COMM | DOT   | QUOT   | T_RCTL |
+| T_LGUI | T_LALT | UP | DOWN | BSPC | TAB | ENT | SPC | LEFT | RIGHT | T_RALT | DVORAK |
+|--------+--------+----+------+------+-----+-----+-----+------+-------+--------+--------|
+
 I tried to keep my layout bare bones, just what would be available on a normal
-keyboard, minus some keys I never used. The bottom left copies a normal
+keyboard, minus some keys I never used. This one secondary layer should cover a
+majority of the keys not found on the home layer. The bottom left copies a normal
 keyboards symbols from shifted numbers, and the rest is placed where convenient,
 with some considerations for one handed use, hence the shortcuts in the top
 left.
 
-#+TODO: qwerty layer for ma friends
-
 #+NAME: secondary-layer
-|----+--------+--------+--------+--------+------+------+----+--------+--------+-----+----|
-| -- | EZUNDO | EZCOPY | EZCUT  | EZPSTE | INS  | EQL  |  7 |      8 |      9 | F11 | -- |
-| -- | ESC    | CAPS   | PGUP   | PGDN   | F4   | ASTR |  4 |      5 |      6 | 0   | -- |
-| -- | EXLM   | AT     | HASH   | DLR    | PERC | CIRC |  1 |      2 |      3 | F12 | -- |
-| -- | --     | EZUP   | EZDOWN | --     | AMPR | PIPE | -- | EZLEFT | EZRGHT | --  | -- |
-|----+--------+--------+--------+--------+------+------+----+--------+--------+-----+----|
-
-But wait, we are missing several important keys!? yes, well, the modifier keys
+|--------+--------+--------+--------+--------+------+------+-----+--------+--------+-------+--------|
+| --     | EZUNDO | EZCOPY | EZCUT  | EZPSTE | INS  | EQL  |   7 |      8 |      9 | --    | --     |
+| EZSHFT | ESC    | CAPS   | PGUP   | PGDN   | HOME | ASTR |   4 |      5 |      6 | 0     | EZSHFT |
+| EZCTRL | EXLM   | AT     | HASH   | DLR    | PERC | CIRC |   1 |      2 |      3 | COM   | EZCTRL |
+| EZGUI  | EZALT  | EZUP   | EZDOWN | SPC    | AMPR | PIPE | END | EZLEFT | EZRGHT | EZALT | EZGUI  |
+|--------+--------+--------+--------+--------+------+------+-----+--------+--------+-------+--------|
+
+Basic command layer for one-shot macros and function keys.
+
+#+NAME: command-layer
+|----+-----+-----+-----+-----+--------+--------+------+-------+------+-----+----|
+| -- | F1  | F2  | F3  | F4  | F5     | F6     | F7   | F8    | F9   | F10 | -- |
+| -- | F11 | F12 | F13 | F14 | F15    | F16    | F17  | F18   | F19  | F20 | -- |
+| -- | F21 | F22 | F23 | F24 | QWERTY | DVORAK | USER | EMAIL | NAME | --  | -- |
+| -- | --  | --  | --  | --  | --     | --     | DIR  | --    | --   | --  | -- |
+|----+-----+-----+-----+-----+--------+--------+------+-------+------+-----+----|
+
+But wait, we are missing several important keys? well, yes, but the modifier keys
 all do other keys when tapped. More about that in the keymap section.
 
 * Keymap Conversion in Python
@@ -55,7 +77,7 @@ all do other keys when tapped. More about that in the keymap section.
 This python can convert that table into the array needed for the keymap file. It
 simply prepends every key with "KC_". I used to use a dictionary to convert some
 keys from the table into qmk keycodes, but the double convertion was
-unneccessary so I simply prepended all my macros with KC and moved all the
+unneccessary so I just prepended all my macros with KC and moved all the
 implementation to the `process-user-input` function.
 
 #+NAME:layer-to-array
@@ -84,55 +106,69 @@ return results
 
 * keymap.c
 
-Now that we have done all the hard work, lets layout our keymap file then define
-our macros.
-
-** Headers And Layer Declaration
+Now that we laid out our layout, lets lay out our kemap file.
 
 #+BEGIN_SRC C :noweb yes
 #include QMK_KEYBOARD_H
 
 extern keymap_config_t keymap_config;
 
-static uint16_t tap_timers[10]  = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-
-char last_mod = -1;
+#+END_SRC
 
-enum planck_layers {
-  _DVORAK,
-  _RISE
-};
+** Keycodes
 
+#+BEGIN_SRC C :noweb yes
 // where the 'T_' communicates how the key does something different when tapped.
 enum planck_keycodes {
-  DVORAK = SAFE_RANGE,
-  KC_T_LALT,
-  KC_T_RALT,
-  KC_T_LGUI,
-  KC_T_RGUI,
-  KC_T_LCTL,
-  KC_T_RCTL,
-  KC_T_LSFT,
-  KC_T_RSFT,
-  KC_T_LRSE,
-  KC_T_RRSE,
-  KC_EZRGHT,
-  KC_EZLEFT,
-  KC_EZUP,
-  KC_EZDOWN,
-  KC_EZUNDO,
-  KC_EZCOPY,
-  KC_EZCUT,
-  KC_EZPSTE
+//DVORAK = SAFE_RANGE,
+KC_T_LALT = SAFE_RANGE,
+KC_T_RALT,
+KC_T_LGUI,
+KC_T_RGUI,
+KC_T_LCTL,
+KC_T_RCTL,
+KC_T_LSFT,
+KC_T_RSFT,
+KC_T_LRSE,
+KC_T_RRSE,
+KC_EZRGHT,
+KC_EZLEFT,
+KC_EZUP,
+KC_EZDOWN,
+KC_EZUNDO,
+KC_EZCOPY,
+KC_EZCUT,
+KC_EZPSTE,
+KC_EZSHFT,
+KC_EZCTRL,
+KC_EZGUI,
+KC_EZALT,
+KC_DVORAK,
+KC_QWERTY,
+KC_USER,
+KC_EMAIL,
+KC_NAME,
+KC_DIR,
+KC_COM
 };
 
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-
 #+END_SRC
 
 ** Import Key table
 
 #+BEGIN_SRC C :noweb yes
+enum planck_layers {
+_DVORAK,
+_QWERTY,
+_RISE,
+_COMMAND
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+#+END_SRC
+
+#+BEGIN_SRC C :noweb yes
 [_DVORAK] =
 
 #+END_SRC
@@ -143,6 +179,16 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 #+END_SRC
 
 #+BEGIN_SRC C :noweb yes
+[_QWERTY] =
+
+#+END_SRC
+
+#+BEGIN_SRC C :noweb yes
+<<layer-to-array(qwerty-layer)>>
+
+#+END_SRC
+
+#+BEGIN_SRC C :noweb yes
 [_RISE] =
 
 #+END_SRC
@@ -152,50 +198,96 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 #+END_SRC
 
-** Process User Input
-*** Tap Key Functionality
+#+BEGIN_SRC C :noweb yes
+[_COMMAND] =
 
-These methods define how I implemented the tap mechanic. Basically, I believe
-that /pressing/ any other key should be grounds for the hold functionality to be
-assumed. My natuaral typing style experiences no delays from my method.
+#+END_SRC
+
+#+BEGIN_SRC C :noweb yes
+<<layer-to-array(command-layer)>>
+
+#+END_SRC
 
 #+BEGIN_SRC C :noweb yes
 };
 
-void mod_press(uint16_t hold_code, int id) {
-    tap_timers[id] = timer_read();
-    last_mod = id;
-    register_code(hold_code);
+#+END_SRC
+
+** Tap Keys
+
+I don't like tap keys coming out on release. When modified, I often let go of
+the modifier too early because the tap button doesn't come out untill release. I
+guess you could save the state of the board on press and then apply it after the
+timer, but what I really want is the keys to come out on press when they can and
+when it is most useful. For me, that is when they are modified a single time. So
+I kind "locked" the board into only doing single modifiers, making them faster.
+Disadvantages are double modified keys must be done with one shot keys (its
+actually not that bad, it feels like emacs!) and triple modified keys are
+impossible at the moment.
+
+#+BEGIN_SRC C :noweb yes
+
+static uint16_t tap_timer = 0;
+char last_mod = 10;
+
+void mod_press(uint16_t tap_code, uint16_t hold_code, int id) {
+    // this first if body makes double modified keys impossible, but stops the
+    // delay when modifying a tap key which would result in the tap key not
+    // getting modified.
+    if (last_mod != id && last_mod != 10) {
+        tap_code16(tap_code);
+        last_mod = 10;
+    } else {
+        tap_timer = timer_read();
+        last_mod = id;
+        register_code(hold_code);
+    }
 }
 
 void mod_lift(uint16_t tap_code, uint16_t hold_code, int id) {
     unregister_code(hold_code);
-    if (last_mod == id && timer_elapsed(tap_timers[id]) < TAPPING_TERM) {
-      tap_code16(tap_code);
-      last_mod = -1;
+    if (last_mod == id && timer_elapsed(tap_timer) < TAPPING_TERM) {
+        tap_code16(tap_code);
+        last_mod = 10;
     }
 }
 
 #+END_SRC
 
-*** Set DVORAK layout
-
-The function that filter's user inputs and applies macros, the begginning is
-pretty basic, setting our main layer and configuring our secondary layer.
+** Process User Input
 
 #+BEGIN_SRC C :noweb yes
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {
-    case DVORAK:
-      if (record->event.pressed) {
-        set_single_persistent_default_layer(_DVORAK);
-      }
-      return false;
-      break;
+    switch (keycode) {
+#+END_SRC
+
+** Layouts
+
+Set Dvorak layout
+
+#+BEGIN_SRC C :noweb yes
+case KC_DVORAK:
+if (record->event.pressed) {
+    set_single_persistent_default_layer(_DVORAK);
+}
+return true;
+break;
+
+#+END_SRC
+
+Set Qwerty layout.
+
+#+BEGIN_SRC C :noweb yes
+case KC_QWERTY:
+if (record->event.pressed) {
+    set_single_persistent_default_layer(_QWERTY);
+}
+return true;
+break;
 
 #+END_SRC
 
-*** Alt  and ()
+** Alt and ()
 
 Left and right alt are ( and ) when tapped. I put them on alt instead of a more
 conveniant key like control because parentheses do not need to be shift modified
@@ -204,24 +296,24 @@ ever, unlike some other tap keys seen in the next sections.
 #+BEGIN_SRC C :noweb yes
 case KC_T_LALT:
 if (record->event.pressed) {
-  mod_press(KC_LALT, 0);
- } else {
-  mod_lift(S(KC_9), KC_LALT, 0);
- }
+    mod_press(S(KC_9), KC_LALT, 0);
+} else {
+    mod_lift(S(KC_9), KC_LALT, 0);
+}
 return false;
 break;
 case KC_T_RALT:
 if (record->event.pressed) {
-  mod_press(KC_RALT, 1);
- } else {
-  mod_lift(S(KC_0), KC_RALT, 1);
- }
+    mod_press(S(KC_0), KC_RALT, 1);
+} else {
+    mod_lift(S(KC_0), KC_RALT, 1);
+}
 return false;
 break;
 
 #+END_SRC
 
-*** Gui  and `\
+** Gui and `\
 
 I place gui in the bottom corner because I believe it is the hardest key to
 reach, so gui seemed like a good fit for a dedicated key that I never want to
@@ -231,24 +323,24 @@ number pad or shifted number keys.
 #+BEGIN_SRC C :noweb yes
 case KC_T_LGUI:
 if (record->event.pressed) {
-  mod_press(KC_LGUI, 2);
- } else {
-  mod_lift(KC_GRAVE, KC_LGUI, 2);
- }
+    mod_press(KC_GRAVE, KC_LGUI, 2);
+} else {
+    mod_lift(KC_GRAVE, KC_LGUI, 2);
+}
 return false;
 break;
 case KC_T_RGUI:
 if (record->event.pressed) {
-  mod_press(KC_RGUI, 3);
- } else {
-  mod_lift(KC_BSLASH, KC_RGUI, 3);
- }
+    mod_press(KC_BSLASH, KC_RGUI, 3);
+} else {
+    mod_lift(KC_BSLASH, KC_RGUI, 3);
+}
 return false;
 break;
 
 #+END_SRC
 
-*** Ctrl and []
+** Ctrl and []
 
 Left and right control are [] respectively when they are tapped, making { and }
 also very convenient.
@@ -256,24 +348,24 @@ also very convenient.
 #+BEGIN_SRC C :noweb yes
 case KC_T_LCTL:
 if (record->event.pressed) {
-  mod_press(KC_LCTL, 4);
- } else {
-  mod_lift(KC_LBRACKET, KC_LCTL, 4);
- }
+    mod_press(KC_LBRACKET, KC_LCTL, 4);
+} else {
+    mod_lift(KC_LBRACKET, KC_LCTL, 4);
+}
 return false;
 break;
 case KC_T_RCTL:
 if (record->event.pressed) {
-  mod_press(KC_RCTL, 5);
- } else {
-  mod_lift(KC_RBRACKET, KC_RCTL, 5);
- }
+    mod_press(KC_RBRACKET, KC_RCTL, 5);
+} else {
+    mod_lift(KC_RBRACKET, KC_RCTL, 5);
+}
 return false;
 break;
 
 #+END_SRC
 
-*** Shft and =-
+** Shft and =-
 
 I place shift on the home row, so having '-' right of my pinkie is standard, and
 it only felt natural to put its opposite, '=/+' on the other side. I put an
@@ -282,24 +374,24 @@ extra one on the right side in the secondary layer for the num pad.
 #+BEGIN_SRC C :noweb yes
 case KC_T_LSFT:
 if (record->event.pressed) {
-  mod_press(KC_LSFT, 6);
- } else {
-  mod_lift(KC_EQUAL, KC_LSFT, 6);
- }
+    mod_press(KC_EQUAL, KC_LSFT, 6);
+} else {
+    mod_lift(KC_EQUAL, KC_LSFT, 6);
+}
 return false;
 break;
 case KC_T_RSFT:
 if (record->event.pressed) {
-  mod_press(KC_RSFT, 7);
- } else {
-  mod_lift(KC_MINUS, KC_RSFT, 7);
- }
+    mod_press(KC_MINUS, KC_RSFT, 7);
+} else {
+    mod_lift(KC_MINUS, KC_RSFT, 7);
+}
 return false;
 break;
 
 #+END_SRC
 
-*** Rise, DEL, and /
+** Rise, DEL, and /
 
 I use the top corners as rise because I decided that I do not like using layers
 with my thumbs. It feels uncomfortable to hold keys down with the side of my
@@ -315,36 +407,78 @@ corner again mimicing a standard dvorak keyboard.
 #+BEGIN_SRC C :noweb yes
 case KC_T_LRSE:
 if (record->event.pressed) {
-  tap_timers[8] = timer_read();
-  last_mod = 8;
-  layer_on(_RISE);
- } else {
-  layer_off(_RISE);
-  if (last_mod == 8 && timer_elapsed(tap_timers[8]) < TAPPING_TERM) {
-    tap_code16(KC_DELETE);
-    last_mod = -1;
-  }
- }
+    tap_timer = timer_read();
+    last_mod = 8;
+    layer_on(_RISE);
+} else {
+    layer_off(_RISE);
+    if (last_mod == 8 && timer_elapsed(tap_timer) < TAPPING_TERM) {
+        tap_code16(KC_DELETE);
+        last_mod = 10;
+    }
+}
 return false;
 break;
 case KC_T_RRSE:
 if (record->event.pressed) {
-  tap_timers[9] = timer_read();
-  last_mod = 9;
-  layer_on(_RISE);
- } else {
-  layer_off(_RISE);
-  if (last_mod == 9 && timer_elapsed(tap_timers[9]) < TAPPING_TERM) {
-    tap_code16(KC_SLASH);
-    last_mod = -1;
-  }
- }
+    tap_timer = timer_read();
+    last_mod = 9;
+    layer_on(_RISE);
+} else {
+    layer_off(_RISE);
+    if (last_mod == 9 && timer_elapsed(tap_timer) < TAPPING_TERM) {
+        tap_code16(KC_SLASH);
+        last_mod = 10;
+    }
+}
 return false;
 break;
 
 #+END_SRC
 
-*** EZ keys
+** EZ Keys
+
+EZ or "easy" keys do things that can already be done on the board, but I want an
+easier way of doing them.
+
+*** One Shot Keys
+
+Since I made modified tap keys occur on press instead of release, I need one
+shot keys to press any key with more than one modifier.
+
+#+BEGIN_SRC C :noweb yes
+case KC_EZSHFT:
+if (record->event.pressed) {
+    set_oneshot_mods(MOD_LSFT);
+    last_mod = 10;
+}
+return false;
+break;
+case KC_EZCTRL:
+if (record->event.pressed) {
+    set_oneshot_mods(MOD_LCTL);
+    last_mod = 10;
+}
+return false;
+break;
+case KC_EZALT:
+if (record->event.pressed) {
+    set_oneshot_mods(MOD_LALT);
+    last_mod = 10;
+}
+return false;
+break;
+case KC_EZGUI:
+if (record->event.pressed) {
+    set_oneshot_mods(MOD_LGUI);
+    last_mod = 10;
+}
+return false;
+break;
+
+#+END_SRC
+
+*** Arrows
 
 I use ctrl+shift+arrows keys a lot, so when the layer key is pressed they became
 lazy versions of themselves with control and shift already pressed.
@@ -355,77 +489,134 @@ left hand like on a qwerty or colemek keyboard.
 #+BEGIN_SRC C :noweb yes
 case KC_EZRGHT:
 if (record->event.pressed) {
-  register_code(KC_LCTL);
-  tap_code16(S(KC_RGHT));
-  unregister_code(KC_LCTL);
-  last_mod = -1;
- }
+    register_code(KC_LCTL);
+    tap_code16(S(KC_RGHT));
+    unregister_code(KC_LCTL);
+    last_mod = 10;
+}
 return false;
 break;
 case KC_EZLEFT:
 if (record->event.pressed) {
-  register_code(KC_LCTL);
-  tap_code16(S(KC_LEFT));
-  unregister_code(KC_LCTL);
-  last_mod = -1;
- }
+    register_code(KC_LCTL);
+    tap_code16(S(KC_LEFT));
+    unregister_code(KC_LCTL);
+    last_mod = 10;
+}
 return false;
 break;
 case KC_EZDOWN:
 if (record->event.pressed) {
-  register_code(KC_LCTL);
-  tap_code16(S(KC_DOWN));
-  unregister_code(KC_LCTL);
-  last_mod = -1;
- }
+    register_code(KC_LCTL);
+    tap_code16(S(KC_DOWN));
+    unregister_code(KC_LCTL);
+    last_mod = 10;
+}
 return false;
 break;
 case KC_EZUP:
 if (record->event.pressed) {
-  register_code(KC_LCTL);
-  tap_code16(S(KC_UP));
-  unregister_code(KC_LCTL);
-  last_mod = -1;
- }
+    register_code(KC_LCTL);
+    tap_code16(S(KC_UP));
+    unregister_code(KC_LCTL);
+    last_mod = 10;
+}
 return false;
 break;
+#+END_SRC
+
+*** Undo, Copy, Cut, Paste
+
+#+BEGIN_SRC C :noweb yes
 case KC_EZUNDO:
 if (record->event.pressed) {
-  tap_code16(C(KC_Z));
-  last_mod = -1;
+    tap_code16(C(KC_Z));
+    last_mod = 10;
 }
 return false;
 break;
 case KC_EZCOPY:
 if (record->event.pressed) {
-  tap_code16(C(KC_C));
-  last_mod = -1;
+    tap_code16(C(KC_C));
+    last_mod = 10;
 }
 return false;
 break;
 case KC_EZCUT:
 if (record->event.pressed) {
-  tap_code16(C(KC_X));
-  last_mod = -1;
+    tap_code16(C(KC_X));
+    last_mod = 10;
 }
 return false;
 break;
 case KC_EZPSTE:
 if (record->event.pressed) {
-  tap_code16(C(KC_P));
-  last_mod = -1;
+    tap_code16(C(KC_V));
+    last_mod = 10;
+}
+return false;
+break;
+#+END_SRC
+
+** Commands
+
+Start command layer one shot
+
+#+BEGIN_SRC C :noweb yes
+case KC_COM:
+if (record->event.pressed) {
+    layer_on(_COMMAND);
+    set_oneshot_layer(_COMMAND, ONESHOT_START);
+    last_mod = 10;
+} else {
+    clear_oneshot_layer_state (ONESHOT_PRESSED);
 }
 return false;
 break;
 #+END_SRC
 
-*** Standard inputs interupt tap
+Just some strings I notice that I type a lot.
+
+#+BEGIN_SRC C :noweb yes
+case KC_USER:
+if (record->event.pressed) {
+    send_string("mhostley");
+    last_mod = 10;
+}
+return true;
+break;
+case KC_EMAIL:
+if (record->event.pressed) {
+    send_string("mhostley@gmail.com");
+    last_mod = 10;
+}
+return true;
+break;
+case KC_NAME:
+if (record->event.pressed) {
+    send_string("Samuel Jahnke");
+    last_mod = 10;
+}
+return true;
+break;
+case KC_DIR:
+if (record->event.pressed) {
+    send_string("home/mhostley/");
+    last_mod = 10;
+}
+return true;
+break;
+
+#+END_SRC
+
+** Standard inputs interupt tap
 
 Finally, if just a standard key is tapped, set the interupted flag.
+Keep this last.
 
 #+BEGIN_SRC C :noweb yes
-  }
-  last_mod = -1;
-  return true;
+}
+last_mod = 10;
+return true;
 }
 #+END_SRC
diff --git a/keyboards/planck/keymaps/samuel/keymap.c b/keyboards/planck/keymaps/samuel/keymap.c
index 53760da767..ff1424489f 100644
--- a/keyboards/planck/keymaps/samuel/keymap.c
+++ b/keyboards/planck/keymaps/samuel/keymap.c
@@ -2,36 +2,45 @@
 
 extern keymap_config_t keymap_config;
 
-static uint16_t tap_timers[10]  = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-
-char last_mod = -1;
-
-enum planck_layers {
-  _DVORAK,
-  _RISE
-};
-
 // where the 'T_' communicates how the key does something different when tapped.
 enum planck_keycodes {
-  DVORAK = SAFE_RANGE,
-  KC_T_LALT,
-  KC_T_RALT,
-  KC_T_LGUI,
-  KC_T_RGUI,
-  KC_T_LCTL,
-  KC_T_RCTL,
-  KC_T_LSFT,
-  KC_T_RSFT,
-  KC_T_LRSE,
-  KC_T_RRSE,
-  KC_EZRGHT,
-  KC_EZLEFT,
-  KC_EZUP,
-  KC_EZDOWN,
-  KC_EZUNDO,
-  KC_EZCOPY,
-  KC_EZCUT,
-  KC_EZPSTE
+//DVORAK = SAFE_RANGE,
+KC_T_LALT = SAFE_RANGE,
+KC_T_RALT,
+KC_T_LGUI,
+KC_T_RGUI,
+KC_T_LCTL,
+KC_T_RCTL,
+KC_T_LSFT,
+KC_T_RSFT,
+KC_T_LRSE,
+KC_T_RRSE,
+KC_EZRGHT,
+KC_EZLEFT,
+KC_EZUP,
+KC_EZDOWN,
+KC_EZUNDO,
+KC_EZCOPY,
+KC_EZCUT,
+KC_EZPSTE,
+KC_EZSHFT,
+KC_EZCTRL,
+KC_EZGUI,
+KC_EZALT,
+KC_DVORAK,
+KC_QWERTY,
+KC_USER,
+KC_EMAIL,
+KC_NAME,
+KC_DIR,
+KC_COM
+};
+
+enum planck_layers {
+_DVORAK,
+_QWERTY,
+_RISE,
+_COMMAND
 };
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
@@ -44,202 +53,307 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 { KC_T_LGUI, KC_T_LALT, KC_UP, KC_DOWN, KC_BSPC, KC_TAB, KC_ENT, KC_SPC, KC_LEFT, KC_RIGHT, KC_T_RALT, KC_T_RGUI}
 },
 
+[_QWERTY] =
+
+{{ KC_T_LRSE, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_T_RRSE},
+{ KC_T_LSFT, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_T_RSFT},
+{ KC_T_LCTL, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_QUOT, KC_T_RCTL},
+{ KC_T_LGUI, KC_T_LALT, KC_UP, KC_DOWN, KC_BSPC, KC_TAB, KC_ENT, KC_SPC, KC_LEFT, KC_RIGHT, KC_T_RALT, KC_DVORAK}
+},
+
 [_RISE] =
 
-{{ KC_TRANSPARENT, KC_EZUNDO, KC_EZCOPY, KC_EZCUT, KC_EZPSTE, KC_INS, KC_EQL, KC_7, KC_8, KC_9, KC_F11, KC_TRANSPARENT},
-{ KC_TRANSPARENT, KC_ESC, KC_CAPS, KC_PGUP, KC_PGDN, KC_F4, KC_ASTR, KC_4, KC_5, KC_6, KC_0, KC_TRANSPARENT},
-{ KC_TRANSPARENT, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_1, KC_2, KC_3, KC_F12, KC_TRANSPARENT},
-{ KC_TRANSPARENT, KC_TRANSPARENT, KC_EZUP, KC_EZDOWN, KC_TRANSPARENT, KC_AMPR, KC_PIPE, KC_TRANSPARENT, KC_EZLEFT, KC_EZRGHT, KC_TRANSPARENT, KC_TRANSPARENT}
+{{ KC_TRANSPARENT, KC_EZUNDO, KC_EZCOPY, KC_EZCUT, KC_EZPSTE, KC_INS, KC_EQL, KC_7, KC_8, KC_9, KC_TRANSPARENT, KC_TRANSPARENT},
+{ KC_EZSHFT, KC_ESC, KC_CAPS, KC_PGUP, KC_PGDN, KC_HOME, KC_ASTR, KC_4, KC_5, KC_6, KC_0, KC_EZSHFT},
+{ KC_EZCTRL, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_1, KC_2, KC_3, KC_COM, KC_EZCTRL},
+{ KC_EZGUI, KC_EZALT, KC_EZUP, KC_EZDOWN, KC_SPC, KC_AMPR, KC_PIPE, KC_END, KC_EZLEFT, KC_EZRGHT, KC_EZALT, KC_EZGUI}
+},
+
+[_COMMAND] =
+
+{{ KC_TRANSPARENT, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_TRANSPARENT},
+{ KC_TRANSPARENT, KC_F11, KC_F12, KC_F13, KC_F14, KC_F15, KC_F16, KC_F17, KC_F18, KC_F19, KC_F20, KC_TRANSPARENT},
+{ KC_TRANSPARENT, KC_F21, KC_F22, KC_F23, KC_F24, KC_QWERTY, KC_DVORAK, KC_USER, KC_EMAIL, KC_NAME, KC_TRANSPARENT, KC_TRANSPARENT},
+{ KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_DIR, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT}
 },
 
 };
 
-void mod_press(uint16_t hold_code, int id) {
-    tap_timers[id] = timer_read();
-    last_mod = id;
-    register_code(hold_code);
+static uint16_t tap_timer = 0;
+char last_mod = 10;
+
+void mod_press(uint16_t tap_code, uint16_t hold_code, int id) {
+    // this first if body makes double modified keys impossible, but stops the
+    // delay when modifying a tap key which would result in the tap key not
+    // getting modified.
+    if (last_mod != id && last_mod != 10) {
+        tap_code16(tap_code);
+        last_mod = 10;
+    } else {
+        tap_timer = timer_read();
+        last_mod = id;
+        register_code(hold_code);
+    }
 }
 
 void mod_lift(uint16_t tap_code, uint16_t hold_code, int id) {
     unregister_code(hold_code);
-    if (last_mod == id && timer_elapsed(tap_timers[id]) < TAPPING_TERM) {
-      tap_code16(tap_code);
-      last_mod = -1;
+    if (last_mod == id && timer_elapsed(tap_timer) < TAPPING_TERM) {
+        tap_code16(tap_code);
+        last_mod = 10;
     }
 }
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {
-    case DVORAK:
-      if (record->event.pressed) {
-        set_single_persistent_default_layer(_DVORAK);
-      }
-      return false;
-      break;
+    switch (keycode) {
+
+case KC_DVORAK:
+if (record->event.pressed) {
+    set_single_persistent_default_layer(_DVORAK);
+}
+return true;
+break;
+
+case KC_QWERTY:
+if (record->event.pressed) {
+    set_single_persistent_default_layer(_QWERTY);
+}
+return true;
+break;
 
 case KC_T_LALT:
 if (record->event.pressed) {
-  mod_press(KC_LALT, 0);
- } else {
-  mod_lift(S(KC_9), KC_LALT, 0);
- }
+    mod_press(S(KC_9), KC_LALT, 0);
+} else {
+    mod_lift(S(KC_9), KC_LALT, 0);
+}
 return false;
 break;
 case KC_T_RALT:
 if (record->event.pressed) {
-  mod_press(KC_RALT, 1);
- } else {
-  mod_lift(S(KC_0), KC_RALT, 1);
- }
+    mod_press(S(KC_0), KC_RALT, 1);
+} else {
+    mod_lift(S(KC_0), KC_RALT, 1);
+}
 return false;
 break;
 
 case KC_T_LGUI:
 if (record->event.pressed) {
-  mod_press(KC_LGUI, 2);
- } else {
-  mod_lift(KC_GRAVE, KC_LGUI, 2);
- }
+    mod_press(KC_GRAVE, KC_LGUI, 2);
+} else {
+    mod_lift(KC_GRAVE, KC_LGUI, 2);
+}
 return false;
 break;
 case KC_T_RGUI:
 if (record->event.pressed) {
-  mod_press(KC_RGUI, 3);
- } else {
-  mod_lift(KC_BSLASH, KC_RGUI, 3);
- }
+    mod_press(KC_BSLASH, KC_RGUI, 3);
+} else {
+    mod_lift(KC_BSLASH, KC_RGUI, 3);
+}
 return false;
 break;
 
 case KC_T_LCTL:
 if (record->event.pressed) {
-  mod_press(KC_LCTL, 4);
- } else {
-  mod_lift(KC_LBRACKET, KC_LCTL, 4);
- }
+    mod_press(KC_LBRACKET, KC_LCTL, 4);
+} else {
+    mod_lift(KC_LBRACKET, KC_LCTL, 4);
+}
 return false;
 break;
 case KC_T_RCTL:
 if (record->event.pressed) {
-  mod_press(KC_RCTL, 5);
- } else {
-  mod_lift(KC_RBRACKET, KC_RCTL, 5);
- }
+    mod_press(KC_RBRACKET, KC_RCTL, 5);
+} else {
+    mod_lift(KC_RBRACKET, KC_RCTL, 5);
+}
 return false;
 break;
 
 case KC_T_LSFT:
 if (record->event.pressed) {
-  mod_press(KC_LSFT, 6);
- } else {
-  mod_lift(KC_EQUAL, KC_LSFT, 6);
- }
+    mod_press(KC_EQUAL, KC_LSFT, 6);
+} else {
+    mod_lift(KC_EQUAL, KC_LSFT, 6);
+}
 return false;
 break;
 case KC_T_RSFT:
 if (record->event.pressed) {
-  mod_press(KC_RSFT, 7);
- } else {
-  mod_lift(KC_MINUS, KC_RSFT, 7);
- }
+    mod_press(KC_MINUS, KC_RSFT, 7);
+} else {
+    mod_lift(KC_MINUS, KC_RSFT, 7);
+}
 return false;
 break;
 
 case KC_T_LRSE:
 if (record->event.pressed) {
-  tap_timers[8] = timer_read();
-  last_mod = 8;
-  layer_on(_RISE);
- } else {
-  layer_off(_RISE);
-  if (last_mod == 8 && timer_elapsed(tap_timers[8]) < TAPPING_TERM) {
-    tap_code16(KC_DELETE);
-    last_mod = -1;
-  }
- }
+    tap_timer = timer_read();
+    last_mod = 8;
+    layer_on(_RISE);
+} else {
+    layer_off(_RISE);
+    if (last_mod == 8 && timer_elapsed(tap_timer) < TAPPING_TERM) {
+        tap_code16(KC_DELETE);
+        last_mod = 10;
+    }
+}
 return false;
 break;
 case KC_T_RRSE:
 if (record->event.pressed) {
-  tap_timers[9] = timer_read();
-  last_mod = 9;
-  layer_on(_RISE);
- } else {
-  layer_off(_RISE);
-  if (last_mod == 9 && timer_elapsed(tap_timers[9]) < TAPPING_TERM) {
-    tap_code16(KC_SLASH);
-    last_mod = -1;
-  }
- }
+    tap_timer = timer_read();
+    last_mod = 9;
+    layer_on(_RISE);
+} else {
+    layer_off(_RISE);
+    if (last_mod == 9 && timer_elapsed(tap_timer) < TAPPING_TERM) {
+        tap_code16(KC_SLASH);
+        last_mod = 10;
+    }
+}
+return false;
+break;
+
+case KC_EZSHFT:
+if (record->event.pressed) {
+    set_oneshot_mods(MOD_LSFT);
+    last_mod = 10;
+}
+return false;
+break;
+case KC_EZCTRL:
+if (record->event.pressed) {
+    set_oneshot_mods(MOD_LCTL);
+    last_mod = 10;
+}
+return false;
+break;
+case KC_EZALT:
+if (record->event.pressed) {
+    set_oneshot_mods(MOD_LALT);
+    last_mod = 10;
+}
+return false;
+break;
+case KC_EZGUI:
+if (record->event.pressed) {
+    set_oneshot_mods(MOD_LGUI);
+    last_mod = 10;
+}
 return false;
 break;
 
 case KC_EZRGHT:
 if (record->event.pressed) {
-  register_code(KC_LCTL);
-  tap_code16(S(KC_RGHT));
-  unregister_code(KC_LCTL);
-  last_mod = -1;
- }
+    register_code(KC_LCTL);
+    tap_code16(S(KC_RGHT));
+    unregister_code(KC_LCTL);
+    last_mod = 10;
+}
 return false;
 break;
 case KC_EZLEFT:
 if (record->event.pressed) {
-  register_code(KC_LCTL);
-  tap_code16(S(KC_LEFT));
-  unregister_code(KC_LCTL);
-  last_mod = -1;
- }
+    register_code(KC_LCTL);
+    tap_code16(S(KC_LEFT));
+    unregister_code(KC_LCTL);
+    last_mod = 10;
+}
 return false;
 break;
 case KC_EZDOWN:
 if (record->event.pressed) {
-  register_code(KC_LCTL);
-  tap_code16(S(KC_DOWN));
-  unregister_code(KC_LCTL);
-  last_mod = -1;
- }
+    register_code(KC_LCTL);
+    tap_code16(S(KC_DOWN));
+    unregister_code(KC_LCTL);
+    last_mod = 10;
+}
 return false;
 break;
 case KC_EZUP:
 if (record->event.pressed) {
-  register_code(KC_LCTL);
-  tap_code16(S(KC_UP));
-  unregister_code(KC_LCTL);
-  last_mod = -1;
- }
+    register_code(KC_LCTL);
+    tap_code16(S(KC_UP));
+    unregister_code(KC_LCTL);
+    last_mod = 10;
+}
 return false;
 break;
+
 case KC_EZUNDO:
 if (record->event.pressed) {
-  tap_code16(C(KC_Z));
-  last_mod = -1;
+    tap_code16(C(KC_Z));
+    last_mod = 10;
 }
 return false;
 break;
 case KC_EZCOPY:
 if (record->event.pressed) {
-  tap_code16(C(KC_C));
-  last_mod = -1;
+    tap_code16(C(KC_C));
+    last_mod = 10;
 }
 return false;
 break;
 case KC_EZCUT:
 if (record->event.pressed) {
-  tap_code16(C(KC_X));
-  last_mod = -1;
+    tap_code16(C(KC_X));
+    last_mod = 10;
 }
 return false;
 break;
 case KC_EZPSTE:
 if (record->event.pressed) {
-  tap_code16(C(KC_P));
-  last_mod = -1;
+    tap_code16(C(KC_V));
+    last_mod = 10;
 }
 return false;
 break;
 
-  }
-  last_mod = -1;
-  return true;
+case KC_COM:
+if (record->event.pressed) {
+    layer_on(_COMMAND);
+    set_oneshot_layer(_COMMAND, ONESHOT_START);
+    last_mod = 10;
+} else {
+    clear_oneshot_layer_state (ONESHOT_PRESSED);
+}
+return false;
+break;
+
+case KC_USER:
+if (record->event.pressed) {
+    send_string("mhostley");
+    last_mod = 10;
+}
+return true;
+break;
+case KC_EMAIL:
+if (record->event.pressed) {
+    send_string("mhostley@gmail.com");
+    last_mod = 10;
+}
+return true;
+break;
+case KC_NAME:
+if (record->event.pressed) {
+    send_string("Samuel Jahnke");
+    last_mod = 10;
+}
+return true;
+break;
+case KC_DIR:
+if (record->event.pressed) {
+    send_string("home/mhostley/");
+    last_mod = 10;
+}
+return true;
+break;
+
+}
+last_mod = 10;
+return true;
 }