~ruther/qmk_firmware

8eaf23ae8146766615cc1cec3fc8e04111e8ef49 — Batuhan Baserdem 7 years ago abce980
User space fixed (#3095)

* Put in my keymaps

* Fixed all but weird lets split issue

* Organized and tried to trobleshoot lets split

* Organized and tried to trobleshoot lets split

* Added bbaserdem keymaps

* Added bbaserdem keymaps

* Fixed stuff

* FIxed a filename error
A keyboards/gherkin/keymaps/bbaserdem/README.md => keyboards/gherkin/keymaps/bbaserdem/README.md +11 -0
@@ 0,0 1,11 @@
# Gherkin Layout
This is my gherkin layout.
It is used as a game pad, and key layout is inspired by spare keys I had lying around.
The firmware is very simple, and only includes one layer keymap, and RGB effects.

# Flashing
The following command should be used from the main qmk directory.
```
make gherkin:bbaserdem
sudo avrdude -p atmgea34u4 -P `ls /dev/ttyACM*` -c avr109 -U flash:.build/gherkin_bbaserdem.hex
```

A keyboards/gherkin/keymaps/bbaserdem/config.h => keyboards/gherkin/keymaps/bbaserdem/config.h +13 -0
@@ 0,0 1,13 @@
#ifndef CONFIG_USER_H
#define CONFIG_USER_H

#include "../../config.h"
#define RGB_DI_PIN F6
#define RGBLED_NUM 10
#define RGBLIGHT_ANIMATIONS
#ifdef BACKLIGHT_LEVELS
#undef BACKLIGHT_LEVELS
#endif
#define BACKLIGHT_LEVELS 3

#endif

A keyboards/gherkin/keymaps/bbaserdem/keymap.c => keyboards/gherkin/keymaps/bbaserdem/keymap.c +36 -0
@@ 0,0 1,36 @@
// This is a game-pad gherkin layout with RGB and LED lights

#include "gherkin.h"

backlight_config_t backlight_config;

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Game pad
 * ,-----------------------------------------------------------.
 * | Esc |  1  |  2  |  3  |  4  |  5  |  6  | Ctl | Alt |  ~  |
 * |-----+-----+-----+-----+-----+-----+-----+-----+-----+-----|
 * | Tab |  Q  |  W  |  E  |  R  |  T  | |^| |  ;  |  '  |  /  |
 * |-----+-----+-----+-----+-----+-----+-----+-----+-----+-----|
 * | Shf |  A  |  S  |  D  |  F  | <-- | |v| | --> |  ,  |  .  |
 * `-----------------------------------------------------------'
 */
    KEYMAP(
        KC_ESCAPE, KC_1, KC_2, KC_3, KC_4, KC_5,    KC_6,    KC_LCTRL, KC_LALT,  KC_GRAVE,
        KC_TAB,    KC_Q, KC_W, KC_E, KC_R, KC_T,    KC_UP,   KC_SCLN,  KC_QUOTE, KC_SLASH,
        KC_LSHIFT, KC_A, KC_S, KC_D, KC_F, KC_LEFT, KC_DOWN, KC_RIGHT, KC_COMMA, KC_DOT
    )
};

void matrix_init_user(void) {
    // Set LED's to max
    _delay_us(300);
    backlight_config.level = 2;
    backlight_config.enable = 1;
    eeconfig_update_backlight(backlight_config.raw);
    backlight_set(backlight_config.level);
    // Set RGB to rainbow mood light
    rgblight_enable();
    rgblight_mode(1);
    rgblight_sethsv(120,255,255);
    rgblight_mode(6);
}

A keyboards/gherkin/keymaps/bbaserdem/rules.mk => keyboards/gherkin/keymaps/bbaserdem/rules.mk +14 -0
@@ 0,0 1,14 @@
ifndef QUANTUM_DIR
  include ../../../../Makefile
endif

STENO_ENABLE = no      # Additional protocols for Stenography(+1700), requires VIRTSER
MOUSEKEY_ENABLE = no   # Mouse keys(+4700)
EXTRAKEY_ENABLE = no   # Audio control and System control(+450)
CONSOLE_ENABLE = no    # Console for debug(+400)
COMMAND_ENABLE = no    # Commands for debug and configuration
SLEEP_LED_ENABLE = no  # Breathing sleep LED during USB suspend
NKRO_ENABLE = yes      # USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
AUDIO_ENABLE = no 	   # Enable audio output from keyboard
RGBLIGHT_ENABLE = yes  # Enable RBG light strips
BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality

A keyboards/lets_split/keymaps/bbaserdem/README.md => keyboards/lets_split/keymaps/bbaserdem/README.md +27 -0
@@ 0,0 1,27 @@
# Lets Split Layout

Check out [user readme](../../../../users/bbaserdem/README.md) for more info.

# Usage

**These commands depend on there being no other arduino connected!**
Also udev rules can be set instead of using sudo.
Please unplug all other usb devices.

To make the hex files;
```
make lets_split/rev2:bbaserdem
make lets_split/rev2:bbaserdem_right
```

For the left half, after plugging in and resetting; (from repo main directory)
```
sudo avrdude -p atmega32u4 -P "$(ls /dev/ttyACM*)" -c avr109 -D -U flash:w:.build/lets_split_rev2_bbaserdem.hex
sudo avrdude -p atmega32u4 -P "$(ls /dev/ttyACM*)" -c avr109 -U eeprom:w:keyboards/lets_split/eeprom-lefthand.eep
```

For the right half;
```
sudo avrdude -p atmgea34u4 -P "$(ls /dev/ttyACM*)" -c avr109 -D -U flash:w:.build/lets_split_rev2_bbaserdem_right.hex
sudo avrdude -p atmega32u4 -P "$(ls /dev/ttyACM*)" -c avr109 -U eeprom:w:keyboards/lets_split/eeprom-righhand.eep
```

A keyboards/lets_split/keymaps/bbaserdem/config.h => keyboards/lets_split/keymaps/bbaserdem/config.h +27 -0
@@ 0,0 1,27 @@
#ifndef CONFIG_USER_H
#define CONFIG_USER_H

#include "../../config.h"

#define USE_SERIAL
#define EE_HANDS

// LED strip stuff
#ifdef RGBLIGHT_ENABLE

// Who thought it was a good idea to predefine these in the rev2/config.h ???
#ifdef RGBLED_NUM
#undef RGBLED_NUM
#endif
#define RGBLED_NUM 12

#define RGBLIGHT_HUE_STEP 6
#define RGBLIGHT_SAT_STEP 12
#define RGBLIGHT_VAL_STEP 20
#define RGBLIGHT_ANIMATIONS
#define RGBLIGHT_EFFECT_SNAKE_LENGTH 6
#define RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL 2000
#define RGBLIGHT_EFFECT_CHRISTMAS_STEP 1
#endif

#endif

A keyboards/lets_split/keymaps/bbaserdem/keymap.c => keyboards/lets_split/keymaps/bbaserdem/keymap.c +37 -0
@@ 0,0 1,37 @@
/*
 * Let's Split - Dvorak turkish
 * Keymap by @bbaserdem
 * Dvorak layout with multiple features
 * Most of the code is in the "user" directory.
 * Check qmk_firmware/users/bbaserdem for the main part of the code
 */
#define KEYMAP(...) LAYOUT_ortho_4x12(__VA_ARGS__)

#include "lets_split.h"
#include "bbaserdem.h"


void matrix_init_keymap (void) {
}

uint32_t layer_state_set_keymap(uint32_t state) {
    return state;
}

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    // Main Dvorak layer
    [_DV] = DVORAK,
    // Turkish and special character overlay
    [_AL] = ALTCHAR,
    // Gaming layer
    [_GA] = GAME,
    // Numbers layer
    [_NU] = NUMBERS,
    // Settings layer
    [_SE] = SETTINGS,
    // Mouse emulation layer
    [_MO] = MOUSE,
#ifdef AUDIO_ENABLE
    [_MU] = MUSIC,
#endif
};

A keyboards/lets_split/keymaps/bbaserdem/rules.mk => keyboards/lets_split/keymaps/bbaserdem/rules.mk +11 -0
@@ 0,0 1,11 @@
# Build options

BACKLIGHT_ENABLE = no		# Switch LEDs
MOUSEKEY_ENABLE = yes		# Emulates mouse key using keypresses
RGBLIGHT_ENABLE = yes 		# LED strips
TAP_DANCE_ENABLE = no 		# Use multi-tap features
AUDIO_ENABLE = no 			# Audio stuff

ifndef QUANTUM_DIR
	include ../../../../Makefile
endif

A keyboards/lets_split/keymaps/bbaserdem_right/README.md => keyboards/lets_split/keymaps/bbaserdem_right/README.md +5 -0
@@ 0,0 1,5 @@
# Lets Split - Right Half

Keymap for my right half, to be used as a numpad.
Check [main readme](../bbaserdem/README.md) for flashing info.


A keyboards/lets_split/keymaps/bbaserdem_right/config.h => keyboards/lets_split/keymaps/bbaserdem_right/config.h +9 -0
@@ 0,0 1,9 @@
#ifndef CONFIG_USER_H
#define CONFIG_USER_H

#include "../../config.h"

#define USE_SERIAL
#define EE_HANDS

#endif

A keyboards/lets_split/keymaps/bbaserdem_right/keymap.c => keyboards/lets_split/keymaps/bbaserdem_right/keymap.c +35 -0
@@ 0,0 1,35 @@
/*
 * Let's Split - Dvorak turkish
 * Keymap by @bbaserdem
 * Dvorak layout with multiple features
 * Most of the code is in the "user" directory.
 * Check qmk_firmware/users/bbaserdem for the main part of the code
 */

#include "lets_split.h"

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

        
/*      Navigation All Supered)                        Numpad
 * ,-----------------------. ,-----------------------.
 * | F4| ` | Q |Alt| L | > | | ) | - | + | = |Ent|Bkp|
 * |---+---+---+---+---+---| |---+---+---+---+---+---|
 * | F3| M |Ent|Ctl| K | ^ | | ( | * | 9 | 6 | 3 | . |
 * |---+---+---+---+---+---| |---+---+---+---+---+---|
 * | F2| T |Spc|Shf| J | v | | % | / | 8 | 5 | 2 | , |
 * |---+---+---+---+---+---| |---+---+---+---+---+---|
 * | F1| F | P |Tab| H | < | |Nlc|Tab| 7 | 4 | 1 | 0 |
 * `-----------------------' `-----------------------' 
 */
    // Main Dvorak layer
    [0] = KEYMAP(
        LGUI(KC_F4), LGUI(KC_GRV), LGUI(KC_Q),   LGUI(KC_LALT), LGUI(KC_L), LGUI(KC_RGHT),
        KC_RPRN,     KC_PMNS,      KC_PPLS,      KC_PEQL,       KC_PENT, KC_BSPC,
        LGUI(KC_F3), LGUI(KC_M),   LGUI(KC_ENT), LGUI(KC_LCTL), LGUI(KC_K), LGUI(KC_UP),
        KC_LPRN,     KC_PAST,      KC_P9,        KC_P6,         KC_P3,   KC_PDOT,
        LGUI(KC_F2), LGUI(KC_T),   LGUI(KC_SPC), LGUI(KC_LSFT), LGUI(KC_J), LGUI(KC_DOWN),
        KC_PERC,     KC_PSLS,      KC_P8,        KC_P5,         KC_P2,   KC_PCMM,
        LGUI(KC_F1), LGUI(KC_F),   LGUI(KC_P),   LGUI(KC_TAB),  LGUI(KC_H), LGUI(KC_LEFT),
        KC_NLCK,     KC_TAB,       KC_P7,        KC_P4,         KC_P1,   KC_P0 )
};

