path: root/keyboards/thevankeyboards/minivan/keymaps/josjoha/keymap.c

/*
 * License (GPL):
  
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

 * Authors: This QMK keymap file is a combination of the default
 * keymap, led code original copied/edited from ../jetpacktuxedo, some
 * copy/paste from QMK documentation code examples (etc).
 * Remainder: © 2019, 2020, 2021 by Jos Boersema
 */

// --------------------------------------v---------------------------------------
//                                 Configuration:
// --------------------------------------v---------------------------------------
#include "./user_config.h" // Edit this file to set user preference compile options.
// --------------------------------------^---------------------------------------



    /* Configurable keymap for Minivan layouts 44, 45, 46 keys.  
     * May work for 12×12×12×[11-12] keys as well.
     * Configuration in ./user_config.h
     */

  /* Overview of the code
   *
   * The base layers are in separate files;
   * process_record_user(), unicode macros are defined in unicode_macros.c;
   * accented characters are defined in unicode_weurope.h
   *
   * Unicode macros facilitate recomputing for re-computing the Dvorak with changed letters 
   * ('descramble'), and exist because space ran out for * XP(…).
   *
   * The led color code might be a bit hairy, due to speed/count middle led overlapping layer color. 
   *
   *  Preprocessor indentation: # always in column one, #includes and #defines
   *  are most to the left unless nested, except in the user configuration
   *  block where room is left for a ‛//’. Logical stuff (#if etc) is
   *  indented from column two, and then in each nesting goes 4 more spaces
   *  to the right, so in between the normal code indentations. There should
   *  be a newline above and below logical statements. This makes preprocessor
   *  statements stand out, while giving more information in each statement.
   *  C indentation: trying to follow QMK standard.
   *
   */


#include QMK_KEYBOARD_H

// Bit masks for the Base layers, to set them as Default, in order to make transparency look back to the right one.
#define _DEF_BASE_MASK 0x1 // Some functions take a bit-mask, where layer 0 (zero) is called 0x1 instead.
#define _ALT_BASE_MASK 0x2 // Some functions take a bit-mask, where layer 0 (zero) is called 0x1 instead.

// Below #defines the internal order of the layers.
// Notice this order in layer_state_set_user as well, regarding the led indicators.
enum {
    _DEF_BASE,  //  Default BASE layer (layer at startup). Typically the letters.

# ifndef MINIFAN_SINGLE_LAYOUT

    _ALT_BASE,  //  Alternative BASE layer.

# endif

    _DEF_NSY,   //  numbers and symbols

# ifndef MINIFAN_SINGLE_LAYOUT

    _ALT_NSY,   //  Alternate version of _DEF_NSY

# endif

    _MOV,  //  movement arrows and mouse
    _RAR,  //  keys RARely used, Unicode config, Power keys, Media keys, alternate mode switch, speed/size count, …

# ifndef REMOVE_PAD

    _PAD,  //  Numbers pad. These are different versions of the same numbers, that is ‛1’ (_NSY) ≠ ‛1’ (_PAD).

# endif

# ifndef REMOVE_ACC // Removes this layer entirely, if set.

    _ACC,  //  Accented letters 

# endif

# ifndef REMOVE_DRA // Removes this layer entirely, if set.

    _DRA,  //  Unusual symbols and whatever else

# endif

# ifndef REMOVE_BON // Removes this layer entirely, if set.

    _BON,  //  Bonus layer with more Unicode symbols

# endif

    _FUN,  //  function keys, layer switcher, given highest order precedence just in case
} ;
// The default and alternate base layers needs to have a low order
// number, so that the other layers can be accessed on top of it.
// Default Layer is set, according to active Base pair.

// What BASE layer is active.
enum {
    _NORMAL_, // BASE layer is _DEF_BASE
    _FULL_,   // BASE layer is _ALT_BASE
# ifdef DVORAK_DESCRAMBLE_HALF // not used with other keymaps
    _HALF_,   // BASE layer is _ALT_BASE For DVORAK_DESCRAMBLE_HALF keymap: does *not* re-compute letters in Unicode
              // This is for different Unicode encodings than “Control+U+HEX” (Linux). It will go through what is set on _RAR
# endif
};
// The mechanism is about what layer to return to, once needing to go back to the letters layer (BASE).

# ifndef STARTUP_ALTERNATE // Startup with in default BASE, normal mode.
short alternate = _NORMAL_;
# else                    // Startup with alternate BASE active
short alternate = _FULL_; // 
# endif

//* Shift detection
bool shift_ison = 0; // keep track of the state of shift (Capslock is ignored). There may be more elegant code for this in
                     //   QMK (a function seems to do it?), but this is simple and keeps the issue isolated to this file.
# define TRUE 1
# define FALSE 0
bool _fun_stay = FALSE; // for making _FUN layer not return to BASE after pressing an F-key
bool leds_on; // toggle leds on/off

# ifdef LEDS_OFF_BASE_DEF  
bool led_middle_on = TRUE; // Set to off later, if startup setting is off.
# endif

bool isolate_trigger = FALSE; // detects if _FUN layer move was pressed, and no other key (no normal use of Shift).
bool capslock; // keeps track of capslock state
bool numlock; // keeps track of numlock state
layer_state_t state_recall; // We are calling the function set_led_colors_ from this file as well.
// speed measuring
bool     speed_measure = SPEED_INIT_VALUE; // feature activated or not on startup
uint32_t speed_counttime; // counts the time
short    speed_countdown = SPEED_COUNTDOWN; // countdown to next computation/effects
int      speed; // we store typing result (keys/second) to make reporting less stressful on user, as it doesn't run away after typing
                // the value is recorded 10 times higher, to allow another digit of precision, needed to calculate Words-Per-Minute
long int speed_batches = 0; // This counts how many batches of SPEED_COUNTDOWN have been added to wordcount_speed_add
long int speed_add = 0; // This just adds the speed computed for every batch of SPEED_COUNTDOWN, also times 10 for precision
// character and word counting, attempting to count the final text being written
bool     sizecount_measure = COUNT_INIT_VALUE; // feature activated or not on startup
long int sizecount_blanks = 0; // This counts spaces/enters as a means of counting words, with manual substraction key
long int sizecount_chars = 0; // This counts characters, substraction for delete/backspace
bool     sizecount_word; // remember if the last character was whitespace, so a second does not count a word
bool     sizecount_menu = FALSE; // menu mode for configuring sizecount led color & alert system for maximum size.
long int sizecount_max = 0; // the maximum system for count, alert user about relative size/limit
bool     sizecount_max_type; // is size counting by word or by character
#define SIZECOUNT_WORD 0 // The type of text size counting: words
#define SIZECOUNT_CHAR 1 //           "                   : characters

/* This file contains mostly the Unicode and special macros.
   It contains the function: process_record_user(...)
   It has been isolated because the source file got long.
 */
#include "./unicode_macros.c"


// Pre-existing function, run when the keyboard starts up.
void keyboard_post_init_user (void) {

# ifdef RGBLIGHT_ENABLE

// Set side leds on/off startup
#     ifdef STARTUP_SIDE_LEDS_OFF
    leds_on = FALSE;
#     else
    leds_on = TRUE;
#     endif

    // Set up RGB effects on _only_ the first LED 
    rgblight_set_effect_range (1, 1); // Takes a range: 1st arg is start, 2nd how many
    rgblight_sethsv_noeeprom (HSV_WHITE); // Startup color of keyboard.
    // Set LED effects to breathing mode
    rgblight_mode_noeeprom (RGBLIGHT_EFFECT_BREATHING + 2);

    // Init the first and last LEDs to a static color.
    setrgb (0, 0, 0, (LED_TYPE *)&led[0]); // Led[0] is led 0
    setrgb (0, 0, 0, (LED_TYPE *)&led[2]); // 2nd led

// The logic seems to be to establish the effect first, and then toggle it on/off.
#     ifdef STARTUP_MID_LED_OFF
    rgblight_disable (); // 
#         ifdef LEDS_OFF_BASE_DEF  // This messes with led effect on/off, so we need to track the state of this setting now.
    led_middle_on = FALSE;
#         endif
#     endif

    isolate_rgblight_set ();

# endif //RGBLIGHT_ENABLE

// Set startup layer
# ifdef STARTUP_ALTERNATE 
    layer_move (_ALT_BASE);
# else
    layer_move (_DEF_BASE);
# endif

    _fun_stay = TRUE; // startup with F-keys not returning to Base after stroke (_FUN)

}


// Writes a number as if typed on keyboard. Typically to show a speed/text size measurement.
// If last argument is TRUE it prints a dot ‛.’ before the last digit
int write_number (long int input, short divide10) { 
    long int step10;
    short digit;
    short start = FALSE;
    short printed = 0;
    char output[2];

    output[1] = '\0';
    if (0 > input) { // number is negative
        send_string ("-"); // minus
        printed++;
        input *= -1; // turn positive
    }
    for (step10 = 1000000000; 0 != step10; step10 /= 10) { // assuming 32 bit, ± 10⁹
        digit = input / step10; 
        input = input % step10;
        if (!start) { // remove leading zeros
            if ((0 != digit) || (1 == step10)) start = TRUE; // If all zeros, always print last zero.
        }
        if (divide10 && (1 == step10)) { // print with a dot before the last digit
            send_string (".");
            printed++;
        }
        if (start) { // print
            output[0] = '0' + digit;
            send_string (output);
            printed++;
        }
    }
    return printed;
}


// This function prevents the middle led from being altered by layer
// switching (showing the layer color, that is), when another 
// functionality takes precedent over the middle led.
void middle_led_control (short hsv_h, short hsv_s, short hsv_v ) {
# ifdef RGBLIGHT_ENABLE

    if (FALSE == speed_measure) { // only touch middle led if no speed measuring going on
       if ( ! ((TRUE == sizecount_measure) && (0 != sizecount_max)) ) { // only touch middle led if no text size
              // counting set to a maximum is going on.

            rgblight_sethsv_noeeprom (hsv_h, hsv_s, hsv_v); // set it
        }
    }

# endif
}


// Set middle led color for speed system. Needed in various places.
void speed_led (int speed) {
# ifdef RGBLIGHT_ENABLE

    speed /= 10; // argument is in 10 times its value
    if ( ! ((TRUE == sizecount_measure) && (0 != sizecount_max)) ) { // only touch middle led if no text size
           // counting set to a maximum is going on.
        rgblight_sethsv_noeeprom (SPEED_HUE_STEP * speed + SPEED_HUE_START, 255, 128); // full saturation, but half lit
        rgblight_set (); // only center led is altered, no need to go through isolate_rgblight_set()
    }

# endif
}