A keyboards/lets_split/keymaps/bbaserdem_right/rules.mk => keyboards/lets_split/keymaps/bbaserdem_right/rules.mk +24 -0
@@ 0,0 1,24 @@
# Build options

BACKLIGHT_ENABLE = no		# Switch LEDs
MOUSEKEY_ENABLE = no		# Emulates mouse key using keypresses
RGBLIGHT_ENABLE = no 		# LED strips
TAP_DANCE_ENABLE = no 		# Use multi-tap features
AUDIO_ENABLE = no 			# Audio stuff
BLUETOOTH_ENABLE = no 		# No bluetooth
COMMAND_ENABLE = no			# Some bootmagic thing
BOOTMAGIC_ENABLE = no 		# Access to EEPROM settings, not needed
CONSOLE_ENABLE = no			# Allows console output with a command
SLEEP_LED_ENABLE = no  		# Breathes LED's when computer is asleep. Untested.
NKRO_ENABLE = no 			# Default is 6KRO which is plenty
MIDI_ENABLE = no 			# Untested feature
FAUXCLICKY_ENABLE = no 		# Emulates clicks using speaker
KEY_LOCK_ENABLE = no 		# Allows locking any key. Not used
API_SYSEX_ENABLE = no 		# Allows OS to send signals.
KEY_LOCK_ENABLE = no 		# Allows locking any key. Not used
UNICODE_ENABLE = no			# Used for unicode character emulation
EXTRAKEY_ENABLE = no		# OS signals like volume control

ifndef QUANTUM_DIR
	include ../../../../Makefile
endif

M keyboards/planck/keymaps/bbaserdem/README.md => keyboards/planck/keymaps/bbaserdem/README.md +9 -29
@@ 1,35 1,15 @@
# Planck Layout

Built this planck layout to use DVORAK with an unorthodox Turkish layout.
If you used a previous layout with a persistent base layer change,
change it to 0 before proceeding.
The layout has the following functionality
Current keymap is for rev4.
Audio is disabled in favor of RGB.
Check out [user readme](../../../../users/bbaserdem/README.md) for more info.

* **QWERTY** can be toggled on/off from **Function** layer.
* **Mouse** layer allows manipulation of the mouse.
* **Function** layer has F and special keys.
* **Symbol** layer has numericals and symbols.
* **Game** layout can be toggled on/off from **Function** layer.
* **Music** layer allows playing sounds like a keyboard.
# Build

Double tapping **Mouse**, **Function** and **Symbol** layers activate them until deacivation.
Topleftmost key turns off **Function**, **Symbol**, **Game** and **Music** layers,
and puts the board into *reset* mode from the **Mouse** layer.
Get keyboard into reset mode, and then;

# Using Turkish letters
```
make planck/rev4:bbaserdem:dfu
```

Instead of a turkish F keyboard layout (very inconvenient to code in),
I opted to modulate characters like an *AltGr* impleentation.
Tap and holding *Alt* on **DVORAK** and **QWERTY** layer will change some letters
to Turkish equivelants.
Shifting these letters will work.
The keycodes should transmit the correct unicode characters combined with shift.
The turkish letters are sent via the unicode implementation.
No software layout change is neccessary (hence making coding easier).
By default, the unicode is set to Linux mode. Switch to windows (non-persistent)
can be done from the associated key in **Function** layer.
**Symbol** layer also has the symbol for Turkish Lira.

# To improve

I want to write a couple pieces of my own music for layer switching.
Either use sudo or set up udev rules.

M keyboards/planck/keymaps/bbaserdem/config.h => keyboards/planck/keymaps/bbaserdem/config.h +14 -36
@@ 3,42 3,20 @@

#include "../../config.h"

#ifdef AUDIO_ENABLE
    // Compose own song in future
    #define STARTUP_SONG SONG(PLANCK_SOUND)

    #define DEFAULT_LAYER_SONGS { SONG(QWERTY_SOUND), \
                                  SONG(COLEMAK_SOUND), \
                                  SONG(DVORAK_SOUND) \
                                }
// LED strip stuff
#ifdef RGBLIGHT_ENABLE
#define RGB_DI_PIN B2
#define RGBLED_NUM 12
#define RGBLIGHT_HUE_STEP 6
#define RGBLIGHT_SAT_STEP 12
#define RGBLIGHT_VAL_STEP 20
#define RGBLIGHT_ANIMATIONS
#define RGBLIGHT_EFFECT_SNAKE_LENGTH 6
#define RGBLIGHT_EFFECT_KNIGHT_LENGTH 2
#define RGBLIGHT_EFFECT_KNIGHT_OFFSET 6
#define RGBLIGHT_EFFECT_KNIGHT_LED_NUM 6
#define RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL 2000
#define RGBLIGHT_EFFECT_CHRISTMAS_STEP 1
#endif

// Enables tap magic
#define TAPPING_TERM 300
#define TAPPING_TOGGLE 1

/*
 * MIDI options
 */

/* Prevent use of disabled MIDI features in the keymap */
//#define MIDI_ENABLE_STRICT 1

/* enable basic MIDI features:
   - MIDI notes can be sent when in Music mode is on
*/

#define MIDI_BASIC

/* enable advanced MIDI features:
   - MIDI notes can be added to the keymap
   - Octave shift and transpose
   - Virtual sustain, portamento, and modulation wheel
   - etc.
*/
//#define MIDI_ADVANCED

/* override number of MIDI tone keycodes (each octave adds 12 keycodes and allocates 12 bytes) */
//#define MIDI_TONE_KEYCODE_OCTAVES 2

#endif

M keyboards/planck/keymaps/bbaserdem/keymap.c => keyboards/planck/keymaps/bbaserdem/keymap.c +23 -407
@@ 1,413 1,29 @@
/* Copyright 2015-2017 Jack Humbert
 *
 * 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/>.
/*
 * PLANCK - Dvorak turkish
 * Keymap by @bbaserdem
 * Dvorak layout with multiple features
 * Most of the code is in the "user" directory.
 * Check qmk_firmware/users/bbaserdem for the main part of the code
 */

#include "planck.h"

#define _______ KC_TRNS
#define XXX KC_NO

#define _DV 0
#define _TD 1
#define _GM 2
#define _MO 3
#define _SY 4
#define _FN 5
#define _MS 6

#define PARAN TD(PAR)
#define CURLY TD(CUR)
#define SQUAR TD(SQU)
#define ANGUL TD(ANG)

#define UNDO    LCTL(KC_Z)
#define REDO    LCTL(KC_Y)
#define COPYCUT TD(CPC)
#define PASTE   LCTL(KC_V)

#define MO_SC_U KC_MS_WH_UP
#define MO_SC_D KC_MS_WH_DOWN
#define MO_SC_L KC_MS_WH_LEFT
#define MO_SC_R KC_MS_WH_RIGHT
#define MO_U    KC_MS_UP
#define MO_D    KC_MS_DOWN
#define MO_L    KC_MS_LEFT
#define MO_R    KC_MS_RIGHT
#define MO_CL_L KC_MS_BTN1
#define MO_CL_R KC_MS_BTN2
#define MO_CL_M KC_MS_BTN3
#define MO_CL_1 KC_MS_BTN4
#define MO_CL_2 KC_MS_BTN5
#define MO_AC_0 KC_MS_ACCEL0
#define MO_AC_1 KC_MS_ACCEL1
#define MO_AC_2 KC_MS_ACCEL2

#define PHY_HB UC(0x0127)
#define PHY_DE UC(0xc2b0)
#define TUR_TL UC(0x20ba)
#define EUR_ER UC(0x20ac)
#define EUR_PN UC(0x00a3)

enum custom_keycodes {
    TUR_A = SAFE_RANGE,
    TUR_C,
    TUR_G,
    TUR_I,
    TUR_O,
    TUR_S,
    TUR_U,
    UNI_LI,
    UNI_WN
};

// Tap dance
enum {
    ATD = 0,
    CLS,
    SCL,
    QUO,
    PAR,
    CUR,
    SQU,
    ANG,
    CPC
};
#include "bbaserdem.h"

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

/* Dvorak
 * ,------------------------------------------------------------------------.
 * | Blt |  "  |  ,  |  .  |  P  |  Y  ||  F  |  G  |  C  |  R  |  L  | Bkp |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * | Esc |  A  |  O  |  E  |  U  |  I  ||  D  |  H  |  T  |  N  |  S  | Del |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |Sh\CL| ; : |  Q  |  J  |  K  |  X  ||  B  |  M  |  W  |  V  |  Z  |MOUSE|
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * | Ctl | Alt | Meta| Tab | SYM | Spc || Ent | FUN | Lft | Dwn |  Up | Rgt |
 * `------------------------------------------------------------------------'
 */
[_DV] = {
  {BL_STEP,TD(QUO),KC_COMM,KC_DOT, KC_P,   KC_Y,   KC_F,   KC_G,   KC_C,   KC_R,   KC_L,   KC_BSPC},
  {KC_ESC ,KC_A,   KC_O,   KC_E,   KC_U,   KC_I,   KC_D,   KC_H,   KC_T,   KC_N,   KC_S,   KC_DEL },
  {TD(CLS),TD(SCL),KC_Q,   KC_J,   KC_K,   KC_X,   KC_B,   KC_M,   KC_W,   KC_V,   KC_Z,   TT(_MO)},
  {KC_LCTL,TD(ATD),KC_LGUI,KC_TAB, TT(_SY),KC_SPC, KC_ENT, TT(_FN),KC_LEFT,KC_DOWN,KC_UP,  KC_RGHT}
},
[_TD] = {
  {_______,_______,_______,_______,_______,_______,_______, TUR_G, TUR_C,  _______,_______,_______},
  {_______, TUR_A,  TUR_O, _______, TUR_U,  TUR_I, _______, PHY_HB,_______,_______, TUR_S, _______},
  {_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______},
  {_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______}
},

/* Game layer
 * ,------------------------------------------------------------------------.
 * | OFF |  Q  |  W  |  E  |  R  |  T  ||  F1 |  F2 | Ctrl|  ^  |Shift| Esc |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |  ~  |  A  |  S  |  D  |  F  |  G  ||  F3 |  F4 |  <  |  v  |  >  |Enter|
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * | Shf |  Z  |  X  |  C  |  V  |  B  ||  F5 |  F6 |  ,  |  .  | / ? | Alt |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * | Alt | Ctrl| ` ~ | - _ |     | Spc || Spc |     |  1  |  2  |  3  |  4  |
 * `------------------------------------------------------------------------'
 */
[_GM] = {
  {TG(_GM),KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_F1,  KC_F2,  KC_RCTL,KC_UP,  KC_RSFT,KC_ESC },
  {KC_TAB, KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_F3,  KC_F4,  KC_LEFT,KC_DOWN,KC_RGHT,KC_ENT },
  {KC_LSFT,KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_F5,  KC_F6,  KC_COMM,KC_DOT, KC_SLSH,KC_RALT},
  {KC_LALT,KC_LCTL,KC_GRV, KC_MINS,_______,KC_SPC, KC_SPC, _______,KC_1,   KC_2,   KC_3,   KC_4   }
},

/* Mouse control layer
 * ,------------------------------------------------------------------------.
 * |     |.....|  ^  |.....|.....|Acc 2||.....|.....|.....| |^| |.....|     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |  <  |  v  |  >  |.....|Acc 1||.....|.....| <-- | |v| | --> |     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     | Left| Mid |Right|.....|Acc 0||.....|.....|Btn 4|.....|Btn 5|     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |     |     |     |     |     ||     |     |     |     |     |     |
 * `------------------------------------------------------------------------'
 */
[_MO] = {
  {TG(_MO),XXX,    MO_U,   XXX,    XXX,    MO_AC_2,XXX,    XXX,    XXX,    MO_SC_U,XXX,    _______},
  {_______,MO_L,   MO_D,   MO_R,   XXX,    MO_AC_1,XXX,    XXX,    MO_SC_L,MO_SC_D,MO_SC_R,_______},
  {_______,MO_CL_L,MO_CL_M,MO_CL_R,XXX,    MO_AC_0,XXX,    XXX,    MO_CL_1,XXX,    MO_CL_2,_______},
  {_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______}
},

/* Symbols layer
 * ,------------------------------------------------------------------------.
 * | OFF |  !  |  1  |  2  |  3  |  &  ||  =  |  +  |  -  |  *  |  %  |     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |  _  | ( ) |  4  |  5  |  6  |  \  ||  /  | [ ] | { } | < > |  |  |     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |degre|  ?  |  7  |  8  |  9  |  ~  ||  `  |  @  |  #  |  $  |  ^  |     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |     |     |  0  |     |     ||     |     |TLira| Euro|Pound|     |
 * `------------------------------------------------------------------------'
 */

[_SY] = {
  {TG(_SY),KC_EXLM,KC_1,   KC_2,   KC_3,   KC_AMPR,KC_EQL, KC_PLUS,KC_MINS,KC_ASTR,KC_PERC,_______},
  {KC_UNDS,PARAN,  KC_4,   KC_5,   KC_6,   KC_BSLS,KC_SLSH,SQUAR,  CURLY,  ANGUL,  KC_PIPE,_______},
  {PHY_DE, KC_QUES,KC_7,   KC_8,   KC_9,   KC_TILD,KC_GRV, KC_AT,  KC_HASH,KC_DLR, KC_CIRC,_______},
  {_______,_______,_______,KC_0,   _______,_______,_______,_______,TUR_TL, EUR_ER, EUR_PN, _______}
},

/* Function layer
 * ,------------------------------------------------------------------------.
 * | OFF | game|music|     |     |RESET||RESET| win | lin | wake|sleep|power|
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |  F1 |  F2 |  F3 |  F4 |  F5 |  F6 ||  F7 |  F8 |  F9 | F10 | F11 | F12 |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     | undo| redo|cutcp|paste|vol 0||prtsc| ins | rev.| stop| play| next|
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |     |     |     |     |vol -||vol +|     | home|pg dn|pg up| end |
 * `------------------------------------------------------------------------'
 */

[_FN] = {
  {TG(_FN),TG(_GM),MU_ON,  _______,_______,RESET,  RESET,  UNI_LI, UNI_WN ,KC_WAKE,KC_SLEP,KC_PWR },
  {KC_F1,  KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,  KC_F7,  KC_F8,  KC_F9,  KC_F10, KC_F11, KC_F12 },
  {_______,UNDO,   REDO,   COPYCUT,PASTE,  KC_MUTE,KC_PSCR,KC_INS, KC_MPRV,KC_MSTP,KC_MPLY,KC_MNXT},
  {_______,_______,_______,_______,_______,KC_VOLD,KC_VOLU,_______,KC_HOME,KC_PGDN,KC_PGUP,KC_END }
},

/* Music layer
 * ,-----------------------------------------------------------------------.
 * | OFF |rec S| stop| play|sped^|spedv|cycle|.....|.....|.....|.....|.....|
 * |-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----|
 * |.....|.....|.....|.....|.....|.....|.....|.....|.....|.....|.....|.....|
 * |-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----|
 * |.....|.....|.....|.....|.....|.....|.....|.....|.....|.....|.....|.....|
 * |-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----|
 * |.....|.....|.....|.....|.....|.....|.....|.....|.....|.....|.....|.....|
 * `-----------------------------------------------------------------------'
 */
[_MS] = {
    { MU_OFF, KC_LCTL, KC_LALT, KC_LGUI, KC_UP, KC_DOWN, MU_MOD, XXX, XXX, XXX, XXX, XXX },
    { XXX,    XXX,     XXX,     XXX,     XXX,   XXX,     XXX,    XXX, XXX, XXX, XXX, XXX },
    { XXX,    XXX,     XXX,     XXX,     XXX,   XXX,     XXX,    XXX, XXX, XXX, XXX, XXX },
    { XXX,    XXX,     XXX,     XXX,     XXX,   XXX,     XXX,    XXX, XXX, XXX, XXX, XXX }
}
};

// Set unicode method to linux.
void matrix_init_user(){
  set_unicode_input_mode(UC_LNX);
}