// do this in one place to handle left/right leds being off here
void isolate_rgblight_set () {
# ifdef RGBLIGHT_ENABLE

    if (!leds_on) { // left/right leds are off
        // overwrite previously colors
        uint8_t led0r = 0; uint8_t led0g = 0; uint8_t led0b = 0;
        uint8_t led2r = 0; uint8_t led2g = 0; uint8_t led2b = 0;
        led0r = 0; 
        led0g = 0; 
        led0b = 0; 
        led2r = 0; 
        led2g = 0; 
        led2b = 0; 
        setrgb(led0r, led0g, led0b, (LED_TYPE *)&led[0]); // Led 0
        setrgb(led2r, led2g, led2b, (LED_TYPE *)&led[2]); // Led 2
    }
    rgblight_set ();

# endif
}


// _FUN layer leds.
void indicate_fun_stay (void) {
# ifdef RGBLIGHT_ENABLE

    uint8_t led0r = 0; uint8_t led0g = 0; uint8_t led0b = 0;
    uint8_t led2r = 0; uint8_t led2g = 0; uint8_t led2b = 0;
    // See also below under _FUN layer led
    if (_fun_stay == TRUE) { // normal mode, 0 (100% normal)
        led0r = 255; // red
        led2r = 255; // Yellow
        led2g = 50;
    }else{
        led0r = 255; // Yellow
        led0g = 50;  //   
        led2r = 255; // red
    }
    setrgb(led0r, led0g, led0b, (LED_TYPE *)&led[0]); // Led 0
    setrgb(led2r, led2g, led2b, (LED_TYPE *)&led[2]); // Led 2
    isolate_rgblight_set ();

# endif //RGBLIGHT_ENABLE
}


// _RAR layer leds
// It is a function because this is called when the Base layer OTHER_BASE key is pressed
void indicate_base (void) {
# ifdef RGBLIGHT_ENABLE

    uint8_t led0r = 0; uint8_t led0g = 0; uint8_t led0b = 0;
    uint8_t led2r = 0; uint8_t led2g = 0; uint8_t led2b = 0;
    // See also below under _FUN layer led
    if (_NORMAL_ == alternate) { // normal mode, 0 (100% normal)
        led0r = 255; //  shine white left led
        led0g = 255;
        led0b = 255;
        rgblight_sethsv_noeeprom (HSV_PURPLE);  // This overrides the speed setting.
        led2r = 100; // purple
        led2b = 100;
    }
#     ifdef DVORAK_DESCRAMBLE_HALF // not used with other keymaps
      else if (_HALF_ == alternate) { // alternate mode, 1 (normal unicode)
        led0r = 100; // purple
        led0b = 100;
        rgblight_sethsv_noeeprom (HSV_WHITE); //  shine white middle led (still breathes)
        led2r = 100; // purple
        led2b = 100;
    }
#     endif
      else if (_FULL_ == alternate) { // alternate mode, 1 (recomputed unicode for DVORAK_DESCRAMBLE)
        led0r = 100; // purple
        led0b = 100;
        rgblight_sethsv_noeeprom (HSV_PURPLE); 
        led2r = 255;//  shine white right led
        led2g = 255; 
        led2b = 255; 
    }
    setrgb(led0r, led0g, led0b, (LED_TYPE *)&led[0]); // Led 0
    setrgb(led2r, led2g, led2b, (LED_TYPE *)&led[2]); // Led 2
    isolate_rgblight_set ();

# endif //RGBLIGHT_ENABLE
}


// Sets led colors for all layers. Including Capslock/Numlock changes. See a computer side activated function for that too:
//                                                                                    led_update_user (…)
void set_led_colors_ (layer_state_t state) {
# ifdef RGBLIGHT_ENABLE

    uint8_t led0r = 0; uint8_t led0g = 0; uint8_t led0b = 0;
    uint8_t led2r = 0; uint8_t led2g = 0; uint8_t led2b = 0;
    short color_ddl = 28 ;

#     ifdef LEDS_OFF_BASE_DEF 
    // Special case of switching centre led effect on/off
    if (!layer_state_cmp (state, _DEF_BASE)) { // letters
        //if (rgblight_is_enabled())
        if (led_middle_on) { // Follows user setting based on _RAR key.
            rgblight_enable_noeeprom (); // Would be easier if middle_led_control (…) could set brightness to dark, but seems to not work.
        }
    }
#     endif

    // The order should be the reverse of the #defines of layer number of the layers on top
    // because higher layer number is higher priority if activated
    /* _DEF_BASE 0 _ALT_BASE 1 _DEF_NSY 2 _ALT_NSY 3 _MOV 4 _RAR 5 _PAD 6 _ACC 7 _DRA 8 _BON 9 _FUN 10 */
    if (layer_state_cmp (state, _FUN)) { // F-keys, and layer toggles
        middle_led_control (HSV_RED); // purple
        indicate_fun_stay (); // Indicates state of _fun_stay, but only when it is being toggled.
        return ; // indicate_fun_stay function already does it all.
    } 

#     ifndef REMOVE_BON // Removes this layer entirely, if set.
    else if (layer_state_cmp (state, _BON)) {  // Bonus layer with encircled numbers and more symbols
        // side leds dark
        middle_led_control (HSV_YELLOW); 
    }
#     endif // REMOVE_BON 

#     ifndef REMOVE_DRA // This cuts out the whole _DRA layer
    else if (layer_state_cmp (state, _DRA)) { // Unicode drawings and unusual things
        led0r = 255; // gold red
        led0g = 128; // 
        led2r = 255; //
        led2g = 128; //
        middle_led_control( HSV_GOLDENROD ); 
    }
#     endif // REMOVE_DRA

#     ifndef REMOVE_ACC // This cuts out the whole _ACC layer.
    else if (layer_state_cmp (state, _ACC)) { // Accented letters (Unicode input layer)
        led0g = 150; // With some blue, because it is also a symbol 
        led0b = 100;
        led2g = 150;
        led2b = 100;
        middle_led_control (HSV_TURQUOISE); // cyan
    }
#    endif // REMOVE_ACC

#    ifndef REMOVE_PAD
    else if (layer_state_cmp (state, _PAD)) { // numbers pad layer
        if (numlock) {
            led0b = 255; // Blue for the numbers part 
            led2g = 255; // Green for the navigation part
        }else{
            led0g = 255; // reversed 
            led2b = 255; //
        }
        middle_led_control (60, 20, 100); // yellow (low saturation)
    }
#     endif // REMOVE_PAD

    //---
    else if (layer_state_cmp (state, _RAR)) { // layer with special keys
        indicate_base (); // this function already does it all
        return; // 
    }
    //---
    else if (layer_state_cmp (state, _MOV)) { // movement layer
        led0g = 255;// movement is green, "go forward"
        led2g = 255; 
        middle_led_control(HSV_GREEN);
    }
    //--- (pair)
    else if (layer_state_cmp (state, _ALT_NSY)) { // alternate, numbers/symbols 
        led0b = 255; //  first led follows the corresponding default layer: _DEF_NSY 
        led2r = color_ddl; // Same as DDL, to which it belongs.
        led2g = color_ddl; // 
        led2b = color_ddl; // 
        middle_led_control (HSV_BLUE); 
    }
    else if (layer_state_cmp (state, _DEF_NSY)) { // symbols and numbers
        led0b = 255; // blue for symbols, like ink (writing)
        led2b = 255;
        middle_led_control (HSV_BLUE);
    }
    //--- (pair)
    // Alternate BASE layer (alternate)
    else if (layer_state_cmp (state, _ALT_BASE)) {

#     if !defined(BASE_NUMPAD__ALT_BASE) // Normal led colors for ‛regular’ base layers like Dvorak, Qwerty. 

        if (capslock) {
           led2r = 255; // Brighter version to indicate capslock
           led2g = 255; // 
           led2b = 255; // 
        } else {
           led2r = color_ddl; // A bit of a white not too bright color on right
           led2g = color_ddl; // 
           led2b = color_ddl; // 
        }

#     else // BASE_NUMPAD__ALT_BASE: numpad on Alternate Base, which should show the state of NumLock

        // This is a copy of the _PAD led colors, but less bright
        if (numlock) {
            led0b = 80; // Blue for the numbers part 
            led2g = 80; // Green for the navigation part
        }else{
            led0g = 80; // reversed 
            led2b = 80; //
        }
        middle_led_control (60, 20, 100); // yellow (low saturation)

#     endif

        middle_led_control (HSV_TEAL); // seems to be the same as CYAN/AZURE, conflicts with _ACC
    }
    // Default layer (generally), normal BASE layer
    else if (layer_state_cmp (state, _DEF_BASE)) { // letters

#     ifdef LEDS_OFF_BASE_DEF 
        led0r = 0; // All leds off when in Default Base
        led0g = 0; // 
        led0b = 0; // 
        rgblight_disable_noeeprom ();
#     else
        if (capslock) {
            led0r = 255; // Brighter version to indicate capslock
            led0g = 255; // 
            led0b = 255; // 
        } else {
            led0r = 28; // A bit of a weak white color on left 
            led0g = 28; // 
            led0b = 28; // 
        }

        middle_led_control (HSV_TEAL);
#     endif // LEDS_OFF_BASE_DEF 
    }
    //---

    setrgb (led0r, led0g, led0b, (LED_TYPE *)&led[0]); // Led 0
    setrgb (led2r, led2g, led2b, (LED_TYPE *)&led[2]); // Led 2

    isolate_rgblight_set ();

# endif //RGBLIGHT_ENABLE
}

// Pre-existing QMK function, called when NumLock/CapsLock key is pressed, including on another keyboard.
// This function sets two booleans that keep track of the current capslock/numlock state, for use in layer led colors.
bool led_update_user (led_t led_state) {

    if (led_state.num_lock) { // This doesn't look at the keyboard leds or any other actual leds. It seems to look at whether
                              // or not the computer has numlock in the on/off state.
        numlock = TRUE;
    }else{
        numlock = FALSE;
    }
    if (led_state.caps_lock) {
        capslock = TRUE;
    }else{
        capslock = FALSE;
    }
    //layer_state_set_user 
    set_led_colors_ (state_recall); // Update leds
    return true ;
}