// User defined keys
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
    // This section is a bit tedious in VIM, so I shortened lines
  // Check for shift letter
  bool is_capital = ( keyboard_report->mods &
      (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT)) ) ^
      ( keyboard_report->mods & MOD_BIT(KC_CAPS) );
  switch (keycode) {
    // Add music layer to music functionality
    case MU_ON:
      if (record->event.pressed) { layer_on(_MS); }
      return true; break;
    case MU_OFF:
      if (record->event.pressed) { layer_off(_MS); }
      return true; break;
    // Turkish letters keycodes
    case TUR_A:
      if (record->event.pressed) {
        if ( is_capital ) {
            unicode_input_start(); register_hex(0x00c2); unicode_input_finish();
        } else {
            unicode_input_start(); register_hex(0x00e2); unicode_input_finish();
        }
      }
      return false; break;
    case TUR_U:
      if (record->event.pressed) {
        if ( is_capital ) {
            unicode_input_start(); register_hex(0x00dc); unicode_input_finish();
        } else {
            unicode_input_start(); register_hex(0x00fc); unicode_input_finish();
        }
      }
      return false; break;
    case TUR_I:
      if (record->event.pressed) {
        if ( is_capital ) {
            unicode_input_start(); register_hex(0x0130); unicode_input_finish();
        } else {
            unicode_input_start(); register_hex(0x0131); unicode_input_finish();
        }
      }
      return false; break;
    case TUR_O:
      if (record->event.pressed) {
        if ( is_capital ) {
            unicode_input_start(); register_hex(0x00d6); unicode_input_finish();
        } else {
            unicode_input_start(); register_hex(0x00f6); unicode_input_finish();
        }
      }
      return false; break;
    case TUR_S:
      if (record->event.pressed) {
        if ( is_capital ) {
            unicode_input_start(); register_hex(0x015e); unicode_input_finish();
        } else {
            unicode_input_start(); register_hex(0x015f); unicode_input_finish();
        }
      }
      return false; break;
    case TUR_G:
      if (record->event.pressed) {
        if ( is_capital ) {
            unicode_input_start(); register_hex(0x011e); unicode_input_finish();
        } else {
            unicode_input_start(); register_hex(0x011f); unicode_input_finish();
        }
      }
      return false; break;
    case TUR_C:
      if (record->event.pressed) {
        if ( is_capital ) {
            unicode_input_start(); register_hex(0x00c7); unicode_input_finish();
        } else {
            unicode_input_start(); register_hex(0x00e7); unicode_input_finish();
        }
      }
      return false; break;
    // Keys to change unicode mode
    case UNI_LI:
      if( record->event.pressed ) {
          set_unicode_input_mode(UC_LNX);
      }
      return false; break;
    case UNI_WN:
      if( record->event.pressed ) {
          set_unicode_input_mode(UC_WIN);
      }
      return false; break;
  }
  return true;
}

// Tap dance feature for the altgr implementation
void altgr_dvo_tap (qk_tap_dance_state_t *state, void *user_data) {
  if (state->count == 1) {
    register_code (KC_RALT);
  } else if (state->count == 2) {
    unregister_code (KC_RALT);
    layer_on(_TD);
  } else if (state->count == 3) {
      layer_off(_TD);
  }
}
void altgr_dvo_end (qk_tap_dance_state_t *state, void *user_data) {
  if (state->count == 1) {
      unregister_code (KC_RALT);
  } else if (state->count == 2) {
      layer_off(_TD);
  }
}

// Shift vs capslock function
void caps_tap (qk_tap_dance_state_t *state, void *user_data) {
    if (state->count == 1) {
        register_code (KC_LSFT);
    } else if (state->count == 2) {
        unregister_code (KC_LSFT);
        register_code (KC_CAPS);
    }
}
void caps_tap_end (qk_tap_dance_state_t *state, void *user_data) {
    if (state->count == 1) {
        unregister_code (KC_LSFT);
    } else {
        unregister_code (KC_CAPS);
    }
}

// Parantheses
void paranthesis_dance (qk_tap_dance_state_t *state, void *user_data) {
    if (state->count == 1) {
        SEND_STRING("()"); register_code(KC_LEFT); unregister_code(KC_LEFT);
        } else if (state->count == 2) {
            SEND_STRING("(");
        } else if (state->count == 3) {
            SEND_STRING(")");
    }
}
void curly_dance (qk_tap_dance_state_t *state, void *user_data) {
    if (state->count == 1) {
        SEND_STRING("{}"); register_code(KC_LEFT); unregister_code(KC_LEFT);
        } else if (state->count == 2) {
            SEND_STRING("{");
        } else if (state->count == 3) {
            SEND_STRING("}");
    }
}

void square_dance (qk_tap_dance_state_t *state, void *user_data) {
    if (state->count == 1) {
        SEND_STRING("[]"); register_code(KC_LEFT); unregister_code(KC_LEFT);
        } else if (state->count == 2) {
            SEND_STRING("[");
        } else if (state->count == 3) {
            SEND_STRING("]");
    }
}

void angular_dance (qk_tap_dance_state_t *state, void *user_data) {
    if (state->count == 1) {
        SEND_STRING("<>"); register_code(KC_LEFT); unregister_code(KC_LEFT);
        } else if (state->count == 2) {
            SEND_STRING("<");
        } else if (state->count == 3) {
            SEND_STRING(">");
    }
}

// Copy or cut feature
void copy_cut (qk_tap_dance_state_t *state, void *user_data) {
    if (state->count == 1) {
        register_code (KC_LCTL);
        register_code (KC_C);
        unregister_code (KC_C);
        unregister_code (KC_LCTL);
    } else if (state->count == 2) {
        register_code (KC_LCTL);
        register_code (KC_X);
        unregister_code (KC_X);
        unregister_code (KC_LCTL);
    }
}

// Tap dance feature
qk_tap_dance_action_t tap_dance_actions[] = {
    // Tap once for Left Ctrl, second one is momentory switch to layer TUR
     [ATD] = ACTION_TAP_DANCE_FN_ADVANCED( altgr_dvo_tap, NULL, altgr_dvo_end )
    // Advanced tap dance feature allows for immediate response to shift
    ,[CLS] = ACTION_TAP_DANCE_FN_ADVANCED( caps_tap, NULL, caps_tap_end )
    // Shifting for double quote and semicolon
    ,[SCL] = ACTION_TAP_DANCE_DOUBLE( KC_SCLN, KC_COLN )
    ,[QUO] = ACTION_TAP_DANCE_DOUBLE( KC_QUOT, KC_DQUO )
    // Tap dances for paranthesis, which sends macros
    ,[PAR] = ACTION_TAP_DANCE_FN_ADVANCED( NULL, NULL, paranthesis_dance )
    ,[CUR] = ACTION_TAP_DANCE_FN_ADVANCED( NULL, NULL, curly_dance )
    ,[SQU] = ACTION_TAP_DANCE_FN_ADVANCED( NULL, NULL, square_dance )
    ,[ANG] = ACTION_TAP_DANCE_FN_ADVANCED( NULL, NULL, angular_dance )
    // Tap dance for copy/cutting
    ,[CPC] = ACTION_TAP_DANCE_FN( copy_cut )
    // Main Dvorak layer
    [_DV] = DVORAK,
    // Turkish and special character overlay
    [_AL] = ALTCHAR,
    // Gaming layer
    [_GA] = GAME,
    // Numbers layer
    [_NU] = NUMBERS,
    // Settings layer
    [_SE] = SETTINGS,
    // Mouse emulation layer
    [_MO] = MOUSE,
#ifdef MUSIC_ENABLE
    // Music mode
    [_MU] = MUSIC,
#endif
};

M keyboards/planck/keymaps/bbaserdem/rules.mk => keyboards/planck/keymaps/bbaserdem/rules.mk +5 -17
@@ 1,22 1,10 @@
# Build options

# ENABLE
TAP_DANCE_ENABLE = yes
UNICODE_ENABLE = yes
MOUSEKEY_ENABLE = yes
EXTRAKEY_ENABLE = yes
NKRO_ENABLE = yes
BACKLIGHT_ENABLE = yes
AUDIO_ENABLE = yes

# DISABLE
BOOTMAGIC_ENABLE = no
MIDI_ENABLE = no

# Not for planck
RGBLIGHT_ENABLE = no #Clashes with audio
BLUETOOTH_ENABLE = no #No bluetooth
SLEEP_LED_ENABLE = no #Uses BACKLIGHT_ENABLE rimer
BACKLIGHT_ENABLE = yes		# Switch LEDs
MOUSEKEY_ENABLE = yes		# Emulates mouse key using keypresses
RGBLIGHT_ENABLE = yes 		# LED strips
TAP_DANCE_ENABLE = no 		# Use multi-tap features
AUDIO_ENABLE = no			# Audio stuff

ifndef QUANTUM_DIR
	include ../../../../Makefile

A keyboards/xd75/keymaps/bbaserdem/config.h => keyboards/xd75/keymaps/bbaserdem/config.h +22 -0
@@ 0,0 1,22 @@
/* Copyright 2017 REPLACE_WITH_YOUR_NAME
 *
 * 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/>.
 */

#ifndef CONFIG_USER_H
#define CONFIG_USER_H

#include "../../config.h"

#endif

A keyboards/xd75/keymaps/bbaserdem/keymap.c => keyboards/xd75/keymaps/bbaserdem/keymap.c +80 -0
@@ 0,0 1,80 @@
#include "xd75.h"
#include "bbaserdem.h"

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Layout
 * ,-----------------------------------------------------------.
 * |Blt|Lck| ` | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | - | = |
 * |---+---+-----------------------------------------------+---|
 * |Int|Trm|                                               |Cps|
 * |---+---|                                               |---|
 * |Clc|Psw|                                               | \ |
 * |---+---|                    PLANCK                     |---|
 * |Rev|Ffw|                                               | [ |
 * |---+---|                                               |---|
 * |Tog|Mut|                                               | ] |
 * `-----------------------------------------------------------'
 */
[_DV] = KM(
    BL_STEP, LGUI(KC_ESC), KC_GRV,KC_1,KC_2,KC_3,KC_4,KC_5,KC_6,KC_7,KC_8,KC_9,KC_0,KC_MINS,KC_EQL,
    KC_WHOM, LGUI(KC_ENT), DVORAK_1, KC_CAPS,
    KC_CALC, LGUI(KC_P),   DVORAK_2, KC_BSLS,
    KC_MPRV, KC_MNXT,      DVORAK_3, KC_LBRC,
    KC_MPLY, KC_MUTE,      DVORAK_4, KC_RBRC ),

[_AL] = KM(
    _______,_______,_______,_______,_______,_______,
    _______,_______,_______,_______,_______,_______,
    _______,_______,_______,
    _______,_______, ALTCHAR_1, _______,
    _______,_______, ALTCHAR_2, _______,
    _______,_______, ALTCHAR_3, _______,
    _______,_______, ALTCHAR_4, _______ ),

[_GA] = KM(
    _______,_______,_______,_______,_______,_______,
    _______,_______,_______,_______,_______,_______,
    _______,_______,_______,
    _______,_______, GAME_1, _______,
    _______,_______, GAME_2, _______,
    _______,_______, GAME_3, _______,
    _______,_______, GAME_4, _______ ),

[_NU] = KM(
    _______,_______,_______,_______,_______,_______,
    _______,_______,_______,_______,_______,_______,
    _______,_______,_______,
    _______,_______, NUMBERS_1, _______,
    _______,_______, NUMBERS_2, _______,
    _______,_______, NUMBERS_3, _______,
    _______,_______, NUMBERS_4, _______ ),

[_SE] = KM(
    _______,_______,_______,_______,_______,_______,
    _______,_______,_______,_______,_______,_______,
    _______,_______,_______,
    _______,_______, SETTINGS_1, _______,
    _______,_______, SETTINGS_2, _______,
    _______,_______, SETTINGS_3, _______,
    _______,_______, SETTINGS_4, _______ ),

[_MO] = KM(
    _______,_______,_______,_______,_______,_______,
    _______,_______,_______,_______,_______,_______,
    _______,_______,_______,
    _______,_______, MOUSE_1, _______,
    _______,_______, MOUSE_2, _______,
    _______,_______, MOUSE_3, _______,
    _______,_______, MOUSE_4, _______ ),

#ifdef AUDIO_ENABLE
[_MU] = KM(
    XXX, XXX, MASK,     XXX,
    XXX, XXX, MASK,     XXX,
    XXX, XXX, MASK,     XXX,
    XXX, XXX, MASK,     XXX,
    XXX, XXX, MUSIC_4,  XXX ),
#endif

};


A keyboards/xd75/keymaps/bbaserdem/readme.md => keyboards/xd75/keymaps/bbaserdem/readme.md +12 -0
@@ 0,0 1,12 @@
# XD75RE Setup

This layout is the xd75re layout, inspired by my planck keymap.
Contains some code from the original keymap here, but had to be modded.

# Make

Take the board into reset mode, then
```
make xd75:bbaserdem:dfu
```
Either sudo it or set permissions in udev.

A keyboards/xd75/keymaps/bbaserdem/rules.mk => keyboards/xd75/keymaps/bbaserdem/rules.mk +10 -0
@@ 0,0 1,10 @@
# Build options
BACKLIGHT_ENABLE = yes		# Switch LEDs
MOUSEKEY_ENABLE = yes		# Emulates mouse key using keypresses
RGBLIGHT_ENABLE = no 		# LED strips
TAP_DANCE_ENABLE = no 		# Use multi-tap features
AUDIO_ENABLE = no  			# Audio stuff

ifndef QUANTUM_DIR
	include ../../../../Makefile
endif

A users/bbaserdem/README.md => users/bbaserdem/README.md +49 -0
@@ 0,0 1,49 @@
# Overview

I have mostly ortholinear keyboards, which share a lot of functions.
For this purpose, I collected them here.

I have the following keymaps:

* Gherkin (Does not use the user space)
* Let's Split
* Let's Split It Up
* Planck

# Layout

I use DVORAK with an unorthodox Turkish layout.
If you wanna grab my code, andused a previous layout with a persistent base
layer change, change it to layer 0 before proceeding.

# Layers

* **Dvorak**: Base layer,withdvorak layout.
* **Alternative**: Has alternate characters.
* **Game**: Toggled from *Function*, comfortable for gaming use.
* **Numeric**: Has numericals and symbols. Can be locked.
* **Function**: Layer has media and function keys.
* **Mouse**: Manipulates mouse. Can be locked.
* **Music** Allows playing sounds like a keyboard.

# Functionality

* **RGB Backlight**: With layer indication, and ability to change base layer lighting mode.
* **Secrets**: By placing a secrets.h, and not tracking it, you can store passwords etc.
* **Mouse**: Mouse emulation, complete with diagonal keys.
* **Turkish**: An AltGr-like overlay that allows some non-common letters, in unicode.

I suggest checking out how I enabled shifting for Turkish layer,
how I planned out RGB lighting, and my mouse implementation; they might offer
some insight into fringe user cases.

# Issues

All features are too big for the 32kB bootloader.
Offenders are audio and rgb lights; it comes down to one or the other.
~The Proton board, and rev 6 should fix that.~

# Credits

I have previously written my keymap by myself before, but I rewrote it here,
heavily inspired by @drashna's user folder.

A users/bbaserdem/bbaserdem.c => users/bbaserdem/bbaserdem.c +651 -0
@@ 0,0 1,651 @@
#include "bbaserdem.h"

/*---------------*\
|*-----MOUSE-----*|
\*---------------*/
#ifdef MOUSEKEY_ENABLE
#include "mousekey.h"
#endif

/*-------------*\
|*-----RGB-----*|
\*-------------*/
#ifdef RGBLIGHT_ENABLE
#include "rgblight.h"
#endif

/*-----------------*\
|*-----SECRETS-----*|
\*-----------------*/
// Enabled by adding a non-tracked secrets.h to this dir.
#if (__has_include("secrets.h"))
#include "secrets.h"
#endif

/*---------------*\
|*-----MUSIC-----*|
\*---------------*/
#ifdef AUDIO_ENABLE
float tone_game[][2]    = SONG(ZELDA_PUZZLE);
float tone_return[][2]  = SONG(ZELDA_TREASURE);
float tone_linux[][2]   = SONG(UNICODE_LINUX);
float tone_windows[][2] = SONG(UNICODE_WINDOWS);
#endif

/*-------------------*\
|*-----TAP-DANCE-----*|
\*-------------------*/
#ifdef TAP_DANCE_ENABLE
qk_tap_dance_action_t tap_dance_actions[] = {
    // Shift on double tap of semicolon
    [SCL] = ACTION_TAP_DANCE_DOUBLE( KC_SCLN, KC_COLN )
};
#endif

/* In keymaps, instead of writing _user functions, write _keymap functions
 * The __attribute__((weak)) allows for empty definitions here, and during
 * compilation, if these functions are defined elsewhere, they are written
 * over. This allows to include custom code from keymaps in the generic code
 * in this file.
 */
__attribute__ ((weak)) void matrix_init_keymap(void) { }
__attribute__ ((weak)) void matrix_scan_keymap(void) { }
__attribute__ ((weak)) bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
    return true;
}
__attribute__ ((weak)) uint32_t layer_state_set_keymap (uint32_t state) {
    return state;
}
__attribute__ ((weak)) void led_set_keymap(uint8_t usb_led) { }

/* ----------------------- *\
 * -----RGB Functions----- *
\* ----------------------- */


#ifdef RGBLIGHT_ENABLE
// Storage variables
extern  rgblight_config_t rgblight_config;
bool    base_sta;   // Keeps track if in saveable state
bool    base_tog;   // Whether base state is active or not
int     base_hue;   // Hue value of base state
int     base_sat;   // Saturation value of base state
int     base_val;   // Brightness value of base state
uint8_t base_mod;   // Animation mode of the base state

// Save the current state of the rgb mode
void rgblight_saveBase(void) {
    base_hue = rgblight_config.hue;
    base_sat = rgblight_config.sat;
    base_val = rgblight_config.val;
    base_mod = rgblight_config.mode;
    base_tog = rgblight_config.enable;
    base_sta = false;   // If saving, that means base layer is being left
}

// Load the base state back 
void rgblight_loadBase(void) {
    // Don't do anything if not enabled
    if ( !base_sta ) {
        if ( base_tog ) {
            rgblight_enable();
            rgblight_mode( base_mod );
            rgblight_sethsv( base_hue, base_sat, base_val );
        } else {
            rgblight_disable();
        }
    }
    // Mark that base is loaded, and to be saved before leaving
    base_sta = true;
}

// Set to plain HSV color
void rgblight_colorStatic( int hu, int sa, int va ) {
    // First, it must be enabled or color change is not written
    rgblight_enable();
    rgblight_mode(1);
    rgblight_sethsv(hu,sa,va);
}
/* HSV values, thank you @drashna!
 * white        (  0,   0, 255)
 * red          (  0, 255, 255)
 * coral        ( 16, 176, 255)
 * orange       ( 39, 255, 255)
 * goldenrod    ( 43, 218, 218)
 * gold         ( 51, 255, 255)
 * yellow       ( 60, 255, 255)
 * chartreuse   ( 90, 255, 255)
 * green        (120, 255, 255)
 * springgreen  (150, 255, 255)
 * turquoise    (174,  90, 112)
 * teal         (180, 255, 128)
 * cyan         (180, 255, 255)
 * azure        (186, 102, 255)
 * blue         (240, 255, 255)
 * purple       (270, 255, 255)
 * magenta      (300, 255, 255)
 * pink         (330, 128, 255)
 */