// pre-existing function, called when layer changes
layer_state_t layer_state_set_user (layer_state_t state) {

  set_led_colors_ (state); // Update leds 
  state_recall = state; // Recall this, for calling set_led_colors_(…) on Num/Capslock changes in led_update_user(…)
  return state;
}

// -------------------------------- layers --------------------------------

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {


/********************        What base layers to use:        **************/

//                         * Dvorak *
# if defined(BASE_DVORAK__DEF_BASE) || defined(BASE_DVORAK__ALT_BASE)
#     include "./base_dvorak.c" // Regular Dvorak.
# endif

//                         * Dvorak descramble *
# if defined(BASE_DVORAK_DESCRAMBLE__ALT_BASE) // only for ‛Alternate’ base
#     include "./base_dvorak_descramble.c" // Dvorak for when computer is already remapping to Dvorak.
# endif

//                         * Qwerty *
# if defined(BASE_QWERTY__DEF_BASE) || defined(BASE_QWERTY__ALT_BASE)
#     include "./base_qwerty.c" // Regular Qwerty.
# endif
    
//                         * Qwerty arrows on Base *
# if defined(BASE_QWERTY_BASEARROW__DEF_BASE) || defined(BASE_QWERTY_BASEARROW__ALT_BASE)
#     include "./base_qwerty_basearrow.c" // Qwerty + arrows
# endif

//                         * Colemak *
# if defined(BASE_COLEMAK__DEF_BASE) || defined(BASE_COLEMAK__ALT_BASE)
#     include "./base_colemak.c" // Regular Colemak.
# endif

//                         * Workman *
# if defined(BASE_WORKMAN__DEF_BASE) || defined(BASE_WORKMAN__ALT_BASE)
#     include "./base_workman.c" // Regular Workman.
# endif

//                         * Numpad *
# if defined(BASE_NUMPAD__ALT_BASE)
#     include "./base_numpad.c" // Numbers pad
# endif

// // ⬇ insert your ./base_YOUR_KEYMAP.c #include here:


//                         * YOUR KEYMAP *
// # if defined(BASE_YOUR_KEYMAP__DEF_BASE) || defined(BASE_YOUR_KEYMAP__ALT_BASE)
// #     include "./base_YOUR_KEYMAP.c" // Your Keymap.
// # endif

// If your keymap also has a ./base_YOUR_KEYMAP.h configuration/header file, #include it in ./user_config.h
// Look for similar inclusions of base header files, similar to the #includes here.
// You should be able to just copy what you did here, and only change “.c” into “.h”.

// // ⬆


        // See the ./bases_*.c file for definition of _DEF_BASE, _DEF_NSY, _ALT_BASE, _ALT_NSY layers, selected in ./user_config.h

        /* ⬆⬇ (next layer) */


# ifndef BASESFILE_LAYER_MOV // Use a definition of this layer in the ./bases_* file, where this #define can be defined.

    /* Layer _MOV: Movement layer: mouse and hands on navigation
     *          Also delete/backspace, to navigate and delete together.
     */

    [ _MOV ] = LAYOUT_redefined (

/*
     Layer _MOV (MOVement, mouse movement on right hand)

     triangle layout (mouse right hand):
    
     <pinky2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                                         <|>-*-                                        //(toggle) on _FUN
     BASE   PgDn  Up    PgUp  Home  Btn3  | xxx   WhDn  MsUp  WhU   WhLft    Bksp
     LCtl   Left  Down  Right End   Btn1  | Btn1  MsLft MsDn  MsRht WhRht    RCtl
     LSht*- xxx   Acc2  Acc1  Acc0  Btn2  | Btn2  Btn3  Btn4  Btn5  xxx      RSht      //(toggle) on BASE
     ----------------------------------------------------------------------------
     LAlt Del   Ent   ___ | PgUp  PgDn  LGUI  RAlt
                      -*-<|>                                                             //(hold) on BASE
     <1 ± <2    <3    <4  | 4>    3>    2>  ± 1>  
        …                                   …

     triangle layout, 'arrow' additional hardware key, with arrow cluster (difference marked _):
    
     <pinky2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                                         <|>-*-                                        //(toggle) on _FUN
     BASE   PgDn  Up    PgUp  Home  Btn3  | xxx   WhDn  MsUp  WhU   WhLft    Bksp
     LCtl   Left  Down  Right End   Btn1  | Btn1  MsLft MsDn  MsRht WhRht    RCtl
     LSht*- xxx   Acc2  Acc1  Acc0  Btn2  | Btn2  Btn3  Btn4  Btn5  _Up_     RSht      //(toggle) on BASE
     ----------------------------------------------------------------------------
                     LAlt Del   Ent   ___ | PgUp       PgDn   _Left__Down__Right_
                                      -*-<|>                                             //(hold) on BASE
                     <1 ± <2    <3    <4  | 4>         3>      2>   _±_    1>  
                        …     

     triangle layout, 'arrow' additional hardware key, with arrow cluster and navigation keys:
    
     <pinky2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                                         <|>-*-                                        //(toggle) on _FUN
     BASE   PgDn  Up    PgUp  Home _Btn4_ | xxx   WhDn  MsUp  WhU   WhLft    Bksp
     LCtl   Left  Down  Right End   Btn1  | Btn1  MsLft MsDn  MsRht WhRht    RCtl
     LSht*- xxx   Acc2  Acc1  Acc0 _Btn5_ | Btn2  Btn3 _Home__PgUp_ _Up_   _PgDn_      //(toggle) on BASE
     ----------------------------------------------------------------------------
                     LAlt Del   Ent   ___ | PgUp      _End_   _Left__Down__Right_
                                      -*-<|>                                             //(hold) on BASE
                     <1 ± <2    <3    <4  | 4>         3>      2>   _±_    1>  
                        …


     flat layout (mouse movement on left hand):
    
     <pinky2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                                         <|>-*-                                        //(toggle) on _FUN
     BASE   WLft  WDn   WUp   WRht  xxx   | Btn3  PgUp  Home  End   PgDn     Bksp
     LCtl   MLft  MDn   MUp   MRht  Btn1  | Btn1  Left  Up    Down  Right    RCtl
     LSht*- Btn5  Btn4  Btn3  Butn2 xxx   | Btn2  Acc0  Acc1  Acc2  xxx      RSht      //(toggle) on BASE
     ----------------------------------------------------------------------------
     LAlt Del   Ent   ___ | PgUp  PgDn  LGUI  RAlt
                      -*-<|>                                                             //(hold) on BASE
     <1 ± <2    <3    <4  | 4>    3>    2>  ± 1>  
        …

     flat layout, 'arrow' additional hardware key, with arrow cluster (difference marked _)
   
     <pinky2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                                         <|>-*-                                        //(toggle) on _FUN
     BASE   WLft  WDn   WUp   WRht  xxx   | Btn3  PgUp  Home  End   PgDn     Bksp
     LCtl   MLft  MDn   MUp   MRht  Btn1  | Btn1  Left  Up    Down  Right    RCtl
     LSht*- Btn5  Btn4  Btn3  Butn2 xxx   | Btn2  Acc0  Acc1  Acc2  xxx      RSht      //(toggle) on BASE
     ----------------------------------------------------------------------------
                     LAlt Del   Ent   ___ | PgUp       _Left_ _Up_  _Down__Right_
                                      -*-<|>                                           //(hold) on BASE
                     <1 ± <2    <3    <4  | 4>          3>     2>   _±_    1>  
                        …

     flat layout, 'arrow' additional hardware key, with arrow cluster and additional navigation keys:
   
     <pinky2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                                         <|>-*-                                        //(toggle) on _FUN
     BASE   WLft  WDn   WUp   WRht  xxx   |_Acc2_ PgUp  Home  End   PgDn     Bksp
     LCtl   MLft  MDn   MUp   MRht  Btn1  | Btn1  Left  Up    Down  Right    RCtl
     LSht*- Btn5  Btn4  Btn3  Butn2 xxx   |_Acc1_ Acc0 _PgUp__Home__End_   _PgDn_      //(toggle) on BASE
     ----------------------------------------------------------------------------
                     LAlt Del   Ent   ___ | PgUp       _Left_ _Up_  _Down__Right_
                                      -*-<|>                                             //(hold) on BASE
                     <1 ± <2    <3    <4  | 4>          3>     2>   _±_    1>  
                        …

     flat layout, 'arrow' additional hardware key, with arrow cluster, additional navigation keys, vi(1) layout:
   
     <pinky2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                                         <|>-*-                                        //(toggle) on _FUN
     BASE   WLft  WDn   WUp   WRht  xxx   |_Acc2_ PgUp  Home  End   PgDn     Bksp
     LCtl   MLft  MDn   MUp   MRht  Btn1  | Left  Down  Up    Right Btn1     RCtl
     LSht*- Btn5  Btn4  Btn3  Butn2 xxx   |_Acc1_ Acc0 _PgUp__Home__End_   _PgDn_      //(toggle) on BASE
     ----------------------------------------------------------------------------
                     LAlt Del   Ent   ___ | PgUp       _Left_ _Down__Up_  _Right_
                                      -*-<|>                                             //(hold) on BASE
                     <1 ± <2    <3    <4  | 4>          3>     2>   _±_    1>  
                        …
 */

         /* Inner default navigation/mouse layout. 11 means row 1, column 1, etc.
          * Configured for arrows on the right, mouse on the left (BTN* on the left side, that is).
          */

#     ifndef ARROWS_TRIANGLE
#         define NAVI_11 KC_BTN3 // NAVI for 'navigation cluster', 11 for row 1, column 1, etc.
#         define                 NAVI_12 KC_PGUP
#         define                                 NAVI_13 KC_HOME
#         define                                                 NAVI_14 KC_END
#         define                                                                NAVI_15 KC_PGDN
#         define NAVI_21 KC_BTN1
#         define                 NAVI_22 KC_LEFT
#         define                                 NAVI_23 KC_UP
#         define                                                 NAVI_24 KC_DOWN
#         define                                                                NAVI_25 KC_RIGHT
#         define NAVI_31 KC_BTN2
#         define                 NAVI_32 KC_ACL0
#         define                                 NAVI_33 KC_ACL1
#         define                                                 NAVI_34 KC_ACL2
#         define                                                                NAVI_35 XXXXXXX
          //-----------------------------------------------------------------------------------
          // Configured for left handed mouse, with xxx,BTN* on the right most column.
#         define MOUS_11 KC_WH_L  // MOUS for mouse, etc.
#         define                 MOUS_12 KC_WH_D
#         define                                 MOUS_13 KC_WH_U
#         define                                                 MOUS_14 KC_WH_R
#         define                                                                MOUS_15 XXXXXXX
#         define MOUS_21 KC_MS_L
#         define                 MOUS_22 KC_MS_D
#         define                                 MOUS_23 KC_MS_U
#         define                                                 MOUS_24 KC_MS_R
#         define                                                                MOUS_25 KC_BTN1
#         define MOUS_31 KC_BTN5
#         define                 MOUS_32 KC_BTN4
#         define                                 MOUS_33 KC_BTN3
#         define                                                 MOUS_34 KC_BTN2
#         define                                                                MOUS_35 XXXXXXX
#     endif

// Alternative navigation/mouse layout: arrows in triangle, and left hand on the left 'wasd' location.
// If you want these arrows on the right hand, you may want to edit this, to put right most column left, etc.

#     ifdef ARROWS_TRIANGLE
#         define NAVI_11 KC_PGDN
#         define                 NAVI_12 KC_UP   
#         define                                 NAVI_13 KC_PGUP
#         define                                                 NAVI_14 KC_HOME
#         define                                                                 NAVI_15 KC_BTN3
#         define NAVI_21 KC_LEFT
#         define                 NAVI_22 KC_DOWN
#         define                                 NAVI_23 KC_RIGHT
#         define                                                  NAVI_24 KC_END
#         define                                                                 NAVI_25 KC_BTN1
#         define NAVI_31 XXXXXXX
#         define                 NAVI_32 KC_ACL2
#         define                                 NAVI_33 KC_ACL1
#         define                                                  NAVI_34 KC_ACL0
#         define                                                                 NAVI_35 KC_BTN2
          //------------------------------------------------------------------------------------
          // If switching hands to put mouse left, same as for navigation side: switch outer columns by editing here.
#         define MOUS_11 XXXXXXX
#         define                 MOUS_12 KC_WH_D
#         define                                 MOUS_13 KC_MS_U
#         define                                                 MOUS_14 KC_WH_U
#         define                                                                MOUS_15 KC_WH_L
#         define MOUS_21 KC_BTN1
#         define                 MOUS_22 KC_MS_L
#         define                                 MOUS_23 KC_MS_D
#         define                                                 MOUS_24 KC_MS_R
#         define                                                                MOUS_25 KC_WH_R
#         define MOUS_31 KC_BTN2
#         define                 MOUS_32 KC_BTN3
#         define                                 MOUS_33 KC_BTN4
#         define                                                 MOUS_34 KC_BTN5
#         define                                                                MOUS_35 XXXXXXX
#     endif

// Default left/right layout, meaning arrows right and mouse left.
#     ifndef ARROWS_LEFT
#         define LEFT_AA MOUS_11
#         define LEFT_AB MOUS_12
#         define LEFT_AC MOUS_13
#         define LEFT_AD MOUS_14
#         define LEFT_AE MOUS_15
#         define LEFT_BA MOUS_21
#         define LEFT_BB MOUS_22
#         define LEFT_BC MOUS_23
#         define LEFT_BD MOUS_24
#         define LEFT_BE MOUS_25
#         define LEFT_CA MOUS_31
#         define LEFT_CB MOUS_32
#         define LEFT_CC MOUS_33
#         define LEFT_CD MOUS_34
#         define LEFT_CE MOUS_35
#         define RGHT_AA NAVI_11
#         define RGHT_AB NAVI_12
#         define RGHT_AC NAVI_13
#         define RGHT_AD NAVI_14
#         define RGHT_AE NAVI_15
#         define RGHT_BA NAVI_21
#         define RGHT_BB NAVI_22
#         define RGHT_BC NAVI_23
#         define RGHT_BD NAVI_24
#         define RGHT_BE NAVI_25
#         define RGHT_CA NAVI_31
#         define RGHT_CB NAVI_32
#         define RGHT_CC NAVI_33
#         define RGHT_CD NAVI_34
#         define RGHT_CE NAVI_35
#     endif
      
#     ifdef ARROWS_LEFT
#         define LEFT_AA NAVI_11
#         define LEFT_AB NAVI_12
#         define LEFT_AC NAVI_13
#         define LEFT_AD NAVI_14
#         define LEFT_AE NAVI_15
#         define LEFT_BA NAVI_21
#         define LEFT_BB NAVI_22
#         define LEFT_BC NAVI_23
#         define LEFT_BD NAVI_24
#         define LEFT_BE NAVI_25
#         define LEFT_CA NAVI_31
#         define LEFT_CB NAVI_32
#         define LEFT_CC NAVI_33
#         define LEFT_CD NAVI_34
#         define LEFT_CE NAVI_35
#         define RGHT_AA MOUS_11
#         define RGHT_AB MOUS_12
#         define RGHT_AC MOUS_13
#         define RGHT_AD MOUS_14
#         define RGHT_AE MOUS_15
#         define RGHT_BA MOUS_21
#         define RGHT_BB MOUS_22
#         define RGHT_BC MOUS_23
#         define RGHT_BD MOUS_24
#         define RGHT_BE MOUS_25
#         define RGHT_CA MOUS_31
#         define RGHT_CB MOUS_32
#         define RGHT_CC MOUS_33
#         define RGHT_CD MOUS_34
#         define RGHT_CE MOUS_35
#     endif

/* Definition of the additional arrow cluster with optional navigation keys, for the 'arrow' hardware layout.
 *
 * By default what becomes the up-arrow (row 2, 2nd key from right) is a no-action key on this layer,
 * which can be displaced without worry.
 * Keys that are displaced for the larger arrow cluster with navigation keys, get moved to the second definition
 * of KC_BTN2 and KC_BTN3, which is on the non-mouse hand.
 *
 * Only the version where the triangle arrows are defined for the left hand, or the version where the flat line
 * arrows are defined for the right hand, are supported.
 *
 * There are several configurations, worked down in order to keep this mess under control.
 *                
 *                                           v----------------------not-defined-------------v----------------v
 *                                 !MOREKEY2_ARROW_CLUSTER   !MOREKEY2_ADD_NAVIGATION  !ARROWS_TRIANGLE  !ARROWS_LEFT             
 * defined MOREKEY2_ARROW_CLUSTER   ......................            yes                    yes            yes
 * defined MOREKEY2_ADD_NAVIGATION        yes                 .......................        yes          only for flat arrows
 * defined ARROWS_TRIANGLE                yes                         yes               ...............      no  
 * defined ARROWS_LEFT                    yes                    only for triangle          yes           ...........
 *                                  MOREKEY2_ARROW_CLUSTER    MOREKEY2_ADD_NAVIGATION   ARROWS_TRIANGLE   ARROWS_LEFT             
 *                                           ^--------------------------defined-------------^----------------^
 *
 * Definition order:
 *  0 no arrow cluster (and therefore no additional navigation keys either)
 *  1 triangle arrows with arrow cluster
 *  2    ''                  ''          + additional navigation and repositioning displaced keys
 *  3 flat arrows with arrow cluster
 *  4    ''                  ''          + additional navigation and repositioning displaced keys
 */

                                               /* 0 (Nothing special, just the default keys)*/

// Default layout without arrow cluster. (With a little imagination you can visualize the keyboard.)
#     if !defined(MOREKEY2_ARROW_CLUSTER) 
//                                                                             Default 
#         define _MOV_KEY_ROW2_KEY1                               KC_RSFT    
#         define _MOV_KEY_ROW2_KEY2                     RGHT_CE              // Key counting from the right to the left. 
#         define _MOV_KEY_ROW2_KEY3           RGHT_CD                        
#         define _MOV_KEY_ROW2_KEY4 RGHT_CC                                  
//                                  ------------------------------------------
#         define _MOV_KEY_ROW1_KEY1                               KC_RALT    //                         ''
#         define _MOV_KEY_ROW1_KEY2                     MORE_key2            //                         ''
#         define _MOV_KEY_ROW1_KEY3           KC__YGUI                       //                         ''                 (etc)
#         define _MOV_KEY_ROW1_KEY4 KC_PGDN                                  
//                <|,>        ,         ,         ,         ,
//                 |, 4>      , 3>      , 2>      , ±       , 1>         // ± is the additional hardware key
#     endif                                                       

                                              /* 1 (triangle arrows with arrow cluster) */

// Patch in the arrows for arrow triangle layout
#     if defined(MOREKEY2_ARROW_CLUSTER) && defined(ARROWS_TRIANGLE)
//                                                                             Arrow cluster
#         define _MOV_KEY_ROW2_KEY2                     KC_UP                
//                                 ------------------------------------------
#         define _MOV_KEY_ROW1_KEY1                               KC_RIGHT   
#         define _MOV_KEY_ROW1_KEY2                     KC_DOWN              
#         define _MOV_KEY_ROW1_KEY3           KC_LEFT                        
//                <|,>        ,         ,         ,         ,
//                 |, 4>      , 3>      , 2>      , ±       , 1> 
#     endif

// The default layout around the arrows
#     if defined(MOREKEY2_ARROW_CLUSTER) && !defined(MOREKEY2_ADD_NAVIGATION) && defined(ARROWS_TRIANGLE)      
//                                                                             Default keys
#         define _MOV_KEY_ROW2_KEY1                               KC_RSFT    
#         define _MOV_KEY_ROW2_KEY3           RGHT_CD                        
#         define _MOV_KEY_ROW2_KEY4 RGHT_CC                                  
//                                 ------------------------------------------
#         define _MOV_KEY_ROW1_KEY4 KC_PGDN                                  
//                <|,>        ,         ,         ,         ,
//                 |, 4>      , 3>      , 2>      , ±       , 1> 
#    endif                                     
                                           
                                              /*  2 (  ''                  ''          + additional navigation and repositioning displaced keys) */

// Patch in the navigation keys for the arrow in triangle layout.
#     if defined(MOREKEY2_ADD_NAVIGATION) && defined(ARROWS_TRIANGLE)        // Navigation additional keys (arrows implied).
#         define _MOV_KEY_ROW2_KEY1                               KC_PGDN    
#         define _MOV_KEY_ROW2_KEY3           KC_PGUP                        
#         define _MOV_KEY_ROW2_KEY4 KC_HOME                                  
//                                 ------------------------------------------
#         define _MOV_KEY_ROW1_KEY4 KC_END                                   
//                    <|,>        ,         ,         ,         ,
//                     |, 4>      , 3>      , 2>      , ±       , 1>         
#     endif

// We have now overwritten the positions of RGHT_CC and RGHT_CD, which could be useful keys.
// You don't want to mess with BTN1 on the other hand, because it needs to select together with mouse moving in many applications.
#     if defined(MOREKEY2_ADD_NAVIGATION) && defined(ARROWS_TRIANGLE) && defined(ARROWS_LEFT)  // ARROWS_LEFT because the wider map is edited
//
//        ... spelling this out to keep brain for exploding:
//        Overwritten (copied from above):
//         #define RGHT_CC MOUS_33
//         #define                                 MOUS_33 KC_BTN4
//         #define RGHT_CD MOUS_34
//         #define                                                 MOUS_34 KC_BTN5
//        'BTN4' and 'BTN5' are overwritten.
//        Where are KC_BTN2 and KC_BTN3 on the non-mouse hand:
//         #define                                                                 NAVI_15 KC_BTN3
//         #define LEFT_AE NAVI_15
//         #define                                                                 NAVI_35 KC_BTN2
//         #define LEFT_CE NAVI_35
//        'LEFT_AE' and 'LEFT_CE' provide room.
//
#         undef  LEFT_AE
#         define LEFT_AE KC_BTN4
#         undef  LEFT_CE
#         define LEFT_CE KC_BTN5
#     endif

                                              /* 3 (flat arrows with arrow cluster) */

#     if defined(MOREKEY2_ARROW_CLUSTER) && !defined(ARROWS_TRIANGLE)
//                                                                         arrow cluster
#         define _MOV_KEY_ROW1_KEY1                               KC_RIGHT                                 
#         define _MOV_KEY_ROW1_KEY2                     KC_DOWN                        
#         define _MOV_KEY_ROW1_KEY3           KC_UP                
#         define _MOV_KEY_ROW1_KEY4 KC_LEFT    
//                    <|,>        ,         ,         ,         ,
//                     |, 4>      , 3>      , 2>      , ±       , 1> 
#     endif

// The default layout around the arrows
#     if defined(MOREKEY2_ARROW_CLUSTER) && !defined(MOREKEY2_ADD_NAVIGATION) && !defined(ARROWS_TRIANGLE)      
//                                                                         Default 
#         define _MOV_KEY_ROW2_KEY1                               KC_RSFT    
#         define _MOV_KEY_ROW2_KEY2                     RGHT_CE              // Key counting from the right to the left. 
#         define _MOV_KEY_ROW2_KEY3           RGHT_CD                        
#         define _MOV_KEY_ROW2_KEY4 RGHT_CC                                  
//                    <|,>        ,         ,         ,         ,
//                     |, 4>      , 3>      , 2>      , ±       , 1> 
#     endif


                                              /* 4 (   ''                  ''          + additional navigation and repositioning displaced keys) */

// The definitions for the additional navigation keys (HOME, etc)
#     if defined(MOREKEY2_ADD_NAVIGATION) && !defined(ARROWS_TRIANGLE)
//                                                                         Additional navigation keys: flat
#         define _MOV_KEY_ROW2_KEY1                               KC_PGDN                                  
#         define _MOV_KEY_ROW2_KEY2                     KC_END                         
#         define _MOV_KEY_ROW2_KEY3           KC_HOME              
#         define _MOV_KEY_ROW2_KEY4 KC_PGUP    
//                    <|,>        ,         ,         ,         ,
//                     |, 4>      , 3>      , 2>      , ±       , 1>         
#     endif

// Replace the overwritten key positions:
# if defined(MOREKEY2_ADD_NAVIGATION) && !defined(ARROWS_TRIANGLE) && !defined(ARROWS_LEFT)   // !ARROWS_LEFT because the wider map is edited
//
//        Overwritten (copied from above):
//         #define RGHT_CC NAVI_33
//         #define                                 NAVI_33 KC_ACL1
//         #define RGHT_CD NAVI_34
//         #define                                                 NAVI_34 KC_ACL2
//        'KC_ACL1' and 'KC_ACL2' are overwritten.
//        Where are BTN2 and BTN3 on the non-mouse hand:
//         #define NAVI_11 KC_BTN3
//         #define RGHT_AA NAVI_11
//         #define NAVI_31 KC_BTN2
//         #define RGHT_CA NAVI_31
//        'RGHT_AA' and 'RGHT_CA' provide room.
//         It seems best to count the acceleration keys from right to left/up on the keyboard.
//
#         undef  RGHT_AA
#         define RGHT_AA KC_ACL2
#         undef  RGHT_CA
#         define RGHT_CA KC_ACL1
#     endif

// Changes the home row on the right hand to become HJKL (as in Qwerty) vi(1) arrow keys,
// and causes the arrow block to move one key to the left. The key lost on the left is
// put back on the other end (pinky).
// Row 3
#     if defined(VI_SWITCHERYDOO) && !defined(ARROWS_TRIANGLE) // For all hardware variants
//                |, indx2>  , index>  , middl>   , ring>     , pinky>    , pink2>    ,
//               <|,>        ,         ,          ,           ,           ,           ,
#         undef  RGHT_BA
#         define RGHT_BA KC_LEFT
#         undef  RGHT_BB
#         define RGHT_BB           KC_DOWN
#         undef  RGHT_BC
#         define RGHT_BC                     KC_UP
#         undef  RGHT_BD
#         define RGHT_BD                                KC_RIGHT
#         undef  RGHT_BE
#         define RGHT_BE                                            KC_BTN1
#     endif
// Row 1
#     if defined(VI_SWITCHERYDOO) && !defined(ARROWS_TRIANGLE) && defined(MOREKEY2_ARROW_CLUSTER) // Only for 'arrow' hardware
//                                                                         arrow cluster
#         undef  _MOV_KEY_ROW1_KEY1 
#         define _MOV_KEY_ROW1_KEY1                               KC_RIGHT                                 
#         undef  _MOV_KEY_ROW1_KEY2
#         define _MOV_KEY_ROW1_KEY2                     KC_UP                          
#         undef  _MOV_KEY_ROW1_KEY3
#         define _MOV_KEY_ROW1_KEY3           KC_DOWN              
#         undef  _MOV_KEY_ROW1_KEY4
#         define _MOV_KEY_ROW1_KEY4 KC_LEFT    
//                    <|,>        ,         ,         ,         ,
//                     |, 4>      , 3>      , 2>      , ±       , 1>         
#     endif

// (If you want to alter something in detail just for your keyboard, it is probably smart to just write in the keycodes (like KC_PGUP) in the final definitions here below.)
//
//      <pink2   , <pinky  , <ring   , <middl  , <index  , <indx2 |, indx2>  , index>  , middl>             , ring>              , pinky>             , pink2>             ,
//               ,         ,         , -*-     ,         ,       <|,>        ,         ,                    ,                    ,                    ,                    ,
        CTO_BASE , LEFT_AA , LEFT_AB , LEFT_AC , LEFT_AD , LEFT_AE , RGHT_AA , RGHT_AB , RGHT_AC            , RGHT_AD            , RGHT_AE            , KC_BSPC            ,
        KC_LCTL  , LEFT_BA , LEFT_BB , LEFT_BC , LEFT_BD , LEFT_BE , RGHT_BA , RGHT_BB , RGHT_BC            , RGHT_BD            , RGHT_BE            , KC_RCTL            ,
        KC_LSFT  , LEFT_CA , LEFT_CB , LEFT_CC , LEFT_CD , LEFT_CE , RGHT_CA , RGHT_CB , _MOV_KEY_ROW2_KEY4 , _MOV_KEY_ROW2_KEY3 , _MOV_KEY_ROW2_KEY2 , _MOV_KEY_ROW2_KEY1 ,
//      --------------------------------------------------------------------------------------------------------------------------------------------------------------------
        KC_LALT 
#     ifdef TRANSMINIVAN_LEFTSIDE
                , TRANS_LEFT
#     endif

#     ifdef MORE_KEY__COMMAND
                , MORE_key1 
#     endif

                , KC_DEL , KC_ENT , _______ 

#     ifdef TRANSMINIVAN_MIDLEFT
                                            , TRANS_MIDLEFT
#     endif

                                            , KC_PGUP 

#     ifdef TRANSMINIVAN_RIGHTSIDE
                                                      , TRANS_RIGHT
#     endif

                                                      , _MOV_KEY_ROW1_KEY4 , _MOV_KEY_ROW1_KEY3

#     ifdef MORE_KEY__ARROW
                                                                           , _MOV_KEY_ROW1_KEY2
#     endif
                                                                                                , _MOV_KEY_ROW1_KEY1
//            ,          ,        , -*-   <|,>        ,                    ,                    ,
//      <1 ±± , <2       , <3     , <4     |, 4>      , 3>                 , 2>                 , ±  ±  1>

                      ),

# endif // BASESFILE_LAYER_MOV

        /* ⬆⬇ */

# ifndef BASESFILE_LAYER_RAR // Use a definition of this layer in the ./bases_* file, where this #define can be defined.

    /* Layer _RAR: Various special keys.
     *          - The key which switches between Default and Alternate base layer.
     *          - Power keys
     *            The power keys have to be pressed with Shift, as a safety guard.
     *            Without shift they write their name, as if someone typed it.
     *          - Media keys
     *          - Brightness for screen keys (depends on computer system if it works)
     *          - Leds of keyboard on/off
     *          - Unicode input mode
     *            ☑  precedes the Unicode input modes, as memory aid and tester
     *               Note that ☑ has no letters in its Unicode, but press with Shift for 🗹 
     *               which does. This matters when testing ‛descramble’ Dvorak mode.
     *          - Capslock is on its normal position
     *          - Insert
     *          - APP (whatever it is) fakes being next to right GUI (though other layer).
     *          - The traditional obsolete button like ScrLk/PrtSc are also included, in
     *            case some program needs them.
     *          - Speed measuring
     *          - Text size measuring
     *          - Some unused spots remaining.
     */

    [ _RAR ] = LAYOUT_redefined (

/*
     _RAR (RARe keys. Power keys, Unicode mode, Alternate BASE, Media, Brightness, Speed, leds, …)
    
     <pink2<pinky <ring <middl <indexx<indx2| indx2>index>middl>ring> pinky> pink2>
                                           <|>      -*-                                //(toggle) on _FUN
     BASE  Cnt/Mx Cnull CWmin  CRprt  Speed | SRprt Play  Next  Prev  Stop RSht(•)   
     CapsL Power• Wake• Sleep• Pause• ScrLk | PrtSc xxx   Vol+  Vol-  Mute Insert     // • requires Shift
     ☑     uLNX   uBSD  uOSX   uWIN   uWNC  | xxx   xxx   Bri+  Bri-  xxx     APP     // Ü(nicode) tester
     ----------------------------------------------------------------------------
     SLed  MLeds RGUI  xxx  | !Alter  xxx   LGUI  ___            // Middle-led, Side-leds, ! 'alternate'
                           <|>                    -*-                                   // (Hold) on BASE
     <1 ±  <2  ± <3    <4   | 4>      3>    2>  ± 1>  
        …                                       …
 */
//
//      <pink2    , <pinky           , <ring            , <middl           , <index           , <indx2           |, indx2>        , index>  , middl>           , ring>              , pinky>  , pink2>        ,
//                ,                  ,                  ,                  , -*-              ,                 <|,>              ,         ,                  ,                    ,         ,               ,
        CTO_BASE  , COUNT_TOG        , COUNT_NULL       , COUNT_WORDMIN    , COUNT_REPORT     , SPEED_TOG         , SPEED_REPORT  , KC_MPLY , KC_MNXT          , KC_MPRV            , KC_MSTP , KC_RSFT       ,
        KC_CAPS   , C_KC_PWR         , C_KC_WAKE        , C_KC_SLEP        , C_KC_PAUS        , KC_SLCK           , KC_PSCR       , XXXXXXX , KC_VOLU          , KC_VOLD            , KC_MUTE , KC_INS        ,
        XP_DRA_CG , UNICODE_MODE_LNX , UNICODE_MODE_BSD , UNICODE_MODE_OSX , UNICODE_MODE_WIN , UNICODE_MODE_WINC , XXXXXXX       , XXXXXXX , KC_BRIGHTNESS_UP , KC_BRIGHTNESS_DOWN , XXXXXXX , KC_APP        ,
//      -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
        LEDS_ON  
#     ifdef TRANSMINIVAN_LEFTSIDE
                , TRANS_LEFT
#     endif

#     ifdef MORE_KEY__COMMAND
                , MORE_key1
#     endif

#     ifdef LEDS_OFF_BASE_DEF  // This messes with led effect on/off, so we need to track the state of this setting now.
                , RGBTOG_ 
#     else                     // Here we don't mess with led effect on/off, so we can use QMK key blindly.
                , RGB_TOG
#     endif
                          , KC__XGUI , XXXXXXX 

#     ifdef TRANSMINIVAN_MIDLEFT
                                               , TRANS_MIDLEFT
#     endif

                                               , OTHER_BASE , XXXXXXX 

#     ifdef TRANSMINIVAN_RIGHTSIDE
                                                                      , TRANS_RIGHT
#     endif                                                           
                                                                      
                                                                      , KC__YGUI
                                                                      
#     ifdef MORE_KEY__ARROW                                           
                                                                      , MORE_key2  
#     endif                                                           
                                                                                 , _______
//              ,         ,          ,       <|,>        ,            ,          ,
//      <1 ± ±  , <2      , <3       , <4     |, 4>      , 3>         , 2>       , ±  ±  1>

                      ),

# endif // BASESFILE_LAYER_RAR

        /* ⬆⬇ */

# ifndef REMOVE_PAD // This removes all references to _PAD in the code, therefore is not functionally the same as BASESFILE_LAYER_PAD

#     ifndef BASESFILE_LAYER_PAD // Use a definition of this layer in the ./bases_* file, where this #define can be defined.

#         ifndef NUMPAD_COMMON_SQUARE // Use default _PAD layer, where numbers are aligned as they are on _NSY.
                                  // Conversely, if this is defined, this layer will resembel a numeric keypad.
                                  // See also base_numpad.c 

    /* Layer _PAD: Numbers pad, for numbers pad version of numbers (computer programs can see the difference).
     *             Number pad navigation will be more or less useless, but there is a repetition of the Numpad
     *             keys 4,2,8,6 row 4 for arrows, and 3,1,7,9 row 2 for navigation, to make it a little easier to find.
     */

    [ _PAD ] = LAYOUT_redefined (

/*
     Layer _PAD Numbers Pad (special symbol versions; regular '1' is not the same as this numpad '1', etc)
    
     <pink2   <pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                    -*-                    <|>                                         //(toggle) on _FUN
     BASE     xxx   xxx   .DEL  4LEFT 2DOWN | 8UP   6RGHT *     xxx   xxx      Bksp
     LCtl     1END  2DOWN 3PGDN 4LEFT 5     | 6RGHT 7HOME 8UP   9PGUP 0INS        -
     LSht     xxx   xxx   /     xxx   =     | +     3PGDN 1END  7HOME 9PGUP    RSht
     -*---------------------------------------------------------------------------- //-*-  toggle on BASE
     LAlt     Del   Tab   ENT  |  NUML  xxx   LGUI  RAlt
                              <|>
     <1   ±   <2    <3    <4   |  4>    3>    2>  ± 1>  
          …                                       …

 */

//
//      <pink2   , <pinky  , <ring   , <middl      , <index  , <indx2     |, indx2>     , index>  , middl>         , ring>   , pinky>  , pink2>      ,
//               ,         ,         ,             ,         , -*-       <|,>           ,         ,                ,         ,         ,             ,
        CTO_BASE , XXXXXXX , XXXXXXX , KC_KP_DOT   , KC_KP_4 , KC_KP_2     , KC_KP_8    , KC_KP_6 , KC_KP_ASTERISK , XXXXXXX , XXXXXXX , KC_BSPC     ,
        KC_LCTL  , KC_KP_1 , KC_KP_2 , KC_KP_3     , KC_KP_4 , KC_KP_5     , KC_KP_6    , KC_KP_7 , KC_KP_8        , KC_KP_9 , KC_KP_0 , KC_KP_MINUS ,
        KC_LSFT  , XXXXXXX , XXXXXXX , KC_KP_SLASH , XXXXXXX , KC_KP_EQUAL , KC_KP_PLUS , KC_KP_3 , KC_KP_1        , KC_KP_7 , KC_KP_9 , KC_RSFT     ,
//      ----------------------------------------------------------------------------------------------------------------------------------------------
        KC_LALT 

#             ifdef TRANSMINIVAN_LEFTSIDE
                , _______ // On Base layers this key typically defaults to MO ( _PAD )
#             endif

#             ifdef MORE_KEY__COMMAND
                , MORE_key1
#             endif

                , KC_DEL , KC_TAB , KC_KP_ENTER

#             ifdef TRANSMINIVAN_MIDLEFT
                                                , TRANS_MIDLEFT
#             endif

                                                , KC_NUMLOCK , XXXXXXX , KC__YGUI

#             ifdef TRANSMINIVAN_RIGHTSIDE
                                                                                  , TRANS_RIGHT
#             endif

#             ifdef MORE_KEY__ARROW
                                                                                  , MORE_key2  
#             endif

                                                                                  , KC_RALT
//              ,        ,        ,           <|,>           ,         ,          ,
//      <1  ± ± , <2     , <3     , <4         |, 4>         , 3>      , 2>       , ±  ±  1>

                      ),

#         else // NUMPAD_COMMON_SQUARE 

    [ _PAD ] = LAYOUT_redefined (

/*
     
     * Layer _PAD: Option for a different _PAD layer in the common layers system.
     *             This variety resembles the square layout of a numerical keyboard.
     *             It is different from one of the Numpad Base layer compile options, in that
     *             it only has a number pad for the right hand. It is also different in featuring
     *             modifiers, and the overall layout is sligthly different (Enter, = symbol).
     *
     *             ‛Tab’ on key 3 left hand is the same as the other _PAD layer option (with the
     *             numbers in a line, equal to the _NSY layer), to retain the same ability to
     *             type Control-Tab. It seems better to have RAlt in its usual place, Enter in
     *             its usual place, than to strictly follow a standard numeric keyboard layout
     *             (which puts Enter somewhere on the right, row 1). It seems easy enough to
     *             type Enter on this key as well, even with the right hand. Numlock is also
     *             in its usual place. Note that ‛Del’ on the left, row 1, is not a numbers pad
     *             Delete/Dot key, but standard Delete, also in the usual place.
     *
     *             This is probably the better one of the square layout numpads, unless you have a use
     *             for the two hands version. This is also available on ‛Base’ Numpad.
     * 
     
     Layer _PAD (Number pad, with NumLock on)
    
     <pink2   <pinky<ring <middl<index<indx2| indx2>index>middl>ring>pin>pink2>
                                           <|>
     BASE     xxx   xxx   xxx   xxx   xxx   | =     7     8     9    -   Bspc
     LCtl     xxx   xxx   xxx   xxx   xxx   | *     4     5     6    +   RCtl
     LSht     xxx   xxx   xxx   xxx   xxx   | /     1     2     3    ,   RSht  
     ------------------------------------------------------------------------
                   LAlt   Del    Tab   Ent  | NumL  0     .     RAlt      
                                           <|>           
                   <1   ±  <2    <3    <4   | 4>    3>    2>  ± 1>  
                        …                   |                 …           

     Layer _PAD (Number pad, with NumLock off)
    
     <pink2   <pinky<ring <middl<index<indx2| indx2>index>middl>ring >pin>pink2>
                                           <|>
     BASE     xxx   xxx   xxx   xxx   xxx   | =     Home  Up    PgUp  -   Bspc
     LCtl     xxx   xxx   xxx   xxx   xxx   | *     Left  5     Right +   RCtl
     LSht     xxx   xxx   xxx   xxx   xxx   | /     End   Down  PgDn  ,   RSht  
     -------------------------------------------------------------------------
                   LAlt   Del    Tab   Ent  | NumL  Ins   Del   RAlt      
                                           <|>
                   <1   ±  <2    <3    <4   | 4>    3>    2>  ± 1>  
                        …                   |                 …           
 
*/

//
//      <pink2   , <pinky  , <ring   , <middl  , <index  , <indx2 |, indx2>         , index>  , middl>  , ring>   , pinky>      , pink2>  ,
//               ,         ,         ,         ,         , -*-   <|,>               ,         ,         ,         ,             ,         ,
        CTO_BASE , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , KC_KP_EQUAL    , KC_KP_7 , KC_KP_8 , KC_KP_9 , KC_KP_MINUS , KC_BSPC ,
        KC_LCTL  , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , KC_KP_ASTERISK , KC_KP_4 , KC_KP_5 , KC_KP_6 , KC_KP_PLUS  , KC_RCTL ,
        KC_LSFT  , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , KC_KP_SLASH    , KC_KP_1 , KC_KP_2 , KC_KP_3 , KC_KP_COMMA , KC_RSFT ,
//      -----------------------------------------------------------------------------------------------------------------------------------
        KC_LALT 

#             ifdef TRANSMINIVAN_LEFTSIDE
                , TRANS_LEFT  
#             endif

#             ifdef MORE_KEY__COMMAND
                , MORE_key1
#             endif

                , KC_DEL     , KC_TAB , KC_KP_ENTER  

#             ifdef TRANSMINIVAN_MIDLEFT
                                                    , TRANS_MIDLEFT
#             endif

                                                    , KC_NUMLOCK , KC_KP_0 

// See comment in ./base_numpad.c on the first layout (double handed Base layer), about the next few keys:
// This layer follows that layout Base Numpad.
// ---⬇

#     ifdef TRANSMINIVAN_RIGHTSIDE
                                                                           , TRANS_RIGHT   
#     endif                                                                                     
                                                                                            
#     ifdef MORE_KEY__ARROW                                                                     
                                                                         //, MORE_key2   
                                                                           , KC__YGUI
#     endif                                                                                           
// ---⬆
                                                                           , KC_KP_DOT  

                                                                                       , KC_RALT
//              ,            ,        ,           <|,>           ,         ,           ,
//      <1  ± ± , <2         , <3     , <4         |, 4>         , 3> ± ±  , 2>        ,       1>

                      ),


#         endif // NUMPAD_COMMON_SQUARE 

#     endif // BASESFILE_LAYER_PAD

# endif // REMOVE_PAD

        /* ⬆⬇ */

# ifndef REMOVE_ACC // This cuts out the whole _ACC layer.

#     ifndef BASESFILE_LAYER_ACC // Use a definition of this layer in the ./bases_* file, where this #define can be defined.

    /* Layer _ACC: Accented and other unusual characters. It seems this would
     *             cover Dutch, German, French, Scandinavia, Italy and Spain.
     *          It should helps with remembering what keys are where, if one
     *             knows the logic behind it (however flawed it might be).
     *          This layer has the uncluttered Tab key (whoohoo!).
     *
     *          The logic is ... Versions of the vowels with accents are
     *                              widened vertically on the board, from their
     *                              normal position.
     *                           Grave is a line going up, thus on upper row. é
     *                           Acute is a line going down, thus on lower row. è
     *                           Diaereses is dots going horizontal, thus middle. ë
     *                           Diareses is umlaut which is most frequent if
     *                              including German, thus home row. ë
     *                           There is no room for Caret on the left, thus it is
     *                              on the right, following same-finger logic (O 
     *                              is ring finger, etc).
     *                           Caret is on the lower row to make room for versions 
     *                              of 'n' and 'c' near their normal position.
     *                           There is no room for ÿŸ on the normal y, because
     *                              íÍ is on it, which is more important, and to
     *                              keep the logic of that block, therefore it is
     *                              as close to it as can be.
     *                           øØ and åÅ follow the same-finger logic (a is left
     *                              hand pinky, etc), and are on remaining spots.
     *                           œŒ and æÆ are also no remaining spots, both close
     *                              to êÊ for the e in there, the œŒ being further
     *                              to the left to follow the same finger logic on
     *                              that right hand side: a on the right, o on the left.
     *                           ¡ and ¿ had no more room on this layer, therefore,
     *                              and because they are unusual, they are on the 
     *                              _DRA(wings) layer. They are located under the keys
     *                              that also have ! and ?, respectively.
     *
     */ 

    [ _ACC ] = LAYOUT_redefined (

/*
     Layer _ACC (ACCented characters, see _RAR layer for input modes)
    
     <pink2    <pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                       -*-              <|>                                            //(toggle) on _FUN
     BASE      áÁ    óÓ    éÉ    úÚ    íÍ    | ýÝ    ijIJ    çÇ    øØ    åÅ    Bksp
     RCTL(Tab) äÄ    öÖ    ëË    üÜ    ïÏ    | ÿŸ    œŒ    æÆ    ñÑ     ß       μ
     LSht      àÀ    òÒ    èÈ    ùÙ    ìÌ    | îÎ    ûÛ    êÊ    ôÔ    â    RSht
     ----------------------------------------------------------------------------
     LAlt ___   ___   Ent  | Spc   ___   ___   RAlt 
          -*-             <|>                                                            //(hold) on BASE
     <1 ± <2    <3    <4   | 4>    3>    2>  ± 1>  
        …                                    …
 */
//
//      <pink2          , <pinky    , <ring     , <middl    , <index    , <indx2   |, indx2>    , index>    , middl>    , ring>     , pinky>    , pink2>    ,
//                      ,           ,           ,           ,           ,         <|,>-*-       ,           ,           ,           ,           ,           ,
        CTO_BASE        , XP_ACC_AA , XP_ACC_AB , XP_ACC_AC , XP_ACC_AD , XP_ACC_AE , XP_ACC_AF , XP_ACC_AG , XP_ACC_AH , XP_ACC_AI , XP_ACC_AJ , KC_BSPC   ,
        LCTL ( KC_TAB ) , XP_ACC_BA , XP_ACC_BB , XP_ACC_BC , XP_ACC_BD , XP_ACC_BE , XP_ACC_BF , XP_ACC_BG , XP_ACC_BH , XP_ACC_BI , XP_ACC_BJ , XP_ACC_BK , 
        KC_LSFT         , XP_ACC_CA , XP_ACC_CB , XP_ACC_CC , XP_ACC_CD , XP_ACC_CE , XP_ACC_CF , XP_ACC_CG , XP_ACC_CH , XP_ACC_CI , XP_ACC_CJ , KC_RSFT   ,
//      ----------------------------------------------------------------------------------------------------------------------------------------------
        KC_LALT 
#         ifdef TRANSMINIVAN_LEFTSIDE
                        , TRANS_LEFT
#         endif

#         ifdef MORE_KEY__COMMAND
                        , MORE_key1
#         endif

                        , _______ , _______ , KC_ENT  

#     ifdef TRANSMINIVAN_MIDLEFT
                                                     , TRANS_MIDLEFT
#     endif

                                                     , KC_SPC , _______ , _______ 

#         ifdef TRANSMINIVAN_RIGHTSIDE
                                                                                  , TRANS_RIGHT
#         endif                                              
                                                             
#         ifdef MORE_KEY__ARROW                              
                                                                                  , MORE_key2  
#         endif                                              
                                                             
                                                                                  , KC_RALT
//              , -*-     ,         ,      <|,>               ,         ,         , 
//      <1 ± ±  , <2      , <3      , <4    |, 4>             , 3>      , 2>      , ±  ±  1>

                      ),

#     endif // BASESFILE_LAYER_ACC

# endif // REMOVE_ACC

        /* ⬆⬇ */

# ifndef REMOVE_DRA // This cuts out the whole _DRA layer

#     ifndef BASESFILE_LAYER_DRA // Use a definition of this layer in the ./bases_* file, where this #define can be defined.

    /* Layer _DRA: Drawings, like various Unicode symbols.
     *   
     */

    [ _DRA ] = LAYOUT_redefined (

/*
     Layer _DRA (DRAwings, whatever else (rendering width varies in different applications))
    
     <pink2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                             -*-        <|>                                            //(toggle) on _FUN
     BASE  “„    ”≤    £≥    ∅ ¢   ±ƒ    | ❦♥    🙂🙁  👍👎   ⁽₍    ⁾₎    Bksp
     Tab   ¹₁    ²₂    ³₃    ⁴₄    ⁵₅    | ⁶₆    ⁷₇    ⁸₈     ⁹₉    ⁰₀    RCTL
     LSht 「━    」─   °〇   •§    …·    | ⮘⮙   ⮚⮛     ¿¡    《┄    》┅   RSht
     -------------------------------------------------------------------------
     LAlt ___   ___   Ent  | Spc   ___   ___   RAlt 
                -*-       <|>      -*-                                                   //(hold) on BASE
     <1 ± <2    <3    <4   | 4>    3>    2>  ± 1>  
        …                                    …
 */
//
//      <pink2   , <pinky    , <ring     , <middl    , <index    , <indx2   |, indx2>    , index>    , middl>    , ring>     , pinky>    , pink2>  ,
//               ,           ,           ,           ,           ,         <|,>          , -*-       ,           ,           ,           ,         ,
        CTO_BASE , XP_DRA_AA , XP_DRA_AB , XP_DRA_AC , XP_DRA_AD , XP_DRA_AE , XP_DRA_AF , XP_DRA_AG , XP_DRA_AH , XP_DRA_AI , XP_DRA_AJ , KC_BSPC ,
        KC_TAB   , XP_DRA_BA , XP_DRA_BB , XP_DRA_BC , XP_DRA_BD , XP_DRA_BE , XP_DRA_BF , XP_DRA_BG , XP_DRA_BH , XP_DRA_BI , XP_DRA_BJ , KC_RCTL ,
        KC_LSFT  , XP_DRA_CA , XP_DRA_CB , XP_DRA_CC , XP_DRA_CD , XP_DRA_CE , XP_DRA_CF , XP_DRA_CG , XP_DRA_CH , XP_DRA_CI , XP_DRA_CJ , KC_RSFT ,
//      --------------------------------------------------------------------------------------------------------------------------------------------
        KC_LALT 

#         ifdef TRANSMINIVAN_LEFTSIDE
                , TRANS_LEFT
#         endif

#         ifdef MORE_KEY__COMMAND
                , MORE_key1
#         endif

                , _______ , _______ , KC_ENT

#     ifdef TRANSMINIVAN_MIDLEFT
                                             , TRANS_MIDLEFT
#     endif

                                             , KC_SPC , _______ , _______ 

#         ifdef TRANSMINIVAN_RIGHTSIDE
                                                                          , TRANS_RIGHT
#         endif

#         ifdef MORE_KEY__ARROW
                                                                          , MORE_key2  
#         endif                          

                                                                          , KC_RALT
//              ,         ,         ,      <|,>       ,         ,         ,
//      <1 ± ±  , <2      , <3      , <4    |, 4>     , 3>      , 2>      , ±  ±  1>

                      ),

#     endif // BASESFILE_LAYER_RAR

# endif // REMOVE_DRA

        /* ⬆⬇ */

# ifndef REMOVE_BON // Removes this layer entirely, if set.

#     ifndef BASESFILE_LAYER_BON // Use a definition of this layer in the ./bases_* file, where this #define can be defined.

/* 
 * Bonus layer: Enumeration numbers, some general purpose / mathematical symbols
 * ⁻ is an exponential minus sign (the center-dot · can be used in exponents too)
 * × is multiplication
 * ‰ is promille, ‱ is pro-tenthousandth
 * 
 */

    [ _BON ] = LAYOUT_redefined (

/* 
     Layer _BON (Bonus layer, a variety of more stuffs.)

     <pink2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
                                   -*-  <|>
     BASE  ‛ 🛠  ’ ⬆   ¤ 🄯   ∑ ©   ‰ ‱   | ★ ٭   😊 ⍨  ×  ⃰   √     ⁻ ⁺    Bksp
     `~    ① ⬅   ② ⬇   ③ ➡   ④ ┏   ⑤  ┓  | ⑥ ┃   ⑦ ┇   ⑧ ╋   ⑨     ⓪ ∞    — ≈    // — is a dash (larger), not hyphen
     LSht  ‹     ›     ÷     ☞ ┗   ≠  ┛  | ✗ ┣   ✓ ┫   ⚠     «     »      RSht
     -------------------------------------------------------------------------
     Left  ___   ___   Ent  | Spc   ___   ___   Right
           -*-   -*-       <|>      -*-                                                   // Activation on BASE
     <1  ± <2    <3    <4   | 4>    3>    2>  ± 1>  
         …                                    …
 */
//
//      <pink2      , <pinky    , <ring     , <middl    , <index    , <indx2   |, indx2>    , index>    , middl>    , ring>     , pinky>    , pink2>    ,
//                  ,           ,           ,           ,           ,         <|,>          ,           ,           ,           ,           ,           ,
        CTO_BASE    , XP_BON_AA , XP_BON_AB , XP_BON_AC , XP_BON_AD , XP_BON_AE , XP_BON_AF , XP_BON_AG , XP_BON_AH , XP_BON_AI , XP_BON_AJ , KC_BSPC   ,
        KC_GRV      , XP_BON_BA , XP_BON_BB , XP_BON_BC , XP_BON_BD , XP_BON_BE , XP_BON_BF , XP_BON_BG , XP_BON_BH , XP_BON_BI , XP_BON_BJ , XP_BON_BK ,
        KC_LSFT     , XP_BON_CA , XP_BON_CB , XP_BON_CC , XP_BON_CD , XP_BON_CE , XP_BON_CF , XP_BON_CG , XP_BON_CH , XP_BON_CI , XP_BON_CJ , KC_RSFT   ,
//      -------------------------------------------------------------------------------------------------------------------------------------------------
        KC_LEFT 

#         ifdef TRANSMINIVAN_LEFTSIDE
                , TRANS_LEFT
#         endif

#         ifdef MORE_KEY__COMMAND
                , MORE_key1
#         endif                 

                , _______ , _______ , KC_ENT

#     ifdef TRANSMINIVAN_MIDLEFT
                                             , TRANS_MIDLEFT
#     endif

                                             , KC_SPC , _______ , _______

#         ifdef TRANSMINIVAN_RIGHTSIDE
                                                                          , TRANS_RIGHT
#         endif

#         ifdef MORE_KEY__ARROW                    
                                                                          , MORE_key2  
#         endif                                                                                           
                                                                          , KC_RIGHT
//              ,         ,         ,      <|,>       ,         ,         ,
//      <1  ± ± , <2      , <3      , <4    |, 4>     , 3>      , 2>      , ± ± 1>

                      ),

#     endif // BASESFILE_LAYER_BON

# endif // REMOVE_BON 

        /* ⬆⬇ */
                          
# ifndef BASESFILE_LAYER_FUN // Use a definition of this layer in the ./bases_* file, where this #define can be defined.

    /* Layer _FUN: Function keys until F20. Some combo modifiers control/alt/shift
     * Toward any layer by toggle. Layer can be set to return to BASE after one F-key press (FUN<, row 1)
     */

    [ _FUN ] = LAYOUT_redefined ( 

/*
     Layer _FUN (F-keys, Layer access, Set BASE key direction)
    
     <pink2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
     toggl toggl set   toggl toggl toggl | toggl toggl                            // Type of layer switch
                                        <|>                                       
     BASE: NUMS: _PAD  _ACC  _DRA  _BON  | _MOV  _RAR  xxx   xxx   xxx    Bksp       //':' are dynamic ...
     LCtl  F1    F2    F3    F4    F5    | F6    F7    F8    F9    F10    RCtl
     LSht  F11   F12   F13   F14   F15   | F16   F17   F18   F19   F20    RSht     
     ----------------------------------------------------------------------*--       //-*-  toggle on BASE
     LAlt  LCtl&  LCtl&  LSht&  | FUN< +LCtl&LSht LGUI   RAlt                        //... < toggle 'stay'
           LSht   LAlt   LAlt   |      &LAlt                                    
           +xxx   +xxx   +xxx   |      +xxx
                               <|>
     <1  ± <2     <3     <4     | 4>   3>         2>  ±  1>                
         …                                            …
 */
//
//      <pink2   , <pinky   , <ring       , <middl   , <index   , <indx2    |, indx2>      , index>      , middl>  , ring>   , pinky>  , pink2>  ,
//               ,          , -*-         ,          ,          ,          <|,>            ,             ,         ,         ,         ,         ,
        CTO_BASE , CTO_NUMS , TO ( _PAD ) , CTO_ACCE , CTO_DRAW , TO ( _BON ), TO ( _MOV ) , TO ( _RAR ) , XXXXXXX , XXXXXXX , XXXXXXX , KC_BSPC ,
        KC_LCTL  , KC_F1    , KC_F2       , KC_F3    , KC_F4    , KC_F5      , KC_F6       , KC_F7       , KC_F8   , KC_F9   , KC_F10  , KC_RCTL ,
        KC_LSFT  , KC_F11   , KC_F12      , KC_F13   , KC_F14   , KC_F15     , KC_F16      , KC_F17      , KC_F18  , KC_F19  , KC_F20  , KC_RSFT ,
//      ------------------------------------------------------------------------------------------------------------------------------------------
        KC_LALT 
#     ifdef TRANSMINIVAN_LEFTSIDE
                , TRANS_LEFT
#     endif

#     ifdef MORE_KEY__COMMAND
                , MORE_key1
#     endif

                , MT ( MOD_LCTL | MOD_LSFT, XXXXXXX ) , MT ( MOD_LCTL | MOD_LALT , XXXXXXX ) , MT ( MOD_LSFT | MOD_LALT , XXXXXXX )

#     ifdef TRANSMINIVAN_MIDLEFT
                                                                                                                                    , TRANS_MIDLEFT
#     endif

                                                                                                                                    , _FUN_STAY , MT ( MOD_LCTL | MOD_LSFT | MOD_LALT , XXXXXXX ) , KC__YGUI

#     ifdef TRANSMINIVAN_RIGHTSIDE
                                                                                                                                                                                                             , _______ // On Base layers this key typically defaults to MO ( _FUN )
#     endif

#     ifdef MORE_KEY__ARROW
                                                                                                                                                                                                             , MORE_key2  
#     endif
                                                                                                                                                                                                             , KC_RALT
//              ,                                     ,                                      ,                                    <|,>          ,                                                 ,          ,
//      <1 ± ±  , <2                                  , <3                                   , <4                                  |, 4>        , 3>                                              , 2>       , ±  ±  1>

                      ),

# endif // BASESFILE_LAYER_FUN

        /* ⬆  */


/*
 * New layer template. Includes left/right movement arrows, deletion, modifiers.
 * If you want a new layer, in the logic of this layout you would add a toggle on the
 * _FUN layer top row on the first free key to it, and optionally alter the hold 
 * layer switch keys on the base layers. (Check if a new layer will fit on the chip.)
 *
    [ _??? ] = LAYOUT_redefined (

// <pink2<pinky<ring <middl<index<indx2| indx2>index>middl>ring> pinky>pink2>
//                                    <|>
// BASE  xxx   xxx   xxx   xxx   xxx   | xxx   xxx   xxx   xxx   xxx    Bksp
// LCtl  xxx   xxx   xxx   xxx   xxx   | xxx   xxx   xxx   xxx   xxx    RCtl
// LSht  xxx   xxx   xxx   xxx   xxx   | xxx   xxx   xxx   xxx   xxx    RSht
// -------------------------------------------------------------------------
// LAlt+Left Del   ___   Ent  | Spc   ___   ___   RAlt+Right
//                           <|>
// <1   ±    <2    <3    <4   | 4>    3>    2>  ± 1>  
//      …                                       …
//
//
//      <pink2   , <pinky  , <ring   , <middl  , <index  , <indx2 |, indx2>  , index>  , middl>  , ring>   , pinky>  , pink2>  ,
//               ,         ,         ,         ,         ,       <|,>        ,         ,         ,         ,         ,         ,
        CTO_BASE , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , KC_BSPC ,
        KC_LCTL  , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , KC_RCTL ,
        KC_LSFT  , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , XXXXXXX , KC_RSFT ,
//      ------------------------------------------------------------------------------------------------------------------------
        LALT_T ( KC_LEFT ) 

# ifdef TRANSMINIVAN_LEFTSIDE
                           , TRANS_LEFT
# endif

# ifdef MORE_KEY__COMMAND
                           , MORE_key1
# endif                 

                           , KC_DEL , XXXXXXX , KC_ENT

#     ifdef TRANSMINIVAN_MIDLEFT
                                                       , TRANS_MIDLEFT
#     endif

                                                       , KC_SPC , XXXXXXX , XXXXXXX

# ifdef TRANSMINIVAN_RIGHTSIDE
                                                                                    , TRANS_RIGHT
# endif

# ifdef MORE_KEY__ARROW
                                                                                    , MORE_key2  
# endif                                                                                          

                                                                                    , RALT_T ( KC_RIGHT )
//                         ,        ,         ,      <|,>       ,         ,         ,
//      <1      ± ±        , <2     , <3      , <4    |, 4>     , 3>      , 2>      , ± ± 1>

                      ),
*/

};