// Set RGBLIGHT state depending on layer
void rgblight_change( uint8_t last_layer ) {
    // Save state, if saving is requested
    /*
    if ( base_sta ) {
        rgblight_saveBase();
    }
    */
    // Change RGB light
    switch ( last_layer ) {
        case _DV:
            // Load base layer
            rgblight_loadBase();
            break;
        case _AL:
            // Do yellow for alternate
            rgblight_colorStatic( 60,255,255);
            break;
        case _GA:
            // Do purple for game
            rgblight_colorStatic(285,255,255);
            break;
        case _NU:
            // Do azure for number
            rgblight_colorStatic(186,200,255);
            break;
        case _SE:
            // Do red for settings
            rgblight_colorStatic( 16,255,255);
            break;
        case _MO:
            // Do green for mouse
            rgblight_colorStatic(120,255,255);
            break;
#ifdef AUDIO_ENABLE
        case _MU:
            // Do orange for music
            rgblight_colorStatic( 39,255,255);
            break;
#endif
        default:
            // Something went wrong
            rgblight_colorStatic(  0,255,255);
            break;
    }
}

#endif

/*---------------------*\
|*-----MATRIX INIT-----*|
\*---------------------*/
void matrix_init_user (void) {

    // Keymap specific things, do it first thing to allow for delays etc
    matrix_init_keymap();

    // Correct unicode
    set_unicode_input_mode(UC_LNX);

    // Make beginning layer DVORAK
    set_single_persistent_default_layer(_DV);

//--RGB light initialize base layer
#ifdef RGBLIGHT_ENABLE
    // Base hue is white, and RGB disabled
    base_hue = 100;
    base_sat = 0;
    base_val = 255;
    base_mod = 2;
    base_tog = false;
    rgblight_enable();
    rgblight_mode(base_mod);
    rgblight_sethsv(base_hue,base_sat,base_val);
    rgblight_disable();
    rgblight_loadBase();
#endif

}

/*---------------------*\
|*-----MATRIX SCAN-----*|
\*---------------------*/
void matrix_scan_user (void) {
    // Keymap specific, do it first
    matrix_scan_keymap();
    // Moved RGB check to layer_state_set_user
}

/*------------------*\
|*-----KEYCODES-----*|
\*------------------*/
bool process_record_user(uint16_t keycode, keyrecord_t *record) {

    // Shift check
    bool is_capital = ( keyboard_report->mods & (MOD_BIT(KC_LSFT)|MOD_BIT(KC_RSFT)) );
    static bool lock_flag = false;
    uint8_t layer = biton32 (layer_state);

    switch (keycode) {
        // Secrets implementation
        case SECRET1 ... SECRET3:
#if (__has_include("secrets.h"))
            if( !record->event.pressed ) {
                send_string_P( secret[ keycode - SECRET1 ] );
            }
#endif
            return false;
            break;
        // If these keys are pressed, load base layer config, and mark saving
        case RGB_TOG:
        case RGB_MOD:
        case RGB_VAI:
        case RGB_VAD:
        case RGB_SAI:
        case RGB_SAD:
        case RGB_HUI:
        case RGB_HUD:
#ifdef RGBLIGHT_ENABLE
            if ( !base_sta ) {
                rgblight_loadBase(); 
            }
#endif
            return true;
            break;

        // Lock functionality: These layers are locked if the LOCKED buttons are
        // pressed. Otherwise, they are momentary toggles
        case K_LOCK:
            if (record->event.pressed) {
                lock_flag = !lock_flag;
            }
            return false;
            break;
        case K_MOUSE:
#ifdef MOUSEKEY_ENABLE
            if (record->event.pressed) {
                layer_on(_MO);
                lock_flag = false;
            } else {
                if ( lock_flag ) {
                    lock_flag = false;
                } else {
                    layer_off(_MO);
                }
            }
#endif
            return false;
            break;
        case K_NUMBR:
            if (record->event.pressed) {
                layer_on(_NU);
                lock_flag = false;
            } else {
                if ( lock_flag ) {
                    lock_flag = false;
                } else {
                    layer_off(_NU);
                }
            }
            return false;
            break;
            
        // Layer switches with sound
        case K_GAMES:
            if (record->event.pressed) {
                // On press, turn off layer if active
                if ( layer == _GA ) {
#ifdef AUDIO_ENABLE
                    stop_all_notes();
                    PLAY_SONG(tone_return);
#endif
                    layer_off(_GA);
                }
            } else {
                // After click, turn on layer if accessed from setting
                if ( layer == _SE ) {
#ifdef AUDIO_ENABLE
                    stop_all_notes();
                    PLAY_SONG(tone_game);
#endif
                    layer_on(_GA);
                    layer_off(_SE);
                }
            }
            return false;
            break;
        case MU_TOG:
#ifdef AUDIO_ENABLE
            if (record->event.pressed) {
                // On press, turn off layer if active
                if ( layer == _SE ) {
                    layer_off(_SE);
                    layer_on(_MU);
                } else {
                    layer_off(_MU);
                }
            }
#endif
            return true;
            break;

//------UNICODE
        // Unicode switches with sound
        case UNI_LI:
#ifdef UNICODE_ENABLE
            if (record->event.pressed) {
#ifdef AUDIO_ENABLE
                stop_all_notes();
                PLAY_SONG(tone_linux);
#endif
                set_unicode_input_mode(UC_LNX);
            }
#endif
            return false;
            break;
        case UNI_WN:
#ifdef UNICODE_ENABLE
            if (record->event.pressed) {
#ifdef AUDIO_ENABLE
                stop_all_notes();
                PLAY_SONG(tone_windows);
#endif
                set_unicode_input_mode(UC_WIN);
            }
#endif
            return false;
            break;

        // Turkish letters, with capital functionality
        case TUR_A:
#ifdef UNICODE_ENABLE
            if (record->event.pressed) {
                if ( is_capital ) {
                    unicode_input_start();
                    register_hex(0x00c2);
                    unicode_input_finish();
                } else {
                    unicode_input_start();
                    register_hex(0x00e2);
                    unicode_input_finish();
                }
            }
#endif
            return false;
            break;
        case TUR_O:
#ifdef UNICODE_ENABLE
            if (record->event.pressed) {
                if ( is_capital ) {
                    unicode_input_start();
                    register_hex(0x00d6);
                    unicode_input_finish();
                } else {
                    unicode_input_start();
                    register_hex(0x00f6);
                    unicode_input_finish();
                }
            }
#endif
            return false;
            break;
        case TUR_U:
#ifdef UNICODE_ENABLE
            if (record->event.pressed) {
                if ( is_capital ) {
                    unicode_input_start();
                    register_hex(0x00dc);
                    unicode_input_finish();
                } else {
                    unicode_input_start();
                    register_hex(0x00fc);
                    unicode_input_finish();
                }
            }
#endif
            return false;
            break;
        case TUR_I:
#ifdef UNICODE_ENABLE
            if (record->event.pressed) {
                if ( is_capital ) {
                    unicode_input_start();
                    register_hex(0x0130);
                    unicode_input_finish();
                } else {
                    unicode_input_start();
                    register_hex(0x0131);
                    unicode_input_finish();
                }
            }
#endif
            return false;
            break;
        case TUR_G:
#ifdef UNICODE_ENABLE
            if (record->event.pressed) {
                if ( is_capital ) {
                    unicode_input_start();
                    register_hex(0x011e);
                    unicode_input_finish();
                } else {
                    unicode_input_start();
                    register_hex(0x011f);
                    unicode_input_finish();
                }
            }
#endif
            return false;
            break;
        case TUR_C:
#ifdef UNICODE_ENABLE
            if (record->event.pressed) {
                if ( is_capital ) {
                    unicode_input_start();
                    register_hex(0x00c7);
                    unicode_input_finish();
                } else {
                    unicode_input_start();
                    register_hex(0x00e7);
                    unicode_input_finish();
                }
            }
#endif
            return false;
            break;
        case TUR_S:
#ifdef UNICODE_ENABLE
            if (record->event.pressed) {
                if ( is_capital ) {
                    unicode_input_start();
                    register_hex(0x015e);
                    unicode_input_finish();
                } else {
                    unicode_input_start();
                    register_hex(0x015f);
                    unicode_input_finish();
                }
            }
#endif
            return false;
            break;

//-------Diagonal mouse movements
        case MO_NE:
#ifdef MOUSEKEY_ENABLE
            if( record->event.pressed ) {
                mousekey_on(MO_N);
                mousekey_on(MO_E);
                mousekey_send();
            } else {
                mousekey_off(MO_N);
                mousekey_off(MO_E);
                mousekey_send();
            }
#endif
            return false;
            break;
        case MO_NW:
#ifdef MOUSEKEY_ENABLE
            if( record->event.pressed ) {
                mousekey_on(MO_N);
                mousekey_on(MO_W);
                mousekey_send();
            } else {
                mousekey_off(MO_N);
                mousekey_off(MO_W);
                mousekey_send();
            }
#endif
            return false;
            break;
        case MO_SE:
#ifdef MOUSEKEY_ENABLE
            if( record->event.pressed ) {
                mousekey_on(MO_S);
                mousekey_on(MO_E);
                mousekey_send();
            } else {
                mousekey_off(MO_S);
                mousekey_off(MO_E);
                mousekey_send();
            }
#endif
            return false;
            break;
        case MO_SW:
#ifdef MOUSEKEY_ENABLE
            if( record->event.pressed ) {
                mousekey_on(MO_S);
                mousekey_on(MO_W);
                mousekey_send();
            } else {
                mousekey_off(MO_S);
                mousekey_off(MO_W);
                mousekey_send();
            }
#endif
            return false;
            break;
        case MO_S_NE:
#ifdef MOUSEKEY_ENABLE
            if( record->event.pressed ) {
                mousekey_on(MO_S_N);
                mousekey_on(MO_S_E);
                mousekey_send();
            } else {
                mousekey_off(MO_S_N);
                mousekey_off(MO_S_E);
                mousekey_send();
            }
#endif
            return false;
            break;
        case MO_S_NW:
#ifdef MOUSEKEY_ENABLE
            if( record->event.pressed ) {
                mousekey_on(MO_S_N);
                mousekey_on(MO_S_W);
                mousekey_send();
            } else {
                mousekey_off(MO_S_N);
                mousekey_off(MO_S_W);
                mousekey_send();
            }
#endif
            return false;
            break;
        case MO_S_SE:
#ifdef MOUSEKEY_ENABLE
            if( record->event.pressed ) {
                mousekey_on(MO_S_S);
                mousekey_on(MO_S_E);
                mousekey_send();
            } else {
                mousekey_off(MO_S_S);
                mousekey_off(MO_S_E);
                mousekey_send();
            }
#endif
            return false;
            break;
        case MO_S_SW:
#ifdef MOUSEKEY_ENABLE
            if( record->event.pressed ) {
                mousekey_on(MO_S_S);
                mousekey_on(MO_S_W);
                mousekey_send();
            } else {
                mousekey_off(MO_S_S);
                mousekey_off(MO_S_W);
                mousekey_send();
            }
#endif
            return false;
            break;
//------DOUBLE PRESS, with added left navigation
        case DBL_SPC:
            if( record->event.pressed ) {
                SEND_STRING("  "SS_TAP(X_LEFT));
            }
            return false;
            break;
        case DBL_ANG:
            if( record->event.pressed ) {
                SEND_STRING("<>"SS_TAP(X_LEFT));
            }
            return false;
            break;
        case DBL_PAR:
            if( record->event.pressed ) {
                SEND_STRING("()"SS_TAP(X_LEFT));
            }
            return false;
            break;
        case DBL_SQR:
            if( record->event.pressed ) {
                SEND_STRING("[]"SS_TAP(X_LEFT));
            }
            return false;
            break;
        case DBL_BRC:
            if( record->event.pressed ) {
                SEND_STRING("{}"SS_TAP(X_LEFT));
            }
            return false;
            break;
        case DBL_QUO:
            if( record->event.pressed ) {
                SEND_STRING("\'\'"SS_TAP(X_LEFT));
            }
            return false;
            break;
        case DBL_DQT:
            if( record->event.pressed ) {
                SEND_STRING("\"\""SS_TAP(X_LEFT));
            }
            return false;
            break;
        case DBL_GRV:
            if( record->event.pressed ) {
                SEND_STRING("``"SS_TAP(X_LEFT));
            }
            return false;
            break;
// END OF KEYCODES
    }
    return process_record_keymap(keycode, record);
}

/*----------------------*\
|*-----LAYER CHANGE-----*|
\*----------------------*/

uint32_t layer_state_set_user(uint32_t state) {

    state = layer_state_set_keymap (state);
#ifdef RGBLIGHT_ENABLE
    // Change RGB lighting depending on the last layer activated
    rgblight_change( biton32(state) );
#endif
    return state;
}

A users/bbaserdem/bbaserdem.h => users/bbaserdem/bbaserdem.h +279 -0
@@ 0,0 1,279 @@
#ifndef USERSPACE
#define USERSPACE

#include "quantum.h"

// Use 7 wide characters for keymaps
#define _______ KC_TRNS
#define XXX     KC_NO

// Layers
#define _DV 0 // Base layer
#define _AL 1 // Alt char overlay
#define _GA 2 // Game layer
#define _NU 3 // Numbers layer
#define _SE 4 // Settings layer
#define _MO 5 // Mouse emulation
#define _MU 6 // Music mode

// Define short macros
#define UNDO    LCTL(KC_Z)
#define REDO    LCTL(KC_Y)
#define COPY    LCTL(KC_C)
#define CUT     LCTL(KC_X)
#define PASTE   LCTL(KC_V)

// Rename mouse keys
#ifdef MOUSEKEY_ENABLE
#define MO_S_N  KC_MS_WH_UP
#define MO_S_S  KC_MS_WH_DOWN
#define MO_S_E  KC_MS_WH_RIGHT
#define MO_S_W  KC_MS_WH_LEFT
#define MO_N    KC_MS_UP
#define MO_S    KC_MS_DOWN
#define MO_E    KC_MS_RIGHT
#define MO_W    KC_MS_LEFT
#define MO_CL_L KC_MS_BTN1
#define MO_CL_R KC_MS_BTN2
#define MO_CL_M KC_MS_BTN3
#define MO_CL_4 KC_MS_BTN4
#define MO_CL_5 KC_MS_BTN5
#define MO_AC_0 KC_MS_ACCEL0
#define MO_AC_1 KC_MS_ACCEL1
#define MO_AC_2 KC_MS_ACCEL2
#else
#define MO_S_N  KC_NO
#define MO_S_S  KC_NO
#define MO_S_E  KC_NO
#define MO_S_W  KC_NO
#define MO_N    KC_NO
#define MO_S    KC_NO
#define MO_E    KC_NO
#define MO_W    KC_NO
#define MO_CL_L KC_NO
#define MO_CL_R KC_NO
#define MO_CL_M KC_NO
#define MO_CL_1 KC_NO
#define MO_CL_2 KC_NO
#define MO_AC_0 KC_NO
#define MO_AC_1 KC_NO
#define MO_AC_2 KC_NO
#endif

// Define non-capitalized UTF shortcuts here
#ifdef UNICODE_ENABLE
#define PHY_HBR UC(0x0127)
#define PHY_DEG UC(0x00b0)
#define CUR_LIR UC(0x20ba)
#define CUR_BIT UC(0x20bf)
#define CUR_EUR UC(0x20ac)
#define CUR_BPN UC(0x00a3)
#define CUR_YEN UC(0x00a5)
#else
#define PHY_HBR KC_NO
#define PHY_DEG KC_NO
#define CUR_LIR KC_NO
#define CUR_BIT KC_NO
#define CUR_EUR KC_NO
#define CUR_BPN KC_NO
#define CUR_YEN KC_NO
#endif

// Make only KC_NO be grabbed by music mode
#ifdef AUDIO_ENABLE
#define MUSIC_MASK keycode == XXX
#endif

// Custom keycodes
enum userspace_custom_keycodes {
    // Turkish letters, with shifting
    TUR_A = SAFE_RANGE,
    TUR_C,
    TUR_G,
    TUR_I,
    TUR_O,
    TUR_S,
    TUR_U,
    // Unicode mode switch
    UNI_LI,
    UNI_WN,
    // Double keys
    DBL_SPC,
    DBL_ANG,
    DBL_PAR,
    DBL_SQR,
    DBL_BRC,
    DBL_QUO,
    DBL_DQT,
    DBL_GRV,
    // Diagonal mouse movements
    MO_NE,
    MO_NW,
    MO_SE,
    MO_SW,
    MO_S_NE,
    MO_S_NW,
    MO_S_SE,
    MO_S_SW,
    // Layer switches and lock functionality
    K_MOUSE,
    K_NUMBR,
    K_LOCK,
    K_GAMES,
    // Secret macros
    SECRET1,
    SECRET2,
    SECRET3
};

// Do tap dancable semicolon key if available
#ifdef TAP_DANCE_ENABLE
#define TAPPING_TERM 300
#define TAPPING_TOGGLE 1
enum {
    SCL = 0
};
#define MY_SCL  TD(SCL)
#else
#define MY_SCL  KC_SCLN
#endif

// Shared keymaps
#define KM(...) KEYMAP(__VA_ARGS__) // Required to expand the CSVs

/* Dvorak
 * ,------------------------------------------------------------------------.
 * | Esc | ' " |  ,  |  .  |  P  |  Y  ||  F  |  G  |  C  |  R  |  L  | Bkp |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * | Tab |  A  |  O  |  E  |  U  |  I  ||  D  |  H  |  T  |  N  |  S  | / ? |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * | SYM | ; : |  Q  |  J  |  K  |  X  ||  B  |  M  |  W  |  V  |  Z  | SET |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * | TUR | OS  | Ctrl| Alt | Shf | Spc || Ent | Lft | Dwn |  Up | Rght| MSE |
 * `------------------------------------------------------------------------' */
#define DVORAK_1 \
    KC_ESC, KC_QUOT,KC_COMM,KC_DOT, KC_P,   KC_Y,   KC_F,   KC_G,   KC_C,   KC_R,   KC_L,   KC_BSPC
#define DVORAK_2 \
    KC_TAB, KC_A,   KC_O,   KC_E,   KC_U,   KC_I,   KC_D,   KC_H,   KC_T,   KC_N,   KC_S,   KC_SLSH
#define DVORAK_3 \
    K_NUMBR,MY_SCL, KC_Q,   KC_J,   KC_K,   KC_X,   KC_B,   KC_M,   KC_W,   KC_V,   KC_Z,   MO(_SE)
#define DVORAK_4 \
    MO(_AL),KC_LGUI,KC_LCTL,KC_LALT,KC_LSFT,KC_SPC, KC_ENT, KC_LEFT,KC_DOWN,KC_RGHT,KC_UP,  K_MOUSE
#define DVORAK KM(DVORAK_1,DVORAK_2,DVORAK_3,DVORAK_4)

/* Alternative character overlay
 * ,------------------------------------------------------------------------.
 * |     | ' ' | Undo| Redo|Pound| Yen ||     |  G  |  C  |     |TLira| Del |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |  A  |  O  | Euro|  U  |  I  ||Degre|Plank|     |     |  S  | Ins |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     | " " | Cut | Copy|Paste|     || BTC | < > | ( ) | [ ] | { } | PgUp|
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |     |     |     |     |     ||     | Home|PgDwn| PgUp| End |     |
 * `------------------------------------------------------------------------' */
#define ALTCHAR_1 \
    _______,DBL_QUO,UNDO,   REDO,   CUR_BPN,CUR_YEN,_______,TUR_G,  TUR_C,  _______,CUR_LIR,KC_DEL
#define ALTCHAR_2 \
    _______,TUR_A,  TUR_O,  CUR_EUR,TUR_U,  TUR_I,  PHY_DEG,PHY_HBR,_______,_______,TUR_S,  KC_INS
#define ALTCHAR_3 \
    _______,DBL_DQT,CUT,    COPY,   PASTE,  _______,CUR_BIT,DBL_ANG,DBL_PAR,DBL_SQR,DBL_BRC,_______
#define ALTCHAR_4 \
    _______,_______,_______,_______,_______,_______,_______,KC_HOME,KC_PGDN,KC_PGUP,KC_END,_______
#define ALTCHAR KM(ALTCHAR_1,ALTCHAR_2,ALTCHAR_3,ALTCHAR_4)

/* Game layer
 * ,------------------------------------------------------------------------.
 * | OFF |  Q  |  W  |  E  |  R  |  T  || Esc |  7  |  8  |  9  |NumLk|Bkspc|
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * | Tab |  A  |  S  |  D  |  F  |  G  ||  F1 |  4  |  5  |  6  |  \  | Ent |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |  Z  |  X  |  C  |  V  |  B  ||  F2 |  1  |  2  |  3  |  ^  |     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |  /  |  `  |     |     |     | Spc || Spc | Ent |  0  |  <  |  v  |  >  |
 * `------------------------------------------------------------------------' */
#define GAME_1 \
    K_GAMES,KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_ESC, KC_P7,  KC_P8,  KC_P9,  KC_NLCK,KC_BSPC
#define GAME_2 \
    KC_TAB, KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_F1,  KC_P4,  KC_P5,  KC_P6,  KC_BSLS,KC_ENT 
#define GAME_3 \
    _______,KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_F2,  KC_P1,  KC_P2,  KC_P3,  KC_UP,  _______
#define GAME_4 \
    KC_SLSH,KC_GRV, _______,_______,_______,KC_SPC, KC_SPC, KC_ENT, KC_P0,  KC_LEFT,KC_DOWN,KC_RGHT
#define GAME KM(GAME_1,GAME_2,GAME_3,GAME_4)

/* Symbols layer
 * ,------------------------------------------------------------------------.
 * | OFF |  `  |  ~  |  [  |  ]  |  {  ||  }  |  -  |  _  |  =  |  +  |     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |  1  |  2  |  3  |  4  |  5  ||  6  |  7  |  8  |  9  |  0  |  \  |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |  !  |  @  |  #  |  $  |  %  ||  ^  |  &  |  *  |  (  |  )  | LCK |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |  |  |     |     |  |  |     |     ||     |     |     |     |     |     |
 * `------------------------------------------------------------------------' */
#define NUMBERS_1 \
    K_NUMBR,KC_GRV, KC_TILD,KC_LBRC,KC_RBRC,KC_LCBR,KC_RCBR,KC_MINS,KC_UNDS,KC_EQL, KC_PLUS,_______
#define NUMBERS_2 \
    _______,KC_1,   KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,   KC_0,   KC_BSLS
#define NUMBERS_3 \
    _______,KC_EXLM,KC_AT,  KC_HASH,KC_DLR, KC_PERC,KC_CIRC,KC_AMPR,KC_ASTR,KC_LPRN,KC_RPRN,K_LOCK
#define NUMBERS_4 \
    KC_PIPE,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______
#define NUMBERS KM(NUMBERS_1,NUMBERS_2,NUMBERS_3,NUMBERS_4)

/* Settings layer
 * ,------------------------------------------------------------------------.
 * |BLLed|  F1 |  F2 |  F3 |  F4 | Lin || Win | Wake|     |Hue -|Hue +|Reset|
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |  F5 |  F6 |  F7 |  F8 |     ||     |     |RGBto|Sat -|Sat +|     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * | Game|  F9 | F10 | F11 | F12 |Vol 0||PrtSc|     |RGBan|Bri -|Bri +|     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |Musir|     |     |     |     |Vol -||Vol +| Prev| Stop|TogMu| Next|     |
 * `------------------------------------------------------------------------' */
#define SETTINGS_1 \
    BL_STEP,KC_F1,  KC_F2,  KC_F3,  KC_F4,  UNI_LI, UNI_WN, KC_WAKE,_______,RGB_HUD,RGB_HUI,RESET  
#define SETTINGS_2 \
    _______,KC_F5,  KC_F6,  KC_F7,  KC_F8,  _______,_______,_______,RGB_TOG,RGB_SAD,RGB_SAI,_______
#define SETTINGS_3 \
    K_GAMES,KC_F9,  KC_F10, KC_F11, KC_F12, KC_MUTE,KC_PSCR,_______,RGB_MOD,RGB_VAD,RGB_VAI,_______
#define SETTINGS_4 \
    MU_TOG, _______,_______,_______,_______,KC_VOLD,KC_VOLU,KC_MPRV,KC_MSTP,KC_MPLY,KC_MNXT,_______
#define SETTINGS KM(SETTINGS_1,SETTINGS_2,SETTINGS_3,SETTINGS_4)

/* Mouse layer
 * ,------------------------------------------------------------------------.
 * |Ulock|  \  |  ^  |  /  |.....|.....||.....|.....| |\|.| |^| | |/|.|     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |  <  | Mid |  >  |Btn 4|.....||.....|Btn 5| <-- | Mid | --> |     |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |  /  |  v  |  \  |.....|.....||.....|.....| |/| | |v| | |\| | LCK |
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |     |     |     |     |     | Left||Right|     |     |Accl0|Accl1|Accl2|
 * `------------------------------------------------------------------------' */
#define MOUSE_1 \
    K_MOUSE,MO_NW,  MO_N,   MO_NE,  XXX,    XXX    ,XXX,    XXX,    MO_S_NW,MO_S_N, MO_S_NE,_______
#define MOUSE_2 \
    _______,MO_W,   MO_CL_M,MO_E,   MO_CL_4,XXX    ,XXX,    MO_CL_5,MO_S_W, MO_CL_M,MO_S_E, _______
#define MOUSE_3 \
    _______,MO_SW,  MO_S,   MO_SE,  XXX,    XXX    ,XXX,    XXX,    MO_S_SW,MO_S_S, MO_S_SE,K_LOCK
#define MOUSE_4 \
    _______,_______,_______,_______,_______,MO_CL_L,MO_CL_R,_______,MO_AC_0,MO_AC_1,MO_AC_2,_______
#define MOUSE KM(MOUSE_1,MOUSE_2,MOUSE_3,MOUSE_4)

/* Music layer
 * ,------------------------------------------------------------------------.
 * |.....|.....|.....|.....|.....|.....||.....|.....|.....|.....|.....|.....|
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |.....|.....|.....|.....|.....|.....||.....|.....|.....|.....|.....|.....|
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * |.....|.....|.....|.....|.....|.....||.....|.....|.....|.....|.....|.....|
 * |-----+-----+-----+-----+-----+-----++-----+-----+-----+-----+-----+-----|
 * | togg| rec | stop| play| slow| fast||modes|.....|.....|.....|.....|.....|
 * `------------------------------------------------------------------------'
 */
#define MASK XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX, XXX
#define MUSIC_4 MU_TOG, KC_LCTL, KC_LALT, KC_LGUI, KC_DOWN, KC_UP, MU_MOD, XXX, XXX, XXX, XXX, XXX
#define MUSIC KM(MASK,MASK,MASK,MUSIC_4)

#endif

A users/bbaserdem/rules.mk => users/bbaserdem/rules.mk +22 -0
@@ 0,0 1,22 @@
SRC += bbaserdem.c
EXTRAFLAGS += -flto

# ENABLE
UNICODE_ENABLE = yes		# Used for unicode character emulation
EXTRAKEY_ENABLE = yes		# OS signals like volume control

# DISABLE
BLUETOOTH_ENABLE = no 		# No bluetooth
COMMAND_ENABLE = no			# Some bootmagic thing
BOOTMAGIC_ENABLE = no 		# Access to EEPROM settings, not needed
CONSOLE_ENABLE = no			# Allows console output with a command
SLEEP_LED_ENABLE = no  		# Breathes LED's when computer is asleep. Untested.
NKRO_ENABLE = no 			# Default is 6KRO which is plenty
MIDI_ENABLE = no 			# Untested feature
FAUXCLICKY_ENABLE = no 		# Emulates clicks using speaker
KEY_LOCK_ENABLE = no 		# Allows locking any key. Not used
API_SYSEX_ENABLE = no 		# Allows OS to send signals.
KEY_LOCK_ENABLE = no 		# Allows locking any key. Not used

# Disabling this makes it compile, prob bad upstream code
# VARIABLE_TRACE = no 		# Allows debugging variables