diff options
985 files changed, 36003 insertions, 10253 deletions
diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml index 782530f62e..c671565a61 100644 --- a/.github/workflows/format.yml +++ b/.github/workflows/format.yml @@ -30,16 +30,14 @@ jobs: run: | pip3 install -r requirements-dev.txt - - uses: trilom/file-changes-action@v1.2.4 + - name: Get changed files id: file_changes - with: - output: ' ' - fileOutput: ' ' + uses: tj-actions/changed-files@v34 - name: Run qmk formatters shell: 'bash {0}' run: | - cat ~/files_added.txt ~/files_modified.txt > ~/files_changed.txt + echo '${{ steps.file_changes.outputs.added_files}}' '${{ steps.file_changes.outputs.modified_files}}' > ~/files_changed.txt qmk format-c --core-only $(< ~/files_changed.txt) || true qmk format-python $(< ~/files_changed.txt) || true qmk format-text $(< ~/files_changed.txt) || true diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml index 8e1dbcaea2..2bae44ae99 100644 --- a/.github/workflows/lint.yml +++ b/.github/workflows/lint.yml @@ -22,21 +22,20 @@ jobs: - name: Install dependencies run: pip3 install -r requirements-dev.txt - - uses: trilom/file-changes-action@v1.2.4 + - name: Get changed files id: file_changes - with: - output: '\n' + uses: tj-actions/changed-files@v34 - name: Print info run: | git rev-parse --short HEAD echo ${{ github.event.pull_request.base.sha }} - echo '${{ steps.file_changes.outputs.files}}' + echo '${{ steps.file_changes.outputs.all_changed_files}}' - name: Run qmk lint shell: 'bash {0}' run: | - QMK_CHANGES=$(echo -e '${{ steps.file_changes.outputs.files}}') + QMK_CHANGES=$(echo -e '${{ steps.file_changes.outputs.all_changed_files}}' | sed 's/ /\n/g') QMK_KEYBOARDS=$(qmk list-keyboards) exit_code=0 diff --git a/.gitmodules b/.gitmodules index 48c7035afa..7d8dbcb4ed 100644 --- a/.gitmodules +++ b/.gitmodules @@ -21,3 +21,7 @@ [submodule "lib/pico-sdk"] path = lib/pico-sdk url = https://github.com/qmk/pico-sdk.git +[submodule "lib/lvgl"] + path = lib/lvgl + url = https://github.com/qmk/lvgl.git + branch = release/v8.2 @@ -402,6 +402,7 @@ ifndef SKIP_GIT if [ ! -e lib/vusb ]; then git submodule sync lib/vusb && git submodule update --depth 50 --init lib/vusb; fi if [ ! -e lib/printf ]; then git submodule sync lib/printf && git submodule update --depth 50 --init lib/printf; fi if [ ! -e lib/pico-sdk ]; then git submodule sync lib/pico-sdk && git submodule update --depth 50 --init lib/pico-sdk; fi + if [ ! -e lib/lvgl ]; then git submodule sync lib/lvgl && git submodule update --depth 50 --init lib/lvgl; fi git submodule status --recursive 2>/dev/null | \ while IFS= read -r x; do \ case "$$x" in \ @@ -432,6 +433,7 @@ git-submodule: [ -e lib/ugfx ] && rm -rf lib/ugfx || true [ -e lib/pico-sdk ] && rm -rf lib/pico-sdk || true [ -e lib/chibios-contrib/ext/mcux-sdk ] && rm -rf lib/chibios-contrib/ext/mcux-sdk || true + [ -e lib/lvgl ] && rm -rf lib/lvgl || true git submodule sync --recursive git submodule update --init --recursive --progress diff --git a/builddefs/build_full_test.mk b/builddefs/build_full_test.mk index 35f0a05b99..964ba773d4 100644 --- a/builddefs/build_full_test.mk +++ b/builddefs/build_full_test.mk @@ -24,6 +24,8 @@ $(TEST)_SRC := \ tests/test_common/matrix.c \ tests/test_common/test_driver.cpp \ tests/test_common/keyboard_report_util.cpp \ + tests/test_common/keycode_util.cpp \ + tests/test_common/keycode_table.cpp \ tests/test_common/test_fixture.cpp \ tests/test_common/test_keymap_key.cpp \ tests/test_common/test_logger.cpp \ diff --git a/builddefs/build_test.mk b/builddefs/build_test.mk index 7c8fdd20e5..4230598373 100644 --- a/builddefs/build_test.mk +++ b/builddefs/build_test.mk @@ -62,6 +62,7 @@ include $(PLATFORM_PATH)/common.mk include $(TMK_PATH)/protocol.mk include $(QUANTUM_PATH)/debounce/tests/rules.mk include $(QUANTUM_PATH)/encoder/tests/rules.mk +include $(QUANTUM_PATH)/os_detection/tests/rules.mk include $(QUANTUM_PATH)/sequencer/tests/rules.mk include $(QUANTUM_PATH)/wear_leveling/tests/rules.mk include $(QUANTUM_PATH)/logging/print.mk diff --git a/builddefs/common_features.mk b/builddefs/common_features.mk index d9130b5338..dbcfcb7145 100644 --- a/builddefs/common_features.mk +++ b/builddefs/common_features.mk @@ -907,3 +907,11 @@ ifeq ($(strip $(ENCODER_ENABLE)), yes) OPT_DEFS += -DENCODER_MAP_ENABLE endif endif + +ifeq ($(strip $(OS_DETECTION_ENABLE)), yes) + SRC += $(QUANTUM_DIR)/os_detection.c + OPT_DEFS += -DOS_DETECTION_ENABLE + ifeq ($(strip $(OS_DETECTION_DEBUG_ENABLE)), yes) + OPT_DEFS += -DOS_DETECTION_DEBUG_ENABLE + endif +endif diff --git a/builddefs/testlist.mk b/builddefs/testlist.mk index 8a30a44972..74a794adcd 100644 --- a/builddefs/testlist.mk +++ b/builddefs/testlist.mk @@ -3,6 +3,7 @@ FULL_TESTS := $(notdir $(TEST_LIST)) include $(QUANTUM_PATH)/debounce/tests/testlist.mk include $(QUANTUM_PATH)/encoder/tests/testlist.mk +include $(QUANTUM_PATH)/os_detection/tests/testlist.mk include $(QUANTUM_PATH)/sequencer/tests/testlist.mk include $(QUANTUM_PATH)/wear_leveling/tests/testlist.mk include $(PLATFORM_PATH)/test/testlist.mk diff --git a/data/constants/keycodes/extras/keycodes_belgian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_belgian_0.0.1.hjson new file mode 100644 index 0000000000..d2b8c1d7d9 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_belgian_0.0.1.hjson @@ -0,0 +1,375 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ² │ & │ é │ " │ ' │ ( │ § │ è │ ! │ ç │ à │ ) │ - │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ A │ Z │ E │ R │ T │ Y │ U │ I │ O │ P │ ^ │ $ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Q │ S │ D │ F │ G │ H │ J │ K │ L │ M │ ù │ µ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ W │ X │ C │ V │ B │ N │ , │ ; │ : │ = │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "BE_SUP2", + "label": "²", + } + "KC_1": { + "key": "BE_AMPR", + "label": "&", + } + "KC_2": { + "key": "BE_EACU", + "label": "é", + } + "KC_3": { + "key": "BE_DQUO", + "label": "\"", + } + "KC_4": { + "key": "BE_QUOT", + "label": "'", + } + "KC_5": { + "key": "BE_LPRN", + "label": "(", + } + "KC_6": { + "key": "BE_SECT", + "label": "§", + } + "KC_7": { + "key": "BE_EGRV", + "label": "è", + } + "KC_8": { + "key": "BE_EXLM", + "label": "!", + } + "KC_9": { + "key": "BE_CCED", + "label": "ç", + } + "KC_0": { + "key": "BE_AGRV", + "label": "à ", + } + "KC_MINS": { + "key": "BE_RPRN", + "label": ")", + } + "KC_EQL": { + "key": "BE_MINS", + "label": "-", + } + "KC_Q": { + "key": "BE_A", + "label": "A", + } + "KC_W": { + "key": "BE_Z", + "label": "Z", + } + "KC_E": { + "key": "BE_E", + "label": "E", + } + "KC_R": { + "key": "BE_R", + "label": "R", + } + "KC_T": { + "key": "BE_T", + "label": "T", + } + "KC_Y": { + "key": "BE_Y", + "label": "Y", + } + "KC_U": { + "key": "BE_U", + "label": "U", + } + "KC_I": { + "key": "BE_I", + "label": "I", + } + "KC_O": { + "key": "BE_O", + "label": "O", + } + "KC_P": { + "key": "BE_P", + "label": "P", + } + "KC_LBRC": { + "key": "BE_DCIR", + "label": "^ (dead)", + } + "KC_RBRC": { + "key": "BE_DLR", + "label": "$", + } + "KC_A": { + "key": "BE_Q", + "label": "Q", + } + "KC_S": { + "key": "BE_S", + "label": "S", + } + "KC_D": { + "key": "BE_D", + "label": "D", + } + "KC_F": { + "key": "BE_F", + "label": "F", + } + "KC_G": { + "key": "BE_G", + "label": "G", + } + "KC_H": { + "key": "BE_H", + "label": "H", + } + "KC_J": { + "key": "BE_J", + "label": "J", + } + "KC_K": { + "key": "BE_K", + "label": "K", + } + "KC_L": { + "key": "BE_L", + "label": "L", + } + "KC_SCLN": { + "key": "BE_M", + "label": "M", + } + "KC_QUOT": { + "key": "BE_UGRV", + "label": "ù", + } + "KC_NUHS": { + "key": "BE_MICR", + "label": "µ", + } + "KC_NUBS": { + "key": "BE_LABK", + "label": "<", + } + "KC_Z": { + "key": "BE_W", + "label": "W", + } + "KC_X": { + "key": "BE_X", + "label": "X", + } + "KC_C": { + "key": "BE_C", + "label": "C", + } + "KC_V": { + "key": "BE_V", + "label": "V", + } + "KC_B": { + "key": "BE_B", + "label": "B", + } + "KC_N": { + "key": "BE_N", + "label": "N", + } + "KC_M": { + "key": "BE_COMM", + "label": ",", + } + "KC_COMM": { + "key": "BE_SCLN", + "label": ";", + } + "KC_DOT": { + "key": "BE_COLN", + "label": ":", + } + "KC_SLSH": { + "key": "BE_EQL", + "label": "=", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ³ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ° │ _ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ * │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ % │ £ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ ? │ . │ / │ + │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(BE_SUP2)": { + "key": "BE_SUP3", + "label": "³", + } + "S(BE_AMPR)": { + "key": "BE_1", + "label": "1", + } + "S(BE_EACU)": { + "key": "BE_2", + "label": "2", + } + "S(BE_DQUO)": { + "key": "BE_3", + "label": "3", + } + "S(BE_QUOT)": { + "key": "BE_4", + "label": "4", + } + "S(BE_LPRN)": { + "key": "BE_5", + "label": "5", + } + "S(BE_SECT)": { + "key": "BE_6", + "label": "6", + } + "S(BE_EGRV)": { + "key": "BE_7", + "label": "7", + } + "S(BE_EXLM)": { + "key": "BE_8", + "label": "8", + } + "S(BE_CCED)": { + "key": "BE_9", + "label": "9", + } + "S(BE_AGRV)": { + "key": "BE_0", + "label": "0", + } + "S(BE_RPRN)": { + "key": "BE_DEG", + "label": "°", + } + "S(BE_MINS)": { + "key": "BE_UNDS", + "label": "_", + } + "S(BE_DCIR)": { + "key": "BE_DIAE", + "label": "¨ (dead)", + } + "S(BE_DLR)": { + "key": "BE_ASTR", + "label": "*", + } + "S(BE_UGRV)": { + "key": "BE_PERC", + "label": "%", + } + "S(BE_MICR)": { + "key": "BE_PND", + "label": "£", + } + "S(BE_LABK)": { + "key": "BE_RABK", + "label": ">", + } + "S(BE_COMM)": { + "key": "BE_QUES", + "label": "?", + } + "S(BE_SCLN)": { + "key": "BE_DOT", + "label": ".", + } + "S(BE_COLN)": { + "key": "BE_SLSH", + "label": "/", + } + "S(BE_EQL)": { + "key": "BE_PLUS", + "label": "+", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ | │ @ │ # │ │ │ ^ │ │ │ { │ } │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ ´ │ ` │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ \ │ │ │ │ │ │ │ │ │ │ ~ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(BE_AMPR)": { + "key": "BE_PIPE", + "label": "|", + } + "ALGR(BE_EACU)": { + "key": "BE_AT", + "label": "@", + } + "ALGR(BE_DQUO)": { + "key": "BE_HASH", + "label": "#", + } + "ALGR(BE_SECT)": { + "key": "BE_CIRC", + "label": "^", + } + "ALGR(BE_CCED)": { + "key": "BE_LCBR", + "label": "{", + } + "ALGR(BE_AGRV)": { + "key": "BE_RCBR", + "label": "}", + } + "ALGR(BE_E)": { + "key": "BE_EURO", + "label": "€", + } + "ALGR(BE_DCIR)": { + "key": "BE_LBRC", + "label": "[", + } + "ALGR(BE_DLR)": { + "key": "BE_RBRC", + "label": "]", + } + "ALGR(BE_UGRV)": { + "key": "BE_ACUT", + "label": "´ (dead)", + } + "ALGR(BE_MICR)": { + "key": "BE_GRV", + "label": "` (dead)", + } + "ALGR(BE_LABK)": { + "key": "BE_BSLS", + "label": "\\", + } + "ALGR(BE_EQL)": { + "key": "BE_TILD", + "label": "~", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_bepo_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_bepo_0.0.1.hjson new file mode 100644 index 0000000000..713f3f2829 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_bepo_0.0.1.hjson @@ -0,0 +1,632 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ $ │ " │ « │ » │ ( │ ) │ @ │ + │ - │ / │ * │ = │ % │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ B │ É │ P │ O │ È │ ^ │ V │ D │ L │ J │ Z │ W │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ U │ I │ E │ , │ C │ T │ S │ R │ N │ M │ Ç │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ Ê │ À │ Y │ X │ . │ K │ ' │ Q │ G │ H │ F │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "BP_DLR", + "label": "$", + } + "KC_1": { + "key": "BP_DQUO", + "label": "\"", + } + "KC_2": { + "key": "BP_LDAQ", + "label": "«", + } + "KC_3": { + "key": "BP_RDAQ", + "label": "»", + } + "KC_4": { + "key": "BP_LPRN", + "label": "(", + } + "KC_5": { + "key": "BP_RPRN", + "label": ")", + } + "KC_6": { + "key": "BP_AT", + "label": "@", + } + "KC_7": { + "key": "BP_PLUS", + "label": "+", + } + "KC_8": { + "key": "BP_MINS", + "label": "-", + } + "KC_9": { + "key": "BP_SLSH", + "label": "/", + } + "KC_0": { + "key": "BP_ASTR", + "label": "*", + } + "KC_MINS": { + "key": "BP_EQL", + "label": "=", + } + "KC_EQL": { + "key": "BP_PERC", + "label": "%", + } + "KC_Q": { + "key": "BP_B", + "label": "B", + } + "KC_W": { + "key": "BP_EACU", + "label": "É", + } + "KC_E": { + "key": "BP_P", + "label": "P", + } + "KC_R": { + "key": "BP_O", + "label": "O", + } + "KC_T": { + "key": "BP_EGRV", + "label": "È", + } + "KC_Y": { + "key": "BP_DCIR", + "label": "^ (dead)", + } + "KC_U": { + "key": "BP_V", + "label": "V", + } + "KC_I": { + "key": "BP_D", + "label": "D", + } + "KC_O": { + "key": "BP_L", + "label": "L", + } + "KC_P": { + "key": "BP_J", + "label": "J", + } + "KC_LBRC": { + "key": "BP_Z", + "label": "Z", + } + "KC_RBRC": { + "key": "BP_W", + "label": "W", + } + "KC_A": { + "key": "BP_A", + "label": "A", + } + "KC_S": { + "key": "BP_U", + "label": "U", + } + "KC_D": { + "key": "BP_I", + "label": "I", + } + "KC_F": { + "key": "BP_E", + "label": "E", + } + "KC_G": { + "key": "BP_COMM", + "label": ",", + } + "KC_H": { + "key": "BP_C", + "label": "C", + } + "KC_J": { + "key": "BP_T", + "label": "T", + } + "KC_K": { + "key": "BP_S", + "label": "S", + } + "KC_L": { + "key": "BP_R", + "label": "R", + } + "KC_SCLN": { + "key": "BP_N", + "label": "N", + } + "KC_QUOT": { + "key": "BP_M", + "label": "M", + } + "KC_BSLS": { + "key": "BP_CCED", + "label": "Ç", + } + "KC_NUBS": { + "key": "BP_ECIR", + "label": "Ê", + } + "KC_Z": { + "key": "BP_AGRV", + "label": "À", + } + "KC_X": { + "key": "BP_Y", + "label": "Y", + } + "KC_C": { + "key": "BP_X", + "label": "X", + } + "KC_V": { + "key": "BP_DOT", + "label": ".", + } + "KC_B": { + "key": "BP_K", + "label": "K", + } + "KC_N": { + "key": "BP_QUOT", + "label": "'", + } + "KC_M": { + "key": "BP_Q", + "label": "Q", + } + "KC_COMM": { + "key": "BP_G", + "label": "G", + } + "KC_DOT": { + "key": "BP_H", + "label": "H", + } + "KC_SLSH": { + "key": "BP_F", + "label": "F", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ # │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ° │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ ! │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ ; │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ : │ │ ? │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(BP_DLR)": { + "key": "BP_HASH", + "label": "#", + } + "S(BP_DQUO)": { + "key": "BP_1", + "label": "1", + } + "S(BP_LDAQ)": { + "key": "BP_2", + "label": "2", + } + "S(BP_RDAQ)": { + "key": "BP_3", + "label": "3", + } + "S(BP_LPRN)": { + "key": "BP_4", + "label": "4", + } + "S(BP_RPRN)": { + "key": "BP_5", + "label": "5", + } + "S(BP_AT)": { + "key": "BP_6", + "label": "6", + } + "S(BP_PLUS)": { + "key": "BP_7", + "label": "7", + } + "S(BP_MINS)": { + "key": "BP_8", + "label": "8", + } + "S(BP_SLSH)": { + "key": "BP_9", + "label": "9", + } + "S(BP_ASTR)": { + "key": "BP_0", + "label": "0", + } + "S(BP_EQL)": { + "key": "BP_DEG", + "label": "°", + } + "S(BP_PERC)": { + "key": "BP_GRV", + "label": "`", + } + "S(BP_DCIR)": { + "key": "BP_EXLM", + "label": "!", + } + "S(BP_COMM)": { + "key": "BP_SCLN", + "label": ";", + } + "S(BP_DOT)": { + "key": "BP_COLN", + "label": ":", + } + "S(BP_QUOT)": { + "key": "BP_QUES", + "label": "?", + } + "S(KC_SPC)": { + "key": "BP_NBSP", + "label": "(non-breaking space)", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ – │ — │ < │ > │ [ │ ] │ ^ │ ± │ − │ ÷ │ × │ ≠│ ‰ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ | │ ´ │ & │ Å’ │ ` │ ¡ │ ˇ │ à │ / │ IJ │ Æ â”‚ ˘ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Æ │ Ù │ ¨ │ € │ │ © │ Þ │ ẞ │ ® │ ~ │ ¯ │ ¸ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ \ │ { │ } │ … │ ~ │ ¿ │ ° │ │ †│ Ë› │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ _ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(BP_DLR)": { + "key": "BP_NDSH", + "label": "–", + } + "ALGR(BP_DQUO)": { + "key": "BP_MDSH", + "label": "—", + } + "ALGR(BP_LDAQ)": { + "key": "BP_LABK", + "label": "<", + } + "ALGR(BP_RDAQ)": { + "key": "BP_RABK", + "label": ">", + } + "ALGR(BP_LPRN)": { + "key": "BP_LBRC", + "label": "[", + } + "ALGR(BP_RPRN)": { + "key": "BP_RBRC", + "label": "]", + } + "ALGR(BP_AT)": { + "key": "BP_CIRC", + "label": "^", + } + "ALGR(BP_PLUS)": { + "key": "BP_PLMN", + "label": "±", + } + "ALGR(BP_MINS)": { + "key": "BP_MMNS", + "label": "−", + } + "ALGR(BP_SLSH)": { + "key": "BP_DIV", + "label": "÷", + } + "ALGR(BP_ASTR)": { + "key": "BP_MUL", + "label": "×", + } + "ALGR(BP_EQL)": { + "key": "BP_NEQL", + "label": "≠", + } + "ALGR(BP_PERC)": { + "key": "BP_PERM", + "label": "‰", + } + "ALGR(BP_B)": { + "key": "BP_PIPE", + "label": "|", + } + "ALGR(BP_EACU)": { + "key": "BP_ACUT", + "label": "´ (dead)", + } + "ALGR(BP_P)": { + "key": "BP_AMPR", + "label": "&", + } + "ALGR(BP_O)": { + "key": "BP_OE", + "label": "Å’", + } + "ALGR(BP_EGRV)": { + "key": "BP_DGRV", + "label": "` (dead)", + } + "ALGR(BP_DCIR)": { + "key": "BP_IEXL", + "label": "¡", + } + "ALGR(BP_V)": { + "key": "BP_CARN", + "label": "ˇ (dead)", + } + "ALGR(BP_D)": { + "key": "BP_ETH", + "label": "Ã", + } + "ALGR(BP_L)": { + "key": "BP_DSLS", + "label": "/ (dead)", + } + "ALGR(BP_J)": { + "key": "BP_IJ", + "label": "IJ", + } + "ALGR(BP_Z)": { + "key": "BP_SCHW", + "label": "Æ", + } + "ALGR(BP_W)": { + "key": "BP_BREV", + "label": "˘ (dead)", + } + "ALGR(BP_A)": { + "key": "BP_AE", + "label": "Æ", + } + "ALGR(BP_U)": { + "key": "BP_UGRV", + "label": "Ù", + } + "ALGR(BP_I)": { + "key": "BP_DIAE", + "label": "¨ (dead)", + } + "ALGR(BP_E)": { + "key": "BP_EURO", + "label": "€", + } + "ALGR(BP_C)": { + "key": "BP_COPY", + "label": "©", + } + "ALGR(BP_T)": { + "key": "BP_THRN", + "label": "Þ", + } + "ALGR(BP_S)": { + "key": "BP_SS", + "label": "ẞ", + } + "ALGR(BP_R)": { + "key": "BP_REGD", + "label": "®", + } + "ALGR(BP_N)": { + "key": "BP_DTIL", + "label": "~ (dead)", + } + "ALGR(BP_M)": { + "key": "BP_MACR", + "label": "¯ (dead)", + } + "ALGR(BP_CCED)": { + "key": "BP_CEDL", + "label": "¸ (dead)", + } + "ALGR(BP_AGRV)": { + "key": "BP_BSLS", + "label": "\\", + } + "ALGR(BP_Y)": { + "key": "BP_LCBR", + "label": "{", + } + "ALGR(BP_X)": { + "key": "BP_RCBR", + "label": "}", + } + "ALGR(BP_DOT)": { + "key": "BP_ELLP", + "label": "…", + } + "ALGR(BP_K)": { + "key": "BP_TILD", + "label": "~", + } + "ALGR(BP_QUES)": { + "key": "BP_IQUE", + "label": "¿", + } + "ALGR(BP_Q)": { + "key": "BP_RNGA", + "label": "° (dead)", + } + "ALGR(BP_G)": { + "key": "BP_DGRK", + "label": "µ (dead Greek key)", + } + "ALGR(BP_H)": { + "key": "BP_DAGG", + "label": "†", + } + "ALGR(BP_F)": { + "key": "BP_OGON", + "label": "Ë› (dead)", + } + "ALGR(KC_SPC)": { + "key": "BP_UNDS", + "label": "_", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¶ │ „ │ “ │ †│ ≤ │ ≥ │ │ ¬ │ ¼ │ ½ │ ¾ │ ′ │ ″ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ ¦ │ Ë â”‚ § │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ Ë™ │ ¤ │ Ì› │ Å¿ │ │ │ â„¢ │ │ º │ , │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ ‘ │ ’ │ · │ ⌨ │ ̉ │ Ì£ │ │ ‡ │ ª │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(BP_DLR))": { + "key": "BP_PARA", + "label": "¶", + } + "S(ALGR(BP_DQUO))": { + "key": "BP_DLQU", + "label": "„", + } + "S(ALGR(BP_LDAQ))": { + "key": "BP_LDQU", + "label": "“", + } + "S(ALGR(BP_RDAQ))": { + "key": "BP_RDQU", + "label": "â€", + } + "S(ALGR(BP_LPRN))": { + "key": "BP_LEQL", + "label": "≤", + } + "S(ALGR(BP_RPRN))": { + "key": "BP_GEQL", + "label": "≥", + } + "S(ALGR(BP_PLUS))": { + "key": "BP_NOT", + "label": "¬", + } + "S(ALGR(BP_MINS))": { + "key": "BP_QRTR", + "label": "¼", + } + "S(ALGR(BP_SLSH))": { + "key": "BP_HALF", + "label": "½", + } + "S(ALGR(BP_ASTR))": { + "key": "BP_TQTR", + "label": "¾", + } + "S(ALGR(BP_EQL))": { + "key": "BP_PRIM", + "label": "′", + } + "S(ALGR(BP_PERC))": { + "key": "BP_DPRM", + "label": "″", + } + "S(ALGR(BP_B))": { + "key": "BP_BRKP", + "label": "¦", + } + "S(ALGR(BP_EACU))": { + "key": "BP_DACU", + "label": "Ë (dead)", + } + "S(ALGR(BP_P))": { + "key": "BP_SECT", + "label": "§", + } + "S(ALGR(BP_I))": { + "key": "BP_DOTA", + "label": "Ë™ (dead)", + } + "S(ALGR(BP_E))": { + "key": "BP_CURR", + "label": "¤ (dead)", + } + "S(ALGR(BP_COMM))": { + "key": "BP_HORN", + "label": "Ì› (dead)", + } + "S(ALGR(BP_C))": { + "key": "BP_LNGS", + "label": "Å¿", + } + "S(ALGR(BP_R))": { + "key": "BP_TM", + "label": "â„¢", + } + "S(ALGR(BP_M))": { + "key": "BP_MORD", + "label": "º", + } + "S(ALGR(BP_CCED))": { + "key": "BP_DCMM", + "label": ", (dead)", + } + "S(ALGR(BP_Y))": { + "key": "BP_LSQU", + "label": "‘", + } + "S(ALGR(BP_X))": { + "key": "BP_RSQU", + "label": "’", + } + "S(ALGR(BP_DOT))": { + "key": "BP_MDDT", + "label": "·", + } + "S(ALGR(BP_K))": { + "key": "BP_KEYB", + "label": "⌨", + } + "S(ALGR(BP_QUOT))": { + "key": "BP_HOKA", + "label": "̉ (dead)", + } + "S(ALGR(BP_Q))": { + "key": "BP_DOTB", + "label": "Ì£ (dead)", + } + "S(ALGR(BP_H))": { + "key": "BP_DDAG", + "label": "‡", + } + "S(ALGR(BP_F))": { + "key": "BP_FORD", + "label": "ª", + } + "S(ALGR(KC_SPC))": { + "key": "BP_NNBS", + "label": "(narrow non-breaking space)", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_brazilian_abnt2_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_brazilian_abnt2_0.0.1.hjson new file mode 100644 index 0000000000..17006a64df --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_brazilian_abnt2_0.0.1.hjson @@ -0,0 +1,379 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ' │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ ´ │ [ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ç │ ~ │ ] │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┤ + * │ │ \ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ ; │ / │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬──┴─┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "BR_QUOT", + "label": "'", + } + "KC_1": { + "key": "BR_1", + "label": "1", + } + "KC_2": { + "key": "BR_2", + "label": "2", + } + "KC_3": { + "key": "BR_3", + "label": "3", + } + "KC_4": { + "key": "BR_4", + "label": "4", + } + "KC_5": { + "key": "BR_5", + "label": "5", + } + "KC_6": { + "key": "BR_6", + "label": "6", + } + "KC_7": { + "key": "BR_7", + "label": "7", + } + "KC_8": { + "key": "BR_8", + "label": "8", + } + "KC_9": { + "key": "BR_9", + "label": "9", + } + "KC_0": { + "key": "BR_0", + "label": "0", + } + "KC_MINS": { + "key": "BR_MINS", + "label": "-", + } + "KC_EQL": { + "key": "BR_EQL", + "label": "=", + } + "KC_Q": { + "key": "BR_Q", + "label": "Q", + } + "KC_W": { + "key": "BR_W", + "label": "W", + } + "KC_E": { + "key": "BR_E", + "label": "E", + } + "KC_R": { + "key": "BR_R", + "label": "R", + } + "KC_T": { + "key": "BR_T", + "label": "T", + } + "KC_Y": { + "key": "BR_Y", + "label": "Y", + } + "KC_U": { + "key": "BR_U", + "label": "U", + } + "KC_I": { + "key": "BR_I", + "label": "I", + } + "KC_O": { + "key": "BR_O", + "label": "O", + } + "KC_P": { + "key": "BR_P", + "label": "P", + } + "KC_LBRC": { + "key": "BR_ACUT", + "label": "´ (dead)", + } + "KC_RBRC": { + "key": "BR_LBRC", + "label": "[", + } + "KC_A": { + "key": "BR_A", + "label": "A", + } + "KC_S": { + "key": "BR_S", + "label": "S", + } + "KC_D": { + "key": "BR_D", + "label": "D", + } + "KC_F": { + "key": "BR_F", + "label": "F", + } + "KC_G": { + "key": "BR_G", + "label": "G", + } + "KC_H": { + "key": "BR_H", + "label": "H", + } + "KC_J": { + "key": "BR_J", + "label": "J", + } + "KC_K": { + "key": "BR_K", + "label": "K", + } + "KC_L": { + "key": "BR_L", + "label": "L", + } + "KC_SCLN": { + "key": "BR_CCED", + "label": "Ç", + } + "KC_QUOT": { + "key": "BR_TILD", + "label": "~ (dead)", + } + "KC_BSLS": { + "key": "BR_RBRC", + "label": "]", + } + "KC_NUBS": { + "key": "BR_BSLS", + "label": "\\", + } + "KC_Z": { + "key": "BR_Z", + "label": "Z", + } + "KC_X": { + "key": "BR_X", + "label": "X", + } + "KC_C": { + "key": "BR_C", + "label": "C", + } + "KC_V": { + "key": "BR_V", + "label": "V", + } + "KC_B": { + "key": "BR_B", + "label": "B", + } + "KC_N": { + "key": "BR_N", + "label": "N", + } + "KC_M": { + "key": "BR_M", + "label": "M", + } + "KC_COMM": { + "key": "BR_COMM", + "label": ",", + } + "KC_DOT": { + "key": "BR_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "BR_SCLN", + "label": ";", + } + "KC_INT1": { + "key": "BR_SLSH", + "label": "/", + } + "KC_PCMM": { + "key": "BR_PDOT", + "label": ".", + } + "KC_PDOT": { + "key": "BR_PCMM", + "label": ",", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ " │ ! │ @ │ # │ $ │ % │ ¨ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ ` │ { │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ ^ │ } │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┤ + * │ │ | │ │ │ │ │ │ │ │ < │ > │ : │ ? │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬──┴─┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(BR_QUOT)": { + "key": "BR_DQUO", + "label": "\"", + } + "S(BR_1)": { + "key": "BR_EXLM", + "label": "!", + } + "S(BR_2)": { + "key": "BR_AT", + "label": "@", + } + "S(BR_3)": { + "key": "BR_HASH", + "label": "#", + } + "S(BR_4)": { + "key": "BR_DLR", + "label": "$", + } + "S(BR_5)": { + "key": "BR_PERC", + "label": "%", + } + "S(BR_6)": { + "key": "BR_DIAE", + "label": "¨ (dead)", + } + "S(BR_7)": { + "key": "BR_AMPR", + "label": "&", + } + "S(BR_8)": { + "key": "BR_ASTR", + "label": "*", + } + "S(BR_9)": { + "key": "BR_LPRN", + "label": "(", + } + "S(BR_0)": { + "key": "BR_RPRN", + "label": ")", + } + "S(BR_MINS)": { + "key": "BR_UNDS", + "label": "_", + } + "S(BR_EQL)": { + "key": "BR_PLUS", + "label": "+", + } + "S(BR_ACUT)": { + "key": "BR_GRV", + "label": "` (dead)", + } + "S(BR_LBRC)": { + "key": "BR_LCBR", + "label": "{", + } + "S(BR_TILD)": { + "key": "BR_CIRC", + "label": "^ (dead)", + } + "S(BR_RBRC)": { + "key": "BR_RCBR", + "label": "}", + } + "S(BR_BSLS)": { + "key": "BR_PIPE", + "label": "|", + } + "S(BR_COMM)": { + "key": "BR_LABK", + "label": "<", + } + "S(BR_DOT)": { + "key": "BR_RABK", + "label": ">", + } + "S(BR_SCLN)": { + "key": "BR_COLN", + "label": ":", + } + "S(BR_SLSH)": { + "key": "BR_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ¹ │ ² │ ³ │ £ │ ¢ │ ¬ │ │ │ │ │ │ § │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ ° │ │ │ │ │ │ │ │ │ ª │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ º │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┤ + * │ │ │ │ │ ₢ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬──┴─┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(BR_1)": { + "key": "BR_SUP1", + "label": "¹", + } + "ALGR(BR_2)": { + "key": "BR_SUP2", + "label": "²", + } + "ALGR(BR_3)": { + "key": "BR_SUP3", + "label": "³", + } + "ALGR(BR_4)": { + "key": "BR_PND", + "label": "£", + } + "ALGR(BR_5)": { + "key": "BR_CENT", + "label": "¢", + } + "ALGR(BR_6)": { + "key": "BR_NOT", + "label": "¬", + } + "ALGR(BR_EQL)": { + "key": "BR_SECT", + "label": "§", + } + "ALGR(BR_E)": { + "key": "BR_DEG", + "label": "°", + } + "ALGR(BR_LBRC)": { + "key": "BR_FORD", + "label": "ª", + } + "ALGR(BR_RBRC)": { + "key": "BR_MORD", + "label": "º", + } + "ALGR(BR_C)": { + "key": "BR_CRUZ", + "label": "₢", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_canadian_multilingual_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_canadian_multilingual_0.0.1.hjson new file mode 100644 index 0000000000..bfe5d5b54c --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_canadian_multilingual_0.0.1.hjson @@ -0,0 +1,641 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ / │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ ^ │ Ç │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ È │ À │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ Ù │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ É │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "CA_SLSH", + "label": "/", + } + "KC_1": { + "key": "CA_1", + "label": "1", + } + "KC_2": { + "key": "CA_2", + "label": "2", + } + "KC_3": { + "key": "CA_3", + "label": "3", + } + "KC_4": { + "key": "CA_4", + "label": "4", + } + "KC_5": { + "key": "CA_5", + "label": "5", + } + "KC_6": { + "key": "CA_6", + "label": "6", + } + "KC_7": { + "key": "CA_7", + "label": "7", + } + "KC_8": { + "key": "CA_8", + "label": "8", + } + "KC_9": { + "key": "CA_9", + "label": "9", + } + "KC_0": { + "key": "CA_0", + "label": "0", + } + "KC_MINS": { + "key": "CA_MINS", + "label": "-", + } + "KC_EQL": { + "key": "CA_EQL", + "label": "=", + } + "KC_Q": { + "key": "CA_Q", + "label": "Q", + } + "KC_W": { + "key": "CA_W", + "label": "W", + } + "KC_E": { + "key": "CA_E", + "label": "E", + } + "KC_R": { + "key": "CA_R", + "label": "R", + } + "KC_T": { + "key": "CA_T", + "label": "T", + } + "KC_Y": { + "key": "CA_Y", + "label": "Y", + } + "KC_U": { + "key": "CA_U", + "label": "U", + } + "KC_I": { + "key": "CA_I", + "label": "I", + } + "KC_O": { + "key": "CA_O", + "label": "O", + } + "KC_P": { + "key": "CA_P", + "label": "P", + } + "KC_LBRC": { + "key": "CA_CIRC", + "label": "^ (dead)", + } + "KC_RBRC": { + "key": "CA_CCED", + "label": "Ç", + } + "KC_A": { + "key": "CA_A", + "label": "A", + } + "KC_S": { + "key": "CA_S", + "label": "S", + } + "KC_D": { + "key": "CA_D", + "label": "D", + } + "KC_F": { + "key": "CA_F", + "label": "F", + } + "KC_G": { + "key": "CA_G", + "label": "G", + } + "KC_H": { + "key": "CA_H", + "label": "H", + } + "KC_J": { + "key": "CA_J", + "label": "J", + } + "KC_K": { + "key": "CA_K", + "label": "K", + } + "KC_L": { + "key": "CA_L", + "label": "L", + } + "KC_SCLN": { + "key": "CA_SCLN", + "label": ";", + } + "KC_QUOT": { + "key": "CA_EGRV", + "label": "É", + } + "KC_NUHS": { + "key": "CA_AGRV", + "label": "À", + } + "KC_NUBS": { + "key": "CA_UGRV", + "label": "Ù", + } + "KC_Z": { + "key": "CA_Z", + "label": "Z", + } + "KC_X": { + "key": "CA_X", + "label": "X", + } + "KC_C": { + "key": "CA_C", + "label": "C", + } + "KC_V": { + "key": "CA_V", + "label": "V", + } + "KC_B": { + "key": "CA_B", + "label": "B", + } + "KC_N": { + "key": "CA_N", + "label": "N", + } + "KC_M": { + "key": "CA_M", + "label": "M", + } + "KC_COMM": { + "key": "CA_COMM", + "label": ",", + } + "KC_DOT": { + "key": "CA_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "CA_EACU", + "label": "É", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ \ │ ! │ @ │ # │ $ │ % │ ? │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ : │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ ' │ " │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(CA_SLSH)": { + "key": "CA_BSLS", + "label": "\\", + } + "S(CA_1)": { + "key": "CA_EXLM", + "label": "!", + } + "S(CA_2)": { + "key": "CA_AT", + "label": "@", + } + "S(CA_3)": { + "key": "CA_HASH", + "label": "#", + } + "S(CA_4)": { + "key": "CA_DLR", + "label": "$", + } + "S(CA_5)": { + "key": "CA_PERC", + "label": "%", + } + "S(CA_6)": { + "key": "CA_QUES", + "label": "?", + } + "S(CA_7)": { + "key": "CA_AMPR", + "label": "&", + } + "S(CA_8)": { + "key": "CA_ASTR", + "label": "*", + } + "S(CA_9)": { + "key": "CA_LPRN", + "label": "(", + } + "S(CA_0)": { + "key": "CA_RPRN", + "label": ")", + } + "S(CA_MINS)": { + "key": "CA_UNDS", + "label": "_", + } + "S(CA_EQL)": { + "key": "CA_PLUS", + "label": "+", + } + "S(CA_CIRC)": { + "key": "CA_DIAE", + "label": "¨ (dead)", + } + "S(CA_SCLN)": { + "key": "CA_COLN", + "label": ":", + } + "S(CA_COMM)": { + "key": "CA_QUOT", + "label": "'", + } + "S(CA_DOT)": { + "key": "CA_DQUO", + "label": "\"", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ | │ │ │ │ ¤ │ │ │ { │ } │ [ │ ] │ │ ¬ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ ` │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ ° │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ « │ » │ │ │ │ │ │ < │ > │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(CA_SLSH)": { + "key": "CA_PIPE", + "label": "|", + } + "ALGR(CA_4)": { + "key": "CA_CURR", + "label": "¤", + } + "ALGR(CA_7)": { + "key": "CA_LCBR", + "label": "{", + } + "ALGR(CA_8)": { + "key": "CA_RCBR", + "label": "}", + } + "ALGR(CA_9)": { + "key": "CA_LBRC", + "label": "[", + } + "ALGR(CA_0)": { + "key": "CA_RBRC", + "label": "]", + } + "ALGR(CA_EQL)": { + "key": "CA_NOT", + "label": "¬", + } + "ALGR(CA_E)": { + "key": "CA_EURO", + "label": "€", + } + "ALGR(CA_CIRC)": { + "key": "CA_GRV", + "label": "` (dead)", + } + "ALGR(CA_CCED)": { + "key": "CA_DTIL", + "label": "~ (dead)", + } + "ALGR(CA_SCLN)": { + "key": "CA_DEG", + "label": "°", + } + "ALGR(CA_Z)": { + "key": "CA_LDAQ", + "label": "«", + } + "ALGR(CA_X)": { + "key": "CA_RDAQ", + "label": "»", + } + "ALGR(CA_COMM)": { + "key": "CA_LABK", + "label": "<", + } + "ALGR(CA_DOT)": { + "key": "CA_RABK", + "label": ">", + } +/* Right Ctrl symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ¹ │ ² │ ³ │ ¼ │ ½ │ ¾ │ │ │ │ │ │ ¸ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Ω │ Š│ Å’ │ ¶ │ Ŧ │ ↠│ ↓ │ → │ Ø │ Þ │ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Æ │ ß │ à │ │ ÅŠ │ Ħ │ IJ │ ĸ │ Ä¿ │ ´ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ ¢ │ “ │ †│ ʼn │ μ │ ― │ Ë™ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "RCTL(CA_1)": { + "key": "CA_SUP1", + "label": "¹", + } + "RCTL(CA_2)": { + "key": "CA_SUP2", + "label": "²", + } + "RCTL(CA_3)": { + "key": "CA_SUP3", + "label": "³", + } + "RCTL(CA_4)": { + "key": "CA_QRTR", + "label": "¼", + } + "RCTL(CA_5)": { + "key": "CA_HALF", + "label": "½", + } + "RCTL(CA_6)": { + "key": "CA_TQTR", + "label": "¾", + } + "RCTL(CA_EQL)": { + "key": "CA_CEDL", + "label": "¸ (dead)", + } + "RCTL(CA_Q)": { + "key": "CA_OMEG", + "label": "Ω", + } + "RCTL(CA_W)": { + "key": "CA_LSTR", + "label": "Å", + } + "RCTL(CA_E)": { + "key": "CA_OE", + "label": "Å’", + } + "RCTL(CA_R)": { + "key": "CA_PARA", + "label": "¶", + } + "RCTL(CA_T)": { + "key": "CA_TSTR", + "label": "Ŧ", + } + "RCTL(CA_Y)": { + "key": "CA_LARR", + "label": "â†", + } + "RCTL(CA_U)": { + "key": "CA_DARR", + "label": "↓", + } + "RCTL(CA_I)": { + "key": "CA_RARR", + "label": "→", + } + "RCTL(CA_O)": { + "key": "CA_OSTR", + "label": "Ø", + } + "RCTL(CA_P)": { + "key": "CA_THRN", + "label": "Þ", + } + "RCTL(CA_CCED)": { + "key": "CA_TILD", + "label": "~", + } + "RCTL(CA_A)": { + "key": "CA_AE", + "label": "Æ", + } + "RCTL(CA_S)": { + "key": "CA_SS", + "label": "ß", + } + "RCTL(CA_D)": { + "key": "CA_ETH", + "label": "Ã", + } + "RCTL(CA_G)": { + "key": "CA_ENG", + "label": "ÅŠ", + } + "RCTL(CA_H)": { + "key": "CA_HSTR", + "label": "Ħ", + } + "RCTL(CA_J)": { + "key": "CA_IJ", + "label": "IJ", + } + "RCTL(CA_K)": { + "key": "CA_KRA", + "label": "ĸ", + } + "RCTL(CA_L)": { + "key": "CA_LMDT", + "label": "Ä¿", + } + "RCTL(CA_SCLN)": { + "key": "CA_ACUT", + "label": "´ (dead)", + } + "RCTL(CA_C)": { + "key": "CA_CENT", + "label": "¢", + } + "RCTL(CA_V)": { + "key": "CA_LDQU", + "label": "“", + } + "RCTL(CA_B)": { + "key": "CA_RDQU", + "label": "â€", + } + "RCTL(CA_N)": { + "key": "CA_APSN", + "label": "ʼn", + } + "RCTL(CA_M)": { + "key": "CA_MICR", + "label": "μ", + } + "RCTL(CA_COMM)": { + "key": "CA_HRZB", + "label": "―", + } + "RCTL(CA_DOT)": { + "key": "CA_DOTA", + "label": "Ë™ (dead)", + } +/* Shift+Right Ctrl symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ - │ ¡ │ │ £ │ │ â…œ │ â… â”‚ â…ž │ â„¢ │ ± │ │ ¿ │ Ë› │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ ® │ │ Â¥ │ ↑ │ ı │ │ │ ° │ ¯ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ § │ │ ª │ │ │ │ │ │ Ë â”‚ ˇ │ ˘ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ ¦ │ │ │ © │ ‘ │ ’ │ ♪ │ º │ × │ ÷ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "RCTL(S(CA_SLSH))": { + "key": "CA_SHYP", + "label": " (soft hyphen)", + } + "RCTL(S(CA_1))": { + "key": "CA_IEXL", + "label": "¡", + } + "RCTL(S(CA_3))": { + "key": "CA_PND", + "label": "£", + } + "RCTL(S(CA_5))": { + "key": "CA_TEIG", + "label": "â…œ", + } + "RCTL(S(CA_6))": { + "key": "CA_FEIG", + "label": "â…", + } + "RCTL(S(CA_7))": { + "key": "CA_SEIG", + "label": "â…ž", + } + "RCTL(S(CA_8))": { + "key": "CA_TM", + "label": "â„¢", + } + "RCTL(S(CA_9))": { + "key": "CA_PLMN", + "label": "±", + } + "RCTL(S(CA_MINS))": { + "key": "CA_IQUE", + "label": "¿", + } + "RCTL(S(CA_EQL))": { + "key": "CA_OGON", + "label": "Ë› (dead)", + } + "RCTL(S(CA_R))": { + "key": "CA_REGD", + "label": "®", + } + "RCTL(S(CA_Y))": { + "key": "CA_YEN", + "label": "Â¥", + } + "RCTL(S(CA_U))": { + "key": "CA_UARR", + "label": "↑", + } + "RCTL(S(CA_I))": { + "key": "CA_DLSI", + "label": "ı", + } + "RCTL(S(CA_CIRC))": { + "key": "CA_RNGA", + "label": "° (dead)", + } + "RCTL(S(CA_CCED))": { + "key": "CA_MACR", + "label": "¯ (dead)", + } + "RCTL(S(CA_S))": { + "key": "CA_SECT", + "label": "§", + } + "RCTL(S(CA_F))": { + "key": "CA_FORD", + "label": "ª", + } + "RCTL(S(CA_SCLN))": { + "key": "CA_DACU", + "label": "Ë (dead)", + } + "RCTL(S(CA_EGRV))": { + "key": "CA_CARN", + "label": "ˇ (dead)", + } + "RCTL(S(CA_AGRV))": { + "key": "CA_BREV", + "label": "˘ (dead)", + } + "RCTL(S(CA_UGRV))": { + "key": "CA_BRKP", + "label": "¦", + } + "RCTL(S(CA_C))": { + "key": "CA_COPY", + "label": "©", + } + "RCTL(S(CA_V))": { + "key": "CA_LSQU", + "label": "‘", + } + "RCTL(S(CA_B))": { + "key": "CA_RSQU", + "label": "’", + } + "RCTL(S(CA_N))": { + "key": "CA_ENOT", + "label": "♪", + } + "RCTL(S(CA_M))": { + "key": "CA_MORD", + "label": "º", + } + "RCTL(S(CA_COMM))": { + "key": "CA_MUL", + "label": "×", + } + "RCTL(S(CA_DOT))": { + "key": "CA_DIV", + "label": "÷", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_colemak_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_colemak_0.0.1.hjson new file mode 100644 index 0000000000..1dc091584b --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_colemak_0.0.1.hjson @@ -0,0 +1,302 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ F │ P │ G │ J │ L │ U │ Y │ ; │ [ │ ] │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ R │ S │ T │ D │ H │ N │ E │ I │ O │ ' │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Z │ X │ C │ V │ B │ K │ M │ , │ . │ / │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "CM_GRV", + "label": "`", + } + "KC_1": { + "key": "CM_1", + "label": "1", + } + "KC_2": { + "key": "CM_2", + "label": "2", + } + "KC_3": { + "key": "CM_3", + "label": "3", + } + "KC_4": { + "key": "CM_4", + "label": "4", + } + "KC_5": { + "key": "CM_5", + "label": "5", + } + "KC_6": { + "key": "CM_6", + "label": "6", + } + "KC_7": { + "key": "CM_7", + "label": "7", + } + "KC_8": { + "key": "CM_8", + "label": "8", + } + "KC_9": { + "key": "CM_9", + "label": "9", + } + "KC_0": { + "key": "CM_0", + "label": "0", + } + "KC_MINS": { + "key": "CM_MINS", + "label": "-", + } + "KC_EQL": { + "key": "CM_EQL", + "label": "=", + } + "KC_Q": { + "key": "CM_Q", + "label": "Q", + } + "KC_W": { + "key": "CM_W", + "label": "W", + } + "KC_E": { + "key": "CM_F", + "label": "F", + } + "KC_R": { + "key": "CM_P", + "label": "P", + } + "KC_T": { + "key": "CM_G", + "label": "G", + } + "KC_Y": { + "key": "CM_J", + "label": "J", + } + "KC_U": { + "key": "CM_L", + "label": "L", + } + "KC_I": { + "key": "CM_U", + "label": "U", + } + "KC_O": { + "key": "CM_Y", + "label": "Y", + } + "KC_P": { + "key": "CM_SCLN", + "label": ";", + } + "KC_LBRC": { + "key": "CM_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "CM_RBRC", + "label": "]", + } + "KC_BSLS": { + "key": "CM_BSLS", + "label": "\\", + } + "KC_A": { + "key": "CM_A", + "label": "A", + } + "KC_S": { + "key": "CM_R", + "label": "R", + } + "KC_D": { + "key": "CM_S", + "label": "S", + } + "KC_F": { + "key": "CM_T", + "label": "T", + } + "KC_G": { + "key": "CM_D", + "label": "D", + } + "KC_H": { + "key": "CM_H", + "label": "H", + } + "KC_J": { + "key": "CM_N", + "label": "N", + } + "KC_K": { + "key": "CM_E", + "label": "E", + } + "KC_L": { + "key": "CM_I", + "label": "I", + } + "KC_SCLN": { + "key": "CM_O", + "label": "O", + } + "KC_QUOT": { + "key": "CM_QUOT", + "label": "'", + } + "KC_Z": { + "key": "CM_Z", + "label": "Z", + } + "KC_X": { + "key": "CM_X", + "label": "X", + } + "KC_C": { + "key": "CM_C", + "label": "C", + } + "KC_V": { + "key": "CM_V", + "label": "V", + } + "KC_B": { + "key": "CM_B", + "label": "B", + } + "KC_N": { + "key": "CM_K", + "label": "K", + } + "KC_M": { + "key": "CM_M", + "label": "M", + } + "KC_COMM": { + "key": "CM_COMM", + "label": ",", + } + "KC_DOT": { + "key": "CM_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "CM_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(CM_GRV)": { + "key": "CM_TILD", + "label": "~", + } + "S(CM_1)": { + "key": "CM_EXLM", + "label": "!", + } + "S(CM_2)": { + "key": "CM_AT", + "label": "@", + } + "S(CM_3)": { + "key": "CM_HASH", + "label": "#", + } + "S(CM_4)": { + "key": "CM_DLR", + "label": "$", + } + "S(CM_5)": { + "key": "CM_PERC", + "label": "%", + } + "S(CM_6)": { + "key": "CM_CIRC", + "label": "^", + } + "S(CM_7)": { + "key": "CM_AMPR", + "label": "&", + } + "S(CM_8)": { + "key": "CM_ASTR", + "label": "*", + } + "S(CM_9)": { + "key": "CM_LPRN", + "label": "(", + } + "S(CM_0)": { + "key": "CM_RPRN", + "label": ")", + } + "S(CM_MINS)": { + "key": "CM_UNDS", + "label": "_", + } + "S(CM_EQL)": { + "key": "CM_PLUS", + "label": "+", + } + "S(CM_SCLN)": { + "key": "CM_COLN", + "label": ":", + } + "S(CM_LBRC)": { + "key": "CM_LCBR", + "label": "{", + } + "S(CM_RBRC)": { + "key": "CM_RCBR", + "label": "}", + } + "S(CM_BSLS)": { + "key": "CM_PIPE", + "label": "|", + } + "S(CM_QUOT)": { + "key": "CM_DQUO", + "label": "\"", + } + "S(CM_COMM)": { + "key": "CM_LABK", + "label": "<", + } + "S(CM_DOT)": { + "key": "CM_RABK", + "label": ">", + } + "S(CM_SLSH)": { + "key": "CM_QUES", + "label": "?", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_croatian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_croatian_0.0.1.hjson new file mode 100644 index 0000000000..82632aa637 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_croatian_0.0.1.hjson @@ -0,0 +1,403 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¸ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Š│ Ä â”‚ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ÄŒ │ Ć │ Ž │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "HR_CEDL", + "label": "¸ (dead)", + } + "KC_1": { + "key": "HR_1", + "label": "1", + } + "KC_2": { + "key": "HR_2", + "label": "2", + } + "KC_3": { + "key": "HR_3", + "label": "3", + } + "KC_4": { + "key": "HR_4", + "label": "4", + } + "KC_5": { + "key": "HR_5", + "label": "5", + } + "KC_6": { + "key": "HR_6", + "label": "6", + } + "KC_7": { + "key": "HR_7", + "label": "7", + } + "KC_8": { + "key": "HR_8", + "label": "8", + } + "KC_9": { + "key": "HR_9", + "label": "9", + } + "KC_0": { + "key": "HR_0", + "label": "0", + } + "KC_MINS": { + "key": "HR_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "HR_PLUS", + "label": "+", + } + "KC_Q": { + "key": "HR_Q", + "label": "Q", + } + "KC_W": { + "key": "HR_W", + "label": "W", + } + "KC_E": { + "key": "HR_E", + "label": "E", + } + "KC_R": { + "key": "HR_R", + "label": "R", + } + "KC_T": { + "key": "HR_T", + "label": "T", + } + "KC_Y": { + "key": "HR_Z", + "label": "Z", + } + "KC_U": { + "key": "HR_U", + "label": "U", + } + "KC_I": { + "key": "HR_I", + "label": "I", + } + "KC_O": { + "key": "HR_O", + "label": "O", + } + "KC_P": { + "key": "HR_P", + "label": "P", + } + "KC_LBRC": { + "key": "HR_SCAR", + "label": "Å ", + } + "KC_RBRC": { + "key": "HR_DSTR", + "label": "Ä", + } + "KC_A": { + "key": "HR_A", + "label": "A", + } + "KC_S": { + "key": "HR_S", + "label": "S", + } + "KC_D": { + "key": "HR_D", + "label": "D", + } + "KC_F": { + "key": "HR_F", + "label": "F", + } + "KC_G": { + "key": "HR_G", + "label": "G", + } + "KC_H": { + "key": "HR_H", + "label": "H", + } + "KC_J": { + "key": "HR_J", + "label": "J", + } + "KC_K": { + "key": "HR_K", + "label": "K", + } + "KC_L": { + "key": "HR_L", + "label": "L", + } + "KC_SCLN": { + "key": "HR_CCAR", + "label": "ÄŒ", + } + "KC_QUOT": { + "key": "HR_CACU", + "label": "Ć", + } + "KC_NUHS": { + "key": "HR_ZCAR", + "label": "Ž", + } + "KC_NUBS": { + "key": "HR_LABK", + "label": "<", + } + "KC_Z": { + "key": "HR_Y", + "label": "Y", + } + "KC_X": { + "key": "HR_X", + "label": "X", + } + "KC_C": { + "key": "HR_C", + "label": "C", + } + "KC_V": { + "key": "HR_V", + "label": "V", + } + "KC_B": { + "key": "HR_B", + "label": "B", + } + "KC_N": { + "key": "HR_N", + "label": "N", + } + "KC_M": { + "key": "HR_M", + "label": "M", + } + "KC_COMM": { + "key": "HR_COMM", + "label": ",", + } + "KC_DOT": { + "key": "HR_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "HR_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¨ │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ * │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(HR_CEDL)": { + "key": "HR_DIAE", + "label": "¨ (dead)", + } + "S(HR_1)": { + "key": "HR_EXLM", + "label": "!", + } + "S(HR_2)": { + "key": "HR_DQUO", + "label": "\"", + } + "S(HR_3)": { + "key": "HR_HASH", + "label": "#", + } + "S(HR_4)": { + "key": "HR_DLR", + "label": "$", + } + "S(HR_5)": { + "key": "HR_PERC", + "label": "%", + } + "S(HR_6)": { + "key": "HR_AMPR", + "label": "&", + } + "S(HR_7)": { + "key": "HR_SLSH", + "label": "/", + } + "S(HR_8)": { + "key": "HR_LPRN", + "label": "(", + } + "S(HR_9)": { + "key": "HR_RPRN", + "label": ")", + } + "S(HR_0)": { + "key": "HR_EQL", + "label": "=", + } + "S(HR_QUOT)": { + "key": "HR_QUES", + "label": "?", + } + "S(HR_PLUS)": { + "key": "HR_ASTR", + "label": "*", + } + "S(HR_LABK)": { + "key": "HR_RABK", + "label": ">", + } + "S(HR_COMM)": { + "key": "HR_SCLN", + "label": ";", + } + "S(HR_DOT)": { + "key": "HR_COLN", + "label": ":", + } + "S(HR_MINS)": { + "key": "HR_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ~ │ ˇ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ ´ │ Ë â”‚ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ \ │ | │ € │ │ │ │ │ │ │ │ ÷ │ × │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ [ │ ] │ │ │ Å‚ │ Š│ │ ß │ ¤ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ @ │ { │ } │ § │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(HR_1)": { + "key": "HR_TILD", + "label": "~", + } + "ALGR(HR_2)": { + "key": "HR_CARN", + "label": "ˇ (dead)", + } + "ALGR(HR_3)": { + "key": "HR_CIRC", + "label": "^ (dead)", + } + "ALGR(HR_4)": { + "key": "HR_BREV", + "label": "˘ (dead)", + } + "ALGR(HR_5)": { + "key": "HR_RNGA", + "label": "° (dead)", + } + "ALGR(HR_6)": { + "key": "HR_OGON", + "label": "Ë› (dead)", + } + "ALGR(HR_7)": { + "key": "HR_GRV", + "label": "`", + } + "ALGR(HR_8)": { + "key": "HR_DOTA", + "label": "Ë™ (dead)", + } + "ALGR(HR_9)": { + "key": "HR_ACUT", + "label": "´ (dead)", + } + "ALGR(HR_0)": { + "key": "HR_DACU", + "label": "Ë (dead)", + } + "ALGR(HR_Q)": { + "key": "HR_BSLS", + "label": "\\", + } + "ALGR(HR_W)": { + "key": "HR_PIPE", + "label": "|", + } + "ALGR(HR_E)": { + "key": "HR_EURO", + "label": "€", + } + "ALGR(HR_SCAR)": { + "key": "HR_DIV", + "label": "÷", + } + "ALGR(HR_DSTR)": { + "key": "HR_MUL", + "label": "×", + } + "ALGR(HR_F)": { + "key": "HR_LBRC", + "label": "[", + } + "ALGR(HR_G)": { + "key": "HR_RBRC", + "label": "]", + } + "ALGR(HR_K)": { + "key": "HR_LLST", + "label": "Å‚", + } + "ALGR(HR_L)": { + "key": "HR_CLST", + "label": "Å", + } + "ALGR(HR_CACU)": { + "key": "HR_SS", + "label": "ß", + } + "ALGR(HR_ZCAR)": { + "key": "HR_CURR", + "label": "¤", + } + "ALGR(HR_V)": { + "key": "HR_AT", + "label": "@", + } + "ALGR(HR_B)": { + "key": "HR_LCBR", + "label": "{", + } + "ALGR(HR_N)": { + "key": "HR_RCBR", + "label": "}", + } + "ALGR(HR_M)": { + "key": "HR_SECT", + "label": "§", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_czech_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_czech_0.0.1.hjson new file mode 100644 index 0000000000..9cfb88c489 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_czech_0.0.1.hjson @@ -0,0 +1,435 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ; │ + │ Ä› │ Å¡ │ Ä â”‚ Å™ │ ž │ ý │ á │ à │ é │ = │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ ú │ ) │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ů │ § │ ¨ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ \ │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "CZ_SCLN", + "label": ";", + } + "KC_1": { + "key": "CZ_PLUS", + "label": "+", + } + "KC_2": { + "key": "CZ_ECAR", + "label": "Ä›", + } + "KC_3": { + "key": "CZ_SCAR", + "label": "Å¡", + } + "KC_4": { + "key": "CZ_CCAR", + "label": "Ä", + } + "KC_5": { + "key": "CZ_RCAR", + "label": "Å™", + } + "KC_6": { + "key": "CZ_ZCAR", + "label": "ž", + } + "KC_7": { + "key": "CZ_YACU", + "label": "ý", + } + "KC_8": { + "key": "CZ_AACU", + "label": "á", + } + "KC_9": { + "key": "CZ_IACU", + "label": "Ã", + } + "KC_0": { + "key": "CZ_EACU", + "label": "é", + } + "KC_MINS": { + "key": "CZ_EQL", + "label": "=", + } + "KC_EQL": { + "key": "CZ_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "CZ_Q", + "label": "Q", + } + "KC_W": { + "key": "CZ_W", + "label": "W", + } + "KC_E": { + "key": "CZ_E", + "label": "E", + } + "KC_R": { + "key": "CZ_R", + "label": "R", + } + "KC_T": { + "key": "CZ_T", + "label": "T", + } + "KC_Y": { + "key": "CZ_Z", + "label": "Z", + } + "KC_U": { + "key": "CZ_U", + "label": "U", + } + "KC_I": { + "key": "CZ_I", + "label": "I", + } + "KC_O": { + "key": "CZ_O", + "label": "O", + } + "KC_P": { + "key": "CZ_P", + "label": "P", + } + "KC_LBRC": { + "key": "CZ_UACU", + "label": "ú", + } + "KC_RBRC": { + "key": "CZ_RPRN", + "label": ")", + } + "KC_A": { + "key": "CZ_A", + "label": "A", + } + "KC_S": { + "key": "CZ_S", + "label": "S", + } + "KC_D": { + "key": "CZ_D", + "label": "D", + } + "KC_F": { + "key": "CZ_F", + "label": "F", + } + "KC_G": { + "key": "CZ_G", + "label": "G", + } + "KC_H": { + "key": "CZ_H", + "label": "H", + } + "KC_J": { + "key": "CZ_J", + "label": "J", + } + "KC_K": { + "key": "CZ_K", + "label": "K", + } + "KC_L": { + "key": "CZ_L", + "label": "L", + } + "KC_SCLN": { + "key": "CZ_URNG", + "label": "ů", + } + "KC_QUOT": { + "key": "CZ_SECT", + "label": "§", + } + "KC_NUHS": { + "key": "CZ_DIAE", + "label": "¨ (dead)", + } + "KC_NUBS": { + "key": "CZ_BSLS", + "label": "\\", + } + "KC_Z": { + "key": "CZ_Y", + "label": "Y", + } + "KC_X": { + "key": "CZ_X", + "label": "X", + } + "KC_C": { + "key": "CZ_C", + "label": "C", + } + "KC_V": { + "key": "CZ_V", + "label": "V", + } + "KC_B": { + "key": "CZ_B", + "label": "B", + } + "KC_N": { + "key": "CZ_N", + "label": "N", + } + "KC_M": { + "key": "CZ_M", + "label": "M", + } + "KC_COMM": { + "key": "CZ_COMM", + "label": ",", + } + "KC_DOT": { + "key": "CZ_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "CZ_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ° │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ % │ ˇ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ / │ ( │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ " │ ! │ ' │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ | │ │ │ │ │ │ │ │ ? │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(CZ_SCLN)": { + "key": "CZ_RNGA", + "label": "° (dead)", + } + "S(CZ_PLUS)": { + "key": "CZ_1", + "label": "1", + } + "S(CZ_ECAR)": { + "key": "CZ_2", + "label": "2", + } + "S(CZ_SCAR)": { + "key": "CZ_3", + "label": "3", + } + "S(CZ_CCAR)": { + "key": "CZ_4", + "label": "4", + } + "S(CZ_RCAR)": { + "key": "CZ_5", + "label": "5", + } + "S(CZ_ZCAR)": { + "key": "CZ_6", + "label": "6", + } + "S(CZ_YACU)": { + "key": "CZ_7", + "label": "7", + } + "S(CZ_AACU)": { + "key": "CZ_8", + "label": "8", + } + "S(CZ_IACU)": { + "key": "CZ_9", + "label": "9", + } + "S(CZ_EACU)": { + "key": "CZ_0", + "label": "0", + } + "S(CZ_EQL)": { + "key": "CZ_PERC", + "label": "%", + } + "S(CZ_ACUT)": { + "key": "CZ_CARN", + "label": "ˇ (dead)", + } + "S(CZ_UACU)": { + "key": "CZ_SLSH", + "label": "/", + } + "S(CZ_RPRN)": { + "key": "CZ_LPRN", + "label": "(", + } + "S(CZ_URNG)": { + "key": "CZ_DQUO", + "label": "\"", + } + "S(CZ_SECT)": { + "key": "CZ_EXLM", + "label": "!", + } + "S(CZ_DIAE)": { + "key": "CZ_QUOT", + "label": "'", + } + "S(CZ_BSLS)": { + "key": "CZ_PIPE", + "label": "|", + } + "S(CZ_COMM)": { + "key": "CZ_QUES", + "label": "?", + } + "S(CZ_DOT)": { + "key": "CZ_COLN", + "label": ":", + } + "S(CZ_MINS)": { + "key": "CZ_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ~ │ │ ^ │ ˘ │ │ Ë› │ ` │ Ë™ │ │ Ë â”‚ │ ¸ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ ÷ │ × │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ Ä‘ │ Ä â”‚ [ │ ] │ │ │ Å‚ │ Š│ $ │ ß │ ¤ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ # │ & │ @ │ { │ } │ │ < │ > │ * │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(CZ_PLUS)": { + "key": "CZ_TILD", + "label": "~", + } + "ALGR(CZ_SCAR)": { + "key": "CZ_CIRC", + "label": "^ (dead)", + } + "ALGR(CZ_CCAR)": { + "key": "CZ_BREV", + "label": "˘ (dead)", + } + "ALGR(CZ_ZCAR)": { + "key": "CZ_OGON", + "label": "Ë› (dead)", + } + "ALGR(CZ_YACU)": { + "key": "CZ_GRV", + "label": "` (dead)", + } + "ALGR(CZ_AACU)": { + "key": "CZ_DOTA", + "label": "Ë™ (dead)", + } + "ALGR(CZ_EACU)": { + "key": "CZ_DACU", + "label": "Ë (dead)", + } + "ALGR(CZ_ACUT)": { + "key": "CZ_CEDL", + "label": "¸ (dead)", + } + "ALGR(CZ_E)": { + "key": "CZ_EURO", + "label": "€", + } + "ALGR(CZ_UACU)": { + "key": "CZ_DIV", + "label": "÷", + } + "ALGR(CZ_RPRN)": { + "key": "CZ_MUL", + "label": "×", + } + "ALGR(CZ_S)": { + "key": "CZ_LDST", + "label": "Ä‘", + } + "ALGR(CZ_D)": { + "key": "CZ_CDST", + "label": "Ä", + } + "ALGR(CZ_F)": { + "key": "CZ_LBRC", + "label": "[", + } + "ALGR(CZ_G)": { + "key": "CZ_RBRC", + "label": "]", + } + "ALGR(CZ_K)": { + "key": "CZ_LLST", + "label": "Å‚", + } + "ALGR(CZ_L)": { + "key": "CZ_CLST", + "label": "Å", + } + "ALGR(CZ_URNG)": { + "key": "CZ_DLR", + "label": "$", + } + "ALGR(CZ_SECT)": { + "key": "CZ_SS", + "label": "ß", + } + "ALGR(CZ_DIAE)": { + "key": "CZ_CURR", + "label": "¤", + } + "ALGR(CZ_X)": { + "key": "CZ_HASH", + "label": "#", + } + "ALGR(CZ_C)": { + "key": "CZ_AMPR", + "label": "&", + } + "ALGR(CZ_V)": { + "key": "CZ_AT", + "label": "@", + } + "ALGR(CZ_B)": { + "key": "CZ_LCBR", + "label": "{", + } + "ALGR(CZ_N)": { + "key": "CZ_RCBR", + "label": "}", + } + "ALGR(CZ_COMM)": { + "key": "CZ_LABK", + "label": "<", + } + "ALGR(CZ_DOT)": { + "key": "CZ_RABK", + "label": ">", + } + "ALGR(CZ_MINS)": { + "key": "CZ_ASTR", + "label": "*", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_danish_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_danish_0.0.1.hjson new file mode 100644 index 0000000000..fffcd9f9ad --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_danish_0.0.1.hjson @@ -0,0 +1,359 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ½ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Å │ ¨ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Æ │ Ø │ ' │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "DK_HALF", + "label": "½", + } + "KC_1": { + "key": "DK_1", + "label": "1", + } + "KC_2": { + "key": "DK_2", + "label": "2", + } + "KC_3": { + "key": "DK_3", + "label": "3", + } + "KC_4": { + "key": "DK_4", + "label": "4", + } + "KC_5": { + "key": "DK_5", + "label": "5", + } + "KC_6": { + "key": "DK_6", + "label": "6", + } + "KC_7": { + "key": "DK_7", + "label": "7", + } + "KC_8": { + "key": "DK_8", + "label": "8", + } + "KC_9": { + "key": "DK_9", + "label": "9", + } + "KC_0": { + "key": "DK_0", + "label": "0", + } + "KC_MINS": { + "key": "DK_PLUS", + "label": "+", + } + "KC_EQL": { + "key": "DK_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "DK_Q", + "label": "Q", + } + "KC_W": { + "key": "DK_W", + "label": "W", + } + "KC_E": { + "key": "DK_E", + "label": "E", + } + "KC_R": { + "key": "DK_R", + "label": "R", + } + "KC_T": { + "key": "DK_T", + "label": "T", + } + "KC_Y": { + "key": "DK_Y", + "label": "Y", + } + "KC_U": { + "key": "DK_U", + "label": "U", + } + "KC_I": { + "key": "DK_I", + "label": "I", + } + "KC_O": { + "key": "DK_O", + "label": "O", + } + "KC_P": { + "key": "DK_P", + "label": "P", + } + "KC_LBRC": { + "key": "DK_ARNG", + "label": "Å", + } + "KC_RBRC": { + "key": "DK_DIAE", + "label": "¨ (dead)", + } + "KC_A": { + "key": "DK_A", + "label": "A", + } + "KC_S": { + "key": "DK_S", + "label": "S", + } + "KC_D": { + "key": "DK_D", + "label": "D", + } + "KC_F": { + "key": "DK_F", + "label": "F", + } + "KC_G": { + "key": "DK_G", + "label": "G", + } + "KC_H": { + "key": "DK_H", + "label": "H", + } + "KC_J": { + "key": "DK_J", + "label": "J", + } + "KC_K": { + "key": "DK_K", + "label": "K", + } + "KC_L": { + "key": "DK_L", + "label": "L", + } + "KC_SCLN": { + "key": "DK_AE", + "label": "Æ", + } + "KC_QUOT": { + "key": "DK_OSTR", + "label": "Ø", + } + "KC_NUHS": { + "key": "DK_QUOT", + "label": "'", + } + "KC_NUBS": { + "key": "DK_LABK", + "label": "<", + } + "KC_Z": { + "key": "DK_Z", + "label": "Z", + } + "KC_X": { + "key": "DK_X", + "label": "X", + } + "KC_C": { + "key": "DK_C", + "label": "C", + } + "KC_V": { + "key": "DK_V", + "label": "V", + } + "KC_B": { + "key": "DK_B", + "label": "B", + } + "KC_N": { + "key": "DK_N", + "label": "N", + } + "KC_M": { + "key": "DK_M", + "label": "M", + } + "KC_COMM": { + "key": "DK_COMM", + "label": ",", + } + "KC_DOT": { + "key": "DK_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "DK_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ § │ ! │ " │ # │ ¤ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(DK_HALF)": { + "key": "DK_SECT", + "label": "§", + } + "S(DK_1)": { + "key": "DK_EXLM", + "label": "!", + } + "S(DK_2)": { + "key": "DK_DQUO", + "label": "\"", + } + "S(DK_3)": { + "key": "DK_HASH", + "label": "#", + } + "S(DK_4)": { + "key": "DK_CURR", + "label": "¤", + } + "S(DK_5)": { + "key": "DK_PERC", + "label": "%", + } + "S(DK_6)": { + "key": "DK_AMPR", + "label": "&", + } + "S(DK_7)": { + "key": "DK_SLSH", + "label": "/", + } + "S(DK_8)": { + "key": "DK_LPRN", + "label": "(", + } + "S(DK_9)": { + "key": "DK_RPRN", + "label": ")", + } + "S(DK_0)": { + "key": "DK_EQL", + "label": "=", + } + "S(DK_PLUS)": { + "key": "DK_QUES", + "label": "?", + } + "S(DK_ACUT)": { + "key": "DK_GRV", + "label": "` (dead)", + } + "S(DK_DIAE)": { + "key": "DK_CIRC", + "label": "^ (dead)", + } + "S(DK_QUOT)": { + "key": "DK_ASTR", + "label": "*", + } + "S(DK_LABK)": { + "key": "DK_RABK", + "label": ">", + } + "S(DK_COMM)": { + "key": "DK_SCLN", + "label": ";", + } + "S(DK_DOT)": { + "key": "DK_COLN", + "label": ":", + } + "S(DK_MINS)": { + "key": "DK_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ @ │ £ │ $ │ € │ │ { │ [ │ ] │ } │ │ | │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ \ │ │ │ │ │ │ │ µ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(DK_2)": { + "key": "DK_AT", + "label": "@", + } + "ALGR(DK_3)": { + "key": "DK_PND", + "label": "£", + } + "ALGR(DK_4)": { + "key": "DK_DLR", + "label": "$", + } + "ALGR(DK_5)": { + "key": "DK_EURO", + "label": "€", + } + "ALGR(DK_7)": { + "key": "DK_LCBR", + "label": "{", + } + "ALGR(DK_8)": { + "key": "DK_LBRC", + "label": "[", + } + "ALGR(DK_9)": { + "key": "DK_RBRC", + "label": "]", + } + "ALGR(DK_0)": { + "key": "DK_RCBR", + "label": "}", + } + "ALGR(DK_ACUT)": { + "key": "DK_PIPE", + "label": "|", + } + "ALGR(DK_DIAE)": { + "key": "DK_TILD", + "label": "~ (dead)", + } + "ALGR(DK_LABK)": { + "key": "DK_BSLS", + "label": "\\", + } + "ALGR(DK_M)": { + "key": "DK_MICR", + "label": "µ", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_dvorak_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_dvorak_0.0.1.hjson new file mode 100644 index 0000000000..534f99c8e6 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_dvorak_0.0.1.hjson @@ -0,0 +1,302 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ [ │ ] │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ ' │ , │ . │ P │ Y │ F │ G │ C │ R │ L │ / │ = │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ O │ E │ U │ I │ D │ H │ T │ N │ S │ - │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ ; │ Q │ J │ K │ X │ B │ M │ W │ V │ Z │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "DV_GRV", + "label": "`", + } + "KC_1": { + "key": "DV_1", + "label": "1", + } + "KC_2": { + "key": "DV_2", + "label": "2", + } + "KC_3": { + "key": "DV_3", + "label": "3", + } + "KC_4": { + "key": "DV_4", + "label": "4", + } + "KC_5": { + "key": "DV_5", + "label": "5", + } + "KC_6": { + "key": "DV_6", + "label": "6", + } + "KC_7": { + "key": "DV_7", + "label": "7", + } + "KC_8": { + "key": "DV_8", + "label": "8", + } + "KC_9": { + "key": "DV_9", + "label": "9", + } + "KC_0": { + "key": "DV_0", + "label": "0", + } + "KC_MINS": { + "key": "DV_LBRC", + "label": "[", + } + "KC_EQL": { + "key": "DV_RBRC", + "label": "]", + } + "KC_Q": { + "key": "DV_QUOT", + "label": "'", + } + "KC_W": { + "key": "DV_COMM", + "label": ",", + } + "KC_E": { + "key": "DV_DOT", + "label": ".", + } + "KC_R": { + "key": "DV_P", + "label": "P", + } + "KC_T": { + "key": "DV_Y", + "label": "Y", + } + "KC_Y": { + "key": "DV_F", + "label": "F", + } + "KC_U": { + "key": "DV_G", + "label": "G", + } + "KC_I": { + "key": "DV_C", + "label": "C", + } + "KC_O": { + "key": "DV_R", + "label": "R", + } + "KC_P": { + "key": "DV_L", + "label": "L", + } + "KC_LBRC": { + "key": "DV_SLSH", + "label": "/", + } + "KC_RBRC": { + "key": "DV_EQL", + "label": "=", + } + "KC_BSLS": { + "key": "DV_BSLS", + "label": "\\", + } + "KC_A": { + "key": "DV_A", + "label": "A", + } + "KC_S": { + "key": "DV_O", + "label": "O", + } + "KC_D": { + "key": "DV_E", + "label": "E", + } + "KC_F": { + "key": "DV_U", + "label": "U", + } + "KC_G": { + "key": "DV_I", + "label": "I", + } + "KC_H": { + "key": "DV_D", + "label": "D", + } + "KC_J": { + "key": "DV_H", + "label": "H", + } + "KC_K": { + "key": "DV_T", + "label": "T", + } + "KC_L": { + "key": "DV_N", + "label": "N", + } + "KC_SCLN": { + "key": "DV_S", + "label": "S", + } + "KC_QUOT": { + "key": "DV_MINS", + "label": "-", + } + "KC_Z": { + "key": "DV_SCLN", + "label": ";", + } + "KC_X": { + "key": "DV_Q", + "label": "Q", + } + "KC_C": { + "key": "DV_J", + "label": "J", + } + "KC_V": { + "key": "DV_K", + "label": "K", + } + "KC_B": { + "key": "DV_X", + "label": "X", + } + "KC_N": { + "key": "DV_B", + "label": "B", + } + "KC_M": { + "key": "DV_M", + "label": "M", + } + "KC_COMM": { + "key": "DV_W", + "label": "W", + } + "KC_DOT": { + "key": "DV_V", + "label": "V", + } + "KC_SLSH": { + "key": "DV_Z", + "label": "Z", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ { │ } │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ " │ < │ > │ │ │ │ │ │ │ │ ? │ + │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ _ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ : │ │ │ │ │ │ │ │ │ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(DV_GRV)": { + "key": "DV_TILD", + "label": "~", + } + "S(DV_1)": { + "key": "DV_EXLM", + "label": "!", + } + "S(DV_2)": { + "key": "DV_AT", + "label": "@", + } + "S(DV_3)": { + "key": "DV_HASH", + "label": "#", + } + "S(DV_4)": { + "key": "DV_DLR", + "label": "$", + } + "S(DV_5)": { + "key": "DV_PERC", + "label": "%", + } + "S(DV_6)": { + "key": "DV_CIRC", + "label": "^", + } + "S(DV_7)": { + "key": "DV_AMPR", + "label": "&", + } + "S(DV_8)": { + "key": "DV_ASTR", + "label": "*", + } + "S(DV_9)": { + "key": "DV_LPRN", + "label": "(", + } + "S(DV_0)": { + "key": "DV_RPRN", + "label": ")", + } + "S(DV_LBRC)": { + "key": "DV_LCBR", + "label": "{", + } + "S(DV_RBRC)": { + "key": "DV_RCBR", + "label": "}", + } + "S(DV_QUOT)": { + "key": "DV_DQUO", + "label": "\"", + } + "S(DV_COMM)": { + "key": "DV_LABK", + "label": "<", + } + "S(DV_DOT)": { + "key": "DV_RABK", + "label": ">", + } + "S(DV_SLSH)": { + "key": "DV_QUES", + "label": "?", + } + "S(DV_EQL)": { + "key": "DV_PLUS", + "label": "+", + } + "S(DV_BSLS)": { + "key": "DV_PIPE", + "label": "|", + } + "S(DV_MINS)": { + "key": "DV_UNDS", + "label": "_", + } + "S(DV_SCLN)": { + "key": "DV_COLN", + "label": ":", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_dvorak_fr_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_dvorak_fr_0.0.1.hjson new file mode 100644 index 0000000000..70c0b3c0aa --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_dvorak_fr_0.0.1.hjson @@ -0,0 +1,317 @@ +{ + "aliases": { +/* Dvorak for the French language + * Version: 2 + * + * The layout is designed by Francis Leboutte <dvorak-fr@algo.be> + * + * Source: https://algo.be/ergo/dvorak-fr.html + */ +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ « │ » │ / │ - │ è │ \ │ ^ │ ( │ ` │ ) │ _ │ [ │ ] │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ : │ ' │ é │ G │ . │ H │ V │ C │ M │ K │ Z │ ¨ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ O │ A │ U │ E │ B │ F │ S │ T │ N │ D │ W │ ~ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ à │ ; │ Q │ , │ I │ Y │ X │ R │ L │ P │ J │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "DV_LDAQ", + "label": "«", + } + "KC_1": { + "key": "DV_RDAQ", + "label": "»", + } + "KC_2": { + "key": "DV_SLSH", + "label": "/", + } + "KC_3": { + "key": "DV_MINS", + "label": "-", + } + "KC_4": { + "key": "DV_EGRV", + "label": "è", + } + "KC_5": { + "key": "DV_BSLS", + "label": "\\", + } + "KC_6": { + "key": "DV_CIRC", + "label": "^ (dead)", + } + "KC_7": { + "key": "DV_LPRN", + "label": "(", + } + "KC_8": { + "key": "DV_GRV", + "label": "` (dead)", + } + "KC_9": { + "key": "DV_RPRN", + "label": ")", + } + "KC_0": { + "key": "DV_UNDS", + "label": "_", + } + "KC_MINS": { + "key": "DV_LBRC", + "label": "[", + } + "KC_EQL": { + "key": "DV_RBRC", + "label": "]", + } + "KC_Q": { + "key": "DV_COLN", + "label": ":", + } + "KC_W": { + "key": "DV_QUOT", + "label": "'", + } + "KC_E": { + "key": "DV_EACU", + "label": "é", + } + "KC_R": { + "key": "DV_G", + "label": "G", + } + "KC_T": { + "key": "DV_DOT", + "label": ".", + } + "KC_Y": { + "key": "DV_H", + "label": "H", + } + "KC_U": { + "key": "DV_V", + "label": "V", + } + "KC_I": { + "key": "DV_C", + "label": "C", + } + "KC_O": { + "key": "DV_M", + "label": "M", + } + "KC_P": { + "key": "DV_K", + "label": "K", + } + "KC_LBRC": { + "key": "DV_Z", + "label": "Z", + } + "KC_RBRC": { + "key": "DV_DIAE", + "label": "¨ (dead)", + } + "KC_A": { + "key": "DV_O", + "label": "O", + } + "KC_S": { + "key": "DV_A", + "label": "A", + } + "KC_D": { + "key": "DV_U", + "label": "U", + } + "KC_F": { + "key": "DV_E", + "label": "E", + } + "KC_G": { + "key": "DV_B", + "label": "B", + } + "KC_H": { + "key": "DV_F", + "label": "F", + } + "KC_J": { + "key": "DV_S", + "label": "S", + } + "KC_K": { + "key": "DV_T", + "label": "T", + } + "KC_L": { + "key": "DV_N", + "label": "N", + } + "KC_SCLN": { + "key": "DV_D", + "label": "D", + } + "KC_QUOT": { + "key": "DV_W", + "label": "W", + } + "KC_NUHS": { + "key": "DV_TILD", + "label": "~ (dead)", + } + "KC_NUBS": { + "key": "DV_AGRV", + "label": "à ", + } + "KC_Z": { + "key": "DV_SCLN", + "label": ";", + } + "KC_X": { + "key": "DV_Q", + "label": "Q", + } + "KC_C": { + "key": "DV_COMM", + "label": ",", + } + "KC_V": { + "key": "DV_I", + "label": "I", + } + "KC_B": { + "key": "DV_Y", + "label": "Y", + } + "KC_N": { + "key": "DV_X", + "label": "X", + } + "KC_M": { + "key": "DV_R", + "label": "R", + } + "KC_COMM": { + "key": "DV_L", + "label": "L", + } + "KC_DOT": { + "key": "DV_P", + "label": "P", + } + "KC_SLSH": { + "key": "DV_J", + "label": "J", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ * │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 0 │ 0 │ + │ % │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ ? │ < │ > │ │ ! │ │ │ │ │ │ │ = │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ # │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ ç │ | │ │ @ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(DV_LDAQ)": { + "key": "DV_ASTR", + "label": "*", + } + "S(DV_RDAQ)": { + "key": "DV_1", + "label": "1", + } + "S(DV_SLSH)": { + "key": "DV_2", + "label": "2", + } + "S(DV_MINS)": { + "key": "DV_3", + "label": "3", + } + "S(DV_EGRV)": { + "key": "DV_4", + "label": "4", + } + "S(DV_BSLS)": { + "key": "DV_5", + "label": "5", + } + "S(DV_CIRC)": { + "key": "DV_6", + "label": "6", + } + "S(DV_LPRN)": { + "key": "DV_7", + "label": "7", + } + "S(DV_GRV)": { + "key": "DV_8", + "label": "8", + } + "S(DV_RPRN)": { + "key": "DV_9", + "label": "9", + } + "S(DV_UNDS)": { + "key": "DV_0", + "label": "0", + } + "S(DV_LBRC)": { + "key": "DV_PLUS", + "label": "+", + } + "S(DV_RBRC)": { + "key": "DV_PERC", + "label": "%", + } + "S(DV_COLN)": { + "key": "DV_QUES", + "label": "?", + } + "S(DV_QUOT)": { + "key": "DV_LABK", + "label": "<", + } + "S(DV_EACU)": { + "key": "DV_RABK", + "label": ">", + } + "S(DV_DOT)": { + "key": "DV_EXLM", + "label": "!", + } + "S(DV_DIAE)": { + "key": "DV_EQL", + "label": "=", + } + "S(DV_TILD)": { + "key": "DV_HASH", + "label": "#", + } + "S(DV_AGRV)": { + "key": "DV_CCED", + "label": "ç", + } + "S(DV_SCLN)": { + "key": "DV_PIPE", + "label": "|", + } + "S(DV_COMM)": { + "key": "DV_AT", + "label": "@", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_dvorak_programmer_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_dvorak_programmer_0.0.1.hjson new file mode 100644 index 0000000000..8a70dae7ef --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_dvorak_programmer_0.0.1.hjson @@ -0,0 +1,302 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ $ │ & │ [ │ { │ } │ ( │ = │ * │ ) │ + │ ] │ ! │ # │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ ; │ , │ . │ P │ Y │ F │ G │ C │ R │ L │ / │ @ │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ O │ E │ U │ I │ D │ H │ T │ N │ S │ - │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ ' │ Q │ J │ K │ X │ B │ M │ W │ V │ Z │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "DP_DLR", + "label": "$", + } + "KC_1": { + "key": "DP_AMPR", + "label": "&", + } + "KC_2": { + "key": "DP_LBRC", + "label": "[", + } + "KC_3": { + "key": "DP_LCBR", + "label": "{", + } + "KC_4": { + "key": "DP_RCBR", + "label": "}", + } + "KC_5": { + "key": "DP_LPRN", + "label": "(", + } + "KC_6": { + "key": "DP_EQL", + "label": "=", + } + "KC_7": { + "key": "DP_ASTR", + "label": "*", + } + "KC_8": { + "key": "DP_RPRN", + "label": ")", + } + "KC_9": { + "key": "DP_PLUS", + "label": "+", + } + "KC_0": { + "key": "DP_RBRC", + "label": "]", + } + "KC_MINS": { + "key": "DP_EXLM", + "label": "!", + } + "KC_EQL": { + "key": "DP_HASH", + "label": "#", + } + "KC_Q": { + "key": "DP_SCLN", + "label": ";", + } + "KC_W": { + "key": "DP_COMM", + "label": ",", + } + "KC_E": { + "key": "DP_DOT", + "label": ".", + } + "KC_R": { + "key": "DP_P", + "label": "P", + } + "KC_T": { + "key": "DP_Y", + "label": "Y", + } + "KC_Y": { + "key": "DP_F", + "label": "F", + } + "KC_U": { + "key": "DP_G", + "label": "G", + } + "KC_I": { + "key": "DP_C", + "label": "C", + } + "KC_O": { + "key": "DP_R", + "label": "R", + } + "KC_P": { + "key": "DP_L", + "label": "L", + } + "KC_LBRC": { + "key": "DP_SLSH", + "label": "/", + } + "KC_RBRC": { + "key": "DP_AT", + "label": "@", + } + "KC_BSLS": { + "key": "DP_BSLS", + "label": "\\", + } + "KC_A": { + "key": "DP_A", + "label": "A", + } + "KC_S": { + "key": "DP_O", + "label": "O", + } + "KC_D": { + "key": "DP_E", + "label": "E", + } + "KC_F": { + "key": "DP_U", + "label": "U", + } + "KC_G": { + "key": "DP_I", + "label": "I", + } + "KC_H": { + "key": "DP_D", + "label": "D", + } + "KC_J": { + "key": "DP_H", + "label": "H", + } + "KC_K": { + "key": "DP_T", + "label": "T", + } + "KC_L": { + "key": "DP_N", + "label": "N", + } + "KC_SCLN": { + "key": "DP_S", + "label": "S", + } + "KC_QUOT": { + "key": "DP_MINS", + "label": "-", + } + "KC_Z": { + "key": "DP_QUOT", + "label": "'", + } + "KC_X": { + "key": "DP_Q", + "label": "Q", + } + "KC_C": { + "key": "DP_J", + "label": "J", + } + "KC_V": { + "key": "DP_K", + "label": "K", + } + "KC_B": { + "key": "DP_X", + "label": "X", + } + "KC_N": { + "key": "DP_B", + "label": "B", + } + "KC_M": { + "key": "DP_M", + "label": "M", + } + "KC_COMM": { + "key": "DP_W", + "label": "W", + } + "KC_DOT": { + "key": "DP_V", + "label": "V", + } + "KC_SLSH": { + "key": "DP_Z", + "label": "Z", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ % │ 7 │ 5 │ 3 │ 1 │ 9 │ 0 │ 2 │ 4 │ 6 │ 8 │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ : │ < │ > │ │ │ │ │ │ │ │ ? │ ^ │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ _ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ " │ │ │ │ │ │ │ │ │ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(DP_DLR)": { + "key": "DP_TILD", + "label": "~", + } + "S(DP_AMPR)": { + "key": "DP_PERC", + "label": "%", + } + "S(DP_LBRC)": { + "key": "DP_7", + "label": "7", + } + "S(DP_LCBR)": { + "key": "DP_5", + "label": "5", + } + "S(DP_RCBR)": { + "key": "DP_3", + "label": "3", + } + "S(DP_LPRN)": { + "key": "DP_1", + "label": "1", + } + "S(DP_EQL)": { + "key": "DP_9", + "label": "9", + } + "S(DP_ASTR)": { + "key": "DP_0", + "label": "0", + } + "S(DP_RPRN)": { + "key": "DP_2", + "label": "2", + } + "S(DP_PLUS)": { + "key": "DP_4", + "label": "4", + } + "S(DP_RBRC)": { + "key": "DP_6", + "label": "6", + } + "S(DP_EXLM)": { + "key": "DP_8", + "label": "8", + } + "S(DP_HASH)": { + "key": "DP_GRV", + "label": "`", + } + "S(DP_SCLN)": { + "key": "DP_COLN", + "label": ":", + } + "S(DP_COMM)": { + "key": "DP_LABK", + "label": "<", + } + "S(DP_DOT)": { + "key": "DP_RABK", + "label": ">", + } + "S(DP_SLSH)": { + "key": "DP_QUES", + "label": "?", + } + "S(DP_AT)": { + "key": "DP_CIRC", + "label": "^", + } + "S(DP_BSLS)": { + "key": "DP_PIPE", + "label": "|", + } + "S(DP_MINS)": { + "key": "DP_UNDS", + "label": "_", + } + "S(DP_QUOT)": { + "key": "DP_DQUO", + "label": "\"", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_estonian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_estonian_0.0.1.hjson new file mode 100644 index 0000000000..bbf7512581 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_estonian_0.0.1.hjson @@ -0,0 +1,367 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ˇ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ü │ Õ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ ' │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "EE_CARN", + "label": "ˇ (dead)", + } + "KC_1": { + "key": "EE_1", + "label": "1", + } + "KC_2": { + "key": "EE_2", + "label": "2", + } + "KC_3": { + "key": "EE_3", + "label": "3", + } + "KC_4": { + "key": "EE_4", + "label": "4", + } + "KC_5": { + "key": "EE_5", + "label": "5", + } + "KC_6": { + "key": "EE_6", + "label": "6", + } + "KC_7": { + "key": "EE_7", + "label": "7", + } + "KC_8": { + "key": "EE_8", + "label": "8", + } + "KC_9": { + "key": "EE_9", + "label": "9", + } + "KC_0": { + "key": "EE_0", + "label": "0", + } + "KC_MINS": { + "key": "EE_PLUS", + "label": "+", + } + "KC_EQL": { + "key": "EE_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "EE_Q", + "label": "Q", + } + "KC_W": { + "key": "EE_W", + "label": "W", + } + "KC_E": { + "key": "EE_E", + "label": "E", + } + "KC_R": { + "key": "EE_R", + "label": "R", + } + "KC_T": { + "key": "EE_T", + "label": "T", + } + "KC_Y": { + "key": "EE_Y", + "label": "Y", + } + "KC_U": { + "key": "EE_U", + "label": "U", + } + "KC_I": { + "key": "EE_I", + "label": "I", + } + "KC_O": { + "key": "EE_O", + "label": "O", + } + "KC_P": { + "key": "EE_P", + "label": "P", + } + "KC_LBRC": { + "key": "EE_UDIA", + "label": "Ü", + } + "KC_RBRC": { + "key": "EE_OTIL", + "label": "Õ", + } + "KC_A": { + "key": "EE_A", + "label": "A", + } + "KC_S": { + "key": "EE_S", + "label": "S", + } + "KC_D": { + "key": "EE_D", + "label": "D", + } + "KC_F": { + "key": "EE_F", + "label": "F", + } + "KC_G": { + "key": "EE_G", + "label": "G", + } + "KC_H": { + "key": "EE_H", + "label": "H", + } + "KC_J": { + "key": "EE_J", + "label": "J", + } + "KC_K": { + "key": "EE_K", + "label": "K", + } + "KC_L": { + "key": "EE_L", + "label": "L", + } + "KC_SCLN": { + "key": "EE_ODIA", + "label": "Ö", + } + "KC_QUOT": { + "key": "EE_ADIA", + "label": "Ä", + } + "KC_NUHS": { + "key": "EE_QUOT", + "label": "'", + } + "KC_NUBS": { + "key": "EE_LABK", + "label": "<", + } + "KC_Z": { + "key": "EE_Z", + "label": "Z", + } + "KC_X": { + "key": "EE_X", + "label": "X", + } + "KC_C": { + "key": "EE_C", + "label": "C", + } + "KC_V": { + "key": "EE_V", + "label": "V", + } + "KC_B": { + "key": "EE_B", + "label": "B", + } + "KC_N": { + "key": "EE_N", + "label": "N", + } + "KC_M": { + "key": "EE_M", + "label": "M", + } + "KC_COMM": { + "key": "EE_COMM", + "label": ",", + } + "KC_DOT": { + "key": "EE_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "EE_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ " │ # │ ¤ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(EE_CARN)": { + "key": "EE_TILD", + "label": "~ (dead)", + } + "S(EE_1)": { + "key": "EE_EXLM", + "label": "!", + } + "S(EE_2)": { + "key": "EE_DQUO", + "label": "\"", + } + "S(EE_3)": { + "key": "EE_HASH", + "label": "#", + } + "S(EE_4)": { + "key": "EE_CURR", + "label": "¤", + } + "S(EE_5)": { + "key": "EE_PERC", + "label": "%", + } + "S(EE_6)": { + "key": "EE_AMPR", + "label": "&", + } + "S(EE_7)": { + "key": "EE_SLSH", + "label": "/", + } + "S(EE_8)": { + "key": "EE_LPRN", + "label": "(", + } + "S(EE_9)": { + "key": "EE_RPRN", + "label": ")", + } + "S(EE_0)": { + "key": "EE_EQL", + "label": "=", + } + "S(EE_PLUS)": { + "key": "EE_QUES", + "label": "?", + } + "S(EE_ACUT)": { + "key": "EE_GRV", + "label": "` (dead)", + } + "S(EE_QUOT)": { + "key": "EE_ASTR", + "label": "*", + } + "S(EE_LABK)": { + "key": "EE_RABK", + "label": ">", + } + "S(EE_COMM)": { + "key": "EE_SCLN", + "label": ";", + } + "S(EE_DOT)": { + "key": "EE_COLN", + "label": ":", + } + "S(EE_MINS)": { + "key": "EE_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ @ │ £ │ $ │ € │ │ { │ [ │ ] │ } │ \ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ § │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ š │ │ │ │ │ │ │ │ │ ^ │ ½ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ | │ ž │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(EE_2)": { + "key": "EE_AT", + "label": "@", + } + "ALGR(EE_3)": { + "key": "EE_PND", + "label": "£", + } + "ALGR(EE_4)": { + "key": "EE_DLR", + "label": "$", + } + "ALGR(EE_5)": { + "key": "EE_EURO", + "label": "€", + } + "ALGR(EE_7)": { + "key": "EE_LCBR", + "label": "{", + } + "ALGR(EE_8)": { + "key": "EE_LBRC", + "label": "[", + } + "ALGR(EE_9)": { + "key": "EE_RBRC", + "label": "]", + } + "ALGR(EE_0)": { + "key": "EE_RCBR", + "label": "}", + } + "ALGR(EE_PLUS)": { + "key": "EE_BSLS", + "label": "\\", + } + "ALGR(EE_OTIL)": { + "key": "EE_SECT", + "label": "§", + } + "ALGR(EE_S)": { + "key": "EE_SCAR", + "label": "š", + } + "ALGR(EE_ADIA)": { + "key": "EE_CIRC", + "label": "^ (dead)", + } + "ALGR(EE_QUOT)": { + "key": "EE_HALF", + "label": "½", + } + "ALGR(EE_LABK)": { + "key": "EE_PIPE", + "label": "|", + } + "ALGR(EE_Z)": { + "key": "EE_ZCAR", + "label": "ž", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_finnish_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_finnish_0.0.1.hjson new file mode 100644 index 0000000000..b284192962 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_finnish_0.0.1.hjson @@ -0,0 +1,359 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Å │ ¨ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ ' │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "FI_SECT", + "label": "§", + } + "KC_1": { + "key": "FI_1", + "label": "1", + } + "KC_2": { + "key": "FI_2", + "label": "2", + } + "KC_3": { + "key": "FI_3", + "label": "3", + } + "KC_4": { + "key": "FI_4", + "label": "4", + } + "KC_5": { + "key": "FI_5", + "label": "5", + } + "KC_6": { + "key": "FI_6", + "label": "6", + } + "KC_7": { + "key": "FI_7", + "label": "7", + } + "KC_8": { + "key": "FI_8", + "label": "8", + } + "KC_9": { + "key": "FI_9", + "label": "9", + } + "KC_0": { + "key": "FI_0", + "label": "0", + } + "KC_MINS": { + "key": "FI_PLUS", + "label": "+", + } + "KC_EQL": { + "key": "FI_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "FI_Q", + "label": "Q", + } + "KC_W": { + "key": "FI_W", + "label": "W", + } + "KC_E": { + "key": "FI_E", + "label": "E", + } + "KC_R": { + "key": "FI_R", + "label": "R", + } + "KC_T": { + "key": "FI_T", + "label": "T", + } + "KC_Y": { + "key": "FI_Y", + "label": "Y", + } + "KC_U": { + "key": "FI_U", + "label": "U", + } + "KC_I": { + "key": "FI_I", + "label": "I", + } + "KC_O": { + "key": "FI_O", + "label": "O", + } + "KC_P": { + "key": "FI_P", + "label": "P", + } + "KC_LBRC": { + "key": "FI_ARNG", + "label": "Å", + } + "KC_RBRC": { + "key": "FI_DIAE", + "label": "¨ (dead)", + } + "KC_A": { + "key": "FI_A", + "label": "A", + } + "KC_S": { + "key": "FI_S", + "label": "S", + } + "KC_D": { + "key": "FI_D", + "label": "D", + } + "KC_F": { + "key": "FI_F", + "label": "F", + } + "KC_G": { + "key": "FI_G", + "label": "G", + } + "KC_H": { + "key": "FI_H", + "label": "H", + } + "KC_J": { + "key": "FI_J", + "label": "J", + } + "KC_K": { + "key": "FI_K", + "label": "K", + } + "KC_L": { + "key": "FI_L", + "label": "L", + } + "KC_SCLN": { + "key": "FI_ODIA", + "label": "Ö", + } + "KC_QUOT": { + "key": "FI_ADIA", + "label": "Ä", + } + "KC_NUHS": { + "key": "FI_QUOT", + "label": "'", + } + "KC_NUBS": { + "key": "FI_LABK", + "label": "<", + } + "KC_Z": { + "key": "FI_Z", + "label": "Z", + } + "KC_X": { + "key": "FI_X", + "label": "X", + } + "KC_C": { + "key": "FI_C", + "label": "C", + } + "KC_V": { + "key": "FI_V", + "label": "V", + } + "KC_B": { + "key": "FI_B", + "label": "B", + } + "KC_N": { + "key": "FI_N", + "label": "N", + } + "KC_M": { + "key": "FI_M", + "label": "M", + } + "KC_COMM": { + "key": "FI_COMM", + "label": ",", + } + "KC_DOT": { + "key": "FI_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "FI_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ½ │ ! │ " │ # │ ¤ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(FI_SECT)": { + "key": "FI_HALF", + "label": "½", + } + "S(FI_1)": { + "key": "FI_EXLM", + "label": "!", + } + "S(FI_2)": { + "key": "FI_DQUO", + "label": "\"", + } + "S(FI_3)": { + "key": "FI_HASH", + "label": "#", + } + "S(FI_4)": { + "key": "FI_CURR", + "label": "¤", + } + "S(FI_5)": { + "key": "FI_PERC", + "label": "%", + } + "S(FI_6)": { + "key": "FI_AMPR", + "label": "&", + } + "S(FI_7)": { + "key": "FI_SLSH", + "label": "/", + } + "S(FI_8)": { + "key": "FI_LPRN", + "label": "(", + } + "S(FI_9)": { + "key": "FI_RPRN", + "label": ")", + } + "S(FI_0)": { + "key": "FI_EQL", + "label": "=", + } + "S(FI_PLUS)": { + "key": "FI_QUES", + "label": "?", + } + "S(FI_ACUT)": { + "key": "FI_GRV", + "label": "` (dead)", + } + "S(FI_DIAE)": { + "key": "FI_CIRC", + "label": "^ (dead)", + } + "S(FI_QUOT)": { + "key": "FI_ASTR", + "label": "*", + } + "S(FI_LABK)": { + "key": "FI_RABK", + "label": ">", + } + "S(FI_COMM)": { + "key": "FI_SCLN", + "label": ";", + } + "S(FI_DOT)": { + "key": "FI_COLN", + "label": ":", + } + "S(FI_MINS)": { + "key": "FI_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ @ │ £ │ $ │ € │ │ { │ [ │ ] │ } │ \ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ | │ │ │ │ │ │ │ µ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(FI_2)": { + "key": "FI_AT", + "label": "@", + } + "ALGR(FI_3)": { + "key": "FI_PND", + "label": "£", + } + "ALGR(FI_4)": { + "key": "FI_DLR", + "label": "$", + } + "ALGR(FI_5)": { + "key": "FI_EURO", + "label": "€", + } + "ALGR(FI_7)": { + "key": "FI_LCBR", + "label": "{", + } + "ALGR(FI_8)": { + "key": "FI_LBRC", + "label": "[", + } + "ALGR(FI_9)": { + "key": "FI_RBRC", + "label": "]", + } + "ALGR(FI_0)": { + "key": "FI_RCBR", + "label": "}", + } + "ALGR(FI_PLUS)": { + "key": "FI_BSLS", + "label": "\\", + } + "ALGR(FI_DIAE)": { + "key": "FI_TILD", + "label": "~ (dead)", + } + "ALGR(FI_LABK)": { + "key": "FI_PIPE", + "label": "|", + } + "ALGR(FI_M)": { + "key": "FI_MICR", + "label": "µ", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_french_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_french_0.0.1.hjson new file mode 100644 index 0000000000..8ba7b35d2e --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_french_0.0.1.hjson @@ -0,0 +1,367 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ² │ & │ é │ " │ ' │ ( │ - │ è │ _ │ ç │ à │ ) │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ A │ Z │ E │ R │ T │ Y │ U │ I │ O │ P │ ^ │ $ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Q │ S │ D │ F │ G │ H │ J │ K │ L │ M │ ù │ * │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ W │ X │ C │ V │ B │ N │ , │ ; │ : │ ! │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "FR_SUP2", + "label": "²", + } + "KC_1": { + "key": "FR_AMPR", + "label": "&", + } + "KC_2": { + "key": "FR_EACU", + "label": "é", + } + "KC_3": { + "key": "FR_DQUO", + "label": "\"", + } + "KC_4": { + "key": "FR_QUOT", + "label": "'", + } + "KC_5": { + "key": "FR_LPRN", + "label": "(", + } + "KC_6": { + "key": "FR_MINS", + "label": "-", + } + "KC_7": { + "key": "FR_EGRV", + "label": "è", + } + "KC_8": { + "key": "FR_UNDS", + "label": "_", + } + "KC_9": { + "key": "FR_CCED", + "label": "ç", + } + "KC_0": { + "key": "FR_AGRV", + "label": "à ", + } + "KC_MINS": { + "key": "FR_RPRN", + "label": ")", + } + "KC_EQL": { + "key": "FR_EQL", + "label": "=", + } + "KC_Q": { + "key": "FR_A", + "label": "A", + } + "KC_W": { + "key": "FR_Z", + "label": "Z", + } + "KC_E": { + "key": "FR_E", + "label": "E", + } + "KC_R": { + "key": "FR_R", + "label": "R", + } + "KC_T": { + "key": "FR_T", + "label": "T", + } + "KC_Y": { + "key": "FR_Y", + "label": "Y", + } + "KC_U": { + "key": "FR_U", + "label": "U", + } + "KC_I": { + "key": "FR_I", + "label": "I", + } + "KC_O": { + "key": "FR_O", + "label": "O", + } + "KC_P": { + "key": "FR_P", + "label": "P", + } + "KC_LBRC": { + "key": "FR_CIRC", + "label": "^ (dead)", + } + "KC_RBRC": { + "key": "FR_DLR", + "label": "$", + } + "KC_A": { + "key": "FR_Q", + "label": "Q", + } + "KC_S": { + "key": "FR_S", + "label": "S", + } + "KC_D": { + "key": "FR_D", + "label": "D", + } + "KC_F": { + "key": "FR_F", + "label": "F", + } + "KC_G": { + "key": "FR_G", + "label": "G", + } + "KC_H": { + "key": "FR_H", + "label": "H", + } + "KC_J": { + "key": "FR_J", + "label": "J", + } + "KC_K": { + "key": "FR_K", + "label": "K", + } + "KC_L": { + "key": "FR_L", + "label": "L", + } + "KC_SCLN": { + "key": "FR_M", + "label": "M", + } + "KC_QUOT": { + "key": "FR_UGRV", + "label": "ù", + } + "KC_NUHS": { + "key": "FR_ASTR", + "label": "*", + } + "KC_NUBS": { + "key": "FR_LABK", + "label": "<", + } + "KC_Z": { + "key": "FR_W", + "label": "W", + } + "KC_X": { + "key": "FR_X", + "label": "X", + } + "KC_C": { + "key": "FR_C", + "label": "C", + } + "KC_V": { + "key": "FR_V", + "label": "V", + } + "KC_B": { + "key": "FR_B", + "label": "B", + } + "KC_N": { + "key": "FR_N", + "label": "N", + } + "KC_M": { + "key": "FR_COMM", + "label": ",", + } + "KC_COMM": { + "key": "FR_SCLN", + "label": ";", + } + "KC_DOT": { + "key": "FR_COLN", + "label": ":", + } + "KC_SLSH": { + "key": "FR_EXLM", + "label": "!", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ° │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ £ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ % │ µ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ ? │ . │ / │ § │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(FR_AMPR)": { + "key": "FR_1", + "label": "1", + } + "S(FR_EACU)": { + "key": "FR_2", + "label": "2", + } + "S(FR_DQUO)": { + "key": "FR_3", + "label": "3", + } + "S(FR_QUOT)": { + "key": "FR_4", + "label": "4", + } + "S(FR_LPRN)": { + "key": "FR_5", + "label": "5", + } + "S(FR_MINS)": { + "key": "FR_6", + "label": "6", + } + "S(FR_EGRV)": { + "key": "FR_7", + "label": "7", + } + "S(FR_UNDS)": { + "key": "FR_8", + "label": "8", + } + "S(FR_CCED)": { + "key": "FR_9", + "label": "9", + } + "S(FR_AGRV)": { + "key": "FR_0", + "label": "0", + } + "S(FR_RPRN)": { + "key": "FR_DEG", + "label": "°", + } + "S(FR_EQL)": { + "key": "FR_PLUS", + "label": "+", + } + "S(FR_CIRC)": { + "key": "FR_DIAE", + "label": "¨ (dead)", + } + "S(FR_DLR)": { + "key": "FR_PND", + "label": "£", + } + "S(FR_UGRV)": { + "key": "FR_PERC", + "label": "%", + } + "S(FR_ASTR)": { + "key": "FR_MICR", + "label": "µ", + } + "S(FR_LABK)": { + "key": "FR_RABK", + "label": ">", + } + "S(FR_COMM)": { + "key": "FR_QUES", + "label": "?", + } + "S(FR_SCLN)": { + "key": "FR_DOT", + "label": ".", + } + "S(FR_COLN)": { + "key": "FR_SLSH", + "label": "/", + } + "S(FR_EXLM)": { + "key": "FR_SECT", + "label": "§", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ ~ │ # │ { │ [ │ | │ ` │ \ │ │ @ │ ] │ } │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ │ ¤ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(FR_EACU)": { + "key": "FR_TILD", + "label": "~ (dead)", + } + "ALGR(FR_DQUO)": { + "key": "FR_HASH", + "label": "#", + } + "ALGR(FR_QUOT)": { + "key": "FR_LCBR", + "label": "{", + } + "ALGR(FR_LPRN)": { + "key": "FR_LBRC", + "label": "[", + } + "ALGR(FR_MINS)": { + "key": "FR_PIPE", + "label": "|", + } + "ALGR(FR_EGRV)": { + "key": "FR_GRV", + "label": "` (dead)", + } + "ALGR(FR_UNDS)": { + "key": "FR_BSLS", + "label": "\\", + } + "ALGR(FR_AGRV)": { + "key": "FR_AT", + "label": "@", + } + "ALGR(FR_RPRN)": { + "key": "FR_RBRC", + "label": "]", + } + "ALGR(FR_EQL)": { + "key": "FR_RCBR", + "label": "}", + } + "ALGR(KC_E)": { + "key": "FR_EURO", + "label": "€", + } + "ALGR(FR_DLR)": { + "key": "FR_CURR", + "label": "¤", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_french_afnor_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_french_afnor_0.0.1.hjson new file mode 100644 index 0000000000..90981d085d --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_french_afnor_0.0.1.hjson @@ -0,0 +1,623 @@ +{ + "aliases": { +/* French AZERTY - AFNOR NF Z71-300 + * + * A standard for the French keyboard + * + * The project was launched at the end of 2015 on the proposal of the General + * Delegation for the French language and the languages of France (Ministry + * of Culture), starting from the observation that the current "azerty" + * keyboards constrain the writing of French, languages regional and European + * languages with Latin alphabet. + * + * For the first time, a standard (NF Z71-300) defines the placement of + * characters on the French keyboard. It offers two layouts, one of which + * closely follows the QWERTY keyboard used by most people who write in French. + * + * However, it is in many ways superior to the old keyboard: + * + * - it contains all the characters required to enter text in French (for example É, Å“ and ") + * - it is designed to be more ergonomic and allow faster typing + * - it includes almost 60 additional characters for entering foreign languages, technical content, etc + * - however, the characters remain easy to locate thanks to intuitive groupings + * + * Source: https://norme-azerty.fr + */ +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ @ │ à │ é │ è │ ê │ ( │ ) │ ‘ │ ’ │ « │ » │ ' │ ^ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ A │ Z │ E │ R │ T │ Y │ U │ I │ O │ P │ - │ + │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Q │ S │ D │ F │ G │ H │ J │ K │ L │ M │ / │ * │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ W │ X │ C │ V │ B │ N │ . │ , │ : │ ; │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "FR_AT", + "label": "@", + } + "KC_1": { + "key": "FR_AGRV", + "label": "à ", + } + "KC_2": { + "key": "FR_EACU", + "label": "é", + } + "KC_3": { + "key": "FR_EGRV", + "label": "è", + } + "KC_4": { + "key": "FR_ECIR", + "label": "ê", + } + "KC_5": { + "key": "FR_LPRN", + "label": "(", + } + "KC_6": { + "key": "FR_RPRN", + "label": ")", + } + "KC_7": { + "key": "FR_LSQU", + "label": "‘", + } + "KC_8": { + "key": "FR_RSQU", + "label": "’", + } + "KC_9": { + "key": "FR_LDAQ", + "label": "«", + } + "KC_0": { + "key": "FR_RDAQ", + "label": "»", + } + "KC_MINS": { + "key": "FR_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "FR_DCIR", + "label": "^ (dead)", + } + "KC_Q": { + "key": "FR_A", + "label": "A", + } + "KC_W": { + "key": "FR_Z", + "label": "Z", + } + "KC_E": { + "key": "FR_E", + "label": "E", + } + "KC_R": { + "key": "FR_R", + "label": "R", + } + "KC_T": { + "key": "FR_T", + "label": "T", + } + "KC_Y": { + "key": "FR_Y", + "label": "Y", + } + "KC_U": { + "key": "FR_U", + "label": "U", + } + "KC_I": { + "key": "FR_I", + "label": "I", + } + "KC_O": { + "key": "FR_O", + "label": "O", + } + "KC_P": { + "key": "FR_P", + "label": "P", + } + "KC_LBRC": { + "key": "FR_MINS", + "label": "-", + } + "KC_RBRC": { + "key": "FR_PLUS", + "label": "+", + } + "KC_A": { + "key": "FR_Q", + "label": "Q", + } + "KC_S": { + "key": "FR_S", + "label": "S", + } + "KC_D": { + "key": "FR_D", + "label": "D", + } + "KC_F": { + "key": "FR_F", + "label": "F", + } + "KC_G": { + "key": "FR_G", + "label": "G", + } + "KC_H": { + "key": "FR_H", + "label": "H", + } + "KC_J": { + "key": "FR_J", + "label": "J", + } + "KC_K": { + "key": "FR_K", + "label": "K", + } + "KC_L": { + "key": "FR_L", + "label": "L", + } + "KC_SCLN": { + "key": "FR_M", + "label": "M", + } + "KC_QUOT": { + "key": "FR_SLSH", + "label": "/", + } + "KC_NUHS": { + "key": "FR_ASTR", + "label": "*", + } + "KC_NUBS": { + "key": "FR_LABK", + "label": "<", + } + "KC_Z": { + "key": "FR_W", + "label": "W", + } + "KC_X": { + "key": "FR_X", + "label": "X", + } + "KC_C": { + "key": "FR_C", + "label": "C", + } + "KC_V": { + "key": "FR_V", + "label": "V", + } + "KC_B": { + "key": "FR_B", + "label": "B", + } + "KC_N": { + "key": "FR_N", + "label": "N", + } + "KC_M": { + "key": "FR_DOT", + "label": ".", + } + "KC_COMM": { + "key": "FR_COMM", + "label": ",", + } + "KC_DOT": { + "key": "FR_COLN", + "label": ":", + } + "KC_SLSH": { + "key": "FR_SCLN", + "label": ";", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ # │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ " │ ¨ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ – │ ± │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ \ │ ½ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ ? │ ! │ … │ = │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(FR_AT)": { + "key": "FR_HASH", + "label": "#", + } + "S(FR_AGRV)": { + "key": "FR_1", + "label": "1", + } + "S(FR_EACU)": { + "key": "FR_2", + "label": "2", + } + "S(FR_EGRV)": { + "key": "FR_3", + "label": "3", + } + "S(FR_ECIR)": { + "key": "FR_4", + "label": "4", + } + "S(FR_LPRN)": { + "key": "FR_5", + "label": "5", + } + "S(FR_RPRN)": { + "key": "FR_6", + "label": "6", + } + "S(FR_LSQU)": { + "key": "FR_7", + "label": "7", + } + "S(FR_RSQU)": { + "key": "FR_8", + "label": "8", + } + "S(FR_LDAQ)": { + "key": "FR_9", + "label": "9", + } + "S(FR_RDAQ)": { + "key": "FR_0", + "label": "0", + } + "S(FR_QUOT)": { + "key": "FR_DQUO", + "label": "\"", + } + "S(FR_DCIR)": { + "key": "FR_DIAE", + "label": "¨ (dead)", + } + "S(FR_MINS)": { + "key": "FR_NDSH", + "label": "–", + } + "S(FR_PLUS)": { + "key": "FR_PLMN", + "label": "±", + } + "S(FR_SLSH)": { + "key": "FR_BSLS", + "label": "\\", + } + "S(FR_ASTR)": { + "key": "FR_HALF", + "label": "½", + } + "S(FR_LABK)": { + "key": "FR_RABK", + "label": ">", + } + "S(FR_DOT)": { + "key": "FR_QUES", + "label": "?", + } + "S(FR_COMM)": { + "key": "FR_EXLM", + "label": "!", + } + "S(FR_COLN)": { + "key": "FR_ELLP", + "label": "…", + } + "S(FR_SCLN)": { + "key": "FR_EQL", + "label": "=", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ˘ │ § │ ´ │ ` │ & │ [ │ ] │ ¯ │ _ │ “ │ †│ ° │ ˇ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ æ │ £ │ € │ ® │ { │ } │ ù │ Ë™ │ Å“ │ % │ − │ †│ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ θ │ ß │ $ │ ¤ │ µ │ Eu│ │ ∕ │ | │ ∞ │ ÷ │ × │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ ≤ │ Ê’ │ © │ ç │ ¸ │ − │ ~ │ ¿ │ ¡ │ · │ ≃ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(FR_AT)": { + "key": "FR_BREV", + "label": "˘ (dead)", + } + "ALGR(FR_AGRV)": { + "key": "FR_SECT", + "label": "§", + } + "ALGR(FR_EACU)": { + "key": "FR_ACUT", + "label": "´ (dead)", + } + "ALGR(FR_EGRV)": { + "key": "FR_GRV", + "label": "` (dead)", + } + "ALGR(FR_ECIR)": { + "key": "FR_AMPR", + "label": "&", + } + "ALGR(FR_LPRN)": { + "key": "FR_LBRC", + "label": "[", + } + "ALGR(FR_RPRN)": { + "key": "FR_RBRC", + "label": "]", + } + "ALGR(FR_LSQU)": { + "key": "FR_MACR", + "label": "¯ (dead)", + } + "ALGR(FR_RSQU)": { + "key": "FR_UNDS", + "label": "_", + } + "ALGR(FR_LDAQ)": { + "key": "FR_LDQU", + "label": "“", + } + "ALGR(FR_RDAQ)": { + "key": "FR_RDQU", + "label": "â€", + } + "ALGR(FR_QUOT)": { + "key": "FR_DEG", + "label": "°", + } + "ALGR(FR_DCIR)": { + "key": "FR_CARN", + "label": "ˇ (dead)", + } + "ALGR(FR_A)": { + "key": "FR_AE", + "label": "æ", + } + "ALGR(FR_Z)": { + "key": "FR_PND", + "label": "£", + } + "ALGR(FR_E)": { + "key": "FR_EURO", + "label": "€", + } + "ALGR(FR_R)": { + "key": "FR_REGD", + "label": "®", + } + "ALGR(FR_T)": { + "key": "FR_LCBR", + "label": "{", + } + "ALGR(FR_Y)": { + "key": "FR_RCBR", + "label": "}", + } + "ALGR(FR_U)": { + "key": "FR_UGRV", + "label": "ù", + } + "ALGR(FR_I)": { + "key": "FR_DOTA", + "label": "Ë™ (dead)", + } + "ALGR(FR_O)": { + "key": "FR_OE", + "label": "Å“", + } + "ALGR(FR_P)": { + "key": "FR_PERC", + "label": "%", + } + "ALGR(FR_MINS)": { + "key": "FR_MMNS", + "label": "−", + } + "ALGR(FR_PLUS)": { + "key": "FR_DAGG", + "label": "†", + } + "ALGR(FR_Q)": { + "key": "FR_THET", + "label": "θ", + } + "ALGR(FR_S)": { + "key": "FR_SS", + "label": "ß", + } + "ALGR(FR_D)": { + "key": "FR_DLR", + "label": "$", + } + "ALGR(FR_F)": { + "key": "FR_CURR", + "label": "¤ (dead monetary key)", + } + "ALGR(FR_G)": { + "key": "FR_DGRK", + "label": "µ (dead Greek key)", + } + "ALGR(FR_H)": { + "key": "FR_EU", + "label": "Eu (dead European symbol key)", + } + "ALGR(FR_K)": { + "key": "FR_DSLS", + "label": "∕ (dead)", + } + "ALGR(FR_L)": { + "key": "FR_PIPE", + "label": "|", + } + "ALGR(FR_M)": { + "key": "FR_INFN", + "label": "∞", + } + "ALGR(FR_SLSH)": { + "key": "FR_DIV", + "label": "÷", + } + "ALGR(FR_ASTR)": { + "key": "FR_MUL", + "label": "×", + } + "ALGR(FR_LABK)": { + "key": "FR_LEQL", + "label": "≤", + } + "ALGR(FR_W)": { + "key": "FR_EZH", + "label": "Ê’", + } + "ALGR(FR_X)": { + "key": "FR_COPY", + "label": "©", + } + "ALGR(FR_C)": { + "key": "FR_CCED", + "label": "ç", + } + "ALGR(FR_V)": { + "key": "FR_CEDL", + "label": "¸ (dead)", + } + "ALGR(FR_B)": { + "key": "FR_DMNS", + "label": "− (dead)", + } + "ALGR(FR_N)": { + "key": "FR_DTIL", + "label": "~ (dead)", + } + "ALGR(FR_DOT)": { + "key": "FR_IQUE", + "label": "¿", + } + "ALGR(FR_COMM)": { + "key": "FR_IEXL", + "label": "¡", + } + "ALGR(FR_COLN)": { + "key": "FR_MDDT", + "label": "·", + } + "ALGR(FR_SCLN)": { + "key": "FR_AEQL", + "label": "≃", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ Ì‘ │ │ │ │ │ Ë â”‚ Ì â”‚ │ — │ ‹ │ › │ Ëš │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ â„¢ │ │ │ Ì£ │ │ ‰ │ ‑ │ ‡ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ Ë â”‚ │ │ │ │ √ │ ¼ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ ≥ │ │ │ │ Ë› │ │ │ │ ̦ │ │ ≠│ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(FR_AT))": { + "key": "FR_IBRV", + "label": "Ì‘ (dead)", + } + "S(ALGR(FR_LPRN))": { + "key": "FR_DACU", + "label": "Ë (dead)", + } + "S(ALGR(FR_RPRN))": { + "key": "FR_DGRV", + "label": "Ì (dead)", + } + "S(ALGR(FR_RSQU))": { + "key": "FR_MDSH", + "label": "—", + } + "S(ALGR(FR_LDAQ))": { + "key": "FR_LSAQ", + "label": "‹", + } + "S(ALGR(FR_RDAQ))": { + "key": "FR_RSAQ", + "label": "›", + } + "S(ALGR(FR_QUOT))": { + "key": "FR_RNGA", + "label": "Ëš (dead)", + } + "S(ALGR(FR_T))": { + "key": "FR_TM", + "label": "â„¢", + } + "S(ALGR(FR_I))": { + "key": "FR_DOTB", + "label": "Ì£ (dead)", + } + "S(ALGR(FR_P))": { + "key": "FR_PERM", + "label": "‰", + } + "S(ALGR(FR_MINS))": { + "key": "FR_NBHY", + "label": "‑ (non-breaking hyphen)", + } + "S(ALGR(FR_PLUS))": { + "key": "FR_DDAG", + "label": "‡", + } + "S(ALGR(FR_H))": { + "key": "FR_MACB", + "label": "Ë (dead)", + } + "S(ALGR(FR_SLSH))": { + "key": "FR_SQRT", + "label": "√", + } + "S(ALGR(FR_ASTR))": { + "key": "FR_QRTR", + "label": "¼", + } + "S(ALGR(FR_LABK))": { + "key": "FR_GEQL", + "label": "≥", + } + "S(ALGR(FR_V))": { + "key": "FR_OGON", + "label": "Ë› (dead)", + } + "S(ALGR(FR_COMM))": { + "key": "FR_DCMM", + "label": "̦ (dead)", + } + "S(ALGR(FR_SCLN))": { + "key": "FR_NEQL", + "label": "≠", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_french_mac_iso_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_french_mac_iso_0.0.1.hjson new file mode 100644 index 0000000000..b698018d5b --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_french_mac_iso_0.0.1.hjson @@ -0,0 +1,676 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ @ │ & │ é │ " │ ' │ ( │ § │ è │ ! │ ç │ à │ ) │ - │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ A │ Z │ E │ R │ T │ Y │ U │ I │ O │ P │ ^ │ $ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Q │ S │ D │ F │ G │ H │ J │ K │ L │ M │ ù │ ` │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ < │ W │ X │ C │ V │ B │ N │ , │ ; │ : │ = │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "KC_GRV": { + "key": "FR_AT", + "label": "@", + } + "KC_1": { + "key": "FR_AMPR", + "label": "&", + } + "KC_2": { + "key": "FR_LEAC", + "label": "é", + } + "KC_3": { + "key": "FR_DQUO", + "label": "\"", + } + "KC_4": { + "key": "FR_QUOT", + "label": "'", + } + "KC_5": { + "key": "FR_LPRN", + "label": "(", + } + "KC_6": { + "key": "FR_SECT", + "label": "§", + } + "KC_7": { + "key": "FR_LEGR", + "label": "è", + } + "KC_8": { + "key": "FR_EXLM", + "label": "!", + } + "KC_9": { + "key": "FR_LCCE", + "label": "ç", + } + "KC_0": { + "key": "FR_LAGR", + "label": "à ", + } + "KC_MINS": { + "key": "FR_RPRN", + "label": ")", + } + "KC_EQL": { + "key": "FR_MINS", + "label": "-", + } + "KC_Q": { + "key": "FR_A", + "label": "A", + } + "KC_W": { + "key": "FR_Z", + "label": "Z", + } + "KC_E": { + "key": "FR_E", + "label": "E", + } + "KC_R": { + "key": "FR_R", + "label": "R", + } + "KC_T": { + "key": "FR_T", + "label": "T", + } + "KC_Y": { + "key": "FR_Y", + "label": "Y", + } + "KC_U": { + "key": "FR_U", + "label": "U", + } + "KC_I": { + "key": "FR_I", + "label": "I", + } + "KC_O": { + "key": "FR_O", + "label": "O", + } + "KC_P": { + "key": "FR_P", + "label": "P", + } + "KC_LBRC": { + "key": "FR_CIRC", + "label": "^", + } + "KC_RBRC": { + "key": "FR_DLR", + "label": "$", + } + "KC_A": { + "key": "FR_Q", + "label": "Q", + } + "KC_S": { + "key": "FR_S", + "label": "S", + } + "KC_D": { + "key": "FR_D", + "label": "D", + } + "KC_F": { + "key": "FR_F", + "label": "F", + } + "KC_G": { + "key": "FR_G", + "label": "G", + } + "KC_H": { + "key": "FR_H", + "label": "H", + } + "KC_J": { + "key": "FR_J", + "label": "J", + } + "KC_K": { + "key": "FR_K", + "label": "K", + } + "KC_L": { + "key": "FR_L", + "label": "L", + } + "KC_SCLN": { + "key": "FR_M", + "label": "M", + } + "KC_QUOT": { + "key": "FR_LUGR", + "label": "ù", + } + "KC_NUHS": { + "key": "FR_GRV", + "label": "`", + } + "KC_NUBS": { + "key": "FR_LABK", + "label": "<", + } + "KC_Z": { + "key": "FR_W", + "label": "W", + } + "KC_X": { + "key": "FR_X", + "label": "X", + } + "KC_C": { + "key": "FR_C", + "label": "C", + } + "KC_V": { + "key": "FR_V", + "label": "V", + } + "KC_B": { + "key": "FR_B", + "label": "B", + } + "KC_N": { + "key": "FR_N", + "label": "N", + } + "KC_M": { + "key": "FR_COMM", + "label": ",", + } + "KC_COMM": { + "key": "FR_SCLN", + "label": ";", + } + "KC_DOT": { + "key": "FR_COLN", + "label": ":", + } + "KC_SLSH": { + "key": "FR_EQL", + "label": "=", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ # │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ° │ _ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ * │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ % │ £ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ > │ │ │ │ │ │ │ ? │ . │ / │ + │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(FR_AT)": { + "key": "FR_HASH", + "label": "#", + } + "S(FR_AMPR)": { + "key": "FR_1", + "label": "1", + } + "S(FR_LEAC)": { + "key": "FR_2", + "label": "2", + } + "S(FR_DQUO)": { + "key": "FR_3", + "label": "3", + } + "S(FR_QUOT)": { + "key": "FR_4", + "label": "4", + } + "S(FR_LPRN)": { + "key": "FR_5", + "label": "5", + } + "S(FR_SECT)": { + "key": "FR_6", + "label": "6", + } + "S(FR_LEGR)": { + "key": "FR_7", + "label": "7", + } + "S(FR_EXLM)": { + "key": "FR_8", + "label": "8", + } + "S(FR_LCCE)": { + "key": "FR_9", + "label": "9", + } + "S(FR_LAGR)": { + "key": "FR_0", + "label": "0", + } + "S(FR_RPRN)": { + "key": "FR_DEG", + "label": "°", + } + "S(FR_MINS)": { + "key": "FR_UNDS", + "label": "_", + } + "S(FR_CIRC)": { + "key": "FR_DIAE", + "label": "¨ (dead)", + } + "S(FR_DLR)": { + "key": "FR_ASTR", + "label": "*", + } + "S(FR_LUGR)": { + "key": "FR_PERC", + "label": "%", + } + "S(FR_GRV)": { + "key": "FR_PND", + "label": "£", + } + "S(FR_LABK)": { + "key": "FR_RABK", + "label": ">", + } + "S(FR_COMM)": { + "key": "FR_QUES", + "label": "?", + } + "S(FR_SCLN)": { + "key": "FR_DOT", + "label": ".", + } + "S(FR_COLN)": { + "key": "FR_SLSH", + "label": "/", + } + "S(FR_EQL)": { + "key": "FR_PLUS", + "label": "+", + } +/* Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ • │  │ ë │ “ │ ‘ │ { │ ¶ │ « │ ¡ │ Ç │ Ø │ } │ — │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ Æ │  │ Ê │ ® │ †│ Ú │ º │ î │ Å’ │ Ï€ │ Ô │ € │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ ‡ │ Ã’ │ ∂ │ Æ’ │ ï¬ â”‚ ÃŒ │ à │ È │ ¬ │ µ │ Ù │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≤ │ ‹ │ ≈ │ © │ â—Š │ ß │ ~ │ ∞ │ … │ ÷ │ ≠│ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "A(FR_AT)": { + "key": "FR_BULT", + "label": "•", + } + "A(FR_AMPR)": { + "key": "FR_APPL", + "label": " (Apple logo)", + } + "A(FR_LEAC)": { + "key": "FR_LEDI", + "label": "ë", + } + "A(FR_DQUO)": { + "key": "FR_LDQU", + "label": "“", + } + "A(FR_QUOT)": { + "key": "FR_LSQU", + "label": "‘", + } + "A(FR_LPRN)": { + "key": "FR_LCBR", + "label": "{", + } + "A(FR_SECT)": { + "key": "FR_PILC", + "label": "¶", + } + "A(FR_LEGR)": { + "key": "FR_LDAQ", + "label": "«", + } + "A(FR_EXLM)": { + "key": "FR_IEXL", + "label": "¡", + } + "A(FR_LCCE)": { + "key": "FR_CCCE", + "label": "Ç", + } + "A(FR_LAGR)": { + "key": "FR_OSTR", + "label": "Ø", + } + "A(FR_RPRN)": { + "key": "FR_RCBR", + "label": "}", + } + "A(FR_MINS)": { + "key": "FR_MDSH", + "label": "—", + } + "A(FR_A)": { + "key": "FR_AE", + "label": "Æ", + } + "A(FR_Z)": { + "key": "FR_CACI", + "label": "Â", + } + "A(FR_E)": { + "key": "FR_ECIR", + "label": "Ê", + } + "A(FR_R)": { + "key": "FR_REGD", + "label": "®", + } + "A(FR_T)": { + "key": "FR_DAGG", + "label": "†", + } + "A(FR_Y)": { + "key": "FR_CUAC", + "label": "Ú", + } + "A(FR_U)": { + "key": "FR_MORD", + "label": "º", + } + "A(FR_I)": { + "key": "FR_LICI", + "label": "î", + } + "A(FR_O)": { + "key": "FR_OE", + "label": "Å’", + } + "A(FR_P)": { + "key": "FR_PI", + "label": "Ï€", + } + "A(FR_CIRC)": { + "key": "FR_OCIR", + "label": "Ô", + } + "A(FR_DLR)": { + "key": "FR_EURO", + "label": "€", + } + "A(FR_Q)": { + "key": "FR_DDAG", + "label": "‡", + } + "A(FR_S)": { + "key": "FR_COGR", + "label": "Ã’", + } + "A(FR_D)": { + "key": "FR_PDIF", + "label": "∂", + } + "A(FR_F)": { + "key": "FR_FHK", + "label": "Æ’", + } + "A(FR_G)": { + "key": "FR_FI", + "label": "ï¬", + } + "A(FR_H)": { + "key": "FR_CIGR", + "label": "ÃŒ", + } + "A(FR_J)": { + "key": "FR_CIDI", + "label": "Ã", + } + "A(FR_K)": { + "key": "FR_CEGR", + "label": "È", + } + "A(FR_L)": { + "key": "FR_NOT", + "label": "¬", + } + "A(FR_M)": { + "key": "FR_MICR", + "label": "µ", + } + "A(FR_LUGR)": { + "key": "FR_CUGR", + "label": "Ù", + } + "A(FR_LABK)": { + "key": "FR_LTEQ", + "label": "≤", + } + "A(FR_W)": { + "key": "FR_LSAQ", + "label": "‹", + } + "A(FR_X)": { + "key": "FR_AEQL", + "label": "≈", + } + "A(FR_C)": { + "key": "FR_COPY", + "label": "©", + } + "A(FR_V)": { + "key": "FR_LOZN", + "label": "â—Š", + } + "A(FR_B)": { + "key": "FR_SS", + "label": "ß", + } + "A(FR_N)": { + "key": "FR_TILD", + "label": "~ (dead)", + } + "A(FR_COMM)": { + "key": "FR_INFN", + "label": "∞", + } + "A(FR_SCLN)": { + "key": "FR_ELLP", + "label": "…", + } + "A(FR_COLN)": { + "key": "FR_DIV", + "label": "÷", + } + "A(FR_EQL)": { + "key": "FR_NEQL", + "label": "≠", + } +/* Shift+Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ Ÿ │ ´ │ „ │ │ │ [ │ Ã¥ │ » │ Û │ à │ │ ] │ – │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ Ã… │ │ ‚ │ â„¢ │ │ ª │ ï │ │ ∠│ │ Â¥ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Ω │ ∑ │ ∆ │ · │ fl │ ÃŽ │ à │ Ë │ | │ Ó │ ‰ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≥ │ › │ ℠│ ¢ │ √ │ ∫ │ ı │ ¿ │ │ \ │ ± │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(A(FR_AT))": { + "key": "FR_CYDI", + "label": "Ÿ", + } + "S(A(FR_AMPR))": { + "key": "FR_ACUT", + "label": "´ (dead)", + } + "S(A(FR_LEAC))": { + "key": "FR_DLQU", + "label": "„", + } + "S(A(FR_LPRN))": { + "key": "FR_LBRC", + "label": "[", + } + "S(A(FR_SECT))": { + "key": "FR_LARI", + "label": "Ã¥", + } + "S(A(FR_LEGR))": { + "key": "FR_RDAQ", + "label": "»", + } + "S(A(FR_EXLM))": { + "key": "FR_CUCI", + "label": "Û", + } + "S(A(FR_LCCE))": { + "key": "FR_CAAC", + "label": "Ã", + } + "S(A(FR_RPRN))": { + "key": "FR_RBRC", + "label": "]", + } + "S(A(FR_MINS))": { + "key": "FR_NDSH", + "label": "–", + } + "S(A(FR_Z))": { + "key": "FR_CARI", + "label": "Ã…", + } + "S(A(FR_R))": { + "key": "FR_SLQU", + "label": "‚", + } + "S(A(FR_T))": { + "key": "FR_TM", + "label": "â„¢", + } + "S(A(FR_U))": { + "key": "FR_FORD", + "label": "ª", + } + "S(A(FR_I))": { + "key": "FR_LIDI", + "label": "ï", + } + "S(A(FR_P))": { + "key": "FR_NARP", + "label": "âˆ", + } + "S(A(FR_DLR))": { + "key": "FR_YEN", + "label": "Â¥", + } + "S(A(FR_Q))": { + "key": "FR_OMEG", + "label": "Ω", + } + "S(A(FR_S))": { + "key": "FR_NARS", + "label": "∑", + } + "S(A(FR_D))": { + "key": "FR_INCR", + "label": "∆", + } + "S(A(FR_F))": { + "key": "FR_MDDT", + "label": "·", + } + "S(A(FR_G))": { + "key": "FR_FL", + "label": "fl", + } + "S(A(FR_H))": { + "key": "FR_CICI", + "label": "ÃŽ", + } + "S(A(FR_J))": { + "key": "FR_CIAC", + "label": "Ã", + } + "S(A(FR_K))": { + "key": "FR_CEDI", + "label": "Ë", + } + "S(A(FR_L))": { + "key": "FR_PIPE", + "label": "|", + } + "S(A(FR_M))": { + "key": "FR_COAC", + "label": "Ó", + } + "S(A(FR_LUGR))": { + "key": "FR_PERM", + "label": "‰", + } + "S(A(FR_LABK))": { + "key": "FR_GTEQ", + "label": "≥", + } + "S(A(FR_W))": { + "key": "FR_RSAQ", + "label": "›", + } + "S(A(FR_X))": { + "key": "FR_FRSL", + "label": "â„", + } + "S(A(FR_C))": { + "key": "FR_CENT", + "label": "¢", + } + "S(A(FR_V))": { + "key": "FR_SQRT", + "label": "√", + } + "S(A(FR_B))": { + "key": "FR_INTG", + "label": "∫", + } + "S(A(FR_N))": { + "key": "FR_DLSI", + "label": "ı", + } + "S(A(FR_COMM))": { + "key": "FR_IQUE", + "label": "¿", + } + "S(A(FR_COLN))": { + "key": "FR_BSLS", + "label": "\\", + } + "S(A(FR_EQL))": { + "key": "FR_PLMN", + "label": "±", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_german_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_german_0.0.1.hjson new file mode 100644 index 0000000000..a1cfd44956 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_german_0.0.1.hjson @@ -0,0 +1,359 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ^ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ß │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Ü │ + │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ # │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "DE_CIRC", + "label": "^ (dead)", + } + "KC_1": { + "key": "DE_1", + "label": "1", + } + "KC_2": { + "key": "DE_2", + "label": "2", + } + "KC_3": { + "key": "DE_3", + "label": "3", + } + "KC_4": { + "key": "DE_4", + "label": "4", + } + "KC_5": { + "key": "DE_5", + "label": "5", + } + "KC_6": { + "key": "DE_6", + "label": "6", + } + "KC_7": { + "key": "DE_7", + "label": "7", + } + "KC_8": { + "key": "DE_8", + "label": "8", + } + "KC_9": { + "key": "DE_9", + "label": "9", + } + "KC_0": { + "key": "DE_0", + "label": "0", + } + "KC_MINS": { + "key": "DE_SS", + "label": "ß", + } + "KC_EQL": { + "key": "DE_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "DE_Q", + "label": "Q", + } + "KC_W": { + "key": "DE_W", + "label": "W", + } + "KC_E": { + "key": "DE_E", + "label": "E", + } + "KC_R": { + "key": "DE_R", + "label": "R", + } + "KC_T": { + "key": "DE_T", + "label": "T", + } + "KC_Y": { + "key": "DE_Z", + "label": "Z", + } + "KC_U": { + "key": "DE_U", + "label": "U", + } + "KC_I": { + "key": "DE_I", + "label": "I", + } + "KC_O": { + "key": "DE_O", + "label": "O", + } + "KC_P": { + "key": "DE_P", + "label": "P", + } + "KC_LBRC": { + "key": "DE_UDIA", + "label": "Ü", + } + "KC_RBRC": { + "key": "DE_PLUS", + "label": "+", + } + "KC_A": { + "key": "DE_A", + "label": "A", + } + "KC_S": { + "key": "DE_S", + "label": "S", + } + "KC_D": { + "key": "DE_D", + "label": "D", + } + "KC_F": { + "key": "DE_F", + "label": "F", + } + "KC_G": { + "key": "DE_G", + "label": "G", + } + "KC_H": { + "key": "DE_H", + "label": "H", + } + "KC_J": { + "key": "DE_J", + "label": "J", + } + "KC_K": { + "key": "DE_K", + "label": "K", + } + "KC_L": { + "key": "DE_L", + "label": "L", + } + "KC_SCLN": { + "key": "DE_ODIA", + "label": "Ö", + } + "KC_QUOT": { + "key": "DE_ADIA", + "label": "Ä", + } + "KC_NUHS": { + "key": "DE_HASH", + "label": "#", + } + "KC_NUBS": { + "key": "DE_LABK", + "label": "<", + } + "KC_Z": { + "key": "DE_Y", + "label": "Y", + } + "KC_X": { + "key": "DE_X", + "label": "X", + } + "KC_C": { + "key": "DE_C", + "label": "C", + } + "KC_V": { + "key": "DE_V", + "label": "V", + } + "KC_B": { + "key": "DE_B", + "label": "B", + } + "KC_N": { + "key": "DE_N", + "label": "N", + } + "KC_M": { + "key": "DE_M", + "label": "M", + } + "KC_COMM": { + "key": "DE_COMM", + "label": ",", + } + "KC_DOT": { + "key": "DE_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "DE_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ° │ ! │ " │ § │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ' │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(DE_CIRC)": { + "key": "DE_DEG", + "label": "°", + } + "S(DE_1)": { + "key": "DE_EXLM", + "label": "!", + } + "S(DE_2)": { + "key": "DE_DQUO", + "label": "\"", + } + "S(DE_3)": { + "key": "DE_SECT", + "label": "§", + } + "S(DE_4)": { + "key": "DE_DLR", + "label": "$", + } + "S(DE_5)": { + "key": "DE_PERC", + "label": "%", + } + "S(DE_6)": { + "key": "DE_AMPR", + "label": "&", + } + "S(DE_7)": { + "key": "DE_SLSH", + "label": "/", + } + "S(DE_8)": { + "key": "DE_LPRN", + "label": "(", + } + "S(DE_9)": { + "key": "DE_RPRN", + "label": ")", + } + "S(DE_0)": { + "key": "DE_EQL", + "label": "=", + } + "S(DE_SS)": { + "key": "DE_QUES", + "label": "?", + } + "S(DE_ACUT)": { + "key": "DE_GRV", + "label": "` (dead)", + } + "S(DE_PLUS)": { + "key": "DE_ASTR", + "label": "*", + } + "S(DE_HASH)": { + "key": "DE_QUOT", + "label": "'", + } + "S(DE_LABK)": { + "key": "DE_RABK", + "label": ">", + } + "S(DE_COMM)": { + "key": "DE_SCLN", + "label": ";", + } + "S(DE_DOT)": { + "key": "DE_COLN", + "label": ":", + } + "S(DE_MINS)": { + "key": "DE_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ ² │ ³ │ │ │ │ { │ [ │ ] │ } │ \ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ @ │ │ € │ │ │ │ │ │ │ │ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ | │ │ │ │ │ │ │ µ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(DE_2)": { + "key": "DE_SUP2", + "label": "²", + } + "ALGR(DE_3)": { + "key": "DE_SUP3", + "label": "³", + } + "ALGR(DE_7)": { + "key": "DE_LCBR", + "label": "{", + } + "ALGR(DE_8)": { + "key": "DE_LBRC", + "label": "[", + } + "ALGR(DE_9)": { + "key": "DE_RBRC", + "label": "]", + } + "ALGR(DE_0)": { + "key": "DE_RCBR", + "label": "}", + } + "ALGR(DE_SS)": { + "key": "DE_BSLS", + "label": "\\", + } + "ALGR(DE_Q)": { + "key": "DE_AT", + "label": "@", + } + "ALGR(DE_E)": { + "key": "DE_EURO", + "label": "€", + } + "ALGR(DE_PLUS)": { + "key": "DE_TILD", + "label": "~", + } + "ALGR(DE_LABK)": { + "key": "DE_PIPE", + "label": "|", + } + "ALGR(DE_M)": { + "key": "DE_MICR", + "label": "µ", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_german_mac_iso_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_german_mac_iso_0.0.1.hjson new file mode 100644 index 0000000000..366ed5b9d1 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_german_mac_iso_0.0.1.hjson @@ -0,0 +1,656 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ^ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ß │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Ãœ │ + │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ # │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "KC_GRV": { + "key": "DE_CIRC", + "label": "^ (dead)", + } + "KC_1": { + "key": "DE_1", + "label": "1", + } + "KC_2": { + "key": "DE_2", + "label": "2", + } + "KC_3": { + "key": "DE_3", + "label": "3", + } + "KC_4": { + "key": "DE_4", + "label": "4", + } + "KC_5": { + "key": "DE_5", + "label": "5", + } + "KC_6": { + "key": "DE_6", + "label": "6", + } + "KC_7": { + "key": "DE_7", + "label": "7", + } + "KC_8": { + "key": "DE_8", + "label": "8", + } + "KC_9": { + "key": "DE_9", + "label": "9", + } + "KC_0": { + "key": "DE_0", + "label": "0", + } + "KC_MINS": { + "key": "DE_SS", + "label": "ß", + } + "KC_EQL": { + "key": "DE_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "DE_Q", + "label": "Q", + } + "KC_W": { + "key": "DE_W", + "label": "W", + } + "KC_E": { + "key": "DE_E", + "label": "E", + } + "KC_R": { + "key": "DE_R", + "label": "R", + } + "KC_T": { + "key": "DE_T", + "label": "T", + } + "KC_Y": { + "key": "DE_Z", + "label": "Z", + } + "KC_U": { + "key": "DE_U", + "label": "U", + } + "KC_I": { + "key": "DE_I", + "label": "I", + } + "KC_O": { + "key": "DE_O", + "label": "O", + } + "KC_P": { + "key": "DE_P", + "label": "P", + } + "KC_LBRC": { + "key": "DE_UDIA", + "label": "Ãœ", + } + "KC_RBRC": { + "key": "DE_PLUS", + "label": "+", + } + "KC_A": { + "key": "DE_A", + "label": "A", + } + "KC_S": { + "key": "DE_S", + "label": "S", + } + "KC_D": { + "key": "DE_D", + "label": "D", + } + "KC_F": { + "key": "DE_F", + "label": "F", + } + "KC_G": { + "key": "DE_G", + "label": "G", + } + "KC_H": { + "key": "DE_H", + "label": "H", + } + "KC_J": { + "key": "DE_J", + "label": "J", + } + "KC_K": { + "key": "DE_K", + "label": "K", + } + "KC_L": { + "key": "DE_L", + "label": "L", + } + "KC_SCLN": { + "key": "DE_ODIA", + "label": "Ö", + } + "KC_QUOT": { + "key": "DE_ADIA", + "label": "Ä", + } + "KC_NUHS": { + "key": "DE_HASH", + "label": "#", + } + "KC_NUBS": { + "key": "DE_LABK", + "label": "<", + } + "KC_Z": { + "key": "DE_Y", + "label": "Y", + } + "KC_X": { + "key": "DE_X", + "label": "X", + } + "KC_C": { + "key": "DE_C", + "label": "C", + } + "KC_V": { + "key": "DE_V", + "label": "V", + } + "KC_B": { + "key": "DE_B", + "label": "B", + } + "KC_N": { + "key": "DE_N", + "label": "N", + } + "KC_M": { + "key": "DE_M", + "label": "M", + } + "KC_COMM": { + "key": "DE_COMM", + "label": ",", + } + "KC_DOT": { + "key": "DE_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "DE_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ° │ ! │ " │ § │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ' │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(DE_CIRC)": { + "key": "DE_DEG", + "label": "°", + } + "S(DE_1)": { + "key": "DE_EXLM", + "label": "!", + } + "S(DE_2)": { + "key": "DE_DQUO", + "label": "\"", + } + "S(DE_3)": { + "key": "DE_SECT", + "label": "§", + } + "S(DE_4)": { + "key": "DE_DLR", + "label": "$", + } + "S(DE_5)": { + "key": "DE_PERC", + "label": "%", + } + "S(DE_6)": { + "key": "DE_AMPR", + "label": "&", + } + "S(DE_7)": { + "key": "DE_SLSH", + "label": "/", + } + "S(DE_8)": { + "key": "DE_LPRN", + "label": "(", + } + "S(DE_9)": { + "key": "DE_RPRN", + "label": ")", + } + "S(DE_0)": { + "key": "DE_EQL", + "label": "=", + } + "S(DE_SS)": { + "key": "DE_QUES", + "label": "?", + } + "S(DE_ACUT)": { + "key": "DE_GRV", + "label": "` (dead)", + } + "S(DE_PLUS)": { + "key": "DE_ASTR", + "label": "*", + } + "S(DE_HASH)": { + "key": "DE_QUOT", + "label": "'", + } + "S(DE_LABK)": { + "key": "DE_RABK", + "label": ">", + } + "S(DE_COMM)": { + "key": "DE_SCLN", + "label": ";", + } + "S(DE_DOT)": { + "key": "DE_COLN", + "label": ":", + } + "S(DE_MINS)": { + "key": "DE_UNDS", + "label": "_", + } +/* Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ „ │ ¡ │ “ │ ¶ │ ¢ │ [ │ ] │ | │ { │ } │ ≠│ ¿ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ « │ ∑ │ € │ ® │ †│ Ω │ ¨ │ ℠│ Ø │ Ï€ │ • │ ± │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Ã… │ ‚ │ ∂ │ Æ’ │ © │ ª │ º │ ∆ │ @ │ Å’ │ Æ │ ‘ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≤ │ Â¥ │ ≈ │ Ç │ √ │ ∫ │ ~ │ µ │ ∞ │ … │ – │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "A(DE_CIRC)": { + "key": "DE_DLQU", + "label": "„", + } + "A(DE_1)": { + "key": "DE_IEXL", + "label": "¡", + } + "A(DE_2)": { + "key": "DE_LDQU", + "label": "“", + } + "A(DE_3)": { + "key": "DE_PILC", + "label": "¶", + } + "A(DE_4)": { + "key": "DE_CENT", + "label": "¢", + } + "A(DE_5)": { + "key": "DE_LBRC", + "label": "[", + } + "A(DE_6)": { + "key": "DE_RBRC", + "label": "]", + } + "A(DE_7)": { + "key": "DE_PIPE", + "label": "|", + } + "A(DE_8)": { + "key": "DE_LCBR", + "label": "{", + } + "A(DE_9)": { + "key": "DE_RCBR", + "label": "}", + } + "A(DE_0)": { + "key": "DE_NEQL", + "label": "≠", + } + "A(DE_SS)": { + "key": "DE_IQUE", + "label": "¿", + } + "A(DE_Q)": { + "key": "DE_LDAQ", + "label": "«", + } + "A(DE_W)": { + "key": "DE_NARS", + "label": "∑", + } + "A(DE_E)": { + "key": "DE_EURO", + "label": "€", + } + "A(DE_R)": { + "key": "DE_REGD", + "label": "®", + } + "A(DE_T)": { + "key": "DE_DAGG", + "label": "†", + } + "A(DE_Z)": { + "key": "DE_OMEG", + "label": "Ω", + } + "A(DE_U)": { + "key": "DE_DIAE", + "label": "¨ (dead)", + } + "A(DE_I)": { + "key": "DE_FRSL", + "label": "â„", + } + "A(DE_O)": { + "key": "DE_OSTR", + "label": "Ø", + } + "A(DE_P)": { + "key": "DE_PI", + "label": "Ï€", + } + "A(DE_UDIA)": { + "key": "DE_BULT", + "label": "•", + } + "A(DE_PLUS)": { + "key": "DE_PLMN", + "label": "±", + } + "A(DE_A)": { + "key": "DE_ARNG", + "label": "Ã…", + } + "A(DE_S)": { + "key": "DE_SLQU", + "label": "‚", + } + "A(DE_D)": { + "key": "DE_PDIF", + "label": "∂", + } + "A(DE_F)": { + "key": "DE_FHK", + "label": "Æ’", + } + "A(DE_G)": { + "key": "DE_COPY", + "label": "©", + } + "A(DE_H)": { + "key": "DE_FORD", + "label": "ª", + } + "A(DE_J)": { + "key": "DE_MORD", + "label": "º", + } + "A(DE_K)": { + "key": "DE_INCR", + "label": "∆", + } + "A(DE_L)": { + "key": "DE_AT", + "label": "@", + } + "A(DE_ODIA)": { + "key": "DE_OE", + "label": "Å’", + } + "A(DE_ADIA)": { + "key": "DE_AE", + "label": "Æ", + } + "A(DE_HASH)": { + "key": "DE_LSQU", + "label": "‘", + } + "A(DE_LABK)": { + "key": "DE_LTEQ", + "label": "≤", + } + "A(DE_Y)": { + "key": "DE_YEN", + "label": "Â¥", + } + "A(DE_X)": { + "key": "DE_AEQL", + "label": "≈", + } + "A(DE_C)": { + "key": "DE_CCCE", + "label": "Ç", + } + "A(DE_V)": { + "key": "DE_SQRT", + "label": "√", + } + "A(DE_B)": { + "key": "DE_INTG", + "label": "∫", + } + "A(DE_N)": { + "key": "DE_TILD", + "label": "~ (dead)", + } + "A(DE_M)": { + "key": "DE_MICR", + "label": "µ", + } + "A(DE_COMM)": { + "key": "DE_INFN", + "label": "∞", + } + "A(DE_DOT)": { + "key": "DE_ELLP", + "label": "…", + } + "A(DE_MINS)": { + "key": "DE_NDSH", + "label": "–", + } +/* Shift+Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ │ ¬ │ †│ │ £ │ ï¬ â”‚ │ \ │ Ëœ │ · │ ¯ │ Ë™ │ Ëš │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ » │ │ ‰ │ ¸ │ Ë â”‚ ˇ │ à │ Û │ │ ∠│ │  │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ à │ â„¢ │ à │ ÃŒ │ Ó │ ı │ │ fl │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≥ │ ‡ │ Ù │ │ â—Š │ ‹ │ › │ ˘ │ Ë› │ ÷ │ — │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(A(DE_1))": { + "key": "DE_NOT", + "label": "¬", + } + "S(A(DE_2))": { + "key": "DE_RDQU", + "label": "â€", + } + "S(A(DE_4))": { + "key": "DE_PND", + "label": "£", + } + "S(A(DE_5))": { + "key": "DE_FI", + "label": "ï¬", + } + "S(A(DE_7))": { + "key": "DE_BSLS", + "label": "\\", + } + "S(A(DE_8))": { + "key": "DE_STIL", + "label": "Ëœ", + } + "S(A(DE_9))": { + "key": "DE_MDDT", + "label": "·", + } + "S(A(DE_0))": { + "key": "DE_MACR", + "label": "¯", + } + "S(A(DE_SS))": { + "key": "DE_DOTA", + "label": "Ë™", + } + "S(A(DE_ACUT))": { + "key": "DE_RNGA", + "label": "Ëš", + } + "S(A(DE_Q))": { + "key": "DE_RDAQ", + "label": "»", + } + "S(A(DE_E))": { + "key": "DE_PERM", + "label": "‰", + } + "S(A(DE_R))": { + "key": "DE_CEDL", + "label": "¸", + } + "S(A(DE_T))": { + "key": "DE_DACU", + "label": "Ë", + } + "S(A(DE_Z))": { + "key": "DE_CARN", + "label": "ˇ", + } + "S(A(DE_U))": { + "key": "DE_AACU", + "label": "Ã", + } + "S(A(DE_I))": { + "key": "DE_UCIR", + "label": "Û", + } + "S(A(DE_P))": { + "key": "DE_NARP", + "label": "âˆ", + } + "S(A(DE_PLUS))": { + "key": "DE_APPL", + "label": " (Apple logo)", + } + "S(A(DE_S))": { + "key": "DE_IACU", + "label": "Ã", + } + "S(A(DE_D))": { + "key": "DE_TM", + "label": "â„¢", + } + "S(A(DE_F))": { + "key": "DE_IDIA", + "label": "Ã", + } + "S(A(DE_G))": { + "key": "DE_IGRV", + "label": "ÃŒ", + } + "S(A(DE_H))": { + "key": "DE_OACU", + "label": "Ó", + } + "S(A(DE_J))": { + "key": "DE_DLSI", + "label": "ı", + } + "S(A(DE_L))": { + "key": "DE_FL", + "label": "fl", + } + "S(A(DE_LABK))": { + "key": "DE_GTEQ", + "label": "≥", + } + "S(A(DE_Y))": { + "key": "DE_DDAG", + "label": "‡", + } + "S(A(DE_X))": { + "key": "DE_UGRV", + "label": "Ù", + } + "S(A(DE_V))": { + "key": "DE_LOZN", + "label": "â—Š", + } + "S(A(DE_B))": { + "key": "DE_LSAQ", + "label": "‹", + } + "S(A(DE_N))": { + "key": "DE_RSAQ", + "label": "›", + } + "S(A(DE_M))": { + "key": "DE_BREV", + "label": "˘", + } + "S(A(DE_COMM))": { + "key": "DE_OGON", + "label": "Ë›", + } + "S(A(DE_DOT))": { + "key": "DE_DIV", + "label": "÷", + } + "S(A(DE_MINS))": { + "key": "DE_MDSH", + "label": "—", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_greek_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_greek_0.0.1.hjson new file mode 100644 index 0000000000..9c7f8796bf --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_greek_0.0.1.hjson @@ -0,0 +1,391 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ ; │ Ï‚ │ Ε │ Ρ │ Τ │ Î¥ │ Θ │ Ι │ Ο │ Π│ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Α │ Σ │ Δ │ Φ │ Γ │ Η │ Ξ │ Κ │ Λ │ ΄ │ ' │ \ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ Ζ │ Χ │ Ψ │ Ω │ Î’ │ Π│ Îœ │ , │ . │ / │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "GR_GRV", + "label": "`", + } + "KC_1": { + "key": "GR_1", + "label": "1", + } + "KC_2": { + "key": "GR_2", + "label": "2", + } + "KC_3": { + "key": "GR_3", + "label": "3", + } + "KC_4": { + "key": "GR_4", + "label": "4", + } + "KC_5": { + "key": "GR_5", + "label": "5", + } + "KC_6": { + "key": "GR_6", + "label": "6", + } + "KC_7": { + "key": "GR_7", + "label": "7", + } + "KC_8": { + "key": "GR_8", + "label": "8", + } + "KC_9": { + "key": "GR_9", + "label": "9", + } + "KC_0": { + "key": "GR_0", + "label": "0", + } + "KC_MINS": { + "key": "GR_MINS", + "label": "-", + } + "KC_EQL": { + "key": "GR_EQL", + "label": "=", + } + "KC_Q": { + "key": "GR_SCLN", + "label": ";", + } + "KC_W": { + "key": "GR_FSIG", + "label": "Ï‚", + } + "KC_E": { + "key": "GR_EPSL", + "label": "Ε", + } + "KC_R": { + "key": "GR_RHO", + "label": "Ρ", + } + "KC_T": { + "key": "GR_TAU", + "label": "Τ", + } + "KC_Y": { + "key": "GR_UPSL", + "label": "Î¥", + } + "KC_U": { + "key": "GR_THET", + "label": "Θ", + } + "KC_I": { + "key": "GR_IOTA", + "label": "Ι", + } + "KC_O": { + "key": "GR_OMCR", + "label": "Ο", + } + "KC_P": { + "key": "GR_PI", + "label": "Î ", + } + "KC_LBRC": { + "key": "GR_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "GR_RBRC", + "label": "]", + } + "KC_A": { + "key": "GR_ALPH", + "label": "Α", + } + "KC_S": { + "key": "GR_SIGM", + "label": "Σ", + } + "KC_D": { + "key": "GR_DELT", + "label": "Δ", + } + "KC_F": { + "key": "GR_PHI", + "label": "Φ", + } + "KC_G": { + "key": "GR_GAMM", + "label": "Γ", + } + "KC_H": { + "key": "GR_ETA", + "label": "Η", + } + "KC_J": { + "key": "GR_XI", + "label": "Ξ", + } + "KC_K": { + "key": "GR_KAPP", + "label": "Κ", + } + "KC_L": { + "key": "GR_LAMB", + "label": "Λ", + } + "KC_SCLN": { + "key": "GR_TONS", + "label": "΄ (dead)", + } + "KC_QUOT": { + "key": "GR_QUOT", + "label": "'", + } + "KC_NUHS": { + "key": "GR_BSLS", + "label": "\\", + } + "KC_Z": { + "key": "GR_ZETA", + "label": "Ζ", + } + "KC_X": { + "key": "GR_CHI", + "label": "Χ", + } + "KC_C": { + "key": "GR_PSI", + "label": "Ψ", + } + "KC_V": { + "key": "GR_OMEG", + "label": "Ω", + } + "KC_B": { + "key": "GR_BETA", + "label": "Î’", + } + "KC_N": { + "key": "GR_NU", + "label": "Î", + } + "KC_M": { + "key": "GR_MU", + "label": "Îœ", + } + "KC_COMM": { + "key": "GR_COMM", + "label": ",", + } + "KC_DOT": { + "key": "GR_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "GR_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ : │ Î… │ │ │ │ │ │ │ │ │ { │ } │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ ¨ │ " │ | │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(GR_GRV)": { + "key": "GR_TILD", + "label": "~", + } + "S(GR_1)": { + "key": "GR_EXLM", + "label": "!", + } + "S(GR_2)": { + "key": "GR_AT", + "label": "@", + } + "S(GR_3)": { + "key": "GR_HASH", + "label": "#", + } + "S(GR_4)": { + "key": "GR_DLR", + "label": "$", + } + "S(GR_5)": { + "key": "GR_PERC", + "label": "%", + } + "S(GR_6)": { + "key": "GR_CIRC", + "label": "^", + } + "S(GR_7)": { + "key": "GR_AMPR", + "label": "&", + } + "S(GR_8)": { + "key": "GR_ASTR", + "label": "*", + } + "S(GR_9)": { + "key": "GR_LPRN", + "label": "(", + } + "S(GR_0)": { + "key": "GR_RPRN", + "label": ")", + } + "S(GR_MINS)": { + "key": "GR_UNDS", + "label": "_", + } + "S(GR_EQL)": { + "key": "GR_PLUS", + "label": "+", + } + "S(GR_SCLN)": { + "key": "GR_COLN", + "label": ":", + } + "S(GR_FSIG)": { + "key": "GR_DIAT", + "label": "Î… (dead)", + } + "S(GR_LBRC)": { + "key": "GR_LCBR", + "label": "{", + } + "S(GR_RBRC)": { + "key": "GR_RCBR", + "label": "}", + } + "S(GR_TONS)": { + "key": "GR_DIAE", + "label": "¨ (dead)", + } + "S(GR_QUOT)": { + "key": "GR_DQUO", + "label": "\"", + } + "S(GR_BSLS)": { + "key": "GR_PIPE", + "label": "|", + } + "S(GR_COMM)": { + "key": "GR_LABK", + "label": "<", + } + "S(GR_DOT)": { + "key": "GR_RABK", + "label": ">", + } + "S(GR_SLSH)": { + "key": "GR_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ ² │ ³ │ £ │ § │ ¶ │ │ ¤ │ ¦ │ ° │ ± │ ½ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ ® │ │ Â¥ │ │ │ │ │ « │ » │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ¬ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ © │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(GR_2)": { + "key": "GR_SUP2", + "label": "²", + } + "ALGR(GR_3)": { + "key": "GR_SUP3", + "label": "³", + } + "ALGR(GR_4)": { + "key": "GR_PND", + "label": "£", + } + "ALGR(GR_5)": { + "key": "GR_SECT", + "label": "§", + } + "ALGR(GR_6)": { + "key": "GR_PILC", + "label": "¶", + } + "ALGR(GR_8)": { + "key": "GR_CURR", + "label": "¤", + } + "ALGR(GR_9)": { + "key": "GR_BRKP", + "label": "¦", + } + "ALGR(GR_0)": { + "key": "GR_DEG", + "label": "°", + } + "ALGR(GR_MINS)": { + "key": "GR_PLMN", + "label": "±", + } + "ALGR(GR_EQL)": { + "key": "GR_HALF", + "label": "½", + } + "ALGR(GR_EPSL)": { + "key": "GR_EURO", + "label": "€", + } + "ALGR(GR_RHO)": { + "key": "GR_REGD", + "label": "®", + } + "ALGR(GR_UPSL)": { + "key": "GR_YEN", + "label": "Â¥", + } + "ALGR(GR_LBRC)": { + "key": "GR_LDAQ", + "label": "«", + } + "ALGR(GR_RBRC)": { + "key": "GR_RDAQ", + "label": "»", + } + "ALGR(GR_BSLS)": { + "key": "GR_NOT", + "label": "¬", + } + "ALGR(GR_PSI)": { + "key": "GR_COPY", + "label": "©", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_hebrew_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_hebrew_0.0.1.hjson new file mode 100644 index 0000000000..b519229f35 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_hebrew_0.0.1.hjson @@ -0,0 +1,347 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ; │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ / │ ' │ פ │ × â”‚ ן │ ו │ ט │ × â”‚ ר │ ק │ ] │ [ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ ×£ │ ך │ ל │ ×— │ ×™ │ ×¢ │ ×› │ ×’ │ ד │ ש │ , │ \ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ ×¥ │ ת │ צ │ מ │ × â”‚ ×” │ ב │ ס │ ×– │ . │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "IL_SCLN", + "label": ";", + } + "KC_1": { + "key": "IL_1", + "label": "1", + } + "KC_2": { + "key": "IL_2", + "label": "2", + } + "KC_3": { + "key": "IL_3", + "label": "3", + } + "KC_4": { + "key": "IL_4", + "label": "4", + } + "KC_5": { + "key": "IL_5", + "label": "5", + } + "KC_6": { + "key": "IL_6", + "label": "6", + } + "KC_7": { + "key": "IL_7", + "label": "7", + } + "KC_8": { + "key": "IL_8", + "label": "8", + } + "KC_9": { + "key": "IL_9", + "label": "9", + } + "KC_0": { + "key": "IL_0", + "label": "0", + } + "KC_MINS": { + "key": "IL_MINS", + "label": "-", + } + "KC_EQL": { + "key": "IL_EQL", + "label": "=", + } + "KC_Q": { + "key": "IL_SLSH", + "label": "/", + } + "KC_W": { + "key": "IL_QUOT", + "label": "'", + } + "KC_E": { + "key": "IL_QOF", + "label": "ק", + } + "KC_R": { + "key": "IL_RESH", + "label": "ר", + } + "KC_T": { + "key": "IL_ALEF", + "label": "×", + } + "KC_Y": { + "key": "IL_TET", + "label": "ט", + } + "KC_U": { + "key": "IL_VAV", + "label": "ו", + } + "KC_I": { + "key": "IL_FNUN", + "label": "ן", + } + "KC_O": { + "key": "IL_FMEM", + "label": "×", + } + "KC_P": { + "key": "IL_PE", + "label": "פ", + } + "KC_LBRC": { + "key": "IL_RBRC", + "label": "]", + } + "KC_RBRC": { + "key": "IL_LBRC", + "label": "[", + } + "KC_A": { + "key": "IL_SHIN", + "label": "ש", + } + "KC_S": { + "key": "IL_DALT", + "label": "ד", + } + "KC_D": { + "key": "IL_GIML", + "label": "×’", + } + "KC_F": { + "key": "IL_KAF", + "label": "×›", + } + "KC_G": { + "key": "IL_AYIN", + "label": "×¢", + } + "KC_H": { + "key": "IL_YOD", + "label": "×™", + } + "KC_J": { + "key": "IL_HET", + "label": "×—", + } + "KC_K": { + "key": "IL_LAMD", + "label": "ל", + } + "KC_L": { + "key": "IL_FKAF", + "label": "ך", + } + "KC_SCLN": { + "key": "IL_FPE", + "label": "×£", + } + "KC_QUOT": { + "key": "IL_COMM", + "label": ",", + } + "KC_NUHS": { + "key": "IL_BSLS", + "label": "\\", + } + "KC_Z": { + "key": "IL_ZAYN", + "label": "×–", + } + "KC_X": { + "key": "IL_SMKH", + "label": "ס", + } + "KC_C": { + "key": "IL_BET", + "label": "ב", + } + "KC_V": { + "key": "IL_HE", + "label": "×”", + } + "KC_B": { + "key": "IL_NUN", + "label": "× ", + } + "KC_N": { + "key": "IL_MEM", + "label": "מ", + } + "KC_M": { + "key": "IL_TSDI", + "label": "צ", + } + "KC_COMM": { + "key": "IL_TAV", + "label": "ת", + } + "KC_DOT": { + "key": "IL_FTSD", + "label": "×¥", + } + "KC_SLSH": { + "key": "IL_DOT", + "label": ".", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ) │ ( │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ } │ { │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ : │ " │ | │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ > │ < │ ? │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(IL_SCLN)": { + "key": "IL_TILD", + "label": "~", + } + "S(IL_1)": { + "key": "IL_EXLM", + "label": "!", + } + "S(IL_2)": { + "key": "IL_AT", + "label": "@", + } + "S(IL_3)": { + "key": "IL_PND", + "label": "#", + } + "S(IL_4)": { + "key": "IL_DLR", + "label": "$", + } + "S(IL_5)": { + "key": "IL_PERC", + "label": "%", + } + "S(IL_6)": { + "key": "IL_CIRC", + "label": "^", + } + "S(IL_7)": { + "key": "IL_AMPR", + "label": "&", + } + "S(IL_8)": { + "key": "IL_ASTR", + "label": "*", + } + "S(IL_9)": { + "key": "IL_RPRN", + "label": ")", + } + "S(IL_0)": { + "key": "IL_LPRN", + "label": "(", + } + "S(IL_MINS)": { + "key": "IL_UNDS", + "label": "_", + } + "S(IL_EQL)": { + "key": "IL_PLUS", + "label": "+", + } + "S(IL_RBRC)": { + "key": "IL_RCBR", + "label": "}", + } + "S(IL_LBRC)": { + "key": "IL_LCBR", + "label": "{", + } + "S(IL_FPE)": { + "key": "IL_COLN", + "label": ":", + } + "S(IL_COMM)": { + "key": "IL_DQUO", + "label": "\"", + } + "S(IL_BSLS)": { + "key": "IL_PIPE", + "label": "|", + } + "S(IL_TAV)": { + "key": "IL_RABK", + "label": ">", + } + "S(IL_FTSD)": { + "key": "IL_LABK", + "label": "<", + } + "S(IL_DOT)": { + "key": "IL_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ │ € │ ₪ │ ° │ │ │ × │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ ×° │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ ײ │ ×± │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ ÷ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(IL_3)": { + "key": "IL_EURO", + "label": "€", + } + "ALGR(IL_4)": { + "key": "IL_SHKL", + "label": "₪", + } + "ALGR(IL_5)": { + "key": "IL_DEG", + "label": "°", + } + "ALGR(IL_8)": { + "key": "IL_MUL", + "label": "×", + } + "ALGR(IL_TET)": { + "key": "IL_DVAV", + "label": "×°", + } + "ALGR(IL_AYIN)": { + "key": "IL_VYOD", + "label": "×±", + } + "ALGR(IL_YOD)": { + "key": "IL_DYOD", + "label": "ײ", + } + "ALGR(IL_DOT)": { + "key": "IL_DIV", + "label": "÷", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_hungarian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_hungarian_0.0.1.hjson new file mode 100644 index 0000000000..d4fc908dc0 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_hungarian_0.0.1.hjson @@ -0,0 +1,435 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ Ö │ Ãœ │ Ó │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Š│ Ú │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ É │ à │ Å° │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ à │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "HU_0", + "label": "0", + } + "KC_1": { + "key": "HU_1", + "label": "1", + } + "KC_2": { + "key": "HU_2", + "label": "2", + } + "KC_3": { + "key": "HU_3", + "label": "3", + } + "KC_4": { + "key": "HU_4", + "label": "4", + } + "KC_5": { + "key": "HU_5", + "label": "5", + } + "KC_6": { + "key": "HU_6", + "label": "6", + } + "KC_7": { + "key": "HU_7", + "label": "7", + } + "KC_8": { + "key": "HU_8", + "label": "8", + } + "KC_9": { + "key": "HU_9", + "label": "9", + } + "KC_0": { + "key": "HU_ODIA", + "label": "Ö", + } + "KC_MINS": { + "key": "HU_UDIA", + "label": "Ãœ", + } + "KC_EQL": { + "key": "HU_OACU", + "label": "Ó", + } + "KC_Q": { + "key": "HU_Q", + "label": "Q", + } + "KC_W": { + "key": "HU_W", + "label": "W", + } + "KC_E": { + "key": "HU_E", + "label": "E", + } + "KC_R": { + "key": "HU_R", + "label": "R", + } + "KC_T": { + "key": "HU_T", + "label": "T", + } + "KC_Y": { + "key": "HU_Z", + "label": "Z", + } + "KC_U": { + "key": "HU_U", + "label": "U", + } + "KC_I": { + "key": "HU_I", + "label": "I", + } + "KC_O": { + "key": "HU_O", + "label": "O", + } + "KC_P": { + "key": "HU_P", + "label": "P", + } + "KC_LBRC": { + "key": "HU_ODAC", + "label": "Å", + } + "KC_RBRC": { + "key": "HU_UACU", + "label": "Ú", + } + "KC_A": { + "key": "HU_A", + "label": "A", + } + "KC_S": { + "key": "HU_S", + "label": "S", + } + "KC_D": { + "key": "HU_D", + "label": "D", + } + "KC_F": { + "key": "HU_F", + "label": "F", + } + "KC_G": { + "key": "HU_G", + "label": "G", + } + "KC_H": { + "key": "HU_H", + "label": "H", + } + "KC_J": { + "key": "HU_J", + "label": "J", + } + "KC_K": { + "key": "HU_K", + "label": "K", + } + "KC_L": { + "key": "HU_L", + "label": "L", + } + "KC_SCLN": { + "key": "HU_EACU", + "label": "É", + } + "KC_QUOT": { + "key": "HU_AACU", + "label": "Ã", + } + "KC_NUHS": { + "key": "HU_UDAC", + "label": "Å°", + } + "KC_NUBS": { + "key": "HU_IACU", + "label": "Ã", + } + "KC_Z": { + "key": "HU_Y", + "label": "Y", + } + "KC_X": { + "key": "HU_X", + "label": "X", + } + "KC_C": { + "key": "HU_C", + "label": "C", + } + "KC_V": { + "key": "HU_V", + "label": "V", + } + "KC_B": { + "key": "HU_B", + "label": "B", + } + "KC_N": { + "key": "HU_N", + "label": "N", + } + "KC_M": { + "key": "HU_M", + "label": "M", + } + "KC_COMM": { + "key": "HU_COMM", + "label": ",", + } + "KC_DOT": { + "key": "HU_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "HU_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ § │ ' │ " │ + │ ! │ % │ / │ = │ ( │ ) │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ ? │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(HU_0)": { + "key": "HU_SECT", + "label": "§", + } + "S(HU_1)": { + "key": "HU_QUOT", + "label": "'", + } + "S(HU_2)": { + "key": "HU_DQUO", + "label": "\"", + } + "S(HU_3)": { + "key": "HU_PLUS", + "label": "+", + } + "S(HU_4)": { + "key": "HU_EXLM", + "label": "!", + } + "S(HU_5)": { + "key": "HU_PERC", + "label": "%", + } + "S(HU_6)": { + "key": "HU_SLSH", + "label": "/", + } + "S(HU_7)": { + "key": "HU_EQL", + "label": "=", + } + "S(HU_8)": { + "key": "HU_LPRN", + "label": "(", + } + "S(HU_9)": { + "key": "HU_RPRN", + "label": ")", + } + "S(HU_COMM)": { + "key": "HU_QUES", + "label": "?", + } + "S(HU_DOT)": { + "key": "HU_COLN", + "label": ":", + } + "S(HU_MINS)": { + "key": "HU_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ~ │ ˇ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ ´ │ Ë â”‚ ¨ │ ¸ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ \ │ | │ Ä │ │ │ │ € │ │ │ │ ÷ │ × │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ ä │ Ä‘ │ Ä â”‚ [ │ ] │ │ │ Å‚ │ Š│ $ │ ß │ ¤ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ > │ # │ & │ @ │ { │ } │ │ ; │ │ * │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(HU_1)": { + "key": "HU_TILD", + "label": "~", + } + "ALGR(HU_2)": { + "key": "HU_CARN", + "label": "ˇ (dead)", + } + "ALGR(HU_3)": { + "key": "HU_CIRC", + "label": "^ (dead)", + } + "ALGR(HU_4)": { + "key": "HU_BREV", + "label": "˘ (dead)", + } + "ALGR(HU_5)": { + "key": "HU_RNGA", + "label": "° (dead)", + } + "ALGR(HU_6)": { + "key": "HU_OGON", + "label": "Ë› (dead)", + } + "ALGR(HU_7)": { + "key": "HU_GRV", + "label": "`", + } + "ALGR(HU_8)": { + "key": "HU_DOTA", + "label": "Ë™ (dead)", + } + "ALGR(HU_9)": { + "key": "HU_ACUT", + "label": "´ (dead)", + } + "ALGR(HU_ODIA)": { + "key": "HU_DACU", + "label": "Ë (dead)", + } + "ALGR(HU_UDIA)": { + "key": "HU_DIAE", + "label": "¨ (dead)", + } + "ALGR(HU_OACU)": { + "key": "HU_CEDL", + "label": "¸ (dead)", + } + "ALGR(HU_Q)": { + "key": "HU_BSLS", + "label": "\\", + } + "ALGR(HU_W)": { + "key": "HU_PIPE", + "label": "|", + } + "ALGR(HU_E)": { + "key": "HU_CADI", + "label": "Ä", + } + "ALGR(HU_U)": { + "key": "HU_EURO", + "label": "€", + } + "ALGR(HU_ODAC)": { + "key": "HU_DIV", + "label": "÷", + } + "ALGR(HU_UACU)": { + "key": "HU_MUL", + "label": "×", + } + "ALGR(HU_A)": { + "key": "HU_LADI", + "label": "ä", + } + "ALGR(HU_S)": { + "key": "HU_LDST", + "label": "Ä‘", + } + "ALGR(HU_D)": { + "key": "HU_CDST", + "label": "Ä", + } + "ALGR(HU_F)": { + "key": "HU_LBRC", + "label": "[", + } + "ALGR(HU_G)": { + "key": "HU_RBRC", + "label": "]", + } + "ALGR(HU_K)": { + "key": "HU_LLST", + "label": "Å‚", + } + "ALGR(HU_L)": { + "key": "HU_CLST", + "label": "Å", + } + "ALGR(HU_EACU)": { + "key": "HU_DLR", + "label": "$", + } + "ALGR(HU_AACU)": { + "key": "HU_SS", + "label": "ß", + } + "ALGR(HU_UDAC)": { + "key": "HU_CURR", + "label": "¤", + } + "ALGR(HU_IACU)": { + "key": "HU_LABK", + "label": "<", + } + "ALGR(HU_Y)": { + "key": "HU_RABK", + "label": ">", + } + "ALGR(HU_X)": { + "key": "HU_HASH", + "label": "#", + } + "ALGR(HU_C)": { + "key": "HU_AMPR", + "label": "&", + } + "ALGR(HU_V)": { + "key": "HU_AT", + "label": "@", + } + "ALGR(HU_B)": { + "key": "HU_LCBR", + "label": "{", + } + "ALGR(HU_N)": { + "key": "HU_RCBR", + "label": "}", + } + "ALGR(HU_COMM)": { + "key": "HU_SCLN", + "label": ";", + } + "ALGR(HU_MINS)": { + "key": "HU_ASTR", + "label": "*", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_icelandic_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_icelandic_0.0.1.hjson new file mode 100644 index 0000000000..f4d6025a77 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_icelandic_0.0.1.hjson @@ -0,0 +1,355 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ° │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ Ö │ - │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ à │ ' │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Æ │ ´ │ + │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ Þ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "IS_RNGA", + "label": "° (dead)", + } + "KC_1": { + "key": "IS_1", + "label": "1", + } + "KC_2": { + "key": "IS_2", + "label": "2", + } + "KC_3": { + "key": "IS_3", + "label": "3", + } + "KC_4": { + "key": "IS_4", + "label": "4", + } + "KC_5": { + "key": "IS_5", + "label": "5", + } + "KC_6": { + "key": "IS_6", + "label": "6", + } + "KC_7": { + "key": "IS_7", + "label": "7", + } + "KC_8": { + "key": "IS_8", + "label": "8", + } + "KC_9": { + "key": "IS_9", + "label": "9", + } + "KC_0": { + "key": "IS_0", + "label": "0", + } + "KC_MINS": { + "key": "IS_ODIA", + "label": "Ö", + } + "KC_EQL": { + "key": "IS_MINS", + "label": "-", + } + "KC_Q": { + "key": "IS_Q", + "label": "Q", + } + "KC_W": { + "key": "IS_W", + "label": "W", + } + "KC_E": { + "key": "IS_E", + "label": "E", + } + "KC_R": { + "key": "IS_R", + "label": "R", + } + "KC_T": { + "key": "IS_T", + "label": "T", + } + "KC_Y": { + "key": "IS_Y", + "label": "Y", + } + "KC_U": { + "key": "IS_U", + "label": "U", + } + "KC_I": { + "key": "IS_I", + "label": "I", + } + "KC_O": { + "key": "IS_O", + "label": "O", + } + "KC_P": { + "key": "IS_P", + "label": "P", + } + "KC_LBRC": { + "key": "IS_ETH", + "label": "Ã", + } + "KC_RBRC": { + "key": "IS_QUOT", + "label": "'", + } + "KC_A": { + "key": "IS_A", + "label": "A", + } + "KC_S": { + "key": "IS_S", + "label": "S", + } + "KC_D": { + "key": "IS_D", + "label": "D", + } + "KC_F": { + "key": "IS_F", + "label": "F", + } + "KC_G": { + "key": "IS_G", + "label": "G", + } + "KC_H": { + "key": "IS_H", + "label": "H", + } + "KC_J": { + "key": "IS_J", + "label": "J", + } + "KC_K": { + "key": "IS_K", + "label": "K", + } + "KC_L": { + "key": "IS_L", + "label": "L", + } + "KC_SCLN": { + "key": "IS_AE", + "label": "Æ", + } + "KC_QUOT": { + "key": "IS_ACUT", + "label": "´ (dead)", + } + "KC_NUHS": { + "key": "IS_PLUS", + "label": "+", + } + "KC_NUBS": { + "key": "IS_LABK", + "label": "<", + } + "KC_Z": { + "key": "IS_Z", + "label": "Z", + } + "KC_X": { + "key": "IS_X", + "label": "X", + } + "KC_C": { + "key": "IS_C", + "label": "C", + } + "KC_V": { + "key": "IS_V", + "label": "V", + } + "KC_B": { + "key": "IS_B", + "label": "B", + } + "KC_N": { + "key": "IS_N", + "label": "N", + } + "KC_M": { + "key": "IS_M", + "label": "M", + } + "KC_COMM": { + "key": "IS_COMM", + "label": ",", + } + "KC_DOT": { + "key": "IS_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "IS_THRN", + "label": "Þ", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¨ │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ │ _ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ? │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(IS_RNGA)": { + "key": "IS_DIAE", + "label": "¨ (dead)", + } + "S(IS_1)": { + "key": "IS_EXLM", + "label": "!", + } + "S(IS_2)": { + "key": "IS_DQUO", + "label": "\"", + } + "S(IS_3)": { + "key": "IS_HASH", + "label": "#", + } + "S(IS_4)": { + "key": "IS_DLR", + "label": "$", + } + "S(IS_5)": { + "key": "IS_PERC", + "label": "%", + } + "S(IS_6)": { + "key": "IS_AMPR", + "label": "&", + } + "S(IS_7)": { + "key": "IS_SLSH", + "label": "/", + } + "S(IS_8)": { + "key": "IS_LPRN", + "label": "(", + } + "S(IS_9)": { + "key": "IS_RPRN", + "label": ")", + } + "S(IS_0)": { + "key": "IS_EQL", + "label": "=", + } + "S(IS_MINS)": { + "key": "IS_UNDS", + "label": "_", + } + "S(IS_QUOT)": { + "key": "IS_QUES", + "label": "?", + } + "S(IS_PLUS)": { + "key": "IS_ASTR", + "label": "*", + } + "S(IS_LABK)": { + "key": "IS_RABK", + "label": ">", + } + "S(IS_COMM)": { + "key": "IS_SCLN", + "label": ";", + } + "S(IS_DOT)": { + "key": "IS_COLN", + "label": ":", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ° │ │ │ │ │ │ │ { │ [ │ ] │ } │ \ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ @ │ │ € │ │ │ │ │ │ │ │ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ ^ │ ` │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ | │ │ │ │ │ │ │ µ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(IS_RNGA)": { + "key": "IS_DEG", + "label": "°", + } + "ALGR(IS_7)": { + "key": "IS_LCBR", + "label": "{", + } + "ALGR(IS_8)": { + "key": "IS_LBRC", + "label": "[", + } + "ALGR(IS_9)": { + "key": "IS_RBRC", + "label": "]", + } + "ALGR(IS_0)": { + "key": "IS_RCBR", + "label": "}", + } + "ALGR(IS_ODIA)": { + "key": "IS_BSLS", + "label": "\\", + } + "ALGR(IS_Q)": { + "key": "IS_AT", + "label": "@", + } + "ALGR(IS_E)": { + "key": "IS_EURO", + "label": "€", + } + "ALGR(IS_QUOT)": { + "key": "IS_TILD", + "label": "~", + } + "ALGR(IS_ACUT)": { + "key": "IS_CIRC", + "label": "^ (dead)", + } + "ALGR(IS_PLUS)": { + "key": "IS_GRV", + "label": "` (dead)", + } + "ALGR(IS_LABK)": { + "key": "IS_PIPE", + "label": "|", + } + "ALGR(IS_M)": { + "key": "IS_MICR", + "label": "µ", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_irish_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_irish_0.0.1.hjson new file mode 100644 index 0000000000..94e553469e --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_irish_0.0.1.hjson @@ -0,0 +1,355 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ # │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ \ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "IE_GRV", + "label": "`", + } + "KC_1": { + "key": "IE_1", + "label": "1", + } + "KC_2": { + "key": "IE_2", + "label": "2", + } + "KC_3": { + "key": "IE_3", + "label": "3", + } + "KC_4": { + "key": "IE_4", + "label": "4", + } + "KC_5": { + "key": "IE_5", + "label": "5", + } + "KC_6": { + "key": "IE_6", + "label": "6", + } + "KC_7": { + "key": "IE_7", + "label": "7", + } + "KC_8": { + "key": "IE_8", + "label": "8", + } + "KC_9": { + "key": "IE_9", + "label": "9", + } + "KC_0": { + "key": "IE_0", + "label": "0", + } + "KC_MINS": { + "key": "IE_MINS", + "label": "-", + } + "KC_EQL": { + "key": "IE_EQL", + "label": "=", + } + "KC_Q": { + "key": "IE_Q", + "label": "Q", + } + "KC_W": { + "key": "IE_W", + "label": "W", + } + "KC_E": { + "key": "IE_E", + "label": "E", + } + "KC_R": { + "key": "IE_R", + "label": "R", + } + "KC_T": { + "key": "IE_T", + "label": "T", + } + "KC_Y": { + "key": "IE_Y", + "label": "Y", + } + "KC_U": { + "key": "IE_U", + "label": "U", + } + "KC_I": { + "key": "IE_I", + "label": "I", + } + "KC_O": { + "key": "IE_O", + "label": "O", + } + "KC_P": { + "key": "IE_P", + "label": "P", + } + "KC_LBRC": { + "key": "IE_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "IE_RBRC", + "label": "]", + } + "KC_A": { + "key": "IE_A", + "label": "A", + } + "KC_S": { + "key": "IE_S", + "label": "S", + } + "KC_D": { + "key": "IE_D", + "label": "D", + } + "KC_F": { + "key": "IE_F", + "label": "F", + } + "KC_G": { + "key": "IE_G", + "label": "G", + } + "KC_H": { + "key": "IE_H", + "label": "H", + } + "KC_J": { + "key": "IE_J", + "label": "J", + } + "KC_K": { + "key": "IE_K", + "label": "K", + } + "KC_L": { + "key": "IE_L", + "label": "L", + } + "KC_SCLN": { + "key": "IE_SCLN", + "label": ";", + } + "KC_QUOT": { + "key": "IE_QUOT", + "label": "'", + } + "KC_NUHS": { + "key": "IE_HASH", + "label": "#", + } + "KC_NUBS": { + "key": "IE_BSLS", + "label": "\\", + } + "KC_Z": { + "key": "IE_Z", + "label": "Z", + } + "KC_X": { + "key": "IE_X", + "label": "X", + } + "KC_C": { + "key": "IE_C", + "label": "C", + } + "KC_V": { + "key": "IE_V", + "label": "V", + } + "KC_B": { + "key": "IE_B", + "label": "B", + } + "KC_N": { + "key": "IE_N", + "label": "N", + } + "KC_M": { + "key": "IE_M", + "label": "M", + } + "KC_COMM": { + "key": "IE_COMM", + "label": ",", + } + "KC_DOT": { + "key": "IE_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "IE_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¬ │ ! │ " │ £ │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ : │ @ │ ~ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ | │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(IE_GRV)": { + "key": "IE_NOT", + "label": "¬", + } + "S(IE_1)": { + "key": "IE_EXLM", + "label": "!", + } + "S(IE_2)": { + "key": "IE_DQUO", + "label": "\"", + } + "S(IE_3)": { + "key": "IE_PND", + "label": "£", + } + "S(IE_4)": { + "key": "IE_DLR", + "label": "$", + } + "S(IE_5)": { + "key": "IE_PERC", + "label": "%", + } + "S(IE_6)": { + "key": "IE_CIRC", + "label": "^", + } + "S(IE_7)": { + "key": "IE_AMPR", + "label": "&", + } + "S(IE_8)": { + "key": "IE_ASTR", + "label": "*", + } + "S(IE_9)": { + "key": "IE_LPRN", + "label": "(", + } + "S(IE_0)": { + "key": "IE_RPRN", + "label": ")", + } + "S(IE_MINS)": { + "key": "IE_UNDS", + "label": "_", + } + "S(IE_EQL)": { + "key": "IE_PLUS", + "label": "+", + } + "S(IE_LBRC)": { + "key": "IE_LCBR", + "label": "{", + } + "S(IE_RBRC)": { + "key": "IE_RCBR", + "label": "}", + } + "S(IE_SCLN)": { + "key": "IE_COLN", + "label": ":", + } + "S(IE_QUOT)": { + "key": "IE_AT", + "label": "@", + } + "S(IE_HASH)": { + "key": "IE_TILD", + "label": "~", + } + "S(IE_BSLS)": { + "key": "IE_PIPE", + "label": "|", + } + "S(IE_COMM)": { + "key": "IE_LABK", + "label": "<", + } + "S(IE_DOT)": { + "key": "IE_RABK", + "label": ">", + } + "S(IE_SLSH)": { + "key": "IE_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¦ │ │ │ │ € │ │ │ │ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ É │ │ │ │ Ú │ à │ Ó │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ à │ │ │ │ │ │ │ │ │ │ ´ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(IE_GRV)": { + "key": "IE_BRKP", + "label": "¦", + } + "ALGR(IE_4)": { + "key": "IE_EURO", + "label": "€", + } + "ALGR(IE_E)": { + "key": "IE_EACU", + "label": "É", + } + "ALGR(IE_U)": { + "key": "IE_UACU", + "label": "Ú", + } + "ALGR(IE_I)": { + "key": "IE_IACU", + "label": "Ã", + } + "ALGR(IE_O)": { + "key": "IE_OACU", + "label": "Ó", + } + "ALGR(IE_A)": { + "key": "IE_AACU", + "label": "Ã", + } + "ALGR(IE_QUOT)": { + "key": "IE_ACUT", + "label": "´ (dead)", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_italian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_italian_0.0.1.hjson new file mode 100644 index 0000000000..951c564f62 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_italian_0.0.1.hjson @@ -0,0 +1,364 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ \ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ì │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ è │ + │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ò │ à │ ù │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "IT_BSLS", + "label": "\\", + } + "KC_1": { + "key": "IT_1", + "label": "1", + } + "KC_2": { + "key": "IT_2", + "label": "2", + } + "KC_3": { + "key": "IT_3", + "label": "3", + } + "KC_4": { + "key": "IT_4", + "label": "4", + } + "KC_5": { + "key": "IT_5", + "label": "5", + } + "KC_6": { + "key": "IT_6", + "label": "6", + } + "KC_7": { + "key": "IT_7", + "label": "7", + } + "KC_8": { + "key": "IT_8", + "label": "8", + } + "KC_9": { + "key": "IT_9", + "label": "9", + } + "KC_0": { + "key": "IT_0", + "label": "0", + } + "KC_MINS": { + "key": "IT_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "IT_IGRV", + "label": "ì", + } + "KC_Q": { + "key": "IT_Q", + "label": "Q", + } + "KC_W": { + "key": "IT_W", + "label": "W", + } + "KC_E": { + "key": "IT_E", + "label": "E", + } + "KC_R": { + "key": "IT_R", + "label": "R", + } + "KC_T": { + "key": "IT_T", + "label": "T", + } + "KC_Y": { + "key": "IT_Y", + "label": "Y", + } + "KC_U": { + "key": "IT_U", + "label": "U", + } + "KC_I": { + "key": "IT_I", + "label": "I", + } + "KC_O": { + "key": "IT_O", + "label": "O", + } + "KC_P": { + "key": "IT_P", + "label": "P", + } + "KC_LBRC": { + "key": "IT_EGRV", + "label": "è", + } + "KC_RBRC": { + "key": "IT_PLUS", + "label": "+", + } + "KC_A": { + "key": "IT_A", + "label": "A", + } + "KC_S": { + "key": "IT_S", + "label": "S", + } + "KC_D": { + "key": "IT_D", + "label": "D", + } + "KC_F": { + "key": "IT_F", + "label": "F", + } + "KC_G": { + "key": "IT_G", + "label": "G", + } + "KC_H": { + "key": "IT_H", + "label": "H", + } + "KC_J": { + "key": "IT_J", + "label": "J", + } + "KC_K": { + "key": "IT_K", + "label": "K", + } + "KC_L": { + "key": "IT_L", + "label": "L", + } + "KC_SCLN": { + "key": "IT_OGRV", + "label": "ò", + } + "KC_QUOT": { + "key": "IT_AGRV", + "label": "à ", + } + "KC_NUHS": { + "key": "IT_UGRV", + "label": "ù", + } + "KC_NUBS": { + "key": "IT_LABK", + "label": "<", + } + "KC_Z": { + "key": "IT_Z", + "label": "Z", + } + "KC_X": { + "key": "IT_X", + "label": "X", + } + "KC_C": { + "key": "IT_C", + "label": "C", + } + "KC_B": { + "key": "IT_B", + "label": "B", + } + "KC_V": { + "key": "IT_V", + "label": "V", + } + "KC_N": { + "key": "IT_N", + "label": "N", + } + "KC_M": { + "key": "IT_M", + "label": "M", + } + "KC_COMM": { + "key": "IT_COMM", + "label": ",", + } + "KC_DOT": { + "key": "IT_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "IT_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ | │ ! │ " │ £ │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ^ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ é │ * │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ ç │ ° │ § │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(IT_BSLS)": { + "key": "IT_PIPE", + "label": "|", + } + "S(IT_1)": { + "key": "IT_EXLM", + "label": "!", + } + "S(IT_2)": { + "key": "IT_DQUO", + "label": "\"", + } + "S(IT_3)": { + "key": "IT_PND", + "label": "£", + } + "S(IT_4)": { + "key": "IT_DLR", + "label": "$", + } + "S(IT_5)": { + "key": "IT_PERC", + "label": "%", + } + "S(IT_6)": { + "key": "IT_AMPR", + "label": "&", + } + "S(IT_7)": { + "key": "IT_SLSH", + "label": "/", + } + "S(IT_8)": { + "key": "IT_LPRN", + "label": "(", + } + "S(IT_9)": { + "key": "IT_RPRN", + "label": ")", + } + "S(IT_0)": { + "key": "IT_EQL", + "label": "=", + } + "S(IT_QUOT)": { + "key": "IT_QUES", + "label": "?", + } + "S(IT_IGRV)": { + "key": "IT_CIRC", + "label": "^", + } + "S(IT_EGRV)": { + "key": "IT_EACU", + "label": "é", + } + "S(IT_PLUS)": { + "key": "IT_ASTR", + "label": "*", + } + "S(IT_OGRV)": { + "key": "IT_CCED", + "label": "ç", + } + "S(IT_AGRV)": { + "key": "IT_DEG", + "label": "°", + } + "S(IT_UGRV)": { + "key": "IT_SECT", + "label": "§", + } + "S(IT_LABK)": { + "key": "IT_RABK", + "label": ">", + } + "S(IT_DOT)": { + "key": "IT_COLN", + "label": ":", + } + "S(IT_COMM)": { + "key": "IT_SCLN", + "label": ";", + } + "S(IT_MINS)": { + "key": "IT_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ @ │ # │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(IT_E)": { + "key": "IT_EURO", + "label": "€", + } + "ALGR(IT_EGRV)": { + "key": "IT_LBRC", + "label": "[", + } + "ALGR(IT_PLUS)": { + "key": "IT_RBRC", + "label": "]", + } + "ALGR(IT_OGRV)": { + "key": "IT_AT", + "label": "@", + } + "ALGR(IT_AGRV)": { + "key": "IT_HASH", + "label": "#", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(IT_EGRV))": { + "key": "IT_LCBR", + "label": "{", + } + "S(ALGR(IT_PLUS))": { + "key": "IT_RCBR", + "label": "}", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_italian_mac_ansi_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_italian_mac_ansi_0.0.1.hjson new file mode 100644 index 0000000000..328755ca67 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_italian_mac_ansi_0.0.1.hjson @@ -0,0 +1,684 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ < │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ì │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ è │ + │ ù │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ò │ à │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "KC_GRV": { + "key": "IT_LABK", + "label": "<", + } + "KC_1": { + "key": "IT_1", + "label": "1", + } + "KC_2": { + "key": "IT_2", + "label": "2", + } + "KC_3": { + "key": "IT_3", + "label": "3", + } + "KC_4": { + "key": "IT_4", + "label": "4", + } + "KC_5": { + "key": "IT_5", + "label": "5", + } + "KC_6": { + "key": "IT_6", + "label": "6", + } + "KC_7": { + "key": "IT_7", + "label": "7", + } + "KC_8": { + "key": "IT_8", + "label": "8", + } + "KC_9": { + "key": "IT_9", + "label": "9", + } + "KC_0": { + "key": "IT_0", + "label": "0", + } + "KC_MINS": { + "key": "IT_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "IT_IGRV", + "label": "ì", + } + "KC_Q": { + "key": "IT_Q", + "label": "Q", + } + "KC_W": { + "key": "IT_W", + "label": "W", + } + "KC_E": { + "key": "IT_E", + "label": "E", + } + "KC_R": { + "key": "IT_R", + "label": "R", + } + "KC_T": { + "key": "IT_T", + "label": "T", + } + "KC_Y": { + "key": "IT_Y", + "label": "Y", + } + "KC_U": { + "key": "IT_U", + "label": "U", + } + "KC_I": { + "key": "IT_I", + "label": "I", + } + "KC_O": { + "key": "IT_O", + "label": "O", + } + "KC_P": { + "key": "IT_P", + "label": "P", + } + "KC_LBRC": { + "key": "IT_EGRV", + "label": "è", + } + "KC_RBRC": { + "key": "IT_PLUS", + "label": "+", + } + "KC_BSLS": { + "key": "IT_UGRV", + "label": "ù", + } + "KC_A": { + "key": "IT_A", + "label": "A", + } + "KC_S": { + "key": "IT_S", + "label": "S", + } + "KC_D": { + "key": "IT_D", + "label": "D", + } + "KC_F": { + "key": "IT_F", + "label": "F", + } + "KC_G": { + "key": "IT_G", + "label": "G", + } + "KC_H": { + "key": "IT_H", + "label": "H", + } + "KC_J": { + "key": "IT_J", + "label": "J", + } + "KC_K": { + "key": "IT_K", + "label": "K", + } + "KC_L": { + "key": "IT_L", + "label": "L", + } + "KC_SCLN": { + "key": "IT_OGRV", + "label": "ò", + } + "KC_QUOT": { + "key": "IT_AGRV", + "label": "à ", + } + "KC_NUBS": { + "key": "IT_BSLS", + "label": "(backslash, not physically present)", + } + "KC_Z": { + "key": "IT_Z", + "label": "Z", + } + "KC_X": { + "key": "IT_X", + "label": "X", + } + "KC_C": { + "key": "IT_C", + "label": "C", + } + "KC_V": { + "key": "IT_V", + "label": "V", + } + "KC_B": { + "key": "IT_B", + "label": "B", + } + "KC_N": { + "key": "IT_N", + "label": "N", + } + "KC_M": { + "key": "IT_M", + "label": "M", + } + "KC_COMM": { + "key": "IT_COMM", + "label": ",", + } + "KC_DOT": { + "key": "IT_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "IT_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ > │ ! │ " │ £ │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ^ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ é │ * │ § │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │ │ │ │ │ │ │ │ │ │ ç │ ° │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(IT_LABK)": { + "key": "IT_RABK", + "label": ">", + } + "S(IT_1)": { + "key": "IT_EXLM", + "label": "!", + } + "S(IT_2)": { + "key": "IT_DQUO", + "label": "\"", + } + "S(IT_3)": { + "key": "IT_PND", + "label": "£", + } + "S(IT_4)": { + "key": "IT_DLR", + "label": "$", + } + "S(IT_5)": { + "key": "IT_PERC", + "label": "%", + } + "S(IT_6)": { + "key": "IT_AMPR", + "label": "&", + } + "S(IT_7)": { + "key": "IT_SLSH", + "label": "/", + } + "S(IT_8)": { + "key": "IT_LPRN", + "label": "(", + } + "S(IT_9)": { + "key": "IT_RPRN", + "label": ")", + } + "S(IT_0)": { + "key": "IT_EQL", + "label": "=", + } + "S(IT_QUOT)": { + "key": "IT_QUES", + "label": "?", + } + "S(IT_IGRV)": { + "key": "IT_CIRC", + "label": "^", + } + "S(IT_EGRV)": { + "key": "IT_EACU", + "label": "é", + } + "S(IT_PLUS)": { + "key": "IT_ASTR", + "label": "*", + } + "S(IT_UGRV)": { + "key": "IT_SECT", + "label": "§", + } + "S(IT_OGRV)": { + "key": "IT_LCCE", + "label": "ç", + } + "S(IT_AGRV)": { + "key": "IT_DEG", + "label": "°", + } + "S(IT_BSLS)": { + "key": "IT_PIPE", + "label": "| (not physically present)", + } + "S(IT_COMM)": { + "key": "IT_SCLN", + "label": ";", + } + "S(IT_DOT)": { + "key": "IT_COLN", + "label": ":", + } + "S(IT_MINS)": { + "key": "IT_UNDS", + "label": "_", + } +/* Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ≤ │ « │ “ │ ‘ │ Â¥ │ ~ │ ‹ │ ÷ │ ´ │ ` │ ≠│ ¡ │ ˆ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ „ │ Ω │ € │ ® │ â„¢ │ Æ │ ¨ │ Å’ │ Ø │ Ï€ │ [ │ ] │ ¶ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │ Ã… │ ß │ ∂ │ Æ’ │ ∞ │ ∆ │ ª │ º │ ¬ │ @ │ # │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ ∑ │ †│ © │ √ │ ∫ │ Ëœ │ µ │ … │ • │ – │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "A(IT_LABK)": { + "key": "IT_LTEQ", + "label": "≤", + } + "A(IT_1)": { + "key": "IT_LDAQ", + "label": "«", + } + "A(IT_2)": { + "key": "IT_LDQU", + "label": "“", + } + "A(IT_3)": { + "key": "IT_LSQU", + "label": "‘", + } + "A(IT_4)": { + "key": "IT_YEN", + "label": "Â¥", + } + "A(IT_5)": { + "key": "IT_TILD", + "label": "~", + } + "A(IT_6)": { + "key": "IT_LSAQ", + "label": "‹", + } + "A(IT_7)": { + "key": "IT_DIV", + "label": "÷", + } + "A(IT_8)": { + "key": "IT_ACUT", + "label": "´ (dead)", + } + "A(IT_9)": { + "key": "IT_DGRV", + "label": "` (dead)", + } + "A(IT_0)": { + "key": "IT_NEQL", + "label": "≠", + } + "A(IT_QUOT)": { + "key": "IT_IEXL", + "label": "¡", + } + "A(IT_IGRV)": { + "key": "IT_DCIR", + "label": "ˆ (dead)", + } + "A(IT_Q)": { + "key": "IT_DLQU", + "label": "„", + } + "A(IT_W)": { + "key": "IT_OMEG", + "label": "Ω", + } + "A(IT_E)": { + "key": "IT_EURO", + "label": "€", + } + "A(IT_R)": { + "key": "IT_REGD", + "label": "®", + } + "A(IT_T)": { + "key": "IT_TM", + "label": "â„¢", + } + "A(IT_Y)": { + "key": "IT_AE", + "label": "Æ", + } + "A(IT_U)": { + "key": "IT_DIAE", + "label": "¨ (dead)", + } + "A(IT_I)": { + "key": "IT_OE", + "label": "Å’", + } + "A(IT_O)": { + "key": "IT_OSTR", + "label": "Ø", + } + "A(IT_P)": { + "key": "IT_PI", + "label": "Ï€", + } + "A(IT_EGRV)": { + "key": "IT_LBRC", + "label": "[", + } + "A(IT_PLUS)": { + "key": "IT_RBRC", + "label": "]", + } + "A(IT_A)": { + "key": "IT_ARNG", + "label": "Ã…", + } + "A(IT_S)": { + "key": "IT_SS", + "label": "ß", + } + "A(IT_D)": { + "key": "IT_PDIF", + "label": "∂", + } + "A(IT_F)": { + "key": "IT_FHK", + "label": "Æ’", + } + "A(IT_G)": { + "key": "IT_INFN", + "label": "∞", + } + "A(IT_H)": { + "key": "IT_INCR", + "label": "∆", + } + "A(IT_J)": { + "key": "IT_FORD", + "label": "ª", + } + "A(IT_K)": { + "key": "IT_MORD", + "label": "º", + } + "A(IT_L)": { + "key": "IT_NOT", + "label": "¬", + } + "A(IT_OGRV)": { + "key": "IT_AT", + "label": "@", + } + "A(IT_AGRV)": { + "key": "IT_HASH", + "label": "#", + } + "A(IT_UGRV)": { + "key": "IT_PILC", + "label": "¶", + } + "A(IT_BSLS)": { + "key": "IT_GRV", + "label": "` (not physically present)", + } + "A(IT_Z)": { + "key": "IT_NARS", + "label": "∑", + } + "A(IT_X)": { + "key": "IT_DAGG", + "label": "†", + } + "A(IT_C)": { + "key": "IT_COPY", + "label": "©", + } + "A(IT_V)": { + "key": "IT_SQRT", + "label": "√", + } + "A(IT_B)": { + "key": "IT_INTG", + "label": "∫", + } + "A(IT_N)": { + "key": "IT_STIL", + "label": "Ëœ (dead)", + } + "A(IT_M)": { + "key": "IT_MICR", + "label": "µ", + } + "A(IT_COMM)": { + "key": "IT_ELLP", + "label": "…", + } + "A(IT_DOT)": { + "key": "IT_BULT", + "label": "•", + } + "A(IT_MINS)": { + "key": "IT_NDSH", + "label": "–", + } +/* Shift+Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ≥ │ » │ †│ ’ │ ¢ │ ‰ │ › │ ℠│  │ │ ≈ │ ¿ │ ± │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ ‚ │ À │ È │ ÃŒ │ Ã’ │ │ Ù │ │ │ ∠│ { │ } │ â—Š │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │ │ ¯ │ ˘ │ Ë™ │ Ëš │ ¸ │ Ë â”‚ Ë› │ ˇ │ Ç │ ∞ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ │ ‡ │ à │ É │ à │ Ó │ Ú │ │ · │ — │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(A(IT_LABK))": { + "key": "IT_GTEQ", + "label": "≥", + } + "S(A(IT_1))": { + "key": "IT_RDAQ", + "label": "»", + } + "S(A(IT_2))": { + "key": "IT_RDQU", + "label": "â€", + } + "S(A(IT_3))": { + "key": "IT_RSQU", + "label": "’", + } + "S(A(IT_4))": { + "key": "IT_CENT", + "label": "¢", + } + "S(A(IT_5))": { + "key": "IT_PERM", + "label": "‰", + } + "S(A(IT_6))": { + "key": "IT_RSAQ", + "label": "›", + } + "S(A(IT_7))": { + "key": "IT_FRSL", + "label": "â„", + } + "S(A(IT_8))": { + "key": "IT_APPL", + "label": " (Apple logo)", + } + "S(A(IT_0))": { + "key": "IT_AEQL", + "label": "≈", + } + "S(A(IT_QUOT))": { + "key": "IT_IQUE", + "label": "¿", + } + "S(A(IT_IGRV))": { + "key": "IT_PLMN", + "label": "±", + } + "S(A(IT_Q))": { + "key": "IT_SLQU", + "label": "‚", + } + "S(A(IT_W))": { + "key": "IT_CAGR", + "label": "À", + } + "S(A(IT_E))": { + "key": "IT_CEGR", + "label": "È", + } + "S(A(IT_R))": { + "key": "IT_CIGR", + "label": "ÃŒ", + } + "S(A(IT_T))": { + "key": "IT_COGR", + "label": "Ã’", + } + "S(A(IT_U))": { + "key": "IT_CUGR", + "label": "Ù", + } + "S(A(IT_P))": { + "key": "IT_NARP", + "label": "âˆ", + } + "S(A(IT_EGRV))": { + "key": "IT_LCBR", + "label": "{", + } + "S(A(IT_PLUS))": { + "key": "IT_RCBR", + "label": "}", + } + "S(A(IT_UGRV))": { + "key": "IT_LOZN", + "label": "â—Š", + } + "S(A(IT_S))": { + "key": "IT_MACR", + "label": "¯", + } + "S(A(IT_D))": { + "key": "IT_BREV", + "label": "˘", + } + "S(A(IT_F))": { + "key": "IT_DOTA", + "label": "Ë™", + } + "S(A(IT_G))": { + "key": "IT_RGNA", + "label": "Ëš", + } + "S(A(IT_H))": { + "key": "IT_CEDL", + "label": "¸", + } + "S(A(IT_J))": { + "key": "IT_DACU", + "label": "Ë", + } + "S(A(IT_K))": { + "key": "IT_OGON", + "label": "Ë›", + } + "S(A(IT_L))": { + "key": "IT_CARN", + "label": "ˇ", + } + "S(A(IT_OGRV))": { + "key": "IT_CCCE", + "label": "Ç", + } + "S(A(IT_X))": { + "key": "IT_DDAG", + "label": "‡", + } + "S(A(IT_C))": { + "key": "IT_CAAC", + "label": "Ã", + } + "S(A(IT_V))": { + "key": "IT_CEAC", + "label": "É", + } + "S(A(IT_B))": { + "key": "IT_CIAC", + "label": "Ã", + } + "S(A(IT_N))": { + "key": "IT_COAC", + "label": "Ó", + } + "S(A(IT_M))": { + "key": "IT_CUAC", + "label": "Ú", + } + "S(A(IT_DOT))": { + "key": "IT_MDDT", + "label": "·", + } + "S(A(IT_MINS))": { + "key": "IT_MDSH", + "label": "—", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_italian_mac_iso_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_italian_mac_iso_0.0.1.hjson new file mode 100644 index 0000000000..4beccd804a --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_italian_mac_iso_0.0.1.hjson @@ -0,0 +1,688 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ \ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ì │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ è │ + │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ò │ à │ ù │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "KC_GRV": { + "key": "IT_BSLS", + "label": "\\", + } + "KC_1": { + "key": "IT_1", + "label": "1", + } + "KC_2": { + "key": "IT_2", + "label": "2", + } + "KC_3": { + "key": "IT_3", + "label": "3", + } + "KC_4": { + "key": "IT_4", + "label": "4", + } + "KC_5": { + "key": "IT_5", + "label": "5", + } + "KC_6": { + "key": "IT_6", + "label": "6", + } + "KC_7": { + "key": "IT_7", + "label": "7", + } + "KC_8": { + "key": "IT_8", + "label": "8", + } + "KC_9": { + "key": "IT_9", + "label": "9", + } + "KC_0": { + "key": "IT_0", + "label": "0", + } + "KC_MINS": { + "key": "IT_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "IT_IGRV", + "label": "ì", + } + "KC_Q": { + "key": "IT_Q", + "label": "Q", + } + "KC_W": { + "key": "IT_W", + "label": "W", + } + "KC_E": { + "key": "IT_E", + "label": "E", + } + "KC_R": { + "key": "IT_R", + "label": "R", + } + "KC_T": { + "key": "IT_T", + "label": "T", + } + "KC_Y": { + "key": "IT_Y", + "label": "Y", + } + "KC_U": { + "key": "IT_U", + "label": "U", + } + "KC_I": { + "key": "IT_I", + "label": "I", + } + "KC_O": { + "key": "IT_O", + "label": "O", + } + "KC_P": { + "key": "IT_P", + "label": "P", + } + "KC_LBRC": { + "key": "IT_EGRV", + "label": "è", + } + "KC_RBRC": { + "key": "IT_PLUS", + "label": "+", + } + "KC_A": { + "key": "IT_A", + "label": "A", + } + "KC_S": { + "key": "IT_S", + "label": "S", + } + "KC_D": { + "key": "IT_D", + "label": "D", + } + "KC_F": { + "key": "IT_F", + "label": "F", + } + "KC_G": { + "key": "IT_G", + "label": "G", + } + "KC_H": { + "key": "IT_H", + "label": "H", + } + "KC_J": { + "key": "IT_J", + "label": "J", + } + "KC_K": { + "key": "IT_K", + "label": "K", + } + "KC_L": { + "key": "IT_L", + "label": "L", + } + "KC_SCLN": { + "key": "IT_OGRV", + "label": "ò", + } + "KC_QUOT": { + "key": "IT_AGRV", + "label": "à ", + } + "KC_NUHS": { + "key": "IT_UGRV", + "label": "ù", + } + "KC_NUBS": { + "key": "IT_LABK", + "label": "<", + } + "KC_Z": { + "key": "IT_Z", + "label": "Z", + } + "KC_X": { + "key": "IT_X", + "label": "X", + } + "KC_C": { + "key": "IT_C", + "label": "C", + } + "KC_V": { + "key": "IT_V", + "label": "V", + } + "KC_B": { + "key": "IT_B", + "label": "B", + } + "KC_N": { + "key": "IT_N", + "label": "N", + } + "KC_M": { + "key": "IT_M", + "label": "M", + } + "KC_COMM": { + "key": "IT_COMM", + "label": ",", + } + "KC_DOT": { + "key": "IT_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "IT_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ | │ ! │ " │ £ │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ^ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ é │ * │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ ç │ ° │ § │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(IT_BSLS)": { + "key": "IT_PIPE", + "label": "|", + } + "S(IT_1)": { + "key": "IT_EXLM", + "label": "!", + } + "S(IT_2)": { + "key": "IT_DQUO", + "label": "\"", + } + "S(IT_3)": { + "key": "IT_PND", + "label": "£", + } + "S(IT_4)": { + "key": "IT_DLR", + "label": "$", + } + "S(IT_5)": { + "key": "IT_PERC", + "label": "%", + } + "S(IT_6)": { + "key": "IT_AMPR", + "label": "&", + } + "S(IT_7)": { + "key": "IT_SLSH", + "label": "/", + } + "S(IT_8)": { + "key": "IT_LPRN", + "label": "(", + } + "S(IT_9)": { + "key": "IT_RPRN", + "label": ")", + } + "S(IT_0)": { + "key": "IT_EQL", + "label": "=", + } + "S(IT_QUOT)": { + "key": "IT_QUES", + "label": "?", + } + "S(IT_IGRV)": { + "key": "IT_CIRC", + "label": "^", + } + "S(IT_EGRV)": { + "key": "IT_EACU", + "label": "é", + } + "S(IT_PLUS)": { + "key": "IT_ASTR", + "label": "*", + } + "S(IT_OGRV)": { + "key": "IT_LCCE", + "label": "ç", + } + "S(IT_AGRV)": { + "key": "IT_DEG", + "label": "°", + } + "S(IT_UGRV)": { + "key": "IT_SECT", + "label": "§", + } + "S(IT_LABK)": { + "key": "IT_RABK", + "label": ">", + } + "S(IT_COMM)": { + "key": "IT_SCLN", + "label": ";", + } + "S(IT_DOT)": { + "key": "IT_COLN", + "label": ":", + } + "S(IT_MINS)": { + "key": "IT_UNDS", + "label": "_", + } +/* Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ` │ « │ “ │ ‘ │ Â¥ │ ~ │ ‹ │ ÷ │ ´ │ ` │ ≠│ ¡ │ ˆ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ „ │ Ω │ € │ ® │ â„¢ │ Æ │ ¨ │ Å’ │ Ø │ Ï€ │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Ã… │ ß │ ∂ │ Æ’ │ ∞ │ ∆ │ ª │ º │ ¬ │ @ │ # │ ¶ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≤ │ ∑ │ †│ © │ √ │ ∫ │ Ëœ │ µ │ … │ • │ – │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "A(IT_BSLS)": { + "key": "IT_GRV", + "label": "`", + } + "A(IT_1)": { + "key": "IT_LDAQ", + "label": "«", + } + "A(IT_2)": { + "key": "IT_LDQU", + "label": "“", + } + "A(IT_3)": { + "key": "IT_LSQU", + "label": "‘", + } + "A(IT_4)": { + "key": "IT_YEN", + "label": "Â¥", + } + "A(IT_5)": { + "key": "IT_TILD", + "label": "~", + } + "A(IT_6)": { + "key": "IT_LSAQ", + "label": "‹", + } + "A(IT_7)": { + "key": "IT_DIV", + "label": "÷", + } + "A(IT_8)": { + "key": "IT_ACUT", + "label": "´ (dead)", + } + "A(IT_9)": { + "key": "IT_DGRV", + "label": "` (dead)", + } + "A(IT_0)": { + "key": "IT_NEQL", + "label": "≠", + } + "A(IT_QUOT)": { + "key": "IT_IEXL", + "label": "¡", + } + "A(IT_IGRV)": { + "key": "IT_DCIR", + "label": "ˆ (dead)", + } + "A(IT_Q)": { + "key": "IT_DLQU", + "label": "„", + } + "A(IT_W)": { + "key": "IT_OMEG", + "label": "Ω", + } + "A(IT_E)": { + "key": "IT_EURO", + "label": "€", + } + "A(IT_R)": { + "key": "IT_REGD", + "label": "®", + } + "A(IT_T)": { + "key": "IT_TM", + "label": "â„¢", + } + "A(IT_Y)": { + "key": "IT_AE", + "label": "Æ", + } + "A(IT_U)": { + "key": "IT_DIAE", + "label": "¨ (dead)", + } + "A(IT_I)": { + "key": "IT_OE", + "label": "Å’", + } + "A(IT_O)": { + "key": "IT_OSTR", + "label": "Ø", + } + "A(IT_P)": { + "key": "IT_PI", + "label": "Ï€", + } + "A(IT_EGRV)": { + "key": "IT_LBRC", + "label": "[", + } + "A(IT_PLUS)": { + "key": "IT_RBRC", + "label": "]", + } + "A(IT_A)": { + "key": "IT_ARNG", + "label": "Ã…", + } + "A(IT_S)": { + "key": "IT_SS", + "label": "ß", + } + "A(IT_D)": { + "key": "IT_PDIF", + "label": "∂", + } + "A(IT_F)": { + "key": "IT_FHK", + "label": "Æ’", + } + "A(IT_G)": { + "key": "IT_INFN", + "label": "∞", + } + "A(IT_H)": { + "key": "IT_INCR", + "label": "∆", + } + "A(IT_J)": { + "key": "IT_FORD", + "label": "ª", + } + "A(IT_K)": { + "key": "IT_MORD", + "label": "º", + } + "A(IT_L)": { + "key": "IT_NOT", + "label": "¬", + } + "A(IT_OGRV)": { + "key": "IT_AT", + "label": "@", + } + "A(IT_AGRV)": { + "key": "IT_HASH", + "label": "#", + } + "A(IT_UGRV)": { + "key": "IT_PILC", + "label": "¶", + } + "A(IT_LABK)": { + "key": "IT_LTEQ", + "label": "≤", + } + "A(IT_Z)": { + "key": "IT_NARS", + "label": "∑", + } + "A(IT_X)": { + "key": "IT_DAGG", + "label": "†", + } + "A(IT_C)": { + "key": "IT_COPY", + "label": "©", + } + "A(IT_V)": { + "key": "IT_SQRT", + "label": "√", + } + "A(IT_B)": { + "key": "IT_INTG", + "label": "∫", + } + "A(IT_N)": { + "key": "IT_STIL", + "label": "Ëœ (dead)", + } + "A(IT_M)": { + "key": "IT_MICR", + "label": "µ", + } + "A(IT_COMM)": { + "key": "IT_ELLP", + "label": "…", + } + "A(IT_DOT)": { + "key": "IT_BULT", + "label": "•", + } + "A(IT_MINS)": { + "key": "IT_NDSH", + "label": "–", + } +/* Shift+Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ı │ » │ †│ ’ │ ¢ │ ‰ │ › │ ℠│  │ │ ≈ │ ¿ │ ± │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ ‚ │ À │ È │ ÃŒ │ Ã’ │ │ Ù │ │ │ ∠│ { │ } │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ ¯ │ ˘ │ Ë™ │ Ëš │ ¸ │ Ë â”‚ Ë› │ ˇ │ Ç │ │ â—Š │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≥ │ │ ‡ │ à │ É │ à │ Ó │ Ú │ │ · │ — │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(A(IT_BSLS))": { + "key": "IT_DLSI", + "label": "ı", + } + "S(A(IT_1))": { + "key": "IT_RDAQ", + "label": "»", + } + "S(A(IT_2))": { + "key": "IT_RDQU", + "label": "â€", + } + "S(A(IT_3))": { + "key": "IT_RSQU", + "label": "’", + } + "S(A(IT_4))": { + "key": "IT_CENT", + "label": "¢", + } + "S(A(IT_5))": { + "key": "IT_PERM", + "label": "‰", + } + "S(A(IT_6))": { + "key": "IT_RSAQ", + "label": "›", + } + "S(A(IT_7))": { + "key": "IT_FRSL", + "label": "â„", + } + "S(A(IT_8))": { + "key": "IT_APPL", + "label": " (Apple logo)", + } + "S(A(IT_0))": { + "key": "IT_AEQL", + "label": "≈", + } + "S(A(IT_QUOT))": { + "key": "IT_IQUE", + "label": "¿", + } + "S(A(IT_IGRV))": { + "key": "IT_PLMN", + "label": "±", + } + "S(A(IT_Q))": { + "key": "IT_SLQU", + "label": "‚", + } + "S(A(IT_W))": { + "key": "IT_CAGR", + "label": "À", + } + "S(A(IT_E))": { + "key": "IT_CEGR", + "label": "È", + } + "S(A(IT_R))": { + "key": "IT_CIGR", + "label": "ÃŒ", + } + "S(A(IT_T))": { + "key": "IT_COGR", + "label": "Ã’", + } + "S(A(IT_U))": { + "key": "IT_CUGR", + "label": "Ù", + } + "S(A(IT_P))": { + "key": "IT_NARP", + "label": "âˆ", + } + "S(A(IT_EGRV))": { + "key": "IT_LCBR", + "label": "{", + } + "S(A(IT_PLUS))": { + "key": "IT_RCBR", + "label": "}", + } + "S(A(IT_S))": { + "key": "IT_MACR", + "label": "¯", + } + "S(A(IT_D))": { + "key": "IT_BREV", + "label": "˘", + } + "S(A(IT_F))": { + "key": "IT_DOTA", + "label": "Ë™", + } + "S(A(IT_G))": { + "key": "IT_RNGA", + "label": "Ëš", + } + "S(A(IT_H))": { + "key": "IT_CEDL", + "label": "¸", + } + "S(A(IT_J))": { + "key": "IT_DACU", + "label": "Ë", + } + "S(A(IT_K))": { + "key": "IT_OGON", + "label": "Ë›", + } + "S(A(IT_L))": { + "key": "IT_CARN", + "label": "ˇ", + } + "S(A(IT_OGRV))": { + "key": "IT_CCCE", + "label": "Ç", + } + "S(A(IT_UGRV))": { + "key": "IT_LOZN", + "label": "â—Š", + } + "S(A(IT_LABK))": { + "key": "IT_GTEQ", + "label": "≥", + } + "S(A(IT_X))": { + "key": "IT_DDAG", + "label": "‡", + } + "S(A(IT_C))": { + "key": "IT_CAAC", + "label": "Ã", + } + "S(A(IT_V))": { + "key": "IT_CEAC", + "label": "É", + } + "S(A(IT_B))": { + "key": "IT_CIAC", + "label": "Ã", + } + "S(A(IT_N))": { + "key": "IT_COAC", + "label": "Ó", + } + "S(A(IT_M))": { + "key": "IT_CUAC", + "label": "Ú", + } + "S(A(IT_DOT))": { + "key": "IT_MDDT", + "label": "·", + } + "S(A(IT_MINS))": { + "key": "IT_MDSH", + "label": "—", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_japanese_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_japanese_0.0.1.hjson new file mode 100644 index 0000000000..d95712abd9 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_japanese_0.0.1.hjson @@ -0,0 +1,330 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┠+ * │Z↔H│ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ ^ │ Â¥ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ @ │ [ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ EisÅ« │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ : │ ] │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┤ + * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ \ │ │ + * ├─────┬──┴┬──┴──┬┴───┴┬──┴───┴──┬┴───┴┬──┴┬──┴┬──┴┬──┴┬─────┤ + * │ │ │ │Muhen│ │ Hen │K↔H│ │ │ │ │ + * └─────┴───┴─────┴─────┴─────────┴─────┴───┴───┴───┴───┴─────┘ + */ + "KC_GRV": { + "key": "JP_ZKHK", + "label": "Zenkaku ↔ Hankaku ↔ Kanji (åŠè§’ ↔ 全角 ↔ æ¼¢å—)", + } + "KC_1": { + "key": "JP_1", + "label": "1", + } + "KC_2": { + "key": "JP_2", + "label": "2", + } + "KC_3": { + "key": "JP_3", + "label": "3", + } + "KC_4": { + "key": "JP_4", + "label": "4", + } + "KC_5": { + "key": "JP_5", + "label": "5", + } + "KC_6": { + "key": "JP_6", + "label": "6", + } + "KC_7": { + "key": "JP_7", + "label": "7", + } + "KC_8": { + "key": "JP_8", + "label": "8", + } + "KC_9": { + "key": "JP_9", + "label": "9", + } + "KC_0": { + "key": "JP_0", + "label": "0", + } + "KC_MINS": { + "key": "JP_MINS", + "label": "-", + } + "KC_EQL": { + "key": "JP_CIRC", + "label": "^", + } + "KC_INT3": { + "key": "JP_YEN", + "label": "Â¥", + } + "KC_Q": { + "key": "JP_Q", + "label": "Q", + } + "KC_W": { + "key": "JP_W", + "label": "W", + } + "KC_E": { + "key": "JP_E", + "label": "E", + } + "KC_R": { + "key": "JP_R", + "label": "R", + } + "KC_T": { + "key": "JP_T", + "label": "T", + } + "KC_Y": { + "key": "JP_Y", + "label": "Y", + } + "KC_U": { + "key": "JP_U", + "label": "U", + } + "KC_I": { + "key": "JP_I", + "label": "I", + } + "KC_O": { + "key": "JP_O", + "label": "O", + } + "KC_P": { + "key": "JP_P", + "label": "P", + } + "KC_LBRC": { + "key": "JP_AT", + "label": "@", + } + "KC_RBRC": { + "key": "JP_LBRC", + "label": "[", + } + "KC_CAPS": { + "key": "JP_EISU", + "label": "EisÅ« (英数)", + } + "KC_A": { + "key": "JP_A", + "label": "A", + } + "KC_S": { + "key": "JP_S", + "label": "S", + } + "KC_D": { + "key": "JP_D", + "label": "D", + } + "KC_F": { + "key": "JP_F", + "label": "F", + } + "KC_G": { + "key": "JP_G", + "label": "G", + } + "KC_H": { + "key": "JP_H", + "label": "H", + } + "KC_J": { + "key": "JP_J", + "label": "J", + } + "KC_K": { + "key": "JP_K", + "label": "K", + } + "KC_L": { + "key": "JP_L", + "label": "L", + } + "KC_SCLN": { + "key": "JP_SCLN", + "label": ";", + } + "KC_QUOT": { + "key": "JP_COLN", + "label": ":", + } + "KC_NUHS": { + "key": "JP_RBRC", + "label": "]", + } + "KC_Z": { + "key": "JP_Z", + "label": "Z", + } + "KC_X": { + "key": "JP_X", + "label": "X", + } + "KC_C": { + "key": "JP_C", + "label": "C", + } + "KC_V": { + "key": "JP_V", + "label": "V", + } + "KC_B": { + "key": "JP_B", + "label": "B", + } + "KC_N": { + "key": "JP_N", + "label": "N", + } + "KC_M": { + "key": "JP_M", + "label": "M", + } + "KC_COMM": { + "key": "JP_COMM", + "label": ",", + } + "KC_DOT": { + "key": "JP_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "JP_SLSH", + "label": "/", + } + "KC_INT1": { + "key": "JP_BSLS", + "label": "\\", + } + "KC_INT5": { + "key": "JP_MHEN", + "label": "Muhenkan (無変æ›)", + } + "KC_INT4": { + "key": "JP_HENK", + "label": "Henkan (変æ›)", + } + "KC_INT2": { + "key": "JP_KANA", + "label": "Katakana ↔ Hiragana ↔ RÅmaji (カタカナ ↔ ã²ã‚‰ãŒãª ↔ ãƒãƒ¼ãƒžå—)", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┠+ * │ │ ! │ " │ # │ $ │ % │ & │ ' │ ( │ ) │ │ = │ ~ │ | │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ ` │ { │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ Caps │ │ │ │ │ │ │ │ │ │ + │ * │ } │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ _ │ │ + * ├─────┬──┴┬──┴──┬┴───┴┬──┴───┴──┬┴───┴┬──┴┬──┴┬──┴┬──┴┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ + * └─────┴───┴─────┴─────┴─────────┴─────┴───┴───┴───┴───┴─────┘ + */ + "S(JP_1)": { + "key": "JP_EXLM", + "label": "!", + } + "S(JP_2)": { + "key": "JP_DQUO", + "label": "\"", + } + "S(JP_3)": { + "key": "JP_HASH", + "label": "#", + } + "S(JP_4)": { + "key": "JP_DLR", + "label": "$", + } + "S(JP_5)": { + "key": "JP_PERC", + "label": "%", + } + "S(JP_6)": { + "key": "JP_AMPR", + "label": "&", + } + "S(JP_7)": { + "key": "JP_QUOT", + "label": "'", + } + "S(JP_8)": { + "key": "JP_LPRN", + "label": "(", + } + "S(JP_9)": { + "key": "JP_RPRN", + "label": ")", + } + "S(JP_MINS)": { + "key": "JP_EQL", + "label": "=", + } + "S(JP_CIRC)": { + "key": "JP_TILD", + "label": "~", + } + "S(JP_YEN)": { + "key": "JP_PIPE", + "label": "|", + } + "S(JP_AT)": { + "key": "JP_GRV", + "label": "`", + } + "S(JP_LBRC)": { + "key": "JP_LCBR", + "label": "{", + } + "S(JP_EISU)": { + "key": "JP_CAPS", + "label": "Caps Lock", + } + "S(JP_SCLN)": { + "key": "JP_PLUS", + "label": "+", + } + "S(JP_COLN)": { + "key": "JP_ASTR", + "label": "*", + } + "S(JP_RBRC)": { + "key": "JP_RCBR", + "label": "}", + } + "S(JP_COMM)": { + "key": "JP_LABK", + "label": "<", + } + "S(JP_DOT)": { + "key": "JP_RABK", + "label": ">", + } + "S(JP_SLSH)": { + "key": "JP_QUES", + "label": "?", + } + "S(JP_BSLS)": { + "key": "JP_UNDS", + "label": "_", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_korean_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_korean_0.0.1.hjson new file mode 100644 index 0000000000..5ee19c9e4e --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_korean_0.0.1.hjson @@ -0,0 +1,310 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ â‚© │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ + * ├─────┬──┴┬──┴──┬┴──┬┴───┴───┴───┴──┬┴──┬┴───┴┬──┴┬───┬─────┤ + * │ │ │ │Hnj│ │H↔Y│ │ │ │ │ + * └─────┴───┴─────┴───┴───────────────┴───┴─────┴───┴───┴─────┘ + */ + "KC_GRV": { + "key": "KR_GRV", + "label": "`", + } + "KC_1": { + "key": "KR_1", + "label": "1", + } + "KC_2": { + "key": "KR_2", + "label": "2", + } + "KC_3": { + "key": "KR_3", + "label": "3", + } + "KC_4": { + "key": "KR_4", + "label": "4", + } + "KC_5": { + "key": "KR_5", + "label": "5", + } + "KC_6": { + "key": "KR_6", + "label": "6", + } + "KC_7": { + "key": "KR_7", + "label": "7", + } + "KC_8": { + "key": "KR_8", + "label": "8", + } + "KC_9": { + "key": "KR_9", + "label": "9", + } + "KC_0": { + "key": "KR_0", + "label": "0", + } + "KC_MINS": { + "key": "KR_MINS", + "label": "-", + } + "KC_EQL": { + "key": "KR_EQL", + "label": "=", + } + "KC_Q": { + "key": "KR_Q", + "label": "Q", + } + "KC_W": { + "key": "KR_W", + "label": "W", + } + "KC_E": { + "key": "KR_E", + "label": "E", + } + "KC_R": { + "key": "KR_R", + "label": "R", + } + "KC_T": { + "key": "KR_T", + "label": "T", + } + "KC_Y": { + "key": "KR_Y", + "label": "Y", + } + "KC_U": { + "key": "KR_U", + "label": "U", + } + "KC_I": { + "key": "KR_I", + "label": "I", + } + "KC_O": { + "key": "KR_O", + "label": "O", + } + "KC_P": { + "key": "KR_P", + "label": "P", + } + "KC_LBRC": { + "key": "KR_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "KR_RBRC", + "label": "]", + } + "KC_BSLS": { + "key": "KR_WON", + "label": "â‚©", + } + "KC_A": { + "key": "KR_A", + "label": "A", + } + "KC_S": { + "key": "KR_S", + "label": "S", + } + "KC_D": { + "key": "KR_D", + "label": "D", + } + "KC_F": { + "key": "KR_F", + "label": "F", + } + "KC_G": { + "key": "KR_G", + "label": "G", + } + "KC_H": { + "key": "KR_H", + "label": "H", + } + "KC_J": { + "key": "KR_J", + "label": "J", + } + "KC_K": { + "key": "KR_K", + "label": "K", + } + "KC_L": { + "key": "KR_L", + "label": "L", + } + "KC_SCLN": { + "key": "KR_SCLN", + "label": ";", + } + "KC_QUOT": { + "key": "KR_QUOT", + "label": "'", + } + "KC_Z": { + "key": "KR_Z", + "label": "Z", + } + "KC_X": { + "key": "KR_X", + "label": "X", + } + "KC_C": { + "key": "KR_C", + "label": "C", + } + "KC_V": { + "key": "KR_V", + "label": "V", + } + "KC_B": { + "key": "KR_B", + "label": "B", + } + "KC_N": { + "key": "KR_N", + "label": "N", + } + "KC_M": { + "key": "KR_M", + "label": "M", + } + "KC_COMM": { + "key": "KR_COMM", + "label": ",", + } + "KC_DOT": { + "key": "KR_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "KR_SLSH", + "label": "/", + } + "KC_LNG2": { + "key": "KR_HANJ", + "label": "Hanja (í•œìž)", + } + "KC_LNG1": { + "key": "KR_HAEN", + "label": "Han ↔ Yeong (í•œ ↔ ì˜)", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├─────┬──┴┬──┴──┬┴──┬┴───┴───┴───┴──┬┴──┬┴───┴┬──┴┬───┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ + * └─────┴───┴─────┴───┴───────────────┴───┴─────┴───┴───┴─────┘ + */ + "S(KR_GRV)": { + "key": "KR_TILD", + "label": "~", + } + "S(KR_1)": { + "key": "KR_EXLM", + "label": "!", + } + "S(KR_2)": { + "key": "KR_AT", + "label": "@", + } + "S(KR_3)": { + "key": "KR_HASH", + "label": "#", + } + "S(KR_4)": { + "key": "KR_DLR", + "label": "$", + } + "S(KR_5)": { + "key": "KR_PERC", + "label": "%", + } + "S(KR_6)": { + "key": "KR_CIRC", + "label": "^", + } + "S(KR_7)": { + "key": "KR_AMPR", + "label": "&", + } + "S(KR_8)": { + "key": "KR_ASTR", + "label": "*", + } + "S(KR_9)": { + "key": "KR_LPRN", + "label": "(", + } + "S(KR_0)": { + "key": "KR_RPRN", + "label": ")", + } + "S(KR_MINS)": { + "key": "KR_UNDS", + "label": "_", + } + "S(KR_EQL)": { + "key": "KR_PLUS", + "label": "+", + } + "S(KR_LBRC)": { + "key": "KR_LCBR", + "label": "{", + } + "S(KR_RBRC)": { + "key": "KR_RCBR", + "label": "}", + } + "S(KR_WON)": { + "key": "KR_PIPE", + "label": "|", + } + "S(KR_SCLN)": { + "key": "KR_COLN", + "label": ":", + } + "S(KR_QUOT)": { + "key": "KR_DQUO", + "label": "\"", + } + "S(KR_COMM)": { + "key": "KR_LABK", + "label": "<", + } + "S(KR_DOT)": { + "key": "KR_RABK", + "label": ">", + } + "S(KR_SLSH)": { + "key": "KR_QUES", + "label": "?", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_latvian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_latvian_0.0.1.hjson new file mode 100644 index 0000000000..ab80f0fdd9 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_latvian_0.0.1.hjson @@ -0,0 +1,440 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ \ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ \ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "LV_GRV", + "label": "`", + } + "KC_1": { + "key": "LV_1", + "label": "1", + } + "KC_2": { + "key": "LV_2", + "label": "2", + } + "KC_3": { + "key": "LV_3", + "label": "3", + } + "KC_4": { + "key": "LV_4", + "label": "4", + } + "KC_5": { + "key": "LV_5", + "label": "5", + } + "KC_6": { + "key": "LV_6", + "label": "6", + } + "KC_7": { + "key": "LV_7", + "label": "7", + } + "KC_8": { + "key": "LV_8", + "label": "8", + } + "KC_9": { + "key": "LV_9", + "label": "9", + } + "KC_0": { + "key": "LV_0", + "label": "0", + } + "KC_MINS": { + "key": "LV_MINS", + "label": "-", + } + "KC_EQL": { + "key": "LV_EQL", + "label": "=", + } + "KC_Q": { + "key": "LV_Q", + "label": "Q", + } + "KC_W": { + "key": "LV_W", + "label": "W", + } + "KC_E": { + "key": "LV_E", + "label": "E", + } + "KC_R": { + "key": "LV_R", + "label": "R", + } + "KC_T": { + "key": "LV_T", + "label": "T", + } + "KC_Y": { + "key": "LV_Y", + "label": "Y", + } + "KC_U": { + "key": "LV_U", + "label": "U", + } + "KC_I": { + "key": "LV_I", + "label": "I", + } + "KC_O": { + "key": "LV_O", + "label": "O", + } + "KC_P": { + "key": "LV_P", + "label": "P", + } + "KC_LBRC": { + "key": "LV_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "LV_RBRC", + "label": "]", + } + "KC_A": { + "key": "LV_A", + "label": "A", + } + "KC_S": { + "key": "LV_S", + "label": "S", + } + "KC_D": { + "key": "LV_D", + "label": "D", + } + "KC_F": { + "key": "LV_F", + "label": "F", + } + "KC_G": { + "key": "LV_G", + "label": "G", + } + "KC_H": { + "key": "LV_H", + "label": "H", + } + "KC_J": { + "key": "LV_J", + "label": "J", + } + "KC_K": { + "key": "LV_K", + "label": "K", + } + "KC_L": { + "key": "LV_L", + "label": "L", + } + "KC_SCLN": { + "key": "LV_SCLN", + "label": ";", + } + "KC_QUOT": { + "key": "LV_QUOT", + "label": "' (dead)", + } + "KC_NUHS": { + "key": "LV_BSLS", + "label": "\\", + } + "KC_NUBS": { + "key": "LV_NUBS", + "label": "\\", + } + "KC_Z": { + "key": "LV_Z", + "label": "Z", + } + "KC_X": { + "key": "LV_X", + "label": "X", + } + "KC_C": { + "key": "LV_C", + "label": "C", + } + "KC_V": { + "key": "LV_V", + "label": "V", + } + "KC_B": { + "key": "LV_B", + "label": "B", + } + "KC_N": { + "key": "LV_N", + "label": "N", + } + "KC_M": { + "key": "LV_M", + "label": "M", + } + "KC_COMM": { + "key": "LV_COMM", + "label": ",", + } + "KC_DOT": { + "key": "LV_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "LV_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ : │ " │ | │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(LV_GRV)": { + "key": "LV_TILD", + "label": "~", + } + "S(LV_1)": { + "key": "LV_EXLM", + "label": "!", + } + "S(LV_2)": { + "key": "LV_AT", + "label": "@", + } + "S(LV_3)": { + "key": "LV_HASH", + "label": "#", + } + "S(LV_4)": { + "key": "LV_DLR", + "label": "$", + } + "S(LV_5)": { + "key": "LV_PERC", + "label": "%", + } + "S(LV_6)": { + "key": "LV_CIRC", + "label": "^", + } + "S(LV_7)": { + "key": "LV_AMPR", + "label": "&", + } + "S(LV_8)": { + "key": "LV_ASTR", + "label": "*", + } + "S(LV_9)": { + "key": "LV_LPRN", + "label": "(", + } + "S(LV_0)": { + "key": "LV_RPRN", + "label": ")", + } + "S(LV_MINS)": { + "key": "LV_UNDS", + "label": "_", + } + "S(LV_EQL)": { + "key": "LV_PLUS", + "label": "+", + } + "S(LV_LBRC)": { + "key": "LV_LCBR", + "label": "{", + } + "S(LV_RBRC)": { + "key": "LV_RCBR", + "label": "}", + } + "S(LV_SCLN)": { + "key": "LV_COLN", + "label": ":", + } + "S(LV_QUOT)": { + "key": "LV_DQUO", + "label": "\" (dead)", + } + "S(LV_BSLS)": { + "key": "LV_PIPE", + "label": "|", + } + "S(LV_COMM)": { + "key": "LV_LABK", + "label": "<", + } + "S(LV_DOT)": { + "key": "LV_RABK", + "label": ">", + } + "S(LV_SLSH)": { + "key": "LV_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ - │ │ « │ » │ € │ │ ’ │ │ │ │ │ – │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ Ē │ Ŗ │ │ │ Ū │ Ī │ Ō │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Ā │ Š│ │ │ Ģ │ │ │ Ķ │ Ļ │ │ ´ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ Ž │ │ Č │ │ │ Ņ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(LV_GRV)": { + "key": "LV_SHYP", + "label": " (soft hyphen)", + } + "ALGR(LV_1)": { + "key": "LV_NBSP", + "label": "(non-breaking space)", + } + "ALGR(LV_2)": { + "key": "LV_LDAQ", + "label": "«", + } + "ALGR(LV_3)": { + "key": "LV_RDAQ", + "label": "»", + } + "ALGR(LV_4)": { + "key": "LV_EURO", + "label": "€", + } + "ALGR(LV_6)": { + "key": "LV_RSQU", + "label": "’", + } + "ALGR(LV_MINS)": { + "key": "LV_NDSH", + "label": "–", + } + "ALGR(LV_E)": { + "key": "LV_EMAC", + "label": "Ē", + } + "ALGR(LV_R)": { + "key": "LV_RCED", + "label": "Ŗ", + } + "ALGR(LV_U)": { + "key": "LV_UMAC", + "label": "Ū", + } + "ALGR(LV_I)": { + "key": "LV_IMAC", + "label": "Ī", + } + "ALGR(LV_O)": { + "key": "LV_OMAC", + "label": "Ō", + } + "ALGR(LV_A)": { + "key": "LV_AMAC", + "label": "Ā", + } + "ALGR(LV_S)": { + "key": "LV_SCAR", + "label": "Š", + } + "ALGR(LV_G)": { + "key": "LV_GCED", + "label": "Ģ", + } + "ALGR(LV_K)": { + "key": "LV_KCED", + "label": "Ķ", + } + "ALGR(LV_L)": { + "key": "LV_LCED", + "label": "Ļ", + } + "ALGR(LV_QUOT)": { + "key": "LV_ACUT", + "label": "´ (dead)", + } + "ALGR(LV_Z)": { + "key": "LV_ZCAR", + "label": "Ž", + } + "ALGR(LV_C)": { + "key": "LV_CCAR", + "label": "Č", + } + "ALGR(LV_N)": { + "key": "LV_NCED", + "label": "Ņ", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ │ │ § │ ° │ │ ± │ × │ │ │ — │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(LV_4))": { + "key": "LV_SECT", + "label": "§", + } + "S(ALGR(LV_5))": { + "key": "LV_DEG", + "label": "°", + } + "S(ALGR(LV_7))": { + "key": "LV_PLMN", + "label": "±", + } + "S(ALGR(LV_8))": { + "key": "LV_MUL", + "label": "×", + } + "S(ALGR(LV_MINS))": { + "key": "LV_MDSH", + "label": "—", + } + "S(ALGR(LV_QUOT))": { + "key": "LV_DIAE", + "label": "¨ (dead)", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_lithuanian_azerty_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_lithuanian_azerty_0.0.1.hjson new file mode 100644 index 0000000000..dfb527878e --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_lithuanian_azerty_0.0.1.hjson @@ -0,0 +1,375 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ ! │ - │ / │ ; │ : │ , │ . │ = │ ( │ ) │ ? │ X │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Ą │ Ž │ E │ R │ T │ Y │ U │ I │ O │ P │ Į │ W │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ Š│ G │ H │ J │ K │ L │ Ų │ Ė │ Q │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ Ū │ C │ V │ B │ N │ M │ Č │ F │ Ę │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "LT_GRV", + "label": "`", + } + "KC_1": { + "key": "LT_EXLM", + "label": "!", + } + "KC_2": { + "key": "LT_MINS", + "label": "-", + } + "KC_3": { + "key": "LT_SLSH", + "label": "/", + } + "KC_4": { + "key": "LT_SCLN", + "label": ";", + } + "KC_5": { + "key": "LT_COLN", + "label": ":", + } + "KC_6": { + "key": "LT_COMM", + "label": ",", + } + "KC_7": { + "key": "LT_DOT", + "label": ".", + } + "KC_8": { + "key": "LT_EQL", + "label": "=", + } + "KC_9": { + "key": "LT_LPRN", + "label": "(", + } + "KC_0": { + "key": "LT_RPRN", + "label": ")", + } + "KC_MINS": { + "key": "LT_QUES", + "label": "?", + } + "KC_EQL": { + "key": "LT_X", + "label": "X", + } + "KC_Q": { + "key": "LT_AOGO", + "label": "Ą", + } + "KC_W": { + "key": "LT_ZCAR", + "label": "Ž", + } + "KC_E": { + "key": "LT_E", + "label": "E", + } + "KC_R": { + "key": "LT_R", + "label": "R", + } + "KC_T": { + "key": "LT_T", + "label": "T", + } + "KC_Y": { + "key": "LT_Y", + "label": "Y", + } + "KC_U": { + "key": "LT_U", + "label": "U", + } + "KC_I": { + "key": "LT_I", + "label": "I", + } + "KC_O": { + "key": "LT_O", + "label": "O", + } + "KC_P": { + "key": "LT_P", + "label": "P", + } + "KC_LBRC": { + "key": "LT_IOGO", + "label": "Į", + } + "KC_RBRC": { + "key": "LT_W", + "label": "W", + } + "KC_A": { + "key": "LT_A", + "label": "A", + } + "KC_S": { + "key": "LT_S", + "label": "S", + } + "KC_D": { + "key": "LT_D", + "label": "D", + } + "KC_F": { + "key": "LT_SCAR", + "label": "Š", + } + "KC_G": { + "key": "LT_G", + "label": "G", + } + "KC_H": { + "key": "LT_H", + "label": "H", + } + "KC_J": { + "key": "LT_J", + "label": "J", + } + "KC_K": { + "key": "LT_K", + "label": "K", + } + "KC_L": { + "key": "LT_L", + "label": "L", + } + "KC_SCLN": { + "key": "LT_UOGO", + "label": "Ų", + } + "KC_QUOT": { + "key": "LT_EDOT", + "label": "Ė", + } + "KC_NUHS": { + "key": "LT_Q", + "label": "Q", + } + "KC_NUBS": { + "key": "LT_LABK", + "label": "<", + } + "KC_Z": { + "key": "LT_Z", + "label": "Z", + } + "KC_X": { + "key": "LT_UMAC", + "label": "Ū", + } + "KC_C": { + "key": "LT_C", + "label": "C", + } + "KC_V": { + "key": "LT_V", + "label": "V", + } + "KC_B": { + "key": "LT_B", + "label": "B", + } + "KC_N": { + "key": "LT_N", + "label": "N", + } + "KC_M": { + "key": "LT_M", + "label": "M", + } + "KC_COMM": { + "key": "LT_CCAR", + "label": "Č", + } + "KC_DOT": { + "key": "LT_F", + "label": "F", + } + "KC_SLSH": { + "key": "LT_EOGO", + "label": "Ę", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(LT_GRV)": { + "key": "LT_TILD", + "label": "~", + } + "S(LT_EXLM)": { + "key": "LT_1", + "label": "1", + } + "S(LT_MINS)": { + "key": "LT_2", + "label": "2", + } + "S(LT_SLSH)": { + "key": "LT_3", + "label": "3", + } + "S(LT_SCLN)": { + "key": "LT_4", + "label": "4", + } + "S(LT_COLN)": { + "key": "LT_5", + "label": "5", + } + "S(LT_COMM)": { + "key": "LT_6", + "label": "6", + } + "S(LT_DOT)": { + "key": "LT_7", + "label": "7", + } + "S(LT_EQL)": { + "key": "LT_8", + "label": "8", + } + "S(LT_LPRN)": { + "key": "LT_9", + "label": "9", + } + "S(LT_RPRN)": { + "key": "LT_0", + "label": "0", + } + "S(LT_QUES)": { + "key": "LT_PLUS", + "label": "+", + } + "S(LT_LABK)": { + "key": "LT_RABK", + "label": ">", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ´ │ @ │ _ │ # │ $ │ § │ ^ │ & │ * │ [ │ ] │ ' │ % │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ { │ } │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ " │ | │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ – │ │ │ │ │ │ │ │ „ │ “ │ \ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(LT_GRV)": { + "key": "LT_ACUT", + "label": "´", + } + "ALGR(LT_EXLM)": { + "key": "LT_AT", + "label": "@", + } + "ALGR(LT_MINS)": { + "key": "LT_UNDS", + "label": "_", + } + "ALGR(LT_SLSH)": { + "key": "LT_HASH", + "label": "#", + } + "ALGR(LT_SCLN)": { + "key": "LT_DLR", + "label": "$", + } + "ALGR(LT_COLN)": { + "key": "LT_SECT", + "label": "§", + } + "ALGR(LT_COMM)": { + "key": "LT_CIRC", + "label": "^", + } + "ALGR(LT_DOT)": { + "key": "LT_AMPR", + "label": "&", + } + "ALGR(LT_EQL)": { + "key": "LT_ASTR", + "label": "*", + } + "ALGR(LT_LPRN)": { + "key": "LT_LBRC", + "label": "[", + } + "ALGR(LT_RPRN)": { + "key": "LT_RBRC", + "label": "]", + } + "ALGR(LT_QUES)": { + "key": "LT_QUOT", + "label": "'", + } + "ALGR(LT_X)": { + "key": "LT_PERC", + "label": "%", + } + "ALGR(LT_E)": { + "key": "LT_EURO", + "label": "€", + } + "ALGR(LT_IOGO)": { + "key": "LT_LCBR", + "label": "{", + } + "ALGR(LT_W)": { + "key": "LT_RCBR", + "label": "}", + } + "ALGR(LT_EDOT)": { + "key": "LT_DQUO", + "label": "\"", + } + "ALGR(LT_Q)": { + "key": "LT_PIPE", + "label": "|", + } + "ALGR(LT_LABK)": { + "key": "LT_NDSH", + "label": "–", + } + "ALGR(LT_CCAR)": { + "key": "LT_DLQU", + "label": "„", + } + "ALGR(LT_F)": { + "key": "LT_LDQU", + "label": "“", + } + "ALGR(LT_EOGO)": { + "key": "LT_BSLS", + "label": "\\", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_lithuanian_qwerty_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_lithuanian_qwerty_0.0.1.hjson new file mode 100644 index 0000000000..a4ea30d592 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_lithuanian_qwerty_0.0.1.hjson @@ -0,0 +1,368 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ Ą │ Č │ Ę │ Ė │ Į │ Š│ Ų │ Ū │ 9 │ 0 │ - │ Ž │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "LT_GRV", + "label": "`", + } + "KC_1": { + "key": "LT_AOGO", + "label": "Ą", + } + "KC_2": { + "key": "LT_CCAR", + "label": "Č", + } + "KC_3": { + "key": "LT_EOGO", + "label": "Ę", + } + "KC_4": { + "key": "LT_EDOT", + "label": "Ė", + } + "KC_5": { + "key": "LT_IOGO", + "label": "Į", + } + "KC_6": { + "key": "LT_SCAR", + "label": "Š", + } + "KC_7": { + "key": "LT_UOGO", + "label": "Ų", + } + "KC_8": { + "key": "LT_UMAC", + "label": "Ū", + } + "KC_9": { + "key": "LT_9", + "label": "9", + } + "KC_0": { + "key": "LT_0", + "label": "0", + } + "KC_MINS": { + "key": "LT_MINS", + "label": "-", + } + "KC_EQL": { + "key": "LT_ZCAR", + "label": "Ž", + } + "KC_Q": { + "key": "LT_Q", + "label": "Q", + } + "KC_W": { + "key": "LT_W", + "label": "W", + } + "KC_E": { + "key": "LT_E", + "label": "E", + } + "KC_R": { + "key": "LT_R", + "label": "R", + } + "KC_T": { + "key": "LT_T", + "label": "T", + } + "KC_Y": { + "key": "LT_Y", + "label": "Y", + } + "KC_U": { + "key": "LT_U", + "label": "U", + } + "KC_I": { + "key": "LT_I", + "label": "I", + } + "KC_O": { + "key": "LT_O", + "label": "O", + } + "KC_P": { + "key": "LT_P", + "label": "P", + } + "KC_LBRC": { + "key": "LT_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "LT_RBRC", + "label": "]", + } + "KC_A": { + "key": "LT_A", + "label": "A", + } + "KC_S": { + "key": "LT_S", + "label": "S", + } + "KC_D": { + "key": "LT_D", + "label": "D", + } + "KC_F": { + "key": "LT_F", + "label": "F", + } + "KC_G": { + "key": "LT_G", + "label": "G", + } + "KC_H": { + "key": "LT_H", + "label": "H", + } + "KC_J": { + "key": "LT_J", + "label": "J", + } + "KC_K": { + "key": "LT_K", + "label": "K", + } + "KC_L": { + "key": "LT_L", + "label": "L", + } + "KC_SCLN": { + "key": "LT_SCLN", + "label": ";", + } + "KC_QUOT": { + "key": "LT_QUOT", + "label": "'", + } + "KC_BSLS": { + "key": "LT_BSLS", + "label": "\\", + } + "KC_Z": { + "key": "LT_Z", + "label": "Z", + } + "KC_X": { + "key": "LT_X", + "label": "X", + } + "KC_C": { + "key": "LT_C", + "label": "C", + } + "KC_V": { + "key": "LT_V", + "label": "V", + } + "KC_B": { + "key": "LT_B", + "label": "B", + } + "KC_N": { + "key": "LT_N", + "label": "N", + } + "KC_M": { + "key": "LT_M", + "label": "M", + } + "KC_COMM": { + "key": "LT_COMM", + "label": ",", + } + "KC_DOT": { + "key": "LT_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "LT_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ │ │ │ │ │ │ │ │ ( │ ) │ _ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(LT_GRV)": { + "key": "LT_TILD", + "label": "~", + } + "S(LT_9)": { + "key": "LT_LPRN", + "label": "(", + } + "S(LT_0)": { + "key": "LT_RPRN", + "label": ")", + } + "S(LT_MINS)": { + "key": "LT_UNDS", + "label": "_", + } + "S(LT_LBRC)": { + "key": "LT_LCBR", + "label": "{", + } + "S(LT_RBRC)": { + "key": "LT_RCBR", + "label": "}", + } + "S(LT_SCLN)": { + "key": "LT_COLN", + "label": ":", + } + "S(LT_QUOT)": { + "key": "LT_DQUO", + "label": "\"", + } + "S(LT_BSLS)": { + "key": "LT_PIPE", + "label": "|", + } + "S(LT_COMM)": { + "key": "LT_LABK", + "label": "<", + } + "S(LT_DOT)": { + "key": "LT_RABK", + "label": ">", + } + "S(LT_SLSH)": { + "key": "LT_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ │ │ │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(LT_AOGO)": { + "key": "LT_1", + "label": "1", + } + "ALGR(LT_CCAR)": { + "key": "LT_2", + "label": "2", + } + "ALGR(LT_EOGO)": { + "key": "LT_3", + "label": "3", + } + "ALGR(LT_EDOT)": { + "key": "LT_4", + "label": "4", + } + "ALGR(LT_IOGO)": { + "key": "LT_5", + "label": "5", + } + "ALGR(LT_SCAR)": { + "key": "LT_6", + "label": "6", + } + "ALGR(LT_UOGO)": { + "key": "LT_7", + "label": "7", + } + "ALGR(LT_UMAC)": { + "key": "LT_8", + "label": "8", + } + "ALGR(LT_ZCAR)": { + "key": "LT_EQL", + "label": "=", + } + "ALGR(LT_E)": { + "key": "LT_EURO", + "label": "€", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ │ │ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(LT_AOGO))": { + "key": "LT_EXLM", + "label": "!", + } + "S(ALGR(LT_CCAR))": { + "key": "LT_AT", + "label": "@", + } + "S(ALGR(LT_EOGO))": { + "key": "LT_HASH", + "label": "#", + } + "S(ALGR(LT_EDOT))": { + "key": "LT_DLR", + "label": "$", + } + "S(ALGR(LT_IOGO))": { + "key": "LT_PERC", + "label": "%", + } + "S(ALGR(LT_SCAR))": { + "key": "LT_CIRC", + "label": "^", + } + "S(ALGR(LT_UOGO))": { + "key": "LT_AMPR", + "label": "&", + } + "S(ALGR(LT_UMAC))": { + "key": "LT_ASTR", + "label": "*", + } + "S(ALGR(LT_ZCAR))": { + "key": "LT_PLUS", + "label": "+", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_neo2_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_neo2_0.0.1.hjson new file mode 100644 index 0000000000..980bddbf7a --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_neo2_0.0.1.hjson @@ -0,0 +1,217 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ^ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ X │ V │ L │ C │ W │ K │ H │ G │ F │ Q │ ß │ ´ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ L3 │ U │ I │ A │ E │ O │ S │ N │ R │ T │ D │ Y │ L3│ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │L4 │ Ü │ Ö │ Ä │ P │ Z │ B │ M │ , │ . │ J │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ L4 │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "NE_CIRC", + "label": "^ (dead)", + } + "KC_1": { + "key": "NE_1", + "label": "1", + } + "KC_2": { + "key": "NE_2", + "label": "2", + } + "KC_3": { + "key": "NE_3", + "label": "3", + } + "KC_4": { + "key": "NE_4", + "label": "4", + } + "KC_5": { + "key": "NE_5", + "label": "5", + } + "KC_6": { + "key": "NE_6", + "label": "6", + } + "KC_7": { + "key": "NE_7", + "label": "7", + } + "KC_8": { + "key": "NE_8", + "label": "8", + } + "KC_9": { + "key": "NE_9", + "label": "9", + } + "KC_0": { + "key": "NE_0", + "label": "0", + } + "KC_MINS": { + "key": "NE_MINS", + "label": "-", + } + "KC_EQL": { + "key": "NE_GRV", + "label": "` (dead)", + } + "KC_Q": { + "key": "NE_X", + "label": "X", + } + "KC_W": { + "key": "NE_V", + "label": "V", + } + "KC_E": { + "key": "NE_L", + "label": "L", + } + "KC_R": { + "key": "NE_C", + "label": "C", + } + "KC_T": { + "key": "NE_W", + "label": "W", + } + "KC_Y": { + "key": "NE_K", + "label": "K", + } + "KC_U": { + "key": "NE_H", + "label": "H", + } + "KC_I": { + "key": "NE_G", + "label": "G", + } + "KC_O": { + "key": "NE_F", + "label": "F", + } + "KC_P": { + "key": "NE_Q", + "label": "Q", + } + "KC_LBRC": { + "key": "NE_SS", + "label": "ß", + } + "KC_RBRC": { + "key": "NE_ACUT", + "label": "´ (dead)", + } + "KC_CAPS": { + "key": "NE_L3L", + "label": "(layer 3)", + } + "KC_A": { + "key": "NE_U", + "label": "U", + } + "KC_S": { + "key": "NE_I", + "label": "I", + } + "KC_D": { + "key": "NE_A", + "label": "A", + } + "KC_F": { + "key": "NE_E", + "label": "E", + } + "KC_G": { + "key": "NE_O", + "label": "O", + } + "KC_H": { + "key": "NE_S", + "label": "S", + } + "KC_J": { + "key": "NE_N", + "label": "N", + } + "KC_K": { + "key": "NE_R", + "label": "R", + } + "KC_L": { + "key": "NE_T", + "label": "T", + } + "KC_SCLN": { + "key": "NE_D", + "label": "D", + } + "KC_QUOT": { + "key": "NE_Y", + "label": "Y", + } + "KC_NUHS": { + "key": "NE_L3R", + "label": "(layer 3)", + } + "KC_NUBS": { + "key": "NE_L4L", + "label": "(layer 4)", + } + "KC_Z": { + "key": "NE_UDIA", + "label": "Ü", + } + "KC_X": { + "key": "NE_ODIA", + "label": "Ö", + } + "KC_C": { + "key": "NE_ADIA", + "label": "Ä", + } + "KC_V": { + "key": "NE_P", + "label": "P", + } + "KC_B": { + "key": "NE_Z", + "label": "Z", + } + "KC_N": { + "key": "NE_B", + "label": "B", + } + "KC_M": { + "key": "NE_M", + "label": "M", + } + "KC_COMM": { + "key": "NE_COMM", + "label": ",", + } + "KC_DOT": { + "key": "NE_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "NE_J", + "label": "J", + } + "KC_ALGR": { + "key": "NE_L4R", + "label": "(layer 4)", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_nordic_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_nordic_0.0.1.hjson new file mode 100644 index 0000000000..fb3d1bc84b --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_nordic_0.0.1.hjson @@ -0,0 +1,116 @@ +{ + "aliases": { + "KC_GRV": { + "key": "NO_HALF" + } + "KC_MINS": { + "key": "NO_PLUS" + } + "KC_EQL": { + "key": "NO_ACUT" + } + "KC_LBRC": { + "key": "NO_AM" + } + "KC_RBRC": { + "key": "NO_QUOT", + "label": "this is the \"umlaut\" char on Nordic keyboards, Apple layout", + } + "KC_SCLN": { + "key": "NO_AE" + } + "KC_QUOT": { + "key": "NO_OSLH" + } + "KC_NUHS": { + "key": "NO_APOS" + } + "KC_NUBS": { + "key": "NO_LESS" + } + "KC_SLSH": { + "key": "NO_MINS" + } + "LSFT(NO_HALF)": { + "key": "NO_SECT" + } + "LSFT(KC_2)": { + "key": "NO_QUO2" + } + "LSFT(KC_4)": { + "key": "NO_BULT" + } + "LSFT(KC_6)": { + "key": "NO_AMPR" + } + "LSFT(KC_7)": { + "key": "NO_SLSH" + } + "LSFT(KC_8)": { + "key": "NO_LPRN" + } + "LSFT(KC_9)": { + "key": "NO_RPRN" + } + "LSFT(KC_0)": { + "key": "NO_EQL" + } + "LSFT(NO_PLUS)": { + "key": "NO_QUES" + } + "LSFT(NO_ACUT)": { + "key": "NO_GRV" + } + "LSFT(NO_QUOT)": { + "key": "NO_CIRC" + } + "LSFT(NO_LESS)": { + "key": "NO_GRTR" + } + "LSFT(KC_COMM)": { + "key": "NO_SCLN" + } + "LSFT(KC_DOT)": { + "key": "NO_COLN" + } + "LSFT(NO_MINS)": { + "key": "NO_UNDS" + } + "ALGR(KC_2)": { + "key": "NO_AT" + } + "ALGR(KC_3)": { + "key": "NO_PND" + } + "ALGR(KC_4)": { + "key": "NO_DLR" + } + "ALGR(KC_7)": { + "key": "NO_LCBR" + } + "ALGR(KC_8)": { + "key": "NO_LBRC" + } + "ALGR(KC_9)": { + "key": "NO_RBRC" + } + "ALGR(KC_0)": { + "key": "NO_RCBR" + } + "ALGR(KC_NUBS)": { + "key": "NO_PIPE" + } + "ALGR(KC_E)": { + "key": "NO_EURO" + } + "ALGR(NO_QUOT)": { + "key": "NO_TILD" + } + "ALGR(KC_MINS)": { + "key": "NO_BSLS" + } + "ALGR(KC_M)": { + "key": "NO_MU" + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_norman_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_norman_0.0.1.hjson new file mode 100644 index 0000000000..98ea7e6aab --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_norman_0.0.1.hjson @@ -0,0 +1,302 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ D │ F │ K │ J │ U │ R │ L │ ; │ [ │ ] │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ S │ E │ T │ G │ Y │ N │ I │ O │ H │ ' │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Z │ X │ C │ V │ B │ P │ M │ , │ . │ / │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "NM_GRV", + "label": "`", + } + "KC_1": { + "key": "NM_1", + "label": "1", + } + "KC_2": { + "key": "NM_2", + "label": "2", + } + "KC_3": { + "key": "NM_3", + "label": "3", + } + "KC_4": { + "key": "NM_4", + "label": "4", + } + "KC_5": { + "key": "NM_5", + "label": "5", + } + "KC_6": { + "key": "NM_6", + "label": "6", + } + "KC_7": { + "key": "NM_7", + "label": "7", + } + "KC_8": { + "key": "NM_8", + "label": "8", + } + "KC_9": { + "key": "NM_9", + "label": "9", + } + "KC_0": { + "key": "NM_0", + "label": "0", + } + "KC_MINS": { + "key": "NM_MINS", + "label": "-", + } + "KC_EQL": { + "key": "NM_EQL", + "label": "=", + } + "KC_Q": { + "key": "NM_Q", + "label": "Q", + } + "KC_W": { + "key": "NM_W", + "label": "W", + } + "KC_E": { + "key": "NM_D", + "label": "D", + } + "KC_R": { + "key": "NM_F", + "label": "F", + } + "KC_T": { + "key": "NM_K", + "label": "K", + } + "KC_Y": { + "key": "NM_J", + "label": "J", + } + "KC_U": { + "key": "NM_U", + "label": "U", + } + "KC_I": { + "key": "NM_R", + "label": "R", + } + "KC_O": { + "key": "NM_L", + "label": "L", + } + "KC_P": { + "key": "NM_SCLN", + "label": ";", + } + "KC_LBRC": { + "key": "NM_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "NM_RBRC", + "label": "]", + } + "KC_BSLS": { + "key": "NM_BSLS", + "label": "\\", + } + "KC_A": { + "key": "NM_A", + "label": "A", + } + "KC_S": { + "key": "NM_S", + "label": "S", + } + "KC_D": { + "key": "NM_E", + "label": "E", + } + "KC_F": { + "key": "NM_T", + "label": "T", + } + "KC_G": { + "key": "NM_G", + "label": "G", + } + "KC_H": { + "key": "NM_Y", + "label": "Y", + } + "KC_J": { + "key": "NM_N", + "label": "N", + } + "KC_K": { + "key": "NM_I", + "label": "I", + } + "KC_L": { + "key": "NM_O", + "label": "O", + } + "KC_SCLN": { + "key": "NM_H", + "label": "H", + } + "KC_QUOT": { + "key": "NM_QUOT", + "label": "'", + } + "KC_Z": { + "key": "NM_Z", + "label": "Z", + } + "KC_X": { + "key": "NM_X", + "label": "X", + } + "KC_C": { + "key": "NM_C", + "label": "C", + } + "KC_V": { + "key": "NM_V", + "label": "V", + } + "KC_B": { + "key": "NM_B", + "label": "B", + } + "KC_N": { + "key": "NM_P", + "label": "P", + } + "KC_M": { + "key": "NM_M", + "label": "M", + } + "KC_COMM": { + "key": "NM_COMM", + "label": ",", + } + "KC_DOT": { + "key": "NM_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "NM_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(NM_GRV)": { + "key": "NM_TILD", + "label": "~", + } + "S(NM_1)": { + "key": "NM_EXLM", + "label": "!", + } + "S(NM_2)": { + "key": "NM_AT", + "label": "@", + } + "S(NM_3)": { + "key": "NM_HASH", + "label": "#", + } + "S(NM_4)": { + "key": "NM_DLR", + "label": "$", + } + "S(NM_5)": { + "key": "NM_PERC", + "label": "%", + } + "S(NM_6)": { + "key": "NM_CIRC", + "label": "^", + } + "S(NM_7)": { + "key": "NM_AMPR", + "label": "&", + } + "S(NM_8)": { + "key": "NM_ASTR", + "label": "*", + } + "S(NM_9)": { + "key": "NM_LPRN", + "label": "(", + } + "S(NM_0)": { + "key": "NM_RPRN", + "label": ")", + } + "S(NM_MINS)": { + "key": "NM_UNDS", + "label": "_", + } + "S(NM_EQL)": { + "key": "NM_PLUS", + "label": "+", + } + "S(NM_SCLN)": { + "key": "NM_COLN", + "label": ":", + } + "S(NM_LBRC)": { + "key": "NM_LCBR", + "label": "{", + } + "S(NM_RBRC)": { + "key": "NM_RCBR", + "label": "}", + } + "S(NM_BSLS)": { + "key": "NM_PIPE", + "label": "|", + } + "S(NM_QUOT)": { + "key": "NM_DQUO", + "label": "\"", + } + "S(NM_COMM)": { + "key": "NM_LABK", + "label": "<", + } + "S(NM_DOT)": { + "key": "NM_RABK", + "label": ">", + } + "S(NM_SLSH)": { + "key": "NM_QUES", + "label": "?", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_norwegian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_norwegian_0.0.1.hjson new file mode 100644 index 0000000000..4e8cbb5d0e --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_norwegian_0.0.1.hjson @@ -0,0 +1,355 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ | │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ \ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Å │ ¨ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ø │ Æ │ ' │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "NO_PIPE", + "label": "|", + } + "KC_1": { + "key": "NO_1", + "label": "1", + } + "KC_2": { + "key": "NO_2", + "label": "2", + } + "KC_3": { + "key": "NO_3", + "label": "3", + } + "KC_4": { + "key": "NO_4", + "label": "4", + } + "KC_5": { + "key": "NO_5", + "label": "5", + } + "KC_6": { + "key": "NO_6", + "label": "6", + } + "KC_7": { + "key": "NO_7", + "label": "7", + } + "KC_8": { + "key": "NO_8", + "label": "8", + } + "KC_9": { + "key": "NO_9", + "label": "9", + } + "KC_0": { + "key": "NO_0", + "label": "0", + } + "KC_MINS": { + "key": "NO_PLUS", + "label": "+", + } + "KC_EQL": { + "key": "NO_BSLS", + "label": "\\", + } + "KC_Q": { + "key": "NO_Q", + "label": "Q", + } + "KC_W": { + "key": "NO_W", + "label": "W", + } + "KC_E": { + "key": "NO_E", + "label": "E", + } + "KC_R": { + "key": "NO_R", + "label": "R", + } + "KC_T": { + "key": "NO_T", + "label": "T", + } + "KC_Y": { + "key": "NO_Y", + "label": "Y", + } + "KC_U": { + "key": "NO_U", + "label": "U", + } + "KC_I": { + "key": "NO_I", + "label": "I", + } + "KC_O": { + "key": "NO_O", + "label": "O", + } + "KC_P": { + "key": "NO_P", + "label": "P", + } + "KC_LBRC": { + "key": "NO_ARNG", + "label": "Å", + } + "KC_RBRC": { + "key": "NO_DIAE", + "label": "¨ (dead)", + } + "KC_A": { + "key": "NO_A", + "label": "A", + } + "KC_S": { + "key": "NO_S", + "label": "S", + } + "KC_D": { + "key": "NO_D", + "label": "D", + } + "KC_F": { + "key": "NO_F", + "label": "F", + } + "KC_G": { + "key": "NO_G", + "label": "G", + } + "KC_H": { + "key": "NO_H", + "label": "H", + } + "KC_J": { + "key": "NO_J", + "label": "J", + } + "KC_K": { + "key": "NO_K", + "label": "K", + } + "KC_L": { + "key": "NO_L", + "label": "L", + } + "KC_SCLN": { + "key": "NO_OSTR", + "label": "Ø", + } + "KC_QUOT": { + "key": "NO_AE", + "label": "Æ", + } + "KC_NUHS": { + "key": "NO_QUOT", + "label": "'", + } + "KC_NUBS": { + "key": "NO_LABK", + "label": "<", + } + "KC_Z": { + "key": "NO_Z", + "label": "Z", + } + "KC_X": { + "key": "NO_X", + "label": "X", + } + "KC_C": { + "key": "NO_C", + "label": "C", + } + "KC_V": { + "key": "NO_V", + "label": "V", + } + "KC_B": { + "key": "NO_B", + "label": "B", + } + "KC_N": { + "key": "NO_N", + "label": "N", + } + "KC_M": { + "key": "NO_M", + "label": "M", + } + "KC_COMM": { + "key": "NO_COMM", + "label": ",", + } + "KC_DOT": { + "key": "NO_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "NO_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ § │ ! │ " │ # │ ¤ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(NO_PIPE)": { + "key": "NO_SECT", + "label": "§", + } + "S(NO_1)": { + "key": "NO_EXLM", + "label": "!", + } + "S(NO_2)": { + "key": "NO_DQUO", + "label": "\"", + } + "S(NO_3)": { + "key": "NO_HASH", + "label": "#", + } + "S(NO_4)": { + "key": "NO_CURR", + "label": "¤", + } + "S(NO_5)": { + "key": "NO_PERC", + "label": "%", + } + "S(NO_6)": { + "key": "NO_AMPR", + "label": "&", + } + "S(NO_7)": { + "key": "NO_SLSH", + "label": "/", + } + "S(NO_8)": { + "key": "NO_LPRN", + "label": "(", + } + "S(NO_9)": { + "key": "NO_RPRN", + "label": ")", + } + "S(NO_0)": { + "key": "NO_EQL", + "label": "=", + } + "S(NO_PLUS)": { + "key": "NO_QUES", + "label": "?", + } + "S(NO_BSLS)": { + "key": "NO_GRV", + "label": "` (dead)", + } + "S(NO_DIAE)": { + "key": "NO_CIRC", + "label": "^ (dead)", + } + "S(NO_QUOT)": { + "key": "NO_ASTR", + "label": "*", + } + "S(NO_LABK)": { + "key": "NO_RABK", + "label": ">", + } + "S(NO_COMM)": { + "key": "NO_SCLN", + "label": ";", + } + "S(NO_DOT)": { + "key": "NO_COLN", + "label": ":", + } + "S(NO_MINS)": { + "key": "NO_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ @ │ £ │ $ │ € │ │ { │ [ │ ] │ } │ │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ µ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(NO_2)": { + "key": "NO_AT", + "label": "@", + } + "ALGR(NO_3)": { + "key": "NO_PND", + "label": "£", + } + "ALGR(NO_4)": { + "key": "NO_DLR", + "label": "$", + } + "ALGR(NO_5)": { + "key": "NO_EURO", + "label": "€", + } + "ALGR(NO_7)": { + "key": "NO_LCBR", + "label": "{", + } + "ALGR(NO_8)": { + "key": "NO_LBRC", + "label": "[", + } + "ALGR(NO_9)": { + "key": "NO_RBRC", + "label": "]", + } + "ALGR(NO_0)": { + "key": "NO_RCBR", + "label": "}", + } + "ALGR(NO_BSLS)": { + "key": "NO_ACUT", + "label": "´ (dead)", + } + "ALGR(NO_DIAE)": { + "key": "NO_TILD", + "label": "~ (dead)", + } + "ALGR(NO_M)": { + "key": "NO_MICR", + "label": "µ", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_plover_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_plover_0.0.1.hjson new file mode 100644 index 0000000000..fb00ef0c62 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_plover_0.0.1.hjson @@ -0,0 +1,86 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │Num│ │ │ │ │ │ │ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ S │ T │ P │ H │ │ * │ F │ P │ L │ T │ D │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ K │ W │ R │ │ │ R │ B │ G │ S │ Z │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ A │ O │ │ E │ U │ │ │ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_1": { + "key": "PV_NUM" + } + "KC_Q": { + "key": "PV_LS" + } + "KC_W": { + "key": "PV_LT" + } + "KC_E": { + "key": "PV_LP" + } + "KC_R": { + "key": "PV_LH" + } + "KC_Y": { + "key": "PV_STAR" + } + "KC_U": { + "key": "PV_RF" + } + "KC_I": { + "key": "PV_RP" + } + "KC_O": { + "key": "PV_RL" + } + "KC_P": { + "key": "PV_RT" + } + "KC_LBRC": { + "key": "PV_RD" + } + "KC_S": { + "key": "PV_LK" + } + "KC_D": { + "key": "PV_LW" + } + "KC_F": { + "key": "PV_LR" + } + "KC_J": { + "key": "PV_RR" + } + "KC_K": { + "key": "PV_RB" + } + "KC_L": { + "key": "PV_RG" + } + "KC_SCLN": { + "key": "PV_RS" + } + "KC_QUOT": { + "key": "PV_RZ" + } + "KC_C": { + "key": "PV_A" + } + "KC_V": { + "key": "PV_O" + } + "KC_N": { + "key": "PV_E" + } + "KC_M": { + "key": "PV_U" + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_plover_dvorak_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_plover_dvorak_0.0.1.hjson new file mode 100644 index 0000000000..9656dd9821 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_plover_dvorak_0.0.1.hjson @@ -0,0 +1,73 @@ +{ + "aliases": { + "DV_1": { + "key": "PD_NUM" + } + "DV_Q": { + "key": "PD_LS" + } + "DV_W": { + "key": "PD_LT" + } + "DV_E": { + "key": "PD_LP" + } + "DV_R": { + "key": "PD_LH" + } + "DV_S": { + "key": "PD_LK" + } + "DV_D": { + "key": "PD_LW" + } + "DV_F": { + "key": "PD_LR" + } + "DV_Y": { + "key": "PD_STAR" + } + "DV_U": { + "key": "PD_RF" + } + "DV_I": { + "key": "PD_RP" + } + "DV_O": { + "key": "PD_RL" + } + "DV_P": { + "key": "PD_RT" + } + "DV_LBRC": { + "key": "PD_RD" + } + "DV_J": { + "key": "PD_RR" + } + "DV_K": { + "key": "PD_RB" + } + "DV_L": { + "key": "PD_RG" + } + "DV_SCLN": { + "key": "PD_RS" + } + "DV_QUOT": { + "key": "PD_RZ" + } + "DV_C": { + "key": "PD_A" + } + "DV_V": { + "key": "PD_O" + } + "DV_N": { + "key": "PD_E" + } + "DV_M": { + "key": "PD_U" + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_polish_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_polish_0.0.1.hjson new file mode 100644 index 0000000000..609011b1f7 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_polish_0.0.1.hjson @@ -0,0 +1,355 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "PL_GRV", + "label": "`", + } + "KC_1": { + "key": "PL_1", + "label": "1", + } + "KC_2": { + "key": "PL_2", + "label": "2", + } + "KC_3": { + "key": "PL_3", + "label": "3", + } + "KC_4": { + "key": "PL_4", + "label": "4", + } + "KC_5": { + "key": "PL_5", + "label": "5", + } + "KC_6": { + "key": "PL_6", + "label": "6", + } + "KC_7": { + "key": "PL_7", + "label": "7", + } + "KC_8": { + "key": "PL_8", + "label": "8", + } + "KC_9": { + "key": "PL_9", + "label": "9", + } + "KC_0": { + "key": "PL_0", + "label": "0", + } + "KC_MINS": { + "key": "PL_MINS", + "label": "-", + } + "KC_EQL": { + "key": "PL_EQL", + "label": "=", + } + "KC_Q": { + "key": "PL_Q", + "label": "Q", + } + "KC_W": { + "key": "PL_W", + "label": "W", + } + "KC_E": { + "key": "PL_E", + "label": "E", + } + "KC_R": { + "key": "PL_R", + "label": "R", + } + "KC_T": { + "key": "PL_T", + "label": "T", + } + "KC_Y": { + "key": "PL_Y", + "label": "Y", + } + "KC_U": { + "key": "PL_U", + "label": "U", + } + "KC_I": { + "key": "PL_I", + "label": "I", + } + "KC_O": { + "key": "PL_O", + "label": "O", + } + "KC_P": { + "key": "PL_P", + "label": "P", + } + "KC_LBRC": { + "key": "PL_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "PL_RBRC", + "label": "]", + } + "KC_BSLS": { + "key": "PL_BSLS", + "label": "\\", + } + "KC_A": { + "key": "PL_A", + "label": "A", + } + "KC_S": { + "key": "PL_S", + "label": "S", + } + "KC_D": { + "key": "PL_D", + "label": "D", + } + "KC_F": { + "key": "PL_F", + "label": "F", + } + "KC_G": { + "key": "PL_G", + "label": "G", + } + "KC_H": { + "key": "PL_H", + "label": "H", + } + "KC_J": { + "key": "PL_J", + "label": "J", + } + "KC_K": { + "key": "PL_K", + "label": "K", + } + "KC_L": { + "key": "PL_L", + "label": "L", + } + "KC_SCLN": { + "key": "PL_SCLN", + "label": ";", + } + "KC_QUOT": { + "key": "PL_QUOT", + "label": "'", + } + "KC_Z": { + "key": "PL_Z", + "label": "Z", + } + "KC_X": { + "key": "PL_X", + "label": "X", + } + "KC_C": { + "key": "PL_C", + "label": "C", + } + "KC_V": { + "key": "PL_V", + "label": "V", + } + "KC_B": { + "key": "PL_B", + "label": "B", + } + "KC_N": { + "key": "PL_N", + "label": "N", + } + "KC_M": { + "key": "PL_M", + "label": "M", + } + "KC_COMM": { + "key": "PL_COMM", + "label": ",", + } + "KC_DOT": { + "key": "PL_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "PL_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(PL_GRV)": { + "key": "PL_TILD", + "label": "~", + } + "S(PL_1)": { + "key": "PL_EXLM", + "label": "!", + } + "S(PL_2)": { + "key": "PL_AT", + "label": "@", + } + "S(PL_3)": { + "key": "PL_HASH", + "label": "#", + } + "S(PL_4)": { + "key": "PL_DLR", + "label": "$", + } + "S(PL_5)": { + "key": "PL_PERC", + "label": "%", + } + "S(PL_6)": { + "key": "PL_CIRC", + "label": "^", + } + "S(PL_7)": { + "key": "PL_AMPR", + "label": "&", + } + "S(PL_8)": { + "key": "PL_ASTR", + "label": "*", + } + "S(PL_9)": { + "key": "PL_LPRN", + "label": "(", + } + "S(PL_0)": { + "key": "PL_RPRN", + "label": ")", + } + "S(PL_MINS)": { + "key": "PL_UNDS", + "label": "_", + } + "S(PL_EQL)": { + "key": "PL_PLUS", + "label": "+", + } + "S(PL_LBRC)": { + "key": "PL_LCBR", + "label": "{", + } + "S(PL_RBRC)": { + "key": "PL_RCBR", + "label": "}", + } + "S(PL_BSLS)": { + "key": "PL_PIPE", + "label": "|", + } + "S(PL_SCLN)": { + "key": "PL_COLN", + "label": ":", + } + "S(PL_QUOT)": { + "key": "PL_DQUO", + "label": "\"", + } + "S(PL_COMM)": { + "key": "PL_LABK", + "label": "<", + } + "S(PL_DOT)": { + "key": "PL_RABK", + "label": ">", + } + "S(PL_SLSH)": { + "key": "PL_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ Ę │ │ │ │ € │ │ Ó │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ Ä„ │ Åš │ │ │ │ │ │ │ Š│ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Å» │ Ź │ Ć │ │ │ Ń │ │ │ │ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(PL_E)": { + "key": "PL_EOGO", + "label": "Ę", + } + "ALGR(PL_U)": { + "key": "PL_EURO", + "label": "€", + } + "ALGR(PL_O)": { + "key": "PL_OACU", + "label": "Ó", + } + "ALGR(PL_A)": { + "key": "PL_AOGO", + "label": "Ä„", + } + "ALGR(PL_S)": { + "key": "PL_SACU", + "label": "Åš", + } + "ALGR(PL_L)": { + "key": "PL_LSTR", + "label": "Å", + } + "ALGR(PL_Z)": { + "key": "PL_ZDOT", + "label": "Å»", + } + "ALGR(PL_X)": { + "key": "PL_ZACU", + "label": "Ź", + } + "ALGR(PL_C)": { + "key": "PL_CACU", + "label": "Ć", + } + "ALGR(PL_N)": { + "key": "PL_NACU", + "label": "Ń", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_portuguese_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_portuguese_0.0.1.hjson new file mode 100644 index 0000000000..c8e43065d2 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_portuguese_0.0.1.hjson @@ -0,0 +1,355 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ \ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ « │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ + │ ´ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ç │ º │ ~ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "PT_BSLS", + "label": "\\", + } + "KC_1": { + "key": "PT_1", + "label": "1", + } + "KC_2": { + "key": "PT_2", + "label": "2", + } + "KC_3": { + "key": "PT_3", + "label": "3", + } + "KC_4": { + "key": "PT_4", + "label": "4", + } + "KC_5": { + "key": "PT_5", + "label": "5", + } + "KC_6": { + "key": "PT_6", + "label": "6", + } + "KC_7": { + "key": "PT_7", + "label": "7", + } + "KC_8": { + "key": "PT_8", + "label": "8", + } + "KC_9": { + "key": "PT_9", + "label": "9", + } + "KC_0": { + "key": "PT_0", + "label": "0", + } + "KC_MINS": { + "key": "PT_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "PT_LDAQ", + "label": "«", + } + "KC_Q": { + "key": "PT_Q", + "label": "Q", + } + "KC_W": { + "key": "PT_W", + "label": "W", + } + "KC_E": { + "key": "PT_E", + "label": "E", + } + "KC_R": { + "key": "PT_R", + "label": "R", + } + "KC_T": { + "key": "PT_T", + "label": "T", + } + "KC_Y": { + "key": "PT_Y", + "label": "Y", + } + "KC_U": { + "key": "PT_U", + "label": "U", + } + "KC_I": { + "key": "PT_I", + "label": "I", + } + "KC_O": { + "key": "PT_O", + "label": "O", + } + "KC_P": { + "key": "PT_P", + "label": "P", + } + "KC_LBRC": { + "key": "PT_PLUS", + "label": "+", + } + "KC_RBRC": { + "key": "PT_ACUT", + "label": "´ (dead)", + } + "KC_A": { + "key": "PT_A", + "label": "A", + } + "KC_S": { + "key": "PT_S", + "label": "S", + } + "KC_D": { + "key": "PT_D", + "label": "D", + } + "KC_F": { + "key": "PT_F", + "label": "F", + } + "KC_G": { + "key": "PT_G", + "label": "G", + } + "KC_H": { + "key": "PT_H", + "label": "H", + } + "KC_J": { + "key": "PT_J", + "label": "J", + } + "KC_K": { + "key": "PT_K", + "label": "K", + } + "KC_L": { + "key": "PT_L", + "label": "L", + } + "KC_SCLN": { + "key": "PT_CCED", + "label": "Ç", + } + "KC_QUOT": { + "key": "PT_MORD", + "label": "º", + } + "KC_NUHS": { + "key": "PT_TILD", + "label": "~ (dead)", + } + "KC_NUBS": { + "key": "PT_LABK", + "label": "<", + } + "KC_Z": { + "key": "PT_Z", + "label": "Z", + } + "KC_X": { + "key": "PT_X", + "label": "X", + } + "KC_C": { + "key": "PT_C", + "label": "C", + } + "KC_V": { + "key": "PT_V", + "label": "V", + } + "KC_B": { + "key": "PT_B", + "label": "B", + } + "KC_N": { + "key": "PT_N", + "label": "N", + } + "KC_M": { + "key": "PT_M", + "label": "M", + } + "KC_COMM": { + "key": "PT_COMM", + "label": ",", + } + "KC_DOT": { + "key": "PT_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "PT_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ | │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ » │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ * │ ` │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ ª │ ^ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(PT_BSLS)": { + "key": "PT_PIPE", + "label": "|", + } + "S(PT_1)": { + "key": "PT_EXLM", + "label": "!", + } + "S(PT_2)": { + "key": "PT_DQUO", + "label": "\"", + } + "S(PT_3)": { + "key": "PT_HASH", + "label": "#", + } + "S(PT_4)": { + "key": "PT_DLR", + "label": "$", + } + "S(PT_5)": { + "key": "PT_PERC", + "label": "%", + } + "S(PT_6)": { + "key": "PT_AMPR", + "label": "&", + } + "S(PT_7)": { + "key": "PT_SLSH", + "label": "/", + } + "S(PT_8)": { + "key": "PT_LPRN", + "label": "(", + } + "S(PT_9)": { + "key": "PT_RPRN", + "label": ")", + } + "S(PT_0)": { + "key": "PT_EQL", + "label": "=", + } + "S(PT_QUOT)": { + "key": "PT_QUES", + "label": "?", + } + "S(PT_LDAQ)": { + "key": "PT_RDAQ", + "label": "»", + } + "S(PT_PLUS)": { + "key": "PT_ASTR", + "label": "*", + } + "S(PT_ACUT)": { + "key": "PT_GRV", + "label": "` (dead)", + } + "S(PT_MORD)": { + "key": "PT_FORD", + "label": "ª", + } + "S(PT_TILD)": { + "key": "PT_CIRC", + "label": "^ (dead)", + } + "S(PT_LABK)": { + "key": "PT_RABK", + "label": ">", + } + "S(PT_COMM)": { + "key": "PT_SCLN", + "label": ";", + } + "S(PT_DOT)": { + "key": "PT_COLN", + "label": ":", + } + "S(PT_MINS)": { + "key": "PT_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ @ │ £ │ § │ │ │ { │ [ │ ] │ } │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ ¨ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(PT_2)": { + "key": "PT_AT", + "label": "@", + } + "ALGR(PT_3)": { + "key": "PT_PND", + "label": "£", + } + "ALGR(PT_4)": { + "key": "PT_SECT", + "label": "§", + } + "ALGR(PT_7)": { + "key": "PT_LCBR", + "label": "{", + } + "ALGR(PT_8)": { + "key": "PT_LBRC", + "label": "[", + } + "ALGR(PT_9)": { + "key": "PT_RBRC", + "label": "]", + } + "ALGR(PT_0)": { + "key": "PT_RCBR", + "label": "}", + } + "ALGR(PT_PLUS)": { + "key": "PT_DIAE", + "label": "¨ (dead)", + } + "ALGR(PT_E)": { + "key": "PT_EURO", + "label": "€", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_portuguese_mac_iso_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_portuguese_mac_iso_0.0.1.hjson new file mode 100644 index 0000000000..b1c9aaad98 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_portuguese_mac_iso_0.0.1.hjson @@ -0,0 +1,620 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ º │ ´ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ç │ ~ │ \ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "KC_GRV": { + "key": "PT_SECT", + "label": "§", + } + "KC_1": { + "key": "PT_1", + "label": "1", + } + "KC_2": { + "key": "PT_2", + "label": "2", + } + "KC_3": { + "key": "PT_3", + "label": "3", + } + "KC_4": { + "key": "PT_4", + "label": "4", + } + "KC_5": { + "key": "PT_5", + "label": "5", + } + "KC_6": { + "key": "PT_6", + "label": "6", + } + "KC_7": { + "key": "PT_7", + "label": "7", + } + "KC_8": { + "key": "PT_8", + "label": "8", + } + "KC_9": { + "key": "PT_9", + "label": "9", + } + "KC_0": { + "key": "PT_0", + "label": "0", + } + "KC_MINS": { + "key": "PT_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "PT_PLUS", + "label": "+", + } + "KC_Q": { + "key": "PT_Q", + "label": "Q", + } + "KC_W": { + "key": "PT_W", + "label": "W", + } + "KC_E": { + "key": "PT_E", + "label": "E", + } + "KC_R": { + "key": "PT_R", + "label": "R", + } + "KC_T": { + "key": "PT_T", + "label": "T", + } + "KC_Y": { + "key": "PT_Y", + "label": "Y", + } + "KC_U": { + "key": "PT_U", + "label": "U", + } + "KC_I": { + "key": "PT_I", + "label": "I", + } + "KC_O": { + "key": "PT_O", + "label": "O", + } + "KC_P": { + "key": "PT_P", + "label": "P", + } + "KC_LBRC": { + "key": "PT_MORD", + "label": "º", + } + "KC_RBRC": { + "key": "PT_ACUT", + "label": "´ (dead)", + } + "KC_A": { + "key": "PT_A", + "label": "A", + } + "KC_S": { + "key": "PT_S", + "label": "S", + } + "KC_D": { + "key": "PT_D", + "label": "D", + } + "KC_F": { + "key": "PT_F", + "label": "F", + } + "KC_G": { + "key": "PT_G", + "label": "G", + } + "KC_H": { + "key": "PT_H", + "label": "H", + } + "KC_J": { + "key": "PT_J", + "label": "J", + } + "KC_K": { + "key": "PT_K", + "label": "K", + } + "KC_L": { + "key": "PT_L", + "label": "L", + } + "KC_SCLN": { + "key": "PT_CCED", + "label": "Ç", + } + "KC_QUOT": { + "key": "PT_TILD", + "label": "~ (dead)", + } + "KC_NUHS": { + "key": "PT_BSLS", + "label": "\\", + } + "KC_NUBS": { + "key": "PT_LABK", + "label": "<", + } + "KC_Z": { + "key": "PT_Z", + "label": "Z", + } + "KC_X": { + "key": "PT_X", + "label": "X", + } + "KC_C": { + "key": "PT_C", + "label": "C", + } + "KC_V": { + "key": "PT_V", + "label": "V", + } + "KC_B": { + "key": "PT_B", + "label": "B", + } + "KC_N": { + "key": "PT_N", + "label": "N", + } + "KC_M": { + "key": "PT_M", + "label": "M", + } + "KC_COMM": { + "key": "PT_COMM", + "label": ",", + } + "KC_DOT": { + "key": "PT_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "PT_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ± │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ * │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ ª │ ` │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ ^ │ | │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(PT_SECT)": { + "key": "PT_PLMN", + "label": "±", + } + "S(PT_1)": { + "key": "PT_EXLM", + "label": "!", + } + "S(PT_2)": { + "key": "PT_DQUO", + "label": "\"", + } + "S(PT_3)": { + "key": "PT_HASH", + "label": "#", + } + "S(PT_4)": { + "key": "PT_DLR", + "label": "$", + } + "S(PT_5)": { + "key": "PT_PERC", + "label": "%", + } + "S(PT_6)": { + "key": "PT_AMPR", + "label": "&", + } + "S(PT_7)": { + "key": "PT_SLSH", + "label": "/", + } + "S(PT_8)": { + "key": "PT_LPRN", + "label": "(", + } + "S(PT_9)": { + "key": "PT_RPRN", + "label": ")", + } + "S(PT_0)": { + "key": "PT_EQL", + "label": "=", + } + "S(PT_QUOT)": { + "key": "PT_QUES", + "label": "?", + } + "S(PT_PLUS)": { + "key": "PT_ASTR", + "label": "*", + } + "S(PT_MORD)": { + "key": "PT_FORD", + "label": "ª", + } + "S(PT_ACUT)": { + "key": "PT_GRV", + "label": "` (dead)", + } + "S(PT_TILD)": { + "key": "PT_CIRC", + "label": "^ (dead)", + } + "S(PT_BSLS)": { + "key": "PT_PIPE", + "label": "|", + } + "S(PT_LABK)": { + "key": "PT_RABK", + "label": ">", + } + "S(PT_COMM)": { + "key": "PT_SCLN", + "label": ";", + } + "S(PT_DOT)": { + "key": "PT_COLN", + "label": ":", + } + "S(PT_MINS)": { + "key": "PT_UNDS", + "label": "_", + } +/* Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ │  │ @ │ € │ £ │ ‰ │ ¶ │ ÷ │ [ │ ] │ ≠│ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ Å’ │ ∑ │ Æ │ ® │ â„¢ │ Â¥ │ †│ ı │ Ø │ Ï€ │ ° │ ¨ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Ã… │ ß │ ∂ │ Æ’ │ Ë™ │ ˇ │ ¯ │ „ │ ‘ │ ¸ │ Ëœ │ ‹ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≤ │ Ω │ « │ © │ √ │ ∫ │ ¬ │ µ │ “ │ … │ — │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "A(PT_1)": { + "key": "PT_APPL", + "label": " (Apple logo)", + } + "A(PT_2)": { + "key": "PT_AT", + "label": "@", + } + "A(PT_3)": { + "key": "PT_EURO", + "label": "€", + } + "A(PT_4)": { + "key": "PT_PND", + "label": "£", + } + "A(PT_5)": { + "key": "PT_PERM", + "label": "‰", + } + "A(PT_6)": { + "key": "PT_PILC", + "label": "¶", + } + "A(PT_7)": { + "key": "PT_DIV", + "label": "÷", + } + "A(PT_8)": { + "key": "PT_LBRC", + "label": "[", + } + "A(PT_9)": { + "key": "PT_RBRC", + "label": "]", + } + "A(PT_0)": { + "key": "PT_NEQL", + "label": "≠", + } + "A(PT_Q)": { + "key": "PT_OE", + "label": "Å’", + } + "A(PT_W)": { + "key": "PT_NARS", + "label": "∑", + } + "A(PT_E)": { + "key": "PT_AE", + "label": "Æ", + } + "A(PT_R)": { + "key": "PT_REGD", + "label": "®", + } + "A(PT_T)": { + "key": "PT_TM", + "label": "â„¢", + } + "A(PT_Y)": { + "key": "PT_YEN", + "label": "Â¥", + } + "A(PT_U)": { + "key": "PT_DAGG", + "label": "†", + } + "A(PT_I)": { + "key": "PT_DLSI", + "label": "ı", + } + "A(PT_O)": { + "key": "PT_OSTR", + "label": "Ø", + } + "A(PT_P)": { + "key": "PT_PI", + "label": "Ï€", + } + "A(PT_MORD)": { + "key": "PT_DEG", + "label": "°", + } + "A(PT_ACUT)": { + "key": "PT_DIAE", + "label": "¨ (dead)", + } + "A(PT_A)": { + "key": "PT_ARNG", + "label": "Ã¥", + } + "A(PT_S)": { + "key": "PT_SS", + "label": "ß", + } + "A(PT_D)": { + "key": "PT_PDIF", + "label": "∂", + } + "A(PT_F)": { + "key": "PT_FHK", + "label": "Æ’", + } + "A(PT_G)": { + "key": "PT_DOTA", + "label": "Ë™", + } + "A(PT_H)": { + "key": "PT_CARN", + "label": "ˇ", + } + "A(PT_J)": { + "key": "PT_MACR", + "label": "¯", + } + "A(PT_K)": { + "key": "PT_DLQU", + "label": "„", + } + "A(PT_L)": { + "key": "PT_LSQU", + "label": "‘", + } + "A(PT_CCED)": { + "key": "PT_CEDL", + "label": "¸", + } + "A(PT_TILD)": { + "key": "PT_STIL", + "label": "Ëœ (dead)", + } + "A(PT_BSLS)": { + "key": "PT_LSAQ", + "label": "‹", + } + "A(PT_LABK)": { + "key": "PT_LTEQ", + "label": "≤", + } + "A(PT_Z)": { + "key": "PT_OMEG", + "label": "Ω", + } + "A(PT_X)": { + "key": "PT_LDAQ", + "label": "«", + } + "A(PT_C)": { + "key": "PT_COPY", + "label": "©", + } + "A(PT_V)": { + "key": "PT_SQRT", + "label": "√", + } + "A(PT_B)": { + "key": "PT_INTG", + "label": "∫", + } + "A(PT_N)": { + "key": "PT_NOT", + "label": "¬", + } + "A(PT_M)": { + "key": "PT_MICR", + "label": "µ", + } + "A(PT_COMM)": { + "key": "PT_LDQU", + "label": "“", + } + "A(PT_DOT)": { + "key": "PT_ELLP", + "label": "…", + } + "A(PT_MINS)": { + "key": "PT_MDSH", + "label": "—", + } +/* Shift+Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ │ ¡ │ ï¬ â”‚ fl │ ¢ │ ∞ │ • │ ℠│ { │ } │ ≈ │ ¿ │ â—Š │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ │ │ │ │ │ ‡ │ Ëš │ │ ∠│ │ Ë â”‚ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ ∆ │ │ │ │ │ ‚ │ ’ │ Ë› │ ˆ │ › │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≥ │ │ » │ │ │ │ │ │ †│ · │ – │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(A(PT_1))": { + "key": "PT_IEXL", + "label": "¡", + } + "S(A(PT_2))": { + "key": "PT_FI", + "label": "ï¬", + } + "S(A(PT_3))": { + "key": "PT_FL", + "label": "fl", + } + "S(A(PT_4))": { + "key": "PT_CENT", + "label": "¢", + } + "S(A(PT_5))": { + "key": "PT_INFN", + "label": "∞", + } + "S(A(PT_6))": { + "key": "PT_BULT", + "label": "•", + } + "S(A(PT_7))": { + "key": "PT_FRSL", + "label": "â„", + } + "S(A(PT_8))": { + "key": "PT_LCBR", + "label": "{", + } + "S(A(PT_9))": { + "key": "PT_RCBR", + "label": "}", + } + "S(A(PT_0))": { + "key": "PT_AEQL", + "label": "≈", + } + "S(A(PT_QUOT))": { + "key": "PT_IQUE", + "label": "¿", + } + "S(A(PT_PLUS))": { + "key": "PT_LOZN", + "label": "â—Š", + } + "S(A(PT_U))": { + "key": "PT_DDAG", + "label": "‡", + } + "S(A(PT_I))": { + "key": "PT_RNGA", + "label": "Ëš", + } + "S(A(PT_P))": { + "key": "PT_NARP", + "label": "âˆ", + } + "S(A(PT_ACUT))": { + "key": "PT_DACU", + "label": "Ë", + } + "S(A(PT_D))": { + "key": "PT_INCR", + "label": "∆", + } + "S(A(PT_K))": { + "key": "PT_SLQU", + "label": "‚", + } + "S(A(PT_L))": { + "key": "PT_RSQU", + "label": "’", + } + "S(A(PT_CCED))": { + "key": "PT_OGON", + "label": "Ë›", + } + "S(A(PT_TILD))": { + "key": "PT_DCIR", + "label": "ˆ (dead)", + } + "S(A(PT_BSLS))": { + "key": "PT_RSAQ", + "label": "›", + } + "S(A(PT_LABK))": { + "key": "PT_GTEQ", + "label": "≥", + } + "S(A(PT_X))": { + "key": "PT_RDAQ", + "label": "»", + } + "S(A(PT_COMM))": { + "key": "PT_RDQU", + "label": "â€", + } + "S(A(PT_DOT))": { + "key": "PT_MDDT", + "label": "·", + } + "S(A(PT_MINS))": { + "key": "PT_NDSH", + "label": "–", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_romanian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_romanian_0.0.1.hjson new file mode 100644 index 0000000000..42b1e89d3b --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_romanian_0.0.1.hjson @@ -0,0 +1,444 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ „ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ä‚ │ ÃŽ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ș │ Èš │  │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ \ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "RO_DLQU", + "label": "„", + } + "KC_1": { + "key": "RO_1", + "label": "1", + } + "KC_2": { + "key": "RO_2", + "label": "2", + } + "KC_3": { + "key": "RO_3", + "label": "3", + } + "KC_4": { + "key": "RO_4", + "label": "4", + } + "KC_5": { + "key": "RO_5", + "label": "5", + } + "KC_6": { + "key": "RO_6", + "label": "6", + } + "KC_7": { + "key": "RO_7", + "label": "7", + } + "KC_8": { + "key": "RO_8", + "label": "8", + } + "KC_9": { + "key": "RO_9", + "label": "9", + } + "KC_0": { + "key": "RO_0", + "label": "0", + } + "KC_MINS": { + "key": "RO_MINS", + "label": "-", + } + "KC_EQL": { + "key": "RO_EQL", + "label": "=", + } + "KC_Q": { + "key": "RO_Q", + "label": "Q", + } + "KC_W": { + "key": "RO_W", + "label": "W", + } + "KC_E": { + "key": "RO_E", + "label": "E", + } + "KC_R": { + "key": "RO_R", + "label": "R", + } + "KC_T": { + "key": "RO_T", + "label": "T", + } + "KC_Y": { + "key": "RO_Y", + "label": "Y", + } + "KC_U": { + "key": "RO_U", + "label": "U", + } + "KC_I": { + "key": "RO_I", + "label": "I", + } + "KC_O": { + "key": "RO_O", + "label": "O", + } + "KC_P": { + "key": "RO_P", + "label": "P", + } + "KC_LBRC": { + "key": "RO_ABRV", + "label": "Ä‚", + } + "KC_RBRC": { + "key": "RO_ICIR", + "label": "ÃŽ", + } + "KC_A": { + "key": "RO_A", + "label": "A", + } + "KC_S": { + "key": "RO_S", + "label": "S", + } + "KC_D": { + "key": "RO_D", + "label": "D", + } + "KC_F": { + "key": "RO_F", + "label": "F", + } + "KC_G": { + "key": "RO_G", + "label": "G", + } + "KC_H": { + "key": "RO_H", + "label": "H", + } + "KC_J": { + "key": "RO_J", + "label": "J", + } + "KC_K": { + "key": "RO_K", + "label": "K", + } + "KC_L": { + "key": "RO_L", + "label": "L", + } + "KC_SCLN": { + "key": "RO_SCOM", + "label": "Ș", + } + "KC_QUOT": { + "key": "RO_TCOM", + "label": "Èš", + } + "KC_NUHS": { + "key": "RO_ACIR", + "label": "Â", + } + "KC_NUBS": { + "key": "RO_BSLS", + "label": "\\", + } + "KC_Z": { + "key": "RO_Z", + "label": "Z", + } + "KC_X": { + "key": "RO_X", + "label": "X", + } + "KC_C": { + "key": "RO_C", + "label": "C", + } + "KC_V": { + "key": "RO_V", + "label": "V", + } + "KC_B": { + "key": "RO_B", + "label": "B", + } + "KC_N": { + "key": "RO_N", + "label": "N", + } + "KC_M": { + "key": "RO_M", + "label": "M", + } + "KC_COMM": { + "key": "RO_COMM", + "label": ",", + } + "KC_DOT": { + "key": "RO_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "RO_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ †│ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ | │ │ │ │ │ │ │ │ ; │ : │ ? │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(RO_DLQU)": { + "key": "RO_RDQU", + "label": "â€", + } + "S(RO_1)": { + "key": "RO_EXLM", + "label": "!", + } + "S(RO_2)": { + "key": "RO_AT", + "label": "@", + } + "S(RO_3)": { + "key": "RO_HASH", + "label": "#", + } + "S(RO_4)": { + "key": "RO_DLR", + "label": "$", + } + "S(RO_5)": { + "key": "RO_PERC", + "label": "%", + } + "S(RO_6)": { + "key": "RO_CIRC", + "label": "^", + } + "S(RO_7)": { + "key": "RO_AMPR", + "label": "&", + } + "S(RO_8)": { + "key": "RO_ASTR", + "label": "*", + } + "S(RO_9)": { + "key": "RO_LPRN", + "label": "(", + } + "S(RO_0)": { + "key": "RO_RPRN", + "label": ")", + } + "S(RO_MINS)": { + "key": "RO_UNDS", + "label": "_", + } + "S(RO_EQL)": { + "key": "RO_PLUS", + "label": "+", + } + "S(RO_BSLS)": { + "key": "RO_PIPE", + "label": "|", + } + "S(RO_COMM)": { + "key": "RO_SCLN", + "label": ";", + } + "S(RO_DOT)": { + "key": "RO_COLN", + "label": ":", + } + "S(RO_SLSH)": { + "key": "RO_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ ~ │ ˇ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ ´ │ Ë â”‚ ¨ │ ¸ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ § │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ ß │ Ä â”‚ │ │ │ │ │ Š│ │ ' │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ © │ │ │ │ │ < │ > │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(RO_DLQU)": { + "key": "RO_GRV", + "label": "`", + } + "ALGR(RO_1)": { + "key": "RO_DTIL", + "label": "~ (dead)", + } + "ALGR(RO_2)": { + "key": "RO_CARN", + "label": "ˇ (dead)", + } + "ALGR(RO_3)": { + "key": "RO_DCIR", + "label": "^ (dead)", + } + "ALGR(RO_4)": { + "key": "RO_BREV", + "label": "˘ (dead)", + } + "ALGR(RO_5)": { + "key": "RO_RNGA", + "label": "° (dead)", + } + "ALGR(RO_6)": { + "key": "RO_OGON", + "label": "Ë› (dead)", + } + "ALGR(RO_7)": { + "key": "RO_DGRV", + "label": "` (dead)", + } + "ALGR(RO_8)": { + "key": "RO_DOTA", + "label": "Ë™ (dead)", + } + "ALGR(RO_9)": { + "key": "RO_ACUT", + "label": "´ (dead)", + } + "ALGR(RO_0)": { + "key": "RO_DACU", + "label": "Ë (dead)", + } + "ALGR(RO_MINS)": { + "key": "RO_DIAE", + "label": "¨ (dead)", + } + "ALGR(RO_EQL)": { + "key": "RO_CEDL", + "label": "¸ (dead)", + } + "ALGR(RO_E)": { + "key": "RO_EURO", + "label": "€", + } + "ALGR(RO_P)": { + "key": "RO_SECT", + "label": "§", + } + "ALGR(RO_ABRV)": { + "key": "RO_LBRC", + "label": "[", + } + "ALGR(RO_ICIR)": { + "key": "RO_RBRC", + "label": "]", + } + "ALGR(RO_S)": { + "key": "RO_SS", + "label": "ß", + } + "ALGR(RO_D)": { + "key": "RO_DSTR", + "label": "Ä", + } + "ALGR(RO_L)": { + "key": "RO_LSTR", + "label": "Å", + } + "ALGR(RO_TCOM)": { + "key": "RO_QUOT", + "label": "'", + } + "ALGR(RO_C)": { + "key": "RO_COPY", + "label": "©", + } + "ALGR(RO_COMM)": { + "key": "RO_LABK", + "label": "<", + } + "ALGR(RO_DOT)": { + "key": "RO_RABK", + "label": ">", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ │ │ │ │ │ │ │ │ │ │ – │ ± │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ " │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ « │ » │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(RO_DLQU))": { + "key": "RO_TILD", + "label": "~", + } + "S(ALGR(RO_MINS))": { + "key": "RO_NDSH", + "label": "–", + } + "S(ALGR(RO_EQL))": { + "key": "RO_PLMN", + "label": "±", + } + "S(ALGR(RO_ABRV))": { + "key": "RO_LCBR", + "label": "{", + } + "S(ALGR(RO_ICIR))": { + "key": "RO_RCBR", + "label": "}", + } + "S(ALGR(RO_TCOM))": { + "key": "RO_DQUO", + "label": "\"", + } + "S(ALGR(RO_COMM))": { + "key": "RO_LDAQ", + "label": "«", + } + "S(ALGR(RO_DOT))": { + "key": "RO_RDAQ", + "label": "»", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_russian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_russian_0.0.1.hjson new file mode 100644 index 0000000000..d83fc0f61f --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_russian_0.0.1.hjson @@ -0,0 +1,291 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ Р│ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Й │ Ц │ У │ К │ Е │ Р│ Г │ Ш │ Щ │ З │ Ð¥ │ Ъ │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ Ф │ Ы │ Ð’ │ Р│ П │ Р│ О │ Л │ Д │ Ж │ Р│ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Я │ Ч │ С │ Ðœ │ И │ Т │ Ь │ Б │ Ю │ . │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "RU_YO", + "label": "Ð", + } + "KC_1": { + "key": "RU_1", + "label": "1", + } + "KC_2": { + "key": "RU_2", + "label": "2", + } + "KC_3": { + "key": "RU_3", + "label": "3", + } + "KC_4": { + "key": "RU_4", + "label": "4", + } + "KC_5": { + "key": "RU_5", + "label": "5", + } + "KC_6": { + "key": "RU_6", + "label": "6", + } + "KC_7": { + "key": "RU_7", + "label": "7", + } + "KC_8": { + "key": "RU_8", + "label": "8", + } + "KC_9": { + "key": "RU_9", + "label": "9", + } + "KC_0": { + "key": "RU_0", + "label": "0", + } + "KC_MINS": { + "key": "RU_MINS", + "label": "-", + } + "KC_EQL": { + "key": "RU_EQL", + "label": "=", + } + "KC_Q": { + "key": "RU_SHTI", + "label": "Й", + } + "KC_W": { + "key": "RU_TSE", + "label": "Ц", + } + "KC_E": { + "key": "RU_U", + "label": "У", + } + "KC_R": { + "key": "RU_KA", + "label": "К", + } + "KC_T": { + "key": "RU_IE", + "label": "Е", + } + "KC_Y": { + "key": "RU_EN", + "label": "Ð", + } + "KC_U": { + "key": "RU_GHE", + "label": "Г", + } + "KC_I": { + "key": "RU_SHA", + "label": "Ш", + } + "KC_O": { + "key": "RU_SHCH", + "label": "Щ", + } + "KC_P": { + "key": "RU_ZE", + "label": "З", + } + "KC_LBRC": { + "key": "RU_HA", + "label": "Ð¥", + } + "KC_RBRC": { + "key": "RU_HARD", + "label": "Ъ", + } + "KC_BSLS": { + "key": "RU_BSLS", + "label": "\\", + } + "KC_A": { + "key": "RU_EF", + "label": "Ф", + } + "KC_S": { + "key": "RU_YERU", + "label": "Ы", + } + "KC_D": { + "key": "RU_VE", + "label": "Ð’", + } + "KC_F": { + "key": "RU_A", + "label": "Ð", + } + "KC_G": { + "key": "RU_PE", + "label": "П", + } + "KC_H": { + "key": "RU_ER", + "label": "Ð ", + } + "KC_J": { + "key": "RU_O", + "label": "О", + } + "KC_K": { + "key": "RU_EL", + "label": "Л", + } + "KC_L": { + "key": "RU_DE", + "label": "Д", + } + "KC_SCLN": { + "key": "RU_ZHE", + "label": "Ж", + } + "KC_QUOT": { + "key": "RU_E", + "label": "Ð", + } + "KC_Z": { + "key": "RU_YA", + "label": "Я", + } + "KC_X": { + "key": "RU_CHE", + "label": "Ч", + } + "KC_C": { + "key": "RU_ES", + "label": "С", + } + "KC_V": { + "key": "RU_EM", + "label": "Ðœ", + } + "KC_B": { + "key": "RU_I", + "label": "И", + } + "KC_N": { + "key": "RU_TE", + "label": "Т", + } + "KC_M": { + "key": "RU_SOFT", + "label": "Ь", + } + "KC_COMM": { + "key": "RU_BE", + "label": "Б", + } + "KC_DOT": { + "key": "RU_YU", + "label": "Ю", + } + "KC_SLSH": { + "key": "RU_DOT", + "label": ".", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ! │ " │ â„– │ ; │ % │ : │ ? │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ / │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ │ │ , │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(RU_1)": { + "key": "RU_EXLM", + "label": "!", + } + "S(RU_2)": { + "key": "RU_DQUO", + "label": "\"", + } + "S(RU_3)": { + "key": "RU_NUM", + "label": "â„–", + } + "S(RU_4)": { + "key": "RU_SCLN", + "label": ";", + } + "S(RU_5)": { + "key": "RU_PERC", + "label": "%", + } + "S(RU_6)": { + "key": "RU_COLN", + "label": ":", + } + "S(RU_7)": { + "key": "RU_QUES", + "label": "?", + } + "S(RU_8)": { + "key": "RU_ASTR", + "label": "*", + } + "S(RU_9)": { + "key": "RU_LPRN", + "label": "(", + } + "S(RU_0)": { + "key": "RU_RPRN", + "label": ")", + } + "S(RU_MINS)": { + "key": "RU_UNDS", + "label": "_", + } + "S(RU_EQL)": { + "key": "RU_PLUS", + "label": "+", + } + "S(RU_BSLS)": { + "key": "RU_SLSH", + "label": "/", + } + "S(RU_DOT)": { + "key": "RU_COMM", + "label": ",", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ │ │ │ │ │ │ ₽ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(RU_8)": { + "key": "RU_RUBL", + "label": "₽", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_serbian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_serbian_0.0.1.hjson new file mode 100644 index 0000000000..98957930a0 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_serbian_0.0.1.hjson @@ -0,0 +1,307 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Љ │ Њ │ Е │ Р│ Т │ З │ У │ И │ О │ П │ Ш │ Ђ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Р│ С │ Д │ Ф │ Г │ Ð¥ │ Ј │ К │ Л │ Ч │ Ћ │ Ж │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Ð… │ Р│ Ц │ Ð’ │ Б │ Р│ Ðœ │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "RS_GRV", + "label": "`", + } + "KC_1": { + "key": "RS_1", + "label": "1", + } + "KC_2": { + "key": "RS_2", + "label": "2", + } + "KC_3": { + "key": "RS_3", + "label": "3", + } + "KC_4": { + "key": "RS_4", + "label": "4", + } + "KC_5": { + "key": "RS_5", + "label": "5", + } + "KC_6": { + "key": "RS_6", + "label": "6", + } + "KC_7": { + "key": "RS_7", + "label": "7", + } + "KC_8": { + "key": "RS_8", + "label": "8", + } + "KC_9": { + "key": "RS_9", + "label": "9", + } + "KC_0": { + "key": "RS_0", + "label": "0", + } + "KC_MINS": { + "key": "RS_QUOT", + "label": "' (dead)", + } + "KC_EQL": { + "key": "RS_PLUS", + "label": "+", + } + "KC_Q": { + "key": "RS_LJE", + "label": "Љ", + } + "KC_W": { + "key": "RS_NJE", + "label": "Њ", + } + "KC_E": { + "key": "RS_IE", + "label": "Е", + } + "KC_R": { + "key": "RS_ER", + "label": "Ð ", + } + "KC_T": { + "key": "RS_TE", + "label": "Т", + } + "KC_Y": { + "key": "RS_ZE", + "label": "З", + } + "KC_U": { + "key": "RS_U", + "label": "У", + } + "KC_I": { + "key": "RS_I", + "label": "И", + } + "KC_O": { + "key": "RS_O", + "label": "О", + } + "KC_P": { + "key": "RS_PE", + "label": "П", + } + "KC_LBRC": { + "key": "RS_SHA", + "label": "Ш", + } + "KC_RBRC": { + "key": "RS_DJE", + "label": "Ђ", + } + "KC_A": { + "key": "RS_A", + "label": "Ð", + } + "KC_S": { + "key": "RS_ES", + "label": "С", + } + "KC_D": { + "key": "RS_DE", + "label": "Д", + } + "KC_F": { + "key": "RS_EF", + "label": "Ф", + } + "KC_G": { + "key": "RS_GHE", + "label": "Г", + } + "KC_H": { + "key": "RS_HA", + "label": "Ð¥", + } + "KC_J": { + "key": "RS_JE", + "label": "Ј", + } + "KC_K": { + "key": "RS_KA", + "label": "К", + } + "KC_L": { + "key": "RS_EL", + "label": "Л", + } + "KC_SCLN": { + "key": "RS_CHE", + "label": "Ч", + } + "KC_QUOT": { + "key": "RS_TSHE", + "label": "Ћ", + } + "KC_NUHS": { + "key": "RS_ZHE", + "label": "Ж", + } + "KC_NUBS": { + "key": "RS_LABK", + "label": "<", + } + "KC_Z": { + "key": "RS_DZE", + "label": "Ð…", + } + "KC_X": { + "key": "RS_DZHE", + "label": "Ð", + } + "KC_C": { + "key": "RS_TSE", + "label": "Ц", + } + "KC_V": { + "key": "RS_VE", + "label": "Ð’", + } + "KC_B": { + "key": "RS_BE", + "label": "Б", + } + "KC_N": { + "key": "RS_EN", + "label": "Ð", + } + "KC_M": { + "key": "RS_EM", + "label": "Ðœ", + } + "KC_COMM": { + "key": "RS_COMM", + "label": ",", + } + "KC_DOT": { + "key": "RS_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "RS_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ * │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(RS_GRV)": { + "key": "RS_TILD", + "label": "~", + } + "S(RS_1)": { + "key": "RS_EXLM", + "label": "!", + } + "S(RS_2)": { + "key": "RS_DQUO", + "label": "\"", + } + "S(RS_3)": { + "key": "RS_HASH", + "label": "#", + } + "S(RS_4)": { + "key": "RS_DLR", + "label": "$", + } + "S(RS_5)": { + "key": "RS_PERC", + "label": "%", + } + "S(RS_6)": { + "key": "RS_AMPR", + "label": "&", + } + "S(RS_7)": { + "key": "RS_SLSH", + "label": "/", + } + "S(RS_8)": { + "key": "RS_LPRN", + "label": "(", + } + "S(RS_9)": { + "key": "RS_RPRN", + "label": ")", + } + "S(RS_0)": { + "key": "RS_EQL", + "label": "=", + } + "S(RS_QUOT)": { + "key": "RS_QUES", + "label": "?", + } + "S(RS_PLUS)": { + "key": "RS_ASTR", + "label": "*", + } + "S(RS_LABK)": { + "key": "RS_RABK", + "label": ">", + } + "S(RS_COMM)": { + "key": "RS_SCLN", + "label": ";", + } + "S(RS_DOT)": { + "key": "RS_COLN", + "label": ":", + } + "S(RS_MINS)": { + "key": "RS_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(RS_IE)": { + "key": "RS_EURO", + "label": "€", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_serbian_latin_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_serbian_latin_0.0.1.hjson new file mode 100644 index 0000000000..ca4746b646 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_serbian_latin_0.0.1.hjson @@ -0,0 +1,407 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ‚ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Š│ Ä â”‚ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ÄŒ │ Ć │ Ž │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "RS_SLQU", + "label": "‚ (dead)", + } + "KC_1": { + "key": "RS_1", + "label": "1", + } + "KC_2": { + "key": "RS_2", + "label": "2", + } + "KC_3": { + "key": "RS_3", + "label": "3", + } + "KC_4": { + "key": "RS_4", + "label": "4", + } + "KC_5": { + "key": "RS_5", + "label": "5", + } + "KC_6": { + "key": "RS_6", + "label": "6", + } + "KC_7": { + "key": "RS_7", + "label": "7", + } + "KC_8": { + "key": "RS_8", + "label": "8", + } + "KC_9": { + "key": "RS_9", + "label": "9", + } + "KC_0": { + "key": "RS_0", + "label": "0", + } + "KC_MINS": { + "key": "RS_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "RS_PLUS", + "label": "+", + } + "KC_Q": { + "key": "RS_Q", + "label": "Q", + } + "KC_W": { + "key": "RS_W", + "label": "W", + } + "KC_E": { + "key": "RS_E", + "label": "E", + } + "KC_R": { + "key": "RS_R", + "label": "R", + } + "KC_T": { + "key": "RS_T", + "label": "T", + } + "KC_Y": { + "key": "RS_Z", + "label": "Z", + } + "KC_U": { + "key": "RS_U", + "label": "U", + } + "KC_I": { + "key": "RS_I", + "label": "I", + } + "KC_O": { + "key": "RS_O", + "label": "O", + } + "KC_P": { + "key": "RS_P", + "label": "P", + } + "KC_LBRC": { + "key": "RS_SCAR", + "label": "Å ", + } + "KC_RBRC": { + "key": "RS_DSTR", + "label": "Ä", + } + "KC_A": { + "key": "RS_A", + "label": "A", + } + "KC_S": { + "key": "RS_S", + "label": "S", + } + "KC_D": { + "key": "RS_D", + "label": "D", + } + "KC_F": { + "key": "RS_F", + "label": "F", + } + "KC_G": { + "key": "RS_G", + "label": "G", + } + "KC_H": { + "key": "RS_H", + "label": "H", + } + "KC_J": { + "key": "RS_J", + "label": "J", + } + "KC_K": { + "key": "RS_K", + "label": "K", + } + "KC_L": { + "key": "RS_L", + "label": "L", + } + "KC_SCLN": { + "key": "RS_CCAR", + "label": "ÄŒ", + } + "KC_QUOT": { + "key": "RS_CACU", + "label": "Ć", + } + "KC_NUHS": { + "key": "RS_ZCAR", + "label": "Ž", + } + "KC_NUBS": { + "key": "RS_LABK", + "label": "<", + } + "KC_Z": { + "key": "RS_Y", + "label": "Y", + } + "KC_X": { + "key": "RS_X", + "label": "X", + } + "KC_C": { + "key": "RS_C", + "label": "C", + } + "KC_V": { + "key": "RS_V", + "label": "V", + } + "KC_B": { + "key": "RS_B", + "label": "B", + } + "KC_N": { + "key": "RS_N", + "label": "N", + } + "KC_M": { + "key": "RS_M", + "label": "M", + } + "KC_COMM": { + "key": "RS_COMM", + "label": ",", + } + "KC_DOT": { + "key": "RS_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "RS_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ * │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(RS_SLQU)": { + "key": "RS_TILD", + "label": "~", + } + "S(RS_1)": { + "key": "RS_EXLM", + "label": "!", + } + "S(RS_2)": { + "key": "RS_DQUO", + "label": "\"", + } + "S(RS_3)": { + "key": "RS_HASH", + "label": "#", + } + "S(RS_4)": { + "key": "RS_DLR", + "label": "$", + } + "S(RS_5)": { + "key": "RS_PERC", + "label": "%", + } + "S(RS_6)": { + "key": "RS_AMPR", + "label": "&", + } + "S(RS_7)": { + "key": "RS_SLSH", + "label": "/", + } + "S(RS_8)": { + "key": "RS_LPRN", + "label": "(", + } + "S(RS_9)": { + "key": "RS_RPRN", + "label": ")", + } + "S(RS_0)": { + "key": "RS_EQL", + "label": "=", + } + "S(RS_QUOT)": { + "key": "RS_QUES", + "label": "?", + } + "S(RS_PLUS)": { + "key": "RS_ASTR", + "label": "*", + } + "S(RS_LABK)": { + "key": "RS_RABK", + "label": ">", + } + "S(RS_COMM)": { + "key": "RS_SCLN", + "label": ";", + } + "S(RS_DOT)": { + "key": "RS_COLN", + "label": ":", + } + "S(RS_MINS)": { + "key": "RS_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ ˇ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ ´ │ Ë â”‚ ¨ │ ¸ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ \ │ | │ € │ │ │ │ │ │ │ │ ÷ │ × │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ [ │ ] │ │ │ Å‚ │ Š│ │ ß │ ¤ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ @ │ { │ } │ § │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(RS_2)": { + "key": "RS_CARN", + "label": "ˇ (dead)", + } + "ALGR(RS_3)": { + "key": "RS_CIRC", + "label": "^ (dead)", + } + "ALGR(RS_4)": { + "key": "RS_BREV", + "label": "˘ (dead)", + } + "ALGR(RS_5)": { + "key": "RS_RNGA", + "label": "° (dead)", + } + "ALGR(RS_6)": { + "key": "RS_OGON", + "label": "Ë› (dead)", + } + "ALGR(RS_7)": { + "key": "RS_GRV", + "label": "`", + } + "ALGR(RS_8)": { + "key": "RS_DOTA", + "label": "Ë™ (dead)", + } + "ALGR(RS_9)": { + "key": "RS_ACUT", + "label": "´ (dead)", + } + "ALGR(RS_0)": { + "key": "RS_DACU", + "label": "Ë (dead)", + } + "ALGR(RS_QUOT)": { + "key": "RS_DIAE", + "label": "¨ (dead)", + } + "ALGR(RS_PLUS)": { + "key": "RS_CEDL", + "label": "¸ (dead)", + } + "ALGR(RS_Q)": { + "key": "RS_BSLS", + "label": "\\", + } + "ALGR(RS_W)": { + "key": "RS_PIPE", + "label": "|", + } + "ALGR(RS_E)": { + "key": "RS_EURO", + "label": "€", + } + "ALGR(RS_SCAR)": { + "key": "RS_DIV", + "label": "÷", + } + "ALGR(RS_DSTR)": { + "key": "RS_MUL", + "label": "×", + } + "ALGR(RS_F)": { + "key": "RS_LBRC", + "label": "[", + } + "ALGR(RS_G)": { + "key": "RS_RBRC", + "label": "]", + } + "ALGR(RS_K)": { + "key": "RS_LLST", + "label": "Å‚", + } + "ALGR(RS_L)": { + "key": "RS_CLST", + "label": "Å", + } + "ALGR(RS_CACU)": { + "key": "RS_SS", + "label": "ß", + } + "ALGR(RS_ZCAR)": { + "key": "RS_CURR", + "label": "¤", + } + "ALGR(RS_V)": { + "key": "RS_AT", + "label": "@", + } + "ALGR(RS_B)": { + "key": "RS_LCBR", + "label": "{", + } + "ALGR(RS_N)": { + "key": "RS_RCBR", + "label": "}", + } + "ALGR(RS_M)": { + "key": "RS_SECT", + "label": "§", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_slovak_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_slovak_0.0.1.hjson new file mode 100644 index 0000000000..14eb4b783a --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_slovak_0.0.1.hjson @@ -0,0 +1,443 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ; │ + │ ľ │ Å¡ │ Ä â”‚ Å¥ │ ž │ ý │ á │ à │ é │ = │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ ú │ ä │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ô │ § │ ň │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ & │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "SK_SCLN", + "label": ";", + } + "KC_1": { + "key": "SK_PLUS", + "label": "+", + } + "KC_2": { + "key": "SK_LCAR", + "label": "ľ", + } + "KC_3": { + "key": "SK_SCAR", + "label": "Å¡", + } + "KC_4": { + "key": "SK_CCAR", + "label": "Ä", + } + "KC_5": { + "key": "SK_TCAR", + "label": "Å¥", + } + "KC_6": { + "key": "SK_ZCAR", + "label": "ž", + } + "KC_7": { + "key": "SK_YACU", + "label": "ý", + } + "KC_8": { + "key": "SK_AACU", + "label": "á", + } + "KC_9": { + "key": "SK_IACU", + "label": "Ã", + } + "KC_0": { + "key": "SK_EACU", + "label": "é", + } + "KC_MINS": { + "key": "SK_EQL", + "label": "=", + } + "KC_EQL": { + "key": "SK_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "SK_Q", + "label": "Q", + } + "KC_W": { + "key": "SK_W", + "label": "W", + } + "KC_E": { + "key": "SK_E", + "label": "E", + } + "KC_R": { + "key": "SK_R", + "label": "R", + } + "KC_T": { + "key": "SK_T", + "label": "T", + } + "KC_Y": { + "key": "SK_Z", + "label": "Z", + } + "KC_U": { + "key": "SK_U", + "label": "U", + } + "KC_I": { + "key": "SK_I", + "label": "I", + } + "KC_O": { + "key": "SK_O", + "label": "O", + } + "KC_P": { + "key": "SK_P", + "label": "P", + } + "KC_LBRC": { + "key": "SK_UACU", + "label": "ú", + } + "KC_RBRC": { + "key": "SK_ADIA", + "label": "ä", + } + "KC_A": { + "key": "SK_A", + "label": "A", + } + "KC_S": { + "key": "SK_S", + "label": "S", + } + "KC_D": { + "key": "SK_D", + "label": "D", + } + "KC_F": { + "key": "SK_F", + "label": "F", + } + "KC_G": { + "key": "SK_G", + "label": "G", + } + "KC_H": { + "key": "SK_H", + "label": "H", + } + "KC_J": { + "key": "SK_J", + "label": "J", + } + "KC_K": { + "key": "SK_K", + "label": "K", + } + "KC_L": { + "key": "SK_L", + "label": "L", + } + "KC_SCLN": { + "key": "SK_OCIR", + "label": "ô", + } + "KC_QUOT": { + "key": "SK_SECT", + "label": "§", + } + "KC_NUHS": { + "key": "SK_NCAR", + "label": "ň", + } + "KC_NUBS": { + "key": "SK_AMPR", + "label": "&", + } + "KC_Z": { + "key": "SK_Y", + "label": "Y", + } + "KC_X": { + "key": "SK_X", + "label": "X", + } + "KC_C": { + "key": "SK_C", + "label": "C", + } + "KC_V": { + "key": "SK_V", + "label": "V", + } + "KC_B": { + "key": "SK_B", + "label": "B", + } + "KC_N": { + "key": "SK_N", + "label": "N", + } + "KC_M": { + "key": "SK_M", + "label": "M", + } + "KC_COMM": { + "key": "SK_COMM", + "label": ",", + } + "KC_DOT": { + "key": "SK_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "SK_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ° │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ % │ ˇ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ / │ ( │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ " │ ! │ ) │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ * │ │ │ │ │ │ │ │ ? │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(SK_SCLN)": { + "key": "SK_RNGA", + "label": "° (dead)", + } + "S(SK_PLUS)": { + "key": "SK_1", + "label": "1", + } + "S(SK_LCAR)": { + "key": "SK_2", + "label": "2", + } + "S(SK_SCAR)": { + "key": "SK_3", + "label": "3", + } + "S(SK_CCAR)": { + "key": "SK_4", + "label": "4", + } + "S(SK_TCAR)": { + "key": "SK_5", + "label": "5", + } + "S(SK_ZCAR)": { + "key": "SK_6", + "label": "6", + } + "S(SK_YACU)": { + "key": "SK_7", + "label": "7", + } + "S(SK_AACU)": { + "key": "SK_8", + "label": "8", + } + "S(SK_IACU)": { + "key": "SK_9", + "label": "9", + } + "S(SK_EACU)": { + "key": "SK_0", + "label": "0", + } + "S(SK_EQL)": { + "key": "SK_PERC", + "label": "%", + } + "S(SK_ACUT)": { + "key": "SK_CARN", + "label": "ˇ (dead)", + } + "S(SK_UACU)": { + "key": "SK_SLSH", + "label": "/", + } + "S(SK_ADIA)": { + "key": "SK_LPRN", + "label": "(", + } + "S(SK_OCIR)": { + "key": "SK_DQUO", + "label": "\"", + } + "S(SK_SECT)": { + "key": "SK_EXLM", + "label": "!", + } + "S(SK_NCAR)": { + "key": "SK_RPRN", + "label": ")", + } + "S(SK_AMPR)": { + "key": "SK_ASTR", + "label": "*", + } + "S(SK_COMM)": { + "key": "SK_QUES", + "label": "?", + } + "S(SK_DOT)": { + "key": "SK_COLN", + "label": ":", + } + "S(SK_MINS)": { + "key": "SK_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ~ │ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ │ Ë â”‚ ¨ │ ¸ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ \ │ | │ € │ │ │ │ │ │ │ ' │ ÷ │ × │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ Ä‘ │ Ä â”‚ [ │ ] │ │ │ Å‚ │ Š│ $ │ ß │ ¤ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ > │ # │ │ @ │ { │ } │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(SK_PLUS)": { + "key": "SK_TILD", + "label": "~", + } + "ALGR(SK_SCAR)": { + "key": "SK_CIRC", + "label": "^ (dead)", + } + "ALGR(SK_CCAR)": { + "key": "SK_BREV", + "label": "˘ (dead)", + } + "ALGR(SK_TCAR)": { + "key": "SK_OGON", + "label": "Ë› (dead)", + } + "ALGR(SK_ZCAR)": { + "key": "SK_GRV", + "label": "`", + } + "ALGR(SK_YACU)": { + "key": "SK_DOTA", + "label": "Ë™ (dead)", + } + "ALGR(SK_EACU)": { + "key": "SK_DACU", + "label": "Ë (dead)", + } + "ALGR(SK_EQL)": { + "key": "SK_DIAE", + "label": "¨ (dead)", + } + "ALGR(SK_ACUT)": { + "key": "SK_CEDL", + "label": "¸ (dead)", + } + "ALGR(SK_Q)": { + "key": "SK_BSLS", + "label": "\\", + } + "ALGR(SK_W)": { + "key": "SK_PIPE", + "label": "|", + } + "ALGR(SK_E)": { + "key": "SK_EURO", + "label": "€", + } + "ALGR(SK_P)": { + "key": "SK_QUOT", + "label": "'", + } + "ALGR(SK_UACU)": { + "key": "SK_DIV", + "label": "÷", + } + "ALGR(SK_ADIA)": { + "key": "SK_MUL", + "label": "×", + } + "ALGR(SK_S)": { + "key": "SK_LDST", + "label": "Ä‘", + } + "ALGR(SK_D)": { + "key": "SK_CDST", + "label": "Ä", + } + "ALGR(SK_F)": { + "key": "SK_LBRC", + "label": "[", + } + "ALGR(SK_G)": { + "key": "SK_RBRC", + "label": "]", + } + "ALGR(SK_K)": { + "key": "SK_LLST", + "label": "Å‚", + } + "ALGR(SK_L)": { + "key": "SK_CLST", + "label": "Å", + } + "ALGR(SK_OCIR)": { + "key": "SK_DLR", + "label": "$", + } + "ALGR(SK_SECT)": { + "key": "SK_SS", + "label": "ß", + } + "ALGR(SK_NCAR)": { + "key": "SK_CURR", + "label": "¤", + } + "ALGR(SK_AMPR)": { + "key": "SK_LABK", + "label": "<", + } + "ALGR(SK_Y)": { + "key": "SK_RABK", + "label": ">", + } + "ALGR(SK_X)": { + "key": "SK_HASH", + "label": "#", + } + "ALGR(SK_V)": { + "key": "SK_AT", + "label": "@", + } + "ALGR(SK_B)": { + "key": "SK_LCBR", + "label": "{", + } + "ALGR(SK_N)": { + "key": "SK_RCBR", + "label": "}", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_slovenian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_slovenian_0.0.1.hjson new file mode 100644 index 0000000000..fd1a4eb4fc --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_slovenian_0.0.1.hjson @@ -0,0 +1,403 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¸ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Š│ Ä â”‚ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ÄŒ │ Ć │ Ž │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "SI_CEDL", + "label": "¸ (dead)", + } + "KC_1": { + "key": "SI_1", + "label": "1", + } + "KC_2": { + "key": "SI_2", + "label": "2", + } + "KC_3": { + "key": "SI_3", + "label": "3", + } + "KC_4": { + "key": "SI_4", + "label": "4", + } + "KC_5": { + "key": "SI_5", + "label": "5", + } + "KC_6": { + "key": "SI_6", + "label": "6", + } + "KC_7": { + "key": "SI_7", + "label": "7", + } + "KC_8": { + "key": "SI_8", + "label": "8", + } + "KC_9": { + "key": "SI_9", + "label": "9", + } + "KC_0": { + "key": "SI_0", + "label": "0", + } + "KC_MINS": { + "key": "SI_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "SI_PLUS", + "label": "+", + } + "KC_Q": { + "key": "SI_Q", + "label": "Q", + } + "KC_W": { + "key": "SI_W", + "label": "W", + } + "KC_E": { + "key": "SI_E", + "label": "E", + } + "KC_R": { + "key": "SI_R", + "label": "R", + } + "KC_T": { + "key": "SI_T", + "label": "T", + } + "KC_Y": { + "key": "SI_Z", + "label": "Z", + } + "KC_U": { + "key": "SI_U", + "label": "U", + } + "KC_I": { + "key": "SI_I", + "label": "I", + } + "KC_O": { + "key": "SI_O", + "label": "O", + } + "KC_P": { + "key": "SI_P", + "label": "P", + } + "KC_LBRC": { + "key": "SI_SCAR", + "label": "Å ", + } + "KC_RBRC": { + "key": "SI_DSTR", + "label": "Ä", + } + "KC_A": { + "key": "SI_A", + "label": "A", + } + "KC_S": { + "key": "SI_S", + "label": "S", + } + "KC_D": { + "key": "SI_D", + "label": "D", + } + "KC_F": { + "key": "SI_F", + "label": "F", + } + "KC_G": { + "key": "SI_G", + "label": "G", + } + "KC_H": { + "key": "SI_H", + "label": "H", + } + "KC_J": { + "key": "SI_J", + "label": "J", + } + "KC_K": { + "key": "SI_K", + "label": "K", + } + "KC_L": { + "key": "SI_L", + "label": "L", + } + "KC_SCLN": { + "key": "SI_CCAR", + "label": "ÄŒ", + } + "KC_QUOT": { + "key": "SI_CACU", + "label": "Ć", + } + "KC_NUHS": { + "key": "SI_ZCAR", + "label": "Ž", + } + "KC_NUBS": { + "key": "SI_LABK", + "label": "<", + } + "KC_Z": { + "key": "SI_Y", + "label": "Y", + } + "KC_X": { + "key": "SI_X", + "label": "X", + } + "KC_C": { + "key": "SI_C", + "label": "C", + } + "KC_V": { + "key": "SI_V", + "label": "V", + } + "KC_B": { + "key": "SI_B", + "label": "B", + } + "KC_N": { + "key": "SI_N", + "label": "N", + } + "KC_M": { + "key": "SI_M", + "label": "M", + } + "KC_COMM": { + "key": "SI_COMM", + "label": ",", + } + "KC_DOT": { + "key": "SI_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "SI_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¨ │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ * │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(SI_CEDL)": { + "key": "SI_DIAE", + "label": "¨ (dead)", + } + "S(SI_1)": { + "key": "SI_EXLM", + "label": "!", + } + "S(SI_2)": { + "key": "SI_DQUO", + "label": "\"", + } + "S(SI_3)": { + "key": "SI_HASH", + "label": "#", + } + "S(SI_4)": { + "key": "SI_DLR", + "label": "$", + } + "S(SI_5)": { + "key": "SI_PERC", + "label": "%", + } + "S(SI_6)": { + "key": "SI_AMPR", + "label": "&", + } + "S(SI_7)": { + "key": "SI_SLSH", + "label": "/", + } + "S(SI_8)": { + "key": "SI_LPRN", + "label": "(", + } + "S(SI_9)": { + "key": "SI_RPRN", + "label": ")", + } + "S(SI_0)": { + "key": "SI_EQL", + "label": "=", + } + "S(SI_QUOT)": { + "key": "SI_QUES", + "label": "?", + } + "S(SI_PLUS)": { + "key": "SI_ASTR", + "label": "*", + } + "S(SI_LABK)": { + "key": "SI_RABK", + "label": ">", + } + "S(SI_COMM)": { + "key": "SI_SCLN", + "label": ";", + } + "S(SI_DOT)": { + "key": "SI_COLN", + "label": ":", + } + "S(SI_MINS)": { + "key": "SI_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ~ │ ˇ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ ´ │ Ë â”‚ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ \ │ | │ € │ │ │ │ │ │ │ │ ÷ │ × │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ [ │ ] │ │ │ Å‚ │ Š│ │ ß │ ¤ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ @ │ { │ } │ § │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(SI_1)": { + "key": "SI_TILD", + "label": "~", + } + "ALGR(SI_2)": { + "key": "SI_CARN", + "label": "ˇ (dead)", + } + "ALGR(SI_3)": { + "key": "SI_CIRC", + "label": "^ (dead)", + } + "ALGR(SI_4)": { + "key": "SI_BREV", + "label": "˘ (dead)", + } + "ALGR(SI_5)": { + "key": "SI_RNGA", + "label": "° (dead)", + } + "ALGR(SI_6)": { + "key": "SI_OGON", + "label": "Ë› (dead)", + } + "ALGR(SI_7)": { + "key": "SI_GRV", + "label": "`", + } + "ALGR(SI_8)": { + "key": "SI_DOTA", + "label": "Ë™ (dead)", + } + "ALGR(SI_9)": { + "key": "SI_ACUT", + "label": "´ (dead)", + } + "ALGR(SI_0)": { + "key": "SI_DACU", + "label": "Ë (dead)", + } + "ALGR(SI_Q)": { + "key": "SI_BSLS", + "label": "\\", + } + "ALGR(SI_W)": { + "key": "SI_PIPE", + "label": "|", + } + "ALGR(SI_E)": { + "key": "SI_EURO", + "label": "€", + } + "ALGR(SI_SCAR)": { + "key": "SI_DIV", + "label": "÷", + } + "ALGR(SI_DSTR)": { + "key": "SI_MUL", + "label": "×", + } + "ALGR(SI_F)": { + "key": "SI_LBRC", + "label": "[", + } + "ALGR(SI_G)": { + "key": "SI_RBRC", + "label": "]", + } + "ALGR(SI_K)": { + "key": "SI_LLST", + "label": "Å‚", + } + "ALGR(SI_L)": { + "key": "SI_CLST", + "label": "Å", + } + "ALGR(SI_CACU)": { + "key": "SI_SS", + "label": "ß", + } + "ALGR(SI_ZCAR)": { + "key": "SI_CURR", + "label": "¤", + } + "ALGR(SI_V)": { + "key": "SI_AT", + "label": "@", + } + "ALGR(SI_B)": { + "key": "SI_LCBR", + "label": "{", + } + "ALGR(SI_N)": { + "key": "SI_RCBR", + "label": "}", + } + "ALGR(SI_M)": { + "key": "SI_SECT", + "label": "§", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_spanish_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_spanish_0.0.1.hjson new file mode 100644 index 0000000000..db3b068e97 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_spanish_0.0.1.hjson @@ -0,0 +1,359 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ º │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ¡ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ ` │ + │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ñ │ ´ │ Ç │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "ES_MORD", + "label": "º", + } + "KC_1": { + "key": "ES_1", + "label": "1", + } + "KC_2": { + "key": "ES_2", + "label": "2", + } + "KC_3": { + "key": "ES_3", + "label": "3", + } + "KC_4": { + "key": "ES_4", + "label": "4", + } + "KC_5": { + "key": "ES_5", + "label": "5", + } + "KC_6": { + "key": "ES_6", + "label": "6", + } + "KC_7": { + "key": "ES_7", + "label": "7", + } + "KC_8": { + "key": "ES_8", + "label": "8", + } + "KC_9": { + "key": "ES_9", + "label": "9", + } + "KC_0": { + "key": "ES_0", + "label": "0", + } + "KC_MINS": { + "key": "ES_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "ES_IEXL", + "label": "¡", + } + "KC_Q": { + "key": "ES_Q", + "label": "Q", + } + "KC_W": { + "key": "ES_W", + "label": "W", + } + "KC_E": { + "key": "ES_E", + "label": "E", + } + "KC_R": { + "key": "ES_R", + "label": "R", + } + "KC_T": { + "key": "ES_T", + "label": "T", + } + "KC_Y": { + "key": "ES_Y", + "label": "Y", + } + "KC_U": { + "key": "ES_U", + "label": "U", + } + "KC_I": { + "key": "ES_I", + "label": "I", + } + "KC_O": { + "key": "ES_O", + "label": "O", + } + "KC_P": { + "key": "ES_P", + "label": "P", + } + "KC_LBRC": { + "key": "ES_GRV", + "label": "` (dead)", + } + "KC_RBRC": { + "key": "ES_PLUS", + "label": "+", + } + "KC_A": { + "key": "ES_A", + "label": "A", + } + "KC_S": { + "key": "ES_S", + "label": "S", + } + "KC_D": { + "key": "ES_D", + "label": "D", + } + "KC_F": { + "key": "ES_F", + "label": "F", + } + "KC_G": { + "key": "ES_G", + "label": "G", + } + "KC_H": { + "key": "ES_H", + "label": "H", + } + "KC_J": { + "key": "ES_J", + "label": "J", + } + "KC_K": { + "key": "ES_K", + "label": "K", + } + "KC_L": { + "key": "ES_L", + "label": "L", + } + "KC_SCLN": { + "key": "ES_NTIL", + "label": "Ñ", + } + "KC_QUOT": { + "key": "ES_ACUT", + "label": "´ (dead)", + } + "KC_NUHS": { + "key": "ES_CCED", + "label": "Ç", + } + "KC_NUBS": { + "key": "ES_LABK", + "label": "<", + } + "KC_Z": { + "key": "ES_Z", + "label": "Z", + } + "KC_X": { + "key": "ES_X", + "label": "X", + } + "KC_C": { + "key": "ES_C", + "label": "C", + } + "KC_V": { + "key": "ES_V", + "label": "V", + } + "KC_B": { + "key": "ES_B", + "label": "B", + } + "KC_N": { + "key": "ES_N", + "label": "N", + } + "KC_M": { + "key": "ES_M", + "label": "M", + } + "KC_COMM": { + "key": "ES_COMM", + "label": ",", + } + "KC_DOT": { + "key": "ES_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "ES_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ª │ ! │ " │ · │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ¿ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ ^ │ * │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ES_MORD)": { + "key": "ES_FORD", + "label": "ª", + } + "S(ES_1)": { + "key": "ES_EXLM", + "label": "!", + } + "S(ES_2)": { + "key": "ES_DQUO", + "label": "\"", + } + "S(ES_3)": { + "key": "ES_BULT", + "label": "·", + } + "S(ES_4)": { + "key": "ES_DLR", + "label": "$", + } + "S(ES_5)": { + "key": "ES_PERC", + "label": "%", + } + "S(ES_6)": { + "key": "ES_AMPR", + "label": "&", + } + "S(ES_7)": { + "key": "ES_SLSH", + "label": "/", + } + "S(ES_8)": { + "key": "ES_LPRN", + "label": "(", + } + "S(ES_9)": { + "key": "ES_RPRN", + "label": ")", + } + "S(ES_0)": { + "key": "ES_EQL", + "label": "=", + } + "S(ES_QUOT)": { + "key": "ES_QUES", + "label": "?", + } + "S(ES_IEXL)": { + "key": "ES_IQUE", + "label": "¿", + } + "S(ES_GRV)": { + "key": "ES_CIRC", + "label": "^ (dead)", + } + "S(ES_PLUS)": { + "key": "ES_ASTR", + "label": "*", + } + "S(ES_ACUT)": { + "key": "ES_DIAE", + "label": "¨ (dead)", + } + "S(ES_LABK)": { + "key": "ES_RABK", + "label": ">", + } + "S(KC_COMM)": { + "key": "ES_SCLN", + "label": ";", + } + "S(KC_DOT)": { + "key": "ES_COLN", + "label": ":", + } + "S(ES_MINS)": { + "key": "ES_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ \ │ | │ @ │ # │ ~ │ € │ ¬ │ │ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(ES_MORD)": { + "key": "ES_BSLS", + "label": "\\", + } + "ALGR(ES_1)": { + "key": "ES_PIPE", + "label": "|", + } + "ALGR(ES_2)": { + "key": "ES_AT", + "label": "@", + } + "ALGR(ES_3)": { + "key": "ES_HASH", + "label": "#", + } + "ALGR(ES_4)": { + "key": "ES_TILD", + "label": "~", + } + "ALGR(ES_5)": { + "key": "ES_EURO", + "label": "€", + } + "ALGR(ES_6)": { + "key": "ES_NOT", + "label": "¬", + } + "ALGR(ES_GRV)": { + "key": "ES_LBRC", + "label": "[", + } + "ALGR(ES_PLUS)": { + "key": "ES_RBRC", + "label": "]", + } + "ALGR(ES_ACUT)": { + "key": "ES_LCBR", + "label": "{", + } + "ALGR(ES_CCED)": { + "key": "ES_RCBR", + "label": "}", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_spanish_dvorak_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_spanish_dvorak_0.0.1.hjson new file mode 100644 index 0000000000..39119a6a91 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_spanish_dvorak_0.0.1.hjson @@ -0,0 +1,359 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ º │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ¡ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ . │ , │ Ñ │ P │ Y │ F │ G │ C │ H │ L │ ` │ + │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ O │ E │ U │ I │ D │ R │ T │ N │ S │ ´ │ Ç │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ - │ Q │ J │ K │ X │ B │ M │ W │ V │ Z │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "DV_MORD", + "label": "º", + } + "KC_1": { + "key": "DV_1", + "label": "1", + } + "KC_2": { + "key": "DV_2", + "label": "2", + } + "KC_3": { + "key": "DV_3", + "label": "3", + } + "KC_4": { + "key": "DV_4", + "label": "4", + } + "KC_5": { + "key": "DV_5", + "label": "5", + } + "KC_6": { + "key": "DV_6", + "label": "6", + } + "KC_7": { + "key": "DV_7", + "label": "7", + } + "KC_8": { + "key": "DV_8", + "label": "8", + } + "KC_9": { + "key": "DV_9", + "label": "9", + } + "KC_0": { + "key": "DV_0", + "label": "0", + } + "KC_MINS": { + "key": "DV_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "DV_IEXL", + "label": "¡", + } + "KC_Q": { + "key": "DV_DOT", + "label": ".", + } + "KC_W": { + "key": "DV_COMM", + "label": ",", + } + "KC_E": { + "key": "DV_NTIL", + "label": "Ñ", + } + "KC_R": { + "key": "DV_P", + "label": "P", + } + "KC_T": { + "key": "DV_Y", + "label": "Y", + } + "KC_Y": { + "key": "DV_F", + "label": "F", + } + "KC_U": { + "key": "DV_G", + "label": "G", + } + "KC_I": { + "key": "DV_C", + "label": "C", + } + "KC_O": { + "key": "DV_H", + "label": "H", + } + "KC_P": { + "key": "DV_L", + "label": "L", + } + "KC_LBRC": { + "key": "DV_GRV", + "label": "` (dead)", + } + "KC_RBRC": { + "key": "DV_PLUS", + "label": "+", + } + "KC_A": { + "key": "DV_A", + "label": "A", + } + "KC_S": { + "key": "DV_O", + "label": "O", + } + "KC_D": { + "key": "DV_E", + "label": "E", + } + "KC_F": { + "key": "DV_U", + "label": "U", + } + "KC_G": { + "key": "DV_I", + "label": "I", + } + "KC_H": { + "key": "DV_D", + "label": "D", + } + "KC_J": { + "key": "DV_R", + "label": "R", + } + "KC_K": { + "key": "DV_T", + "label": "T", + } + "KC_L": { + "key": "DV_N", + "label": "N", + } + "KC_SCLN": { + "key": "DV_S", + "label": "S", + } + "KC_QUOT": { + "key": "DV_ACUT", + "label": "´ (dead)", + } + "KC_NUHS": { + "key": "DV_CCED", + "label": "Ç", + } + "KC_NUBS": { + "key": "DV_LABK", + "label": "<", + } + "KC_Z": { + "key": "DV_MINS", + "label": "-", + } + "KC_X": { + "key": "DV_Q", + "label": "Q", + } + "KC_C": { + "key": "DV_J", + "label": "J", + } + "KC_V": { + "key": "DV_K", + "label": "K", + } + "KC_B": { + "key": "DV_X", + "label": "X", + } + "KC_N": { + "key": "DV_B", + "label": "B", + } + "KC_M": { + "key": "DV_M", + "label": "M", + } + "KC_COMM": { + "key": "DV_W", + "label": "W", + } + "KC_DOT": { + "key": "DV_V", + "label": "V", + } + "KC_SLSH": { + "key": "DV_Z", + "label": "Z", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ª │ ! │ " │ · │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ¿ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ : │ ; │ │ │ │ │ │ │ │ │ ^ │ * │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ _ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(DV_MORD)": { + "key": "DV_FORD", + "label": "ª", + } + "S(DV_1)": { + "key": "DV_EXLM", + "label": "!", + } + "S(DV_2)": { + "key": "DV_DQUO", + "label": "\"", + } + "S(DV_3)": { + "key": "DV_BULT", + "label": "·", + } + "S(DV_4)": { + "key": "DV_DLR", + "label": "$", + } + "S(DV_5)": { + "key": "DV_PERC", + "label": "%", + } + "S(DV_6)": { + "key": "DV_AMPR", + "label": "&", + } + "S(DV_7)": { + "key": "DV_SLSH", + "label": "/", + } + "S(DV_8)": { + "key": "DV_LPRN", + "label": "(", + } + "S(DV_9)": { + "key": "DV_RPRN", + "label": ")", + } + "S(DV_0)": { + "key": "DV_EQL", + "label": "=", + } + "S(DV_QUOT)": { + "key": "DV_QUES", + "label": "?", + } + "S(DV_IEXL)": { + "key": "DV_IQUE", + "label": "¿", + } + "S(DV_DOT)": { + "key": "DV_COLN", + "label": ":", + } + "S(DV_COMM)": { + "key": "DV_SCLN", + "label": ";", + } + "S(DV_GRV)": { + "key": "DV_CIRC", + "label": "^ (dead)", + } + "S(DV_PLUS)": { + "key": "DV_ASTR", + "label": "*", + } + "S(DV_ACUT)": { + "key": "DV_DIAE", + "label": "¨ (dead)", + } + "S(DV_LABK)": { + "key": "DV_RABK", + "label": ">", + } + "S(DV_MINS)": { + "key": "DV_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ \ │ | │ @ │ # │ ~ │ € │ ¬ │ │ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(DV_MORD)": { + "key": "DV_BSLS", + "label": "\\", + } + "ALGR(DV_1)": { + "key": "DV_PIPE", + "label": "|", + } + "ALGR(DV_2)": { + "key": "DV_AT", + "label": "@", + } + "ALGR(DV_3)": { + "key": "DV_HASH", + "label": "#", + } + "ALGR(DV_4)": { + "key": "DV_TILD", + "label": "~", + } + "ALGR(DV_5)": { + "key": "DV_EURO", + "label": "€", + } + "ALGR(DV_6)": { + "key": "DV_NOT", + "label": "¬", + } + "ALGR(DV_GRV)": { + "key": "DV_LBRC", + "label": "[", + } + "ALGR(DV_PLUS)": { + "key": "DV_RBRC", + "label": "]", + } + "ALGR(DV_ACUT)": { + "key": "DV_LCBR", + "label": "{", + } + "ALGR(DV_CCED)": { + "key": "DV_RCBR", + "label": "}", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_swedish_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_swedish_0.0.1.hjson new file mode 100644 index 0000000000..6db71ea241 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_swedish_0.0.1.hjson @@ -0,0 +1,359 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Å │ ¨ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ ' │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "SE_SECT", + "label": "§", + } + "KC_1": { + "key": "SE_1", + "label": "1", + } + "KC_2": { + "key": "SE_2", + "label": "2", + } + "KC_3": { + "key": "SE_3", + "label": "3", + } + "KC_4": { + "key": "SE_4", + "label": "4", + } + "KC_5": { + "key": "SE_5", + "label": "5", + } + "KC_6": { + "key": "SE_6", + "label": "6", + } + "KC_7": { + "key": "SE_7", + "label": "7", + } + "KC_8": { + "key": "SE_8", + "label": "8", + } + "KC_9": { + "key": "SE_9", + "label": "9", + } + "KC_0": { + "key": "SE_0", + "label": "0", + } + "KC_MINS": { + "key": "SE_PLUS", + "label": "+", + } + "KC_EQL": { + "key": "SE_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "SE_Q", + "label": "Q", + } + "KC_W": { + "key": "SE_W", + "label": "W", + } + "KC_E": { + "key": "SE_E", + "label": "E", + } + "KC_R": { + "key": "SE_R", + "label": "R", + } + "KC_T": { + "key": "SE_T", + "label": "T", + } + "KC_Y": { + "key": "SE_Y", + "label": "Y", + } + "KC_U": { + "key": "SE_U", + "label": "U", + } + "KC_I": { + "key": "SE_I", + "label": "I", + } + "KC_O": { + "key": "SE_O", + "label": "O", + } + "KC_P": { + "key": "SE_P", + "label": "P", + } + "KC_LBRC": { + "key": "SE_ARNG", + "label": "Å", + } + "KC_RBRC": { + "key": "SE_DIAE", + "label": "¨ (dead)", + } + "KC_A": { + "key": "SE_A", + "label": "A", + } + "KC_S": { + "key": "SE_S", + "label": "S", + } + "KC_D": { + "key": "SE_D", + "label": "D", + } + "KC_F": { + "key": "SE_F", + "label": "F", + } + "KC_G": { + "key": "SE_G", + "label": "G", + } + "KC_H": { + "key": "SE_H", + "label": "H", + } + "KC_J": { + "key": "SE_J", + "label": "J", + } + "KC_K": { + "key": "SE_K", + "label": "K", + } + "KC_L": { + "key": "SE_L", + "label": "L", + } + "KC_SCLN": { + "key": "SE_ODIA", + "label": "Ö", + } + "KC_QUOT": { + "key": "SE_ADIA", + "label": "Ä", + } + "KC_NUHS": { + "key": "SE_QUOT", + "label": "'", + } + "KC_NUBS": { + "key": "SE_LABK", + "label": "<", + } + "KC_Z": { + "key": "SE_Z", + "label": "Z", + } + "KC_X": { + "key": "SE_X", + "label": "X", + } + "KC_C": { + "key": "SE_C", + "label": "C", + } + "KC_V": { + "key": "SE_V", + "label": "V", + } + "KC_B": { + "key": "SE_B", + "label": "B", + } + "KC_N": { + "key": "SE_N", + "label": "N", + } + "KC_M": { + "key": "SE_M", + "label": "M", + } + "KC_COMM": { + "key": "SE_COMM", + "label": ",", + } + "KC_DOT": { + "key": "SE_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "SE_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ½ │ ! │ " │ # │ ¤ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(SE_SECT)": { + "key": "SE_HALF", + "label": "½", + } + "S(SE_1)": { + "key": "SE_EXLM", + "label": "!", + } + "S(SE_2)": { + "key": "SE_DQUO", + "label": "\"", + } + "S(SE_3)": { + "key": "SE_HASH", + "label": "#", + } + "S(SE_4)": { + "key": "SE_CURR", + "label": "¤", + } + "S(SE_5)": { + "key": "SE_PERC", + "label": "%", + } + "S(SE_6)": { + "key": "SE_AMPR", + "label": "&", + } + "S(SE_7)": { + "key": "SE_SLSH", + "label": "/", + } + "S(SE_8)": { + "key": "SE_LPRN", + "label": "(", + } + "S(SE_9)": { + "key": "SE_RPRN", + "label": ")", + } + "S(SE_0)": { + "key": "SE_EQL", + "label": "=", + } + "S(SE_PLUS)": { + "key": "SE_QUES", + "label": "?", + } + "S(SE_ACUT)": { + "key": "SE_GRV", + "label": "` (dead)", + } + "S(SE_DIAE)": { + "key": "SE_CIRC", + "label": "^ (dead)", + } + "S(SE_QUOT)": { + "key": "SE_ASTR", + "label": "*", + } + "S(SE_LABK)": { + "key": "SE_RABK", + "label": ">", + } + "S(SE_COMM)": { + "key": "SE_SCLN", + "label": ";", + } + "S(SE_DOT)": { + "key": "SE_COLN", + "label": ":", + } + "S(SE_MINS)": { + "key": "SE_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ @ │ £ │ $ │ € │ │ { │ [ │ ] │ } │ \ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ | │ │ │ │ │ │ │ µ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(SE_2)": { + "key": "SE_AT", + "label": "@", + } + "ALGR(SE_3)": { + "key": "SE_PND", + "label": "£", + } + "ALGR(SE_4)": { + "key": "SE_DLR", + "label": "$", + } + "ALGR(SE_5)": { + "key": "SE_EURO", + "label": "€", + } + "ALGR(SE_7)": { + "key": "SE_LCBR", + "label": "{", + } + "ALGR(SE_8)": { + "key": "SE_LBRC", + "label": "[", + } + "ALGR(SE_9)": { + "key": "SE_RBRC", + "label": "]", + } + "ALGR(SE_0)": { + "key": "SE_RCBR", + "label": "}", + } + "ALGR(SE_PLUS)": { + "key": "SE_BSLS", + "label": "\\", + } + "ALGR(SE_DIAE)": { + "key": "SE_TILD", + "label": "~ (dead)", + } + "ALGR(SE_LABK)": { + "key": "SE_PIPE", + "label": "|", + } + "ALGR(SE_M)": { + "key": "SE_MICR", + "label": "µ", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_swedish_mac_ansi_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_swedish_mac_ansi_0.0.1.hjson new file mode 100644 index 0000000000..ab7c3ad8d1 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_swedish_mac_ansi_0.0.1.hjson @@ -0,0 +1,642 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ < │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ ' │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "KC_GRV": { + "key": "SE_LABK", + "label": "<", + } + "KC_1": { + "key": "SE_1", + "label": "1", + } + "KC_2": { + "key": "SE_2", + "label": "2", + } + "KC_3": { + "key": "SE_3", + "label": "3", + } + "KC_4": { + "key": "SE_4", + "label": "4", + } + "KC_5": { + "key": "SE_5", + "label": "5", + } + "KC_6": { + "key": "SE_6", + "label": "6", + } + "KC_7": { + "key": "SE_7", + "label": "7", + } + "KC_8": { + "key": "SE_8", + "label": "8", + } + "KC_9": { + "key": "SE_9", + "label": "9", + } + "KC_0": { + "key": "SE_0", + "label": "0", + } + "KC_MINS": { + "key": "SE_PLUS", + "label": "+", + } + "KC_EQL": { + "key": "SE_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "SE_Q", + "label": "Q", + } + "KC_W": { + "key": "SE_W", + "label": "W", + } + "KC_E": { + "key": "SE_E", + "label": "E", + } + "KC_R": { + "key": "SE_R", + "label": "R", + } + "KC_T": { + "key": "SE_T", + "label": "T", + } + "KC_Y": { + "key": "SE_Y", + "label": "Y", + } + "KC_U": { + "key": "SE_U", + "label": "U", + } + "KC_I": { + "key": "SE_I", + "label": "I", + } + "KC_O": { + "key": "SE_O", + "label": "O", + } + "KC_P": { + "key": "SE_P", + "label": "P", + } + "KC_LBRC": { + "key": "SE_ARNG", + "label": "Ã…", + } + "KC_RBRC": { + "key": "SE_DIAE", + "label": "¨ (dead)", + } + "KC_NUHS": { + "key": "SE_QUOT", + "label": "'", + } + "KC_A": { + "key": "SE_A", + "label": "A", + } + "KC_S": { + "key": "SE_S", + "label": "S", + } + "KC_D": { + "key": "SE_D", + "label": "D", + } + "KC_F": { + "key": "SE_F", + "label": "F", + } + "KC_G": { + "key": "SE_G", + "label": "G", + } + "KC_H": { + "key": "SE_H", + "label": "H", + } + "KC_J": { + "key": "SE_J", + "label": "J", + } + "KC_K": { + "key": "SE_K", + "label": "K", + } + "KC_L": { + "key": "SE_L", + "label": "L", + } + "KC_SCLN": { + "key": "SE_ODIA", + "label": "Ö", + } + "KC_QUOT": { + "key": "SE_ADIA", + "label": "Ä", + } + "KC_Z": { + "key": "SE_Z", + "label": "Z", + } + "KC_X": { + "key": "SE_X", + "label": "X", + } + "KC_C": { + "key": "SE_C", + "label": "C", + } + "KC_V": { + "key": "SE_V", + "label": "V", + } + "KC_B": { + "key": "SE_B", + "label": "B", + } + "KC_N": { + "key": "SE_N", + "label": "N", + } + "KC_M": { + "key": "SE_M", + "label": "M", + } + "KC_COMM": { + "key": "SE_COMM", + "label": ",", + } + "KC_DOT": { + "key": "SE_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "SE_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ > │ ! │ " │ # │ € │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ * │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(SE_LABK)": { + "key": "SE_RABK", + "label": ">", + } + "S(SE_1)": { + "key": "SE_EXLM", + "label": "!", + } + "S(SE_2)": { + "key": "SE_DQUO", + "label": "\"", + } + "S(SE_3)": { + "key": "SE_HASH", + "label": "#", + } + "S(SE_4)": { + "key": "SE_EURO", + "label": "€", + } + "S(SE_5)": { + "key": "SE_PERC", + "label": "%", + } + "S(SE_6)": { + "key": "SE_AMPR", + "label": "&", + } + "S(SE_7)": { + "key": "SE_SLSH", + "label": "/", + } + "S(SE_8)": { + "key": "SE_LPRN", + "label": "(", + } + "S(SE_9)": { + "key": "SE_RPRN", + "label": ")", + } + "S(SE_0)": { + "key": "SE_EQL", + "label": "=", + } + "S(SE_PLUS)": { + "key": "SE_QUES", + "label": "?", + } + "S(SE_ACUT)": { + "key": "SE_GRV", + "label": "`", + } + "S(SE_DIAE)": { + "key": "SE_CIRC", + "label": "^ (dead)", + } + "S(SE_QUOT)": { + "key": "SE_ASTR", + "label": "*", + } + "S(SE_COMM)": { + "key": "SE_SCLN", + "label": ";", + } + "S(SE_DOT)": { + "key": "SE_COLN", + "label": ":", + } + "S(SE_MINS)": { + "key": "SE_UNDS", + "label": "_", + } +/* Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ≤ │ © │ â„¢ │ £ │ $ │ ∞ │ § │ | │ [ │ ] │ ≈ │ ± │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ • │ Ω │ É │ ® │ †│ µ │ Ãœ │ ı │ Å’ │ Ï€ │ Ë™ │ ~ │ @ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │  │ ß │ ∂ │ Æ’ │ ¸ │ Ë› │ √ │ ª │ ï¬ â”‚ Ø │ Æ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ ÷ │ │ Ç │ ‹ │ › │ ‘ │ ’ │ ‚ │ … │ – │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + * + */ + "A(SE_LABK)": { + "key": "SE_LTEQ", + "label": "≤", + } + "A(SE_1)": { + "key": "SE_COPY", + "label": "©", + } + "A(SE_2)": { + "key": "SE_TM", + "label": "â„¢", + } + "A(SE_3)": { + "key": "SE_PND", + "label": "£", + } + "A(SE_4)": { + "key": "SE_DLR", + "label": "$", + } + "A(SE_5)": { + "key": "SE_INFN", + "label": "∞", + } + "A(SE_6)": { + "key": "SE_SECT", + "label": "§", + } + "A(SE_7)": { + "key": "SE_PIPE", + "label": "|", + } + "A(SE_8)": { + "key": "SE_LBRC", + "label": "[", + } + "A(SE_9)": { + "key": "SE_RBRC", + "label": "]", + } + "A(SE_0)": { + "key": "SE_AEQL", + "label": "≈", + } + "A(SE_PLUS)": { + "key": "SE_PLMN", + "label": "±", + } + "A(SE_Q)": { + "key": "SE_BULT", + "label": "•", + } + "A(SE_W)": { + "key": "SE_OMEG", + "label": "Ω", + } + "A(SE_E)": { + "key": "SE_EACU", + "label": "É", + } + "A(SE_R)": { + "key": "SE_REGD", + "label": "®", + } + "A(SE_T)": { + "key": "SE_DAGG", + "label": "†", + } + "A(SE_Y)": { + "key": "SE_MICR", + "label": "µ", + } + "A(SE_U)": { + "key": "SE_UDIA", + "label": "Ãœ", + } + "A(SE_I)": { + "key": "SE_DLSI", + "label": "ı", + } + "A(SE_O)": { + "key": "SE_OE", + "label": "Å’", + } + "A(SE_P)": { + "key": "SE_PI", + "label": "Ï€", + } + "A(SE_ARNG)": { + "key": "SE_DOTA", + "label": "Ë™", + } + "A(SE_DIAE)": { + "key": "SE_TILD", + "label": "~ (dead)", + } + "A(SE_QUOT)": { + "key": "SE_AT", + "label": "@", + } + "A(SE_A)": { + "key": "SE_APPL", + "label": " (Apple logo)", + } + "A(SE_S)": { + "key": "SE_SS", + "label": "ß", + } + "A(SE_D)": { + "key": "SE_PDIF", + "label": "∂", + } + "A(SE_F)": { + "key": "SE_FHK", + "label": "Æ’", + } + "A(SE_G)": { + "key": "SE_CEDL", + "label": "¸", + } + "A(SE_H)": { + "key": "SE_OGON", + "label": "Ë›", + } + "A(SE_J)": { + "key": "SE_SQRT", + "label": "√", + } + "A(SE_K)": { + "key": "SE_FORD", + "label": "ª", + } + "A(SE_L)": { + "key": "SE_FI", + "label": "ï¬", + } + "A(SE_ODIA)": { + "key": "SE_OSTR", + "label": "Ø", + } + "A(SE_ADIA)": { + "key": "SE_AE", + "label": "Æ", + } + "A(SE_Z)": { + "key": "SE_DIV", + "label": "÷", + } + "A(SE_C)": { + "key": "SE_CCED", + "label": "Ç", + } + "A(SE_V)": { + "key": "SE_LSAQ", + "label": "‹", + } + "A(SE_B)": { + "key": "SE_RSAQ", + "label": "›", + } + "A(SE_N)": { + "key": "SE_LSQU", + "label": "‘", + } + "A(SE_M)": { + "key": "SE_RSQU", + "label": "’", + } + "A(SE_COMM)": { + "key": "SE_SLQU", + "label": "‚", + } + "A(SE_DOT)": { + "key": "SE_ELLP", + "label": "…", + } + "A(SE_MINS)": { + "key": "SE_NDSH", + "label": "–", + } +/* Shift+Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ≥ │ ¡ │ │ Â¥ │ ¢ │ ‰ │ ¶ │ \ │ { │ } │ ≠│ ¿ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ ° │ Ë â”‚ │ │ ‡ │ Ëœ │ │ ˆ │ │ ∠│ Ëš │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │ â—Š │ ∑ │ ∆ │ ∫ │ ¯ │ ˘ │ ¬ │ º │ fl │ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ ℠│ ˇ │ │ « │ » │ “ │ †│ „ │ · │ — │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + * + */ + "S(A(SE_LABK))": { + "key": "SE_GTEQ", + "label": "≥", + } + "S(A(SE_1))": { + "key": "SE_IEXL", + "label": "¡", + } + "S(A(SE_3))": { + "key": "SE_YEN", + "label": "Â¥", + } + "S(A(SE_4))": { + "key": "SE_CENT", + "label": "¢", + } + "S(A(SE_5))": { + "key": "SE_PERM", + "label": "‰", + } + "S(A(SE_6))": { + "key": "SE_PILC", + "label": "¶", + } + "S(A(SE_7))": { + "key": "SE_BSLS", + "label": "\\", + } + "S(A(SE_8))": { + "key": "SE_LCBR", + "label": "{", + } + "S(A(SE_9))": { + "key": "SE_RCBR", + "label": "}", + } + "S(A(SE_0))": { + "key": "SE_NEQL", + "label": "≠", + } + "S(A(SE_PLUS))": { + "key": "SE_IQUE", + "label": "¿", + } + "S(A(SE_Q))": { + "key": "SE_DEG", + "label": "°", + } + "S(A(SE_W))": { + "key": "SE_DACU", + "label": "Ë", + } + "S(A(SE_T))": { + "key": "SE_DDAG", + "label": "‡", + } + "S(A(SE_Y))": { + "key": "SE_STIL", + "label": "Ëœ", + } + "S(A(SE_I))": { + "key": "SE_DCIR", + "label": "ˆ", + } + "S(A(SE_P))": { + "key": "SE_NARP", + "label": "âˆ", + } + "S(A(SE_ARNG))": { + "key": "SE_RNGA", + "label": "Ëš", + } + "S(A(SE_A))": { + "key": "SE_LOZN", + "label": "â—Š", + } + "S(A(SE_S))": { + "key": "SE_NARS", + "label": "∑", + } + "S(A(SE_D))": { + "key": "SE_INCR", + "label": "∆", + } + "S(A(SE_F))": { + "key": "SE_INTG", + "label": "∫", + } + "S(A(SE_G))": { + "key": "SE_MACR", + "label": "¯", + } + "S(A(SE_H))": { + "key": "SE_BREV", + "label": "˘", + } + "S(A(SE_J))": { + "key": "SE_NOT", + "label": "¬", + } + "S(A(SE_K))": { + "key": "SE_MORD", + "label": "º", + } + "S(A(SE_L))": { + "key": "SE_FL", + "label": "fl", + } + "S(A(SE_Z))": { + "key": "SE_FRSL", + "label": "â„", + } + "S(A(SE_X))": { + "key": "SE_CARN", + "label": "ˇ", + } + "S(A(SE_V))": { + "key": "SE_LDAQ", + "label": "«", + } + "S(A(SE_B))": { + "key": "SE_RDAQ", + "label": "»", + } + "S(A(SE_N))": { + "key": "SE_LDQU", + "label": "“", + } + "S(A(SE_M))": { + "key": "SE_RDQU", + "label": "â€", + } + "S(A(SE_COMM))": { + "key": "SE_DLQU", + "label": "„", + } + "S(A(SE_DOT))": { + "key": "SE_MDDT", + "label": "·", + } + "S(A(SE_MINS))": { + "key": "SE_MDSH", + "label": "—", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_swedish_mac_iso_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_swedish_mac_iso_0.0.1.hjson new file mode 100644 index 0000000000..cafd815776 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_swedish_mac_iso_0.0.1.hjson @@ -0,0 +1,640 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ ' │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "KC_GRV": { + "key": "SE_SECT", + "label": "§", + } + "KC_1": { + "key": "SE_1", + "label": "1", + } + "KC_2": { + "key": "SE_2", + "label": "2", + } + "KC_3": { + "key": "SE_3", + "label": "3", + } + "KC_4": { + "key": "SE_4", + "label": "4", + } + "KC_5": { + "key": "SE_5", + "label": "5", + } + "KC_6": { + "key": "SE_6", + "label": "6", + } + "KC_7": { + "key": "SE_7", + "label": "7", + } + "KC_8": { + "key": "SE_8", + "label": "8", + } + "KC_9": { + "key": "SE_9", + "label": "9", + } + "KC_0": { + "key": "SE_0", + "label": "0", + } + "KC_MINS": { + "key": "SE_PLUS", + "label": "+", + } + "KC_EQL": { + "key": "SE_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "SE_Q", + "label": "Q", + } + "KC_W": { + "key": "SE_W", + "label": "W", + } + "KC_E": { + "key": "SE_E", + "label": "E", + } + "KC_R": { + "key": "SE_R", + "label": "R", + } + "KC_T": { + "key": "SE_T", + "label": "T", + } + "KC_Y": { + "key": "SE_Y", + "label": "Y", + } + "KC_U": { + "key": "SE_U", + "label": "U", + } + "KC_I": { + "key": "SE_I", + "label": "I", + } + "KC_O": { + "key": "SE_O", + "label": "O", + } + "KC_P": { + "key": "SE_P", + "label": "P", + } + "KC_LBRC": { + "key": "SE_ARNG", + "label": "Ã…", + } + "KC_RBRC": { + "key": "SE_DIAE", + "label": "¨ (dead)", + } + "KC_A": { + "key": "SE_A", + "label": "A", + } + "KC_S": { + "key": "SE_S", + "label": "S", + } + "KC_D": { + "key": "SE_D", + "label": "D", + } + "KC_F": { + "key": "SE_F", + "label": "F", + } + "KC_G": { + "key": "SE_G", + "label": "G", + } + "KC_H": { + "key": "SE_H", + "label": "H", + } + "KC_J": { + "key": "SE_J", + "label": "J", + } + "KC_K": { + "key": "SE_K", + "label": "K", + } + "KC_L": { + "key": "SE_L", + "label": "L", + } + "KC_SCLN": { + "key": "SE_ODIA", + "label": "Ö", + } + "KC_QUOT": { + "key": "SE_ADIA", + "label": "Ä", + } + "KC_NUHS": { + "key": "SE_QUOT", + "label": "'", + } + "KC_NUBS": { + "key": "SE_LABK", + "label": "<", + } + "KC_Z": { + "key": "SE_Z", + "label": "Z", + } + "KC_X": { + "key": "SE_X", + "label": "X", + } + "KC_C": { + "key": "SE_C", + "label": "C", + } + "KC_V": { + "key": "SE_V", + "label": "V", + } + "KC_B": { + "key": "SE_B", + "label": "B", + } + "KC_N": { + "key": "SE_N", + "label": "N", + } + "KC_M": { + "key": "SE_M", + "label": "M", + } + "KC_COMM": { + "key": "SE_COMM", + "label": ",", + } + "KC_DOT": { + "key": "SE_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "SE_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ° │ ! │ " │ # │ € │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(SE_SECT)": { + "key": "SE_DEG", + "label": "°", + } + "S(SE_1)": { + "key": "SE_EXLM", + "label": "!", + } + "S(SE_2)": { + "key": "SE_DQUO", + "label": "\"", + } + "S(SE_3)": { + "key": "SE_HASH", + "label": "#", + } + "S(SE_4)": { + "key": "SE_EURO", + "label": "€", + } + "S(SE_5)": { + "key": "SE_PERC", + "label": "%", + } + "S(SE_6)": { + "key": "SE_AMPR", + "label": "&", + } + "S(SE_7)": { + "key": "SE_SLSH", + "label": "/", + } + "S(SE_8)": { + "key": "SE_LPRN", + "label": "(", + } + "S(SE_9)": { + "key": "SE_RPRN", + "label": ")", + } + "S(SE_0)": { + "key": "SE_EQL", + "label": "=", + } + "S(SE_PLUS)": { + "key": "SE_QUES", + "label": "?", + } + "S(SE_ACUT)": { + "key": "SE_GRV", + "label": "`", + } + "S(SE_DIAE)": { + "key": "SE_CIRC", + "label": "^ (dead)", + } + "S(SE_QUOT)": { + "key": "SE_ASTR", + "label": "*", + } + "S(SE_LABK)": { + "key": "SE_RABK", + "label": ">", + } + "S(SE_COMM)": { + "key": "SE_SCLN", + "label": ";", + } + "S(SE_DOT)": { + "key": "SE_COLN", + "label": ":", + } + "S(SE_MINS)": { + "key": "SE_UNDS", + "label": "_", + } +/* Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ¶ │ © │ â„¢ │ £ │ $ │ ∞ │ │ | │ [ │ ] │ ≈ │ ± │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ • │ Ω │ É │ ® │ †│ µ │ Ãœ │ ı │ Å’ │ Ï€ │ Ë™ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │  │ ß │ ∂ │ Æ’ │ ¸ │ Ë› │ √ │ ª │ ï¬ â”‚ Ø │ Æ │ @ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≤ │ ÷ │ │ Ç │ ‹ │ › │ ‘ │ ’ │ ‚ │ … │ – │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "A(SE_SECT)": { + "key": "SE_PILC", + "label": "¶", + } + "A(SE_1)": { + "key": "SE_COPY", + "label": "©", + } + "A(SE_2)": { + "key": "SE_TM", + "label": "â„¢", + } + "A(SE_3)": { + "key": "SE_PND", + "label": "£", + } + "A(SE_4)": { + "key": "SE_DLR", + "label": "$", + } + "A(SE_5)": { + "key": "SE_INFN", + "label": "∞", + } + "A(SE_7)": { + "key": "SE_PIPE", + "label": "|", + } + "A(SE_8)": { + "key": "SE_LBRC", + "label": "[", + } + "A(SE_9)": { + "key": "SE_RBRC", + "label": "]", + } + "A(SE_0)": { + "key": "SE_AEQL", + "label": "≈", + } + "A(SE_PLUS)": { + "key": "SE_PLMN", + "label": "±", + } + "A(SE_Q)": { + "key": "SE_BULT", + "label": "•", + } + "A(SE_W)": { + "key": "SE_OMEG", + "label": "Ω", + } + "A(SE_E)": { + "key": "SE_EACU", + "label": "É", + } + "A(SE_R)": { + "key": "SE_REGD", + "label": "®", + } + "A(SE_T)": { + "key": "SE_DAGG", + "label": "†", + } + "A(SE_Y)": { + "key": "SE_MICR", + "label": "µ", + } + "A(SE_U)": { + "key": "SE_UDIA", + "label": "Ãœ", + } + "A(SE_I)": { + "key": "SE_DLSI", + "label": "ı", + } + "A(SE_O)": { + "key": "SE_OE", + "label": "Å’", + } + "A(SE_P)": { + "key": "SE_PI", + "label": "Ï€", + } + "A(SE_ARNG)": { + "key": "SE_DOTA", + "label": "Ë™", + } + "A(SE_DIAE)": { + "key": "SE_TILD", + "label": "~ (dead)", + } + "A(SE_A)": { + "key": "SE_APPL", + "label": " (Apple logo)", + } + "A(SE_S)": { + "key": "SE_SS", + "label": "ß", + } + "A(SE_D)": { + "key": "SE_PDIF", + "label": "∂", + } + "A(SE_F)": { + "key": "SE_FHK", + "label": "Æ’", + } + "A(SE_G)": { + "key": "SE_CEDL", + "label": "¸", + } + "A(SE_H)": { + "key": "SE_OGON", + "label": "Ë›", + } + "A(SE_J)": { + "key": "SE_SQRT", + "label": "√", + } + "A(SE_K)": { + "key": "SE_FORD", + "label": "ª", + } + "A(SE_L)": { + "key": "SE_FI", + "label": "ï¬", + } + "A(SE_ODIA)": { + "key": "SE_OSTR", + "label": "Ø", + } + "A(SE_ADIA)": { + "key": "SE_AE", + "label": "Æ", + } + "A(SE_QUOT)": { + "key": "SE_AT", + "label": "@", + } + "A(SE_LABK)": { + "key": "SE_LTEQ", + "label": "≤", + } + "A(SE_Z)": { + "key": "SE_DIV", + "label": "÷", + } + "A(SE_C)": { + "key": "SE_CCED", + "label": "Ç", + } + "A(SE_V)": { + "key": "SE_LSAQ", + "label": "‹", + } + "A(SE_B)": { + "key": "SE_RSAQ", + "label": "›", + } + "A(SE_N)": { + "key": "SE_LSQU", + "label": "‘", + } + "A(SE_M)": { + "key": "SE_RSQU", + "label": "’", + } + "A(SE_COMM)": { + "key": "SE_SLQU", + "label": "‚", + } + "A(SE_DOT)": { + "key": "SE_ELLP", + "label": "…", + } + "A(SE_MINS)": { + "key": "SE_NDSH", + "label": "–", + } +/* Shift+Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ │ ¡ │ †│ Â¥ │ ¢ │ ‰ │ │ \ │ { │ } │ ≠│ ¿ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ Ë â”‚ │ │ ‡ │ Ëœ │ │ ˆ │ │ ∠│ Ëš │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ â—Š │ ∑ │ ∆ │ ∫ │ ¯ │ ˘ │ ¬ │ º │ fl │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≥ │ ℠│ ˇ │ │ « │ » │ “ │ †│ „ │ · │ — │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(A(SE_1))": { + "key": "SE_IEXL", + "label": "¡", + } + "S(A(SE_3))": { + "key": "SE_YEN", + "label": "Â¥", + } + "S(A(SE_4))": { + "key": "SE_CENT", + "label": "¢", + } + "S(A(SE_5))": { + "key": "SE_PERM", + "label": "‰", + } + "S(A(SE_7))": { + "key": "SE_BSLS", + "label": "\\", + } + "S(A(SE_8))": { + "key": "SE_LCBR", + "label": "{", + } + "S(A(SE_9))": { + "key": "SE_RCBR", + "label": "}", + } + "S(A(SE_0))": { + "key": "SE_NEQL", + "label": "≠", + } + "S(A(SE_PLUS))": { + "key": "SE_IQUE", + "label": "¿", + } + "S(A(SE_W))": { + "key": "SE_DACU", + "label": "Ë", + } + "S(A(SE_T))": { + "key": "SE_DDAG", + "label": "‡", + } + "S(A(SE_Y))": { + "key": "SE_STIL", + "label": "Ëœ", + } + "S(A(SE_I))": { + "key": "SE_DCIR", + "label": "ˆ", + } + "S(A(SE_P))": { + "key": "SE_NARP", + "label": "âˆ", + } + "S(A(SE_ARNG))": { + "key": "SE_RNGA", + "label": "Ëš", + } + "S(A(SE_A))": { + "key": "SE_LOZN", + "label": "â—Š", + } + "S(A(SE_S))": { + "key": "SE_NARS", + "label": "∑", + } + "S(A(SE_D))": { + "key": "SE_INCR", + "label": "∆", + } + "S(A(SE_F))": { + "key": "SE_INTG", + "label": "∫", + } + "S(A(SE_G))": { + "key": "SE_MACR", + "label": "¯", + } + "S(A(SE_H))": { + "key": "SE_BREV", + "label": "˘", + } + "S(A(SE_J))": { + "key": "SE_NOT", + "label": "¬", + } + "S(A(SE_K))": { + "key": "SE_MORD", + "label": "º", + } + "S(A(SE_L))": { + "key": "SE_FL", + "label": "fl", + } + "S(A(SE_LABK))": { + "key": "SE_GTEQ", + "label": "≥", + } + "S(A(SE_Z))": { + "key": "SE_FRSL", + "label": "â„", + } + "S(A(SE_X))": { + "key": "SE_CARN", + "label": "ˇ", + } + "S(A(SE_V))": { + "key": "SE_LDAQ", + "label": "«", + } + "S(A(SE_B))": { + "key": "SE_RDAQ", + "label": "»", + } + "S(A(SE_N))": { + "key": "SE_LDQU", + "label": "“", + } + "S(A(SE_M))": { + "key": "SE_RDQU", + "label": "â€", + } + "S(A(SE_COMM))": { + "key": "SE_DLQU", + "label": "„", + } + "S(A(SE_DOT))": { + "key": "SE_MDDT", + "label": "·", + } + "S(A(SE_MINS))": { + "key": "SE_MDSH", + "label": "—", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_swedish_pro_mac_ansi_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_swedish_pro_mac_ansi_0.0.1.hjson new file mode 100644 index 0000000000..c82c79c711 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_swedish_pro_mac_ansi_0.0.1.hjson @@ -0,0 +1,642 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ < │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ ' │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "KC_GRV": { + "key": "SE_LABK", + "label": "<", + } + "KC_1": { + "key": "SE_1", + "label": "1", + } + "KC_2": { + "key": "SE_2", + "label": "2", + } + "KC_3": { + "key": "SE_3", + "label": "3", + } + "KC_4": { + "key": "SE_4", + "label": "4", + } + "KC_5": { + "key": "SE_5", + "label": "5", + } + "KC_6": { + "key": "SE_6", + "label": "6", + } + "KC_7": { + "key": "SE_7", + "label": "7", + } + "KC_8": { + "key": "SE_8", + "label": "8", + } + "KC_9": { + "key": "SE_9", + "label": "9", + } + "KC_0": { + "key": "SE_0", + "label": "0", + } + "KC_MINS": { + "key": "SE_PLUS", + "label": "+", + } + "KC_EQL": { + "key": "SE_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "SE_Q", + "label": "Q", + } + "KC_W": { + "key": "SE_W", + "label": "W", + } + "KC_E": { + "key": "SE_E", + "label": "E", + } + "KC_R": { + "key": "SE_R", + "label": "R", + } + "KC_T": { + "key": "SE_T", + "label": "T", + } + "KC_Y": { + "key": "SE_Y", + "label": "Y", + } + "KC_U": { + "key": "SE_U", + "label": "U", + } + "KC_I": { + "key": "SE_I", + "label": "I", + } + "KC_O": { + "key": "SE_O", + "label": "O", + } + "KC_P": { + "key": "SE_P", + "label": "P", + } + "KC_LBRC": { + "key": "SE_ARNG", + "label": "Ã…", + } + "KC_RBRC": { + "key": "SE_DIAE", + "label": "¨ (dead)", + } + "KC_NUHS": { + "key": "SE_QUOT", + "label": "'", + } + "KC_A": { + "key": "SE_A", + "label": "A", + } + "KC_S": { + "key": "SE_S", + "label": "S", + } + "KC_D": { + "key": "SE_D", + "label": "D", + } + "KC_F": { + "key": "SE_F", + "label": "F", + } + "KC_G": { + "key": "SE_G", + "label": "G", + } + "KC_H": { + "key": "SE_H", + "label": "H", + } + "KC_J": { + "key": "SE_J", + "label": "J", + } + "KC_K": { + "key": "SE_K", + "label": "K", + } + "KC_L": { + "key": "SE_L", + "label": "L", + } + "KC_SCLN": { + "key": "SE_ODIA", + "label": "Ö", + } + "KC_QUOT": { + "key": "SE_ADIA", + "label": "Ä", + } + "KC_Z": { + "key": "SE_Z", + "label": "Z", + } + "KC_X": { + "key": "SE_X", + "label": "X", + } + "KC_C": { + "key": "SE_C", + "label": "C", + } + "KC_V": { + "key": "SE_V", + "label": "V", + } + "KC_B": { + "key": "SE_B", + "label": "B", + } + "KC_N": { + "key": "SE_N", + "label": "N", + } + "KC_M": { + "key": "SE_M", + "label": "M", + } + "KC_COMM": { + "key": "SE_COMM", + "label": ",", + } + "KC_DOT": { + "key": "SE_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "SE_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ > │ ! │ " │ # │ € │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ * │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(SE_LABK)": { + "key": "SE_RABK", + "label": ">", + } + "S(SE_1)": { + "key": "SE_EXLM", + "label": "!", + } + "S(SE_2)": { + "key": "SE_DQUO", + "label": "\"", + } + "S(SE_3)": { + "key": "SE_HASH", + "label": "#", + } + "S(SE_4)": { + "key": "SE_EURO", + "label": "€", + } + "S(SE_5)": { + "key": "SE_PERC", + "label": "%", + } + "S(SE_6)": { + "key": "SE_AMPR", + "label": "&", + } + "S(SE_7)": { + "key": "SE_SLSH", + "label": "/", + } + "S(SE_8)": { + "key": "SE_LPRN", + "label": "(", + } + "S(SE_9)": { + "key": "SE_RPRN", + "label": ")", + } + "S(SE_0)": { + "key": "SE_EQL", + "label": "=", + } + "S(SE_PLUS)": { + "key": "SE_QUES", + "label": "?", + } + "S(SE_ACUT)": { + "key": "SE_GRV", + "label": "`", + } + "S(SE_DIAE)": { + "key": "SE_CIRC", + "label": "^ (dead)", + } + "S(SE_QUOT)": { + "key": "SE_ASTR", + "label": "*", + } + "S(SE_COMM)": { + "key": "SE_SCLN", + "label": ";", + } + "S(SE_DOT)": { + "key": "SE_COLN", + "label": ":", + } + "S(SE_MINS)": { + "key": "SE_UNDS", + "label": "_", + } +/* Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ≤ │ © │ @ │ £ │ $ │ ∞ │ § │ | │ [ │ ] │ ≈ │ ± │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ • │ Ω │ É │ ® │ †│ µ │ Ãœ │ ı │ Å’ │ Ï€ │ Ë™ │ ~ │ â„¢ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │  │ ß │ ∂ │ Æ’ │ ¸ │ Ë› │ √ │ ª │ ï¬ â”‚ Ø │ Æ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ ÷ │ │ Ç │ ‹ │ › │ ‘ │ ’ │ ‚ │ … │ – │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + * + */ + "A(SE_LABK)": { + "key": "SE_LTEQ", + "label": "≤", + } + "A(SE_1)": { + "key": "SE_COPY", + "label": "©", + } + "A(SE_2)": { + "key": "SE_AT", + "label": "@", + } + "A(SE_3)": { + "key": "SE_PND", + "label": "£", + } + "A(SE_4)": { + "key": "SE_DLR", + "label": "$", + } + "A(SE_5)": { + "key": "SE_INFN", + "label": "∞", + } + "A(SE_6)": { + "key": "SE_SECT", + "label": "§", + } + "A(SE_7)": { + "key": "SE_PIPE", + "label": "|", + } + "A(SE_8)": { + "key": "SE_LBRC", + "label": "[", + } + "A(SE_9)": { + "key": "SE_RBRC", + "label": "]", + } + "A(SE_0)": { + "key": "SE_AEQL", + "label": "≈", + } + "A(SE_PLUS)": { + "key": "SE_PLMN", + "label": "±", + } + "A(SE_Q)": { + "key": "SE_BULT", + "label": "•", + } + "A(SE_W)": { + "key": "SE_OMEG", + "label": "Ω", + } + "A(SE_E)": { + "key": "SE_EACU", + "label": "É", + } + "A(SE_R)": { + "key": "SE_REGD", + "label": "®", + } + "A(SE_T)": { + "key": "SE_DAGG", + "label": "†", + } + "A(SE_Y)": { + "key": "SE_MICR", + "label": "µ", + } + "A(SE_U)": { + "key": "SE_UDIA", + "label": "Ãœ", + } + "A(SE_I)": { + "key": "SE_DLSI", + "label": "ı", + } + "A(SE_O)": { + "key": "SE_OE", + "label": "Å’", + } + "A(SE_P)": { + "key": "SE_PI", + "label": "Ï€", + } + "A(SE_ARNG)": { + "key": "SE_DOTA", + "label": "Ë™", + } + "A(SE_DIAE)": { + "key": "SE_TILD", + "label": "~ (dead)", + } + "A(SE_QUOT)": { + "key": "SE_TM", + "label": "â„¢", + } + "A(SE_A)": { + "key": "SE_APPL", + "label": " (Apple logo)", + } + "A(SE_S)": { + "key": "SE_SS", + "label": "ß", + } + "A(SE_D)": { + "key": "SE_PDIF", + "label": "∂", + } + "A(SE_F)": { + "key": "SE_FHK", + "label": "Æ’", + } + "A(SE_G)": { + "key": "SE_CEDL", + "label": "¸", + } + "A(SE_H)": { + "key": "SE_OGON", + "label": "Ë›", + } + "A(SE_J)": { + "key": "SE_SQRT", + "label": "√", + } + "A(SE_K)": { + "key": "SE_FORD", + "label": "ª", + } + "A(SE_L)": { + "key": "SE_FI", + "label": "ï¬", + } + "A(SE_ODIA)": { + "key": "SE_OSTR", + "label": "Ø", + } + "A(SE_ADIA)": { + "key": "SE_AE", + "label": "Æ", + } + "A(SE_Z)": { + "key": "SE_DIV", + "label": "÷", + } + "A(SE_C)": { + "key": "SE_CCED", + "label": "Ç", + } + "A(SE_V)": { + "key": "SE_LSAQ", + "label": "‹", + } + "A(SE_B)": { + "key": "SE_RSAQ", + "label": "›", + } + "A(SE_N)": { + "key": "SE_LSQU", + "label": "‘", + } + "A(SE_M)": { + "key": "SE_RSQU", + "label": "’", + } + "A(SE_COMM)": { + "key": "SE_SLQU", + "label": "‚", + } + "A(SE_DOT)": { + "key": "SE_ELLP", + "label": "…", + } + "A(SE_MINS)": { + "key": "SE_NDSH", + "label": "–", + } +/* Shift+Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ≥ │ ¡ │ │ Â¥ │ ¢ │ ‰ │ ¶ │ \ │ { │ } │ ≠│ ¿ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ ° │ Ë â”‚ │ │ ‡ │ Ëœ │ │ ˆ │ │ ∠│ Ëš │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ + * │ │ â—Š │ ∑ │ ∆ │ ∫ │ ¯ │ ˘ │ ¬ │ º │ fl │ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ + * │ │ ℠│ ˇ │ │ « │ » │ “ │ †│ „ │ · │ — │ │ + * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + * + */ + "S(A(SE_LABK))": { + "key": "SE_GTEQ", + "label": "≥", + } + "S(A(SE_1))": { + "key": "SE_IEXL", + "label": "¡", + } + "S(A(SE_3))": { + "key": "SE_YEN", + "label": "Â¥", + } + "S(A(SE_4))": { + "key": "SE_CENT", + "label": "¢", + } + "S(A(SE_5))": { + "key": "SE_PERM", + "label": "‰", + } + "S(A(SE_6))": { + "key": "SE_PILC", + "label": "¶", + } + "S(A(SE_7))": { + "key": "SE_BSLS", + "label": "\\", + } + "S(A(SE_8))": { + "key": "SE_LCBR", + "label": "{", + } + "S(A(SE_9))": { + "key": "SE_RCBR", + "label": "}", + } + "S(A(SE_0))": { + "key": "SE_NEQL", + "label": "≠", + } + "S(A(SE_PLUS))": { + "key": "SE_IQUE", + "label": "¿", + } + "S(A(SE_Q))": { + "key": "SE_DEG", + "label": "°", + } + "S(A(SE_W))": { + "key": "SE_DACU", + "label": "Ë", + } + "S(A(SE_T))": { + "key": "SE_DDAG", + "label": "‡", + } + "S(A(SE_Y))": { + "key": "SE_STIL", + "label": "Ëœ", + } + "S(A(SE_I))": { + "key": "SE_DCIR", + "label": "ˆ", + } + "S(A(SE_P))": { + "key": "SE_NARP", + "label": "âˆ", + } + "S(A(SE_ARNG))": { + "key": "SE_RNGA", + "label": "Ëš", + } + "S(A(SE_A))": { + "key": "SE_LOZN", + "label": "â—Š", + } + "S(A(SE_S))": { + "key": "SE_NARS", + "label": "∑", + } + "S(A(SE_D))": { + "key": "SE_INCR", + "label": "∆", + } + "S(A(SE_F))": { + "key": "SE_INTG", + "label": "∫", + } + "S(A(SE_G))": { + "key": "SE_MACR", + "label": "¯", + } + "S(A(SE_H))": { + "key": "SE_BREV", + "label": "˘", + } + "S(A(SE_J))": { + "key": "SE_NOT", + "label": "¬", + } + "S(A(SE_K))": { + "key": "SE_MORD", + "label": "º", + } + "S(A(SE_L))": { + "key": "SE_FL", + "label": "fl", + } + "S(A(SE_Z))": { + "key": "SE_FRSL", + "label": "â„", + } + "S(A(SE_X))": { + "key": "SE_CARN", + "label": "ˇ", + } + "S(A(SE_V))": { + "key": "SE_LDAQ", + "label": "«", + } + "S(A(SE_B))": { + "key": "SE_RDAQ", + "label": "»", + } + "S(A(SE_N))": { + "key": "SE_LDQU", + "label": "“", + } + "S(A(SE_M))": { + "key": "SE_RDQU", + "label": "â€", + } + "S(A(SE_COMM))": { + "key": "SE_DLQU", + "label": "„", + } + "S(A(SE_DOT))": { + "key": "SE_MDDT", + "label": "·", + } + "S(A(SE_MINS))": { + "key": "SE_MDSH", + "label": "—", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_swedish_pro_mac_iso_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_swedish_pro_mac_iso_0.0.1.hjson new file mode 100644 index 0000000000..4555739ccd --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_swedish_pro_mac_iso_0.0.1.hjson @@ -0,0 +1,640 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ ' │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "KC_GRV": { + "key": "SE_SECT", + "label": "§", + } + "KC_1": { + "key": "SE_1", + "label": "1", + } + "KC_2": { + "key": "SE_2", + "label": "2", + } + "KC_3": { + "key": "SE_3", + "label": "3", + } + "KC_4": { + "key": "SE_4", + "label": "4", + } + "KC_5": { + "key": "SE_5", + "label": "5", + } + "KC_6": { + "key": "SE_6", + "label": "6", + } + "KC_7": { + "key": "SE_7", + "label": "7", + } + "KC_8": { + "key": "SE_8", + "label": "8", + } + "KC_9": { + "key": "SE_9", + "label": "9", + } + "KC_0": { + "key": "SE_0", + "label": "0", + } + "KC_MINS": { + "key": "SE_PLUS", + "label": "+", + } + "KC_EQL": { + "key": "SE_ACUT", + "label": "´ (dead)", + } + "KC_Q": { + "key": "SE_Q", + "label": "Q", + } + "KC_W": { + "key": "SE_W", + "label": "W", + } + "KC_E": { + "key": "SE_E", + "label": "E", + } + "KC_R": { + "key": "SE_R", + "label": "R", + } + "KC_T": { + "key": "SE_T", + "label": "T", + } + "KC_Y": { + "key": "SE_Y", + "label": "Y", + } + "KC_U": { + "key": "SE_U", + "label": "U", + } + "KC_I": { + "key": "SE_I", + "label": "I", + } + "KC_O": { + "key": "SE_O", + "label": "O", + } + "KC_P": { + "key": "SE_P", + "label": "P", + } + "KC_LBRC": { + "key": "SE_ARNG", + "label": "Ã…", + } + "KC_RBRC": { + "key": "SE_DIAE", + "label": "¨ (dead)", + } + "KC_A": { + "key": "SE_A", + "label": "A", + } + "KC_S": { + "key": "SE_S", + "label": "S", + } + "KC_D": { + "key": "SE_D", + "label": "D", + } + "KC_F": { + "key": "SE_F", + "label": "F", + } + "KC_G": { + "key": "SE_G", + "label": "G", + } + "KC_H": { + "key": "SE_H", + "label": "H", + } + "KC_J": { + "key": "SE_J", + "label": "J", + } + "KC_K": { + "key": "SE_K", + "label": "K", + } + "KC_L": { + "key": "SE_L", + "label": "L", + } + "KC_SCLN": { + "key": "SE_ODIA", + "label": "Ö", + } + "KC_QUOT": { + "key": "SE_ADIA", + "label": "Ä", + } + "KC_NUHS": { + "key": "SE_QUOT", + "label": "'", + } + "KC_NUBS": { + "key": "SE_LABK", + "label": "<", + } + "KC_Z": { + "key": "SE_Z", + "label": "Z", + } + "KC_X": { + "key": "SE_X", + "label": "X", + } + "KC_C": { + "key": "SE_C", + "label": "C", + } + "KC_V": { + "key": "SE_V", + "label": "V", + } + "KC_B": { + "key": "SE_B", + "label": "B", + } + "KC_N": { + "key": "SE_N", + "label": "N", + } + "KC_M": { + "key": "SE_M", + "label": "M", + } + "KC_COMM": { + "key": "SE_COMM", + "label": ",", + } + "KC_DOT": { + "key": "SE_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "SE_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ° │ ! │ " │ # │ € │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(SE_SECT)": { + "key": "SE_DEG", + "label": "°", + } + "S(SE_1)": { + "key": "SE_EXLM", + "label": "!", + } + "S(SE_2)": { + "key": "SE_DQUO", + "label": "\"", + } + "S(SE_3)": { + "key": "SE_HASH", + "label": "#", + } + "S(SE_4)": { + "key": "SE_EURO", + "label": "€", + } + "S(SE_5)": { + "key": "SE_PERC", + "label": "%", + } + "S(SE_6)": { + "key": "SE_AMPR", + "label": "&", + } + "S(SE_7)": { + "key": "SE_SLSH", + "label": "/", + } + "S(SE_8)": { + "key": "SE_LPRN", + "label": "(", + } + "S(SE_9)": { + "key": "SE_RPRN", + "label": ")", + } + "S(SE_0)": { + "key": "SE_EQL", + "label": "=", + } + "S(SE_PLUS)": { + "key": "SE_QUES", + "label": "?", + } + "S(SE_ACUT)": { + "key": "SE_GRV", + "label": "`", + } + "S(SE_DIAE)": { + "key": "SE_CIRC", + "label": "^ (dead)", + } + "S(SE_QUOT)": { + "key": "SE_ASTR", + "label": "*", + } + "S(SE_LABK)": { + "key": "SE_RABK", + "label": ">", + } + "S(SE_COMM)": { + "key": "SE_SCLN", + "label": ";", + } + "S(SE_DOT)": { + "key": "SE_COLN", + "label": ":", + } + "S(SE_MINS)": { + "key": "SE_UNDS", + "label": "_", + } +/* Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ ¶ │ © │ @ │ £ │ $ │ ∞ │ │ | │ [ │ ] │ ≈ │ ± │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ • │ Ω │ É │ ® │ †│ µ │ Ãœ │ ı │ Å’ │ Ï€ │ Ë™ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │  │ ß │ ∂ │ Æ’ │ ¸ │ Ë› │ √ │ ª │ ï¬ â”‚ Ø │ Æ │ â„¢ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≤ │ ÷ │ │ Ç │ ‹ │ › │ ‘ │ ’ │ ‚ │ … │ – │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "A(SE_SECT)": { + "key": "SE_PILC", + "label": "¶", + } + "A(SE_1)": { + "key": "SE_COPY", + "label": "©", + } + "A(SE_2)": { + "key": "SE_AT", + "label": "@", + } + "A(SE_3)": { + "key": "SE_PND", + "label": "£", + } + "A(SE_4)": { + "key": "SE_DLR", + "label": "$", + } + "A(SE_5)": { + "key": "SE_INFN", + "label": "∞", + } + "A(SE_7)": { + "key": "SE_PIPE", + "label": "|", + } + "A(SE_8)": { + "key": "SE_LBRC", + "label": "[", + } + "A(SE_9)": { + "key": "SE_RBRC", + "label": "]", + } + "A(SE_0)": { + "key": "SE_AEQL", + "label": "≈", + } + "A(SE_PLUS)": { + "key": "SE_PLMN", + "label": "±", + } + "A(SE_Q)": { + "key": "SE_BULT", + "label": "•", + } + "A(SE_W)": { + "key": "SE_OMEG", + "label": "Ω", + } + "A(SE_E)": { + "key": "SE_EACU", + "label": "É", + } + "A(SE_R)": { + "key": "SE_REGD", + "label": "®", + } + "A(SE_T)": { + "key": "SE_DAGG", + "label": "†", + } + "A(SE_Y)": { + "key": "SE_MICR", + "label": "µ", + } + "A(SE_U)": { + "key": "SE_UDIA", + "label": "Ãœ", + } + "A(SE_I)": { + "key": "SE_DLSI", + "label": "ı", + } + "A(SE_O)": { + "key": "SE_OE", + "label": "Å’", + } + "A(SE_P)": { + "key": "SE_PI", + "label": "Ï€", + } + "A(SE_ARNG)": { + "key": "SE_DOTA", + "label": "Ë™", + } + "A(SE_DIAE)": { + "key": "SE_TILD", + "label": "~ (dead)", + } + "A(SE_A)": { + "key": "SE_APPL", + "label": " (Apple logo)", + } + "A(SE_S)": { + "key": "SE_SS", + "label": "ß", + } + "A(SE_D)": { + "key": "SE_PDIF", + "label": "∂", + } + "A(SE_F)": { + "key": "SE_FHK", + "label": "Æ’", + } + "A(SE_G)": { + "key": "SE_CEDL", + "label": "¸", + } + "A(SE_H)": { + "key": "SE_OGON", + "label": "Ë›", + } + "A(SE_J)": { + "key": "SE_SQRT", + "label": "√", + } + "A(SE_K)": { + "key": "SE_FORD", + "label": "ª", + } + "A(SE_L)": { + "key": "SE_FI", + "label": "ï¬", + } + "A(SE_ODIA)": { + "key": "SE_OSTR", + "label": "Ø", + } + "A(SE_ADIA)": { + "key": "SE_AE", + "label": "Æ", + } + "A(SE_QUOT)": { + "key": "SE_TM", + "label": "â„¢", + } + "A(SE_LABK)": { + "key": "SE_LTEQ", + "label": "≤", + } + "A(SE_Z)": { + "key": "SE_DIV", + "label": "÷", + } + "A(SE_C)": { + "key": "SE_CCED", + "label": "Ç", + } + "A(SE_V)": { + "key": "SE_LSAQ", + "label": "‹", + } + "A(SE_B)": { + "key": "SE_RSAQ", + "label": "›", + } + "A(SE_N)": { + "key": "SE_LSQU", + "label": "‘", + } + "A(SE_M)": { + "key": "SE_RSQU", + "label": "’", + } + "A(SE_COMM)": { + "key": "SE_SLQU", + "label": "‚", + } + "A(SE_DOT)": { + "key": "SE_ELLP", + "label": "…", + } + "A(SE_MINS)": { + "key": "SE_NDSH", + "label": "–", + } +/* Shift+Alted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠+ * │ │ ¡ │ †│ Â¥ │ ¢ │ ‰ │ │ \ │ { │ } │ ≠│ ¿ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ + * │ │ │ Ë â”‚ │ │ ‡ │ Ëœ │ │ ˆ │ │ ∠│ Ëš │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ â—Š │ ∑ │ ∆ │ ∫ │ ¯ │ ˘ │ ¬ │ º │ fl │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ + * │ │ ≥ │ ℠│ ˇ │ │ « │ » │ “ │ †│ „ │ · │ — │ │ + * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ + * │ │ │ │ │ │ │ │ + * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ + */ + "S(A(SE_1))": { + "key": "SE_IEXL", + "label": "¡", + } + "S(A(SE_3))": { + "key": "SE_YEN", + "label": "Â¥", + } + "S(A(SE_4))": { + "key": "SE_CENT", + "label": "¢", + } + "S(A(SE_5))": { + "key": "SE_PERM", + "label": "‰", + } + "S(A(SE_7))": { + "key": "SE_BSLS", + "label": "\\", + } + "S(A(SE_8))": { + "key": "SE_LCBR", + "label": "{", + } + "S(A(SE_9))": { + "key": "SE_RCBR", + "label": "}", + } + "S(A(SE_0))": { + "key": "SE_NEQL", + "label": "≠", + } + "S(A(SE_PLUS))": { + "key": "SE_IQUE", + "label": "¿", + } + "S(A(SE_W))": { + "key": "SE_DACU", + "label": "Ë", + } + "S(A(SE_T))": { + "key": "SE_DDAG", + "label": "‡", + } + "S(A(SE_Y))": { + "key": "SE_STIL", + "label": "Ëœ", + } + "S(A(SE_I))": { + "key": "SE_DCIR", + "label": "ˆ", + } + "S(A(SE_P))": { + "key": "SE_NARP", + "label": "âˆ", + } + "S(A(SE_ARNG))": { + "key": "SE_RNGA", + "label": "Ëš", + } + "S(A(SE_A))": { + "key": "SE_LOZN", + "label": "â—Š", + } + "S(A(SE_S))": { + "key": "SE_NARS", + "label": "∑", + } + "S(A(SE_D))": { + "key": "SE_INCR", + "label": "∆", + } + "S(A(SE_F))": { + "key": "SE_INTG", + "label": "∫", + } + "S(A(SE_G))": { + "key": "SE_MACR", + "label": "¯", + } + "S(A(SE_H))": { + "key": "SE_BREV", + "label": "˘", + } + "S(A(SE_J))": { + "key": "SE_NOT", + "label": "¬", + } + "S(A(SE_K))": { + "key": "SE_MORD", + "label": "º", + } + "S(A(SE_L))": { + "key": "SE_FL", + "label": "fl", + } + "S(A(SE_LABK))": { + "key": "SE_GTEQ", + "label": "≥", + } + "S(A(SE_Z))": { + "key": "SE_FRSL", + "label": "â„", + } + "S(A(SE_X))": { + "key": "SE_CARN", + "label": "ˇ", + } + "S(A(SE_V))": { + "key": "SE_LDAQ", + "label": "«", + } + "S(A(SE_B))": { + "key": "SE_RDAQ", + "label": "»", + } + "S(A(SE_N))": { + "key": "SE_LDQU", + "label": "“", + } + "S(A(SE_M))": { + "key": "SE_RDQU", + "label": "â€", + } + "S(A(SE_COMM))": { + "key": "SE_DLQU", + "label": "„", + } + "S(A(SE_DOT))": { + "key": "SE_MDDT", + "label": "·", + } + "S(A(SE_MINS))": { + "key": "SE_MDSH", + "label": "—", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_swiss_de_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_swiss_de_0.0.1.hjson new file mode 100644 index 0000000000..ae260a5e56 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_swiss_de_0.0.1.hjson @@ -0,0 +1,379 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ^ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ ü │ ¨ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ö │ ä │ $ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "CH_SECT", + "label": "§", + } + "KC_1": { + "key": "CH_1", + "label": "1", + } + "KC_2": { + "key": "CH_2", + "label": "2", + } + "KC_3": { + "key": "CH_3", + "label": "3", + } + "KC_4": { + "key": "CH_4", + "label": "4", + } + "KC_5": { + "key": "CH_5", + "label": "5", + } + "KC_6": { + "key": "CH_6", + "label": "6", + } + "KC_7": { + "key": "CH_7", + "label": "7", + } + "KC_8": { + "key": "CH_8", + "label": "8", + } + "KC_9": { + "key": "CH_9", + "label": "9", + } + "KC_0": { + "key": "CH_0", + "label": "0", + } + "KC_MINS": { + "key": "CH_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "CH_CIRC", + "label": "^ (dead)", + } + "KC_Q": { + "key": "CH_Q", + "label": "Q", + } + "KC_W": { + "key": "CH_W", + "label": "W", + } + "KC_E": { + "key": "CH_E", + "label": "E", + } + "KC_R": { + "key": "CH_R", + "label": "R", + } + "KC_T": { + "key": "CH_T", + "label": "T", + } + "KC_Y": { + "key": "CH_Z", + "label": "Z", + } + "KC_U": { + "key": "CH_U", + "label": "U", + } + "KC_I": { + "key": "CH_I", + "label": "I", + } + "KC_O": { + "key": "CH_O", + "label": "O", + } + "KC_P": { + "key": "CH_P", + "label": "P", + } + "KC_LBRC": { + "key": "CH_UDIA", + "label": "ü", + } + "KC_RBRC": { + "key": "CH_DIAE", + "label": "¨ (dead)", + } + "KC_A": { + "key": "CH_A", + "label": "A", + } + "KC_S": { + "key": "CH_S", + "label": "S", + } + "KC_D": { + "key": "CH_D", + "label": "D", + } + "KC_F": { + "key": "CH_F", + "label": "F", + } + "KC_G": { + "key": "CH_G", + "label": "G", + } + "KC_H": { + "key": "CH_H", + "label": "H", + } + "KC_J": { + "key": "CH_J", + "label": "J", + } + "KC_K": { + "key": "CH_K", + "label": "K", + } + "KC_L": { + "key": "CH_L", + "label": "L", + } + "KC_SCLN": { + "key": "CH_ODIA", + "label": "ö", + } + "KC_QUOT": { + "key": "CH_ADIA", + "label": "ä", + } + "KC_NUHS": { + "key": "CH_DLR", + "label": "$", + } + "KC_NUBS": { + "key": "CH_LABK", + "label": "<", + } + "KC_Z": { + "key": "CH_Y", + "label": "Y", + } + "KC_X": { + "key": "CH_X", + "label": "X", + } + "KC_C": { + "key": "CH_C", + "label": "C", + } + "KC_V": { + "key": "CH_V", + "label": "V", + } + "KC_B": { + "key": "CH_B", + "label": "B", + } + "KC_N": { + "key": "CH_N", + "label": "N", + } + "KC_M": { + "key": "CH_M", + "label": "M", + } + "KC_COMM": { + "key": "CH_COMM", + "label": ",", + } + "KC_DOT": { + "key": "CH_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "CH_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ° │ + │ " │ * │ ç │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ è │ ! │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ é │ à │ £ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(CH_SECT)": { + "key": "CH_DEG", + "label": "°", + } + "S(CH_1)": { + "key": "CH_PLUS", + "label": "+", + } + "S(CH_2)": { + "key": "CH_DQUO", + "label": "\"", + } + "S(CH_3)": { + "key": "CH_ASTR", + "label": "*", + } + "S(CH_4)": { + "key": "CH_CCED", + "label": "ç", + } + "S(CH_5)": { + "key": "CH_PERC", + "label": "%", + } + "S(CH_6)": { + "key": "CH_AMPR", + "label": "&", + } + "S(CH_7)": { + "key": "CH_SLSH", + "label": "/", + } + "S(CH_8)": { + "key": "CH_LPRN", + "label": "(", + } + "S(CH_9)": { + "key": "CH_RPRN", + "label": ")", + } + "S(CH_0)": { + "key": "CH_EQL", + "label": "=", + } + "S(CH_QUOT)": { + "key": "CH_QUES", + "label": "?", + } + "S(CH_CIRC)": { + "key": "CH_GRV", + "label": "` (dead)", + } + "S(CH_UDIA)": { + "key": "CH_EGRV", + "label": "è", + } + "S(CH_DIAE)": { + "key": "CH_EXLM", + "label": "!", + } + "S(CH_ODIA)": { + "key": "CH_EACU", + "label": "é", + } + "S(CH_ADIA)": { + "key": "CH_AGRV", + "label": "à ", + } + "S(CH_DLR)": { + "key": "CH_PND", + "label": "£", + } + "S(CH_LABK)": { + "key": "CH_RABK", + "label": ">", + } + "S(CH_COMM)": { + "key": "CH_SCLN", + "label": ";", + } + "S(CH_DOT)": { + "key": "CH_COLN", + "label": ":", + } + "S(CH_MINS)": { + "key": "CH_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ¦ │ @ │ # │ │ │ ¬ │ | │ ¢ │ │ │ ´ │ ~ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ \ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(CH_1)": { + "key": "CH_BRKP", + "label": "¦", + } + "ALGR(CH_2)": { + "key": "CH_AT", + "label": "@", + } + "ALGR(CH_3)": { + "key": "CH_HASH", + "label": "#", + } + "ALGR(CH_6)": { + "key": "CH_NOT", + "label": "¬", + } + "ALGR(CH_7)": { + "key": "CH_PIPE", + "label": "|", + } + "ALGR(CH_8)": { + "key": "CH_CENT", + "label": "¢", + } + "ALGR(CH_QUOT)": { + "key": "CH_ACUT", + "label": "´ (dead)", + } + "ALGR(CH_CIRC)": { + "key": "CH_TILD", + "label": "~ (dead)", + } + "ALGR(CH_E)": { + "key": "CH_EURO", + "label": "€", + } + "ALGR(CH_UDIA)": { + "key": "CH_LBRC", + "label": "[", + } + "ALGR(CH_DIAE)": { + "key": "CH_RBRC", + "label": "]", + } + "ALGR(CH_ADIA)": { + "key": "CH_LCBR", + "label": "{", + } + "ALGR(CH_DLR)": { + "key": "CH_RCBR", + "label": "}", + } + "ALGR(CH_LABK)": { + "key": "CH_BSLS", + "label": "\\", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_swiss_fr_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_swiss_fr_0.0.1.hjson new file mode 100644 index 0000000000..83fb86e49c --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_swiss_fr_0.0.1.hjson @@ -0,0 +1,379 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ^ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ è │ ¨ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ é │ à │ $ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "CH_SECT", + "label": "§", + } + "KC_1": { + "key": "CH_1", + "label": "1", + } + "KC_2": { + "key": "CH_2", + "label": "2", + } + "KC_3": { + "key": "CH_3", + "label": "3", + } + "KC_4": { + "key": "CH_4", + "label": "4", + } + "KC_5": { + "key": "CH_5", + "label": "5", + } + "KC_6": { + "key": "CH_6", + "label": "6", + } + "KC_7": { + "key": "CH_7", + "label": "7", + } + "KC_8": { + "key": "CH_8", + "label": "8", + } + "KC_9": { + "key": "CH_9", + "label": "9", + } + "KC_0": { + "key": "CH_0", + "label": "0", + } + "KC_MINS": { + "key": "CH_QUOT", + "label": "'", + } + "KC_EQL": { + "key": "CH_CIRC", + "label": "^ (dead)", + } + "KC_Q": { + "key": "CH_Q", + "label": "Q", + } + "KC_W": { + "key": "CH_W", + "label": "W", + } + "KC_E": { + "key": "CH_E", + "label": "E", + } + "KC_R": { + "key": "CH_R", + "label": "R", + } + "KC_T": { + "key": "CH_T", + "label": "T", + } + "KC_Y": { + "key": "CH_Z", + "label": "Z", + } + "KC_U": { + "key": "CH_U", + "label": "U", + } + "KC_I": { + "key": "CH_I", + "label": "I", + } + "KC_O": { + "key": "CH_O", + "label": "O", + } + "KC_P": { + "key": "CH_P", + "label": "P", + } + "KC_LBRC": { + "key": "CH_EGRV", + "label": "è", + } + "KC_RBRC": { + "key": "CH_DIAE", + "label": "¨ (dead)", + } + "KC_A": { + "key": "CH_A", + "label": "A", + } + "KC_S": { + "key": "CH_S", + "label": "S", + } + "KC_D": { + "key": "CH_D", + "label": "D", + } + "KC_F": { + "key": "CH_F", + "label": "F", + } + "KC_G": { + "key": "CH_G", + "label": "G", + } + "KC_H": { + "key": "CH_H", + "label": "H", + } + "KC_J": { + "key": "CH_J", + "label": "J", + } + "KC_K": { + "key": "CH_K", + "label": "K", + } + "KC_L": { + "key": "CH_L", + "label": "L", + } + "KC_SCLN": { + "key": "CH_EACU", + "label": "é", + } + "KC_QUOT": { + "key": "CH_AGRV", + "label": "à ", + } + "KC_NUHS": { + "key": "CH_DLR", + "label": "$", + } + "KC_NUBS": { + "key": "CH_LABK", + "label": "<", + } + "KC_Z": { + "key": "CH_Y", + "label": "Y", + } + "KC_X": { + "key": "CH_X", + "label": "X", + } + "KC_C": { + "key": "CH_C", + "label": "C", + } + "KC_V": { + "key": "CH_V", + "label": "V", + } + "KC_B": { + "key": "CH_B", + "label": "B", + } + "KC_N": { + "key": "CH_N", + "label": "N", + } + "KC_M": { + "key": "CH_M", + "label": "M", + } + "KC_COMM": { + "key": "CH_COMM", + "label": ",", + } + "KC_DOT": { + "key": "CH_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "CH_MINS", + "label": "-", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ° │ + │ " │ * │ ç │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ ü │ ! │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ ö │ ä │ £ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(CH_SECT)": { + "key": "CH_DEG", + "label": "°", + } + "S(CH_1)": { + "key": "CH_PLUS", + "label": "+", + } + "S(CH_2)": { + "key": "CH_DQUO", + "label": "\"", + } + "S(CH_3)": { + "key": "CH_ASTR", + "label": "*", + } + "S(CH_4)": { + "key": "CH_CCED", + "label": "ç", + } + "S(CH_5)": { + "key": "CH_PERC", + "label": "%", + } + "S(CH_6)": { + "key": "CH_AMPR", + "label": "&", + } + "S(CH_7)": { + "key": "CH_SLSH", + "label": "/", + } + "S(CH_8)": { + "key": "CH_LPRN", + "label": "(", + } + "S(CH_9)": { + "key": "CH_RPRN", + "label": ")", + } + "S(CH_0)": { + "key": "CH_EQL", + "label": "=", + } + "S(CH_QUOT)": { + "key": "CH_QUES", + "label": "?", + } + "S(CH_CIRC)": { + "key": "CH_GRV", + "label": "` (dead)", + } + "S(CH_EGRV)": { + "key": "CH_UDIA", + "label": "ü", + } + "S(CH_DIAE)": { + "key": "CH_EXLM", + "label": "!", + } + "S(CH_EACU)": { + "key": "CH_ODIA", + "label": "ö", + } + "S(CH_AGRV)": { + "key": "CH_ADIA", + "label": "ä", + } + "S(CH_DLR)": { + "key": "CH_PND", + "label": "£", + } + "S(CH_LABK)": { + "key": "CH_RABK", + "label": ">", + } + "S(CH_COMM)": { + "key": "CH_SCLN", + "label": ";", + } + "S(CH_DOT)": { + "key": "CH_COLN", + "label": ":", + } + "S(CH_MINS)": { + "key": "CH_UNDS", + "label": "_", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ¦ │ @ │ # │ │ │ ¬ │ | │ ¢ │ │ │ ´ │ ~ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ € │ │ │ │ │ │ │ │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ \ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(CH_1)": { + "key": "CH_BRKP", + "label": "¦", + } + "ALGR(CH_2)": { + "key": "CH_AT", + "label": "@", + } + "ALGR(CH_3)": { + "key": "CH_HASH", + "label": "#", + } + "ALGR(CH_6)": { + "key": "CH_NOT", + "label": "¬", + } + "ALGR(CH_7)": { + "key": "CH_PIPE", + "label": "|", + } + "ALGR(CH_8)": { + "key": "CH_CENT", + "label": "¢", + } + "ALGR(CH_QUOT)": { + "key": "CH_ACUT", + "label": "´ (dead)", + } + "ALGR(CH_CIRC)": { + "key": "CH_TILD", + "label": "~ (dead)", + } + "ALGR(CH_E)": { + "key": "CH_EURO", + "label": "€", + } + "ALGR(CH_EGRV)": { + "key": "CH_LBRC", + "label": "[", + } + "ALGR(CH_DIAE)": { + "key": "CH_RBRC", + "label": "]", + } + "ALGR(CH_AGRV)": { + "key": "CH_LCBR", + "label": "{", + } + "ALGR(CH_DLR)": { + "key": "CH_RCBR", + "label": "}", + } + "ALGR(CH_LABK)": { + "key": "CH_BSLS", + "label": "\\", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_turkish_f_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_turkish_f_0.0.1.hjson new file mode 100644 index 0000000000..2689f10dbe --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_turkish_f_0.0.1.hjson @@ -0,0 +1,480 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ + │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ / │ - │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ F │ G │ Ğ │ I │ O │ D │ R │ N │ H │ P │ Q │ W │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ U │ İ │ E │ A │ Ü │ T │ K │ M │ L │ Y │ Ş │ X │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ J │ Ö │ V │ C │ Ç │ Z │ S │ B │ . │ , │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "TR_PLUS", + "label": "+", + } + "KC_1": { + "key": "TR_1", + "label": "1", + } + "KC_2": { + "key": "TR_2", + "label": "2", + } + "KC_3": { + "key": "TR_3", + "label": "3", + } + "KC_4": { + "key": "TR_4", + "label": "4", + } + "KC_5": { + "key": "TR_5", + "label": "5", + } + "KC_6": { + "key": "TR_6", + "label": "6", + } + "KC_7": { + "key": "TR_7", + "label": "7", + } + "KC_8": { + "key": "TR_8", + "label": "8", + } + "KC_9": { + "key": "TR_9", + "label": "9", + } + "KC_0": { + "key": "TR_0", + "label": "0", + } + "KC_MINS": { + "key": "TR_SLSH", + "label": "/", + } + "KC_EQL": { + "key": "TR_MINS", + "label": "-", + } + "KC_Q": { + "key": "TR_F", + "label": "F", + } + "KC_W": { + "key": "TR_G", + "label": "G", + } + "KC_E": { + "key": "TR_GBRV", + "label": "Ğ", + } + "KC_R": { + "key": "TR_I", + "label": "I", + } + "KC_T": { + "key": "TR_O", + "label": "O", + } + "KC_Y": { + "key": "TR_D", + "label": "D", + } + "KC_U": { + "key": "TR_R", + "label": "R", + } + "KC_I": { + "key": "TR_N", + "label": "N", + } + "KC_O": { + "key": "TR_H", + "label": "H", + } + "KC_P": { + "key": "TR_P", + "label": "P", + } + "KC_LBRC": { + "key": "TR_Q", + "label": "Q", + } + "KC_RBRC": { + "key": "TR_W", + "label": "W", + } + "KC_A": { + "key": "TR_U", + "label": "U", + } + "KC_S": { + "key": "TR_IDOT", + "label": "İ", + } + "KC_D": { + "key": "TR_E", + "label": "E", + } + "KC_F": { + "key": "TR_A", + "label": "A", + } + "KC_G": { + "key": "TR_UDIA", + "label": "Ü", + } + "KC_H": { + "key": "TR_T", + "label": "T", + } + "KC_J": { + "key": "TR_K", + "label": "K", + } + "KC_K": { + "key": "TR_M", + "label": "M", + } + "KC_L": { + "key": "TR_L", + "label": "L", + } + "KC_SCLN": { + "key": "TR_Y", + "label": "Y", + } + "KC_QUOT": { + "key": "TR_SCED", + "label": "Ş", + } + "KC_NUHS": { + "key": "TR_X", + "label": "X", + } + "KC_NUBS": { + "key": "TR_LABK", + "label": "<", + } + "KC_Z": { + "key": "TR_J", + "label": "J", + } + "KC_X": { + "key": "TR_ODIA", + "label": "Ö", + } + "KC_C": { + "key": "TR_V", + "label": "V", + } + "KC_V": { + "key": "TR_C", + "label": "C", + } + "KC_B": { + "key": "TR_CCED", + "label": "Ç", + } + "KC_N": { + "key": "TR_Z", + "label": "Z", + } + "KC_M": { + "key": "TR_S", + "label": "S", + } + "KC_COMM": { + "key": "TR_B", + "label": "B", + } + "KC_DOT": { + "key": "TR_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "TR_COMM", + "label": ",", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ * │ ! │ " │ ^ │ $ │ % │ & │ ' │ ( │ ) │ = │ ? │ _ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ │ : │ ; │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(TR_PLUS)": { + "key": "TR_ASTR", + "label": "*", + } + "S(TR_1)": { + "key": "TR_EXLM", + "label": "!", + } + "S(TR_2)": { + "key": "TR_DQUO", + "label": "\"", + } + "S(TR_3)": { + "key": "TR_CIRC", + "label": "^ (dead)", + } + "S(TR_4)": { + "key": "TR_DLR", + "label": "$", + } + "S(TR_5)": { + "key": "TR_PERC", + "label": "%", + } + "S(TR_6)": { + "key": "TR_AMPR", + "label": "&", + } + "S(TR_7)": { + "key": "TR_QUOT", + "label": "'", + } + "S(TR_8)": { + "key": "TR_LPRN", + "label": "(", + } + "S(TR_9)": { + "key": "TR_RPRN", + "label": ")", + } + "S(TR_0)": { + "key": "TR_EQL", + "label": "=", + } + "S(TR_SLSH)": { + "key": "TR_QUES", + "label": "?", + } + "S(TR_MINS)": { + "key": "TR_UNDS", + "label": "_", + } + "S(TR_LABK)": { + "key": "TR_RABK", + "label": ">", + } + "S(TR_DOT)": { + "key": "TR_COLN", + "label": ":", + } + "S(TR_COMM)": { + "key": "TR_SCLN", + "label": ";", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¬ │ ¹ │ ² │ # │ ¼ │ ½ │ ¾ │ { │ [ │ ] │ } │ \ │ | │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ @ │ │ │ ¶ │ │ ¥ │ │ │ Ø │ £ │ ¨ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Æ │ ß │ € │ │ │ ₺ │ │ │ │ ´ │ │ ` │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ « │ » │ ¢ │ │ │ │ µ │ × │ ÷ │ - │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(TR_PLUS)": { + "key": "TR_NOT", + "label": "¬", + } + "ALGR(TR_1)": { + "key": "TR_SUP1", + "label": "¹", + } + "ALGR(TR_2)": { + "key": "TR_SUP2", + "label": "²", + } + "ALGR(TR_3)": { + "key": "TR_HASH", + "label": "#", + } + "ALGR(TR_4)": { + "key": "TR_QRTR", + "label": "¼", + } + "ALGR(TR_5)": { + "key": "TR_HALF", + "label": "½", + } + "ALGR(TR_6)": { + "key": "TR_TQTR", + "label": "¾", + } + "ALGR(TR_7)": { + "key": "TR_LCBR", + "label": "{", + } + "ALGR(TR_8)": { + "key": "TR_LBRC", + "label": "[", + } + "ALGR(TR_9)": { + "key": "TR_RBRC", + "label": "]", + } + "ALGR(TR_0)": { + "key": "TR_RCBR", + "label": "}", + } + "ALGR(TR_SLSH)": { + "key": "TR_BSLS", + "label": "\\", + } + "ALGR(TR_MINS)": { + "key": "TR_PIPE", + "label": "|", + } + "ALGR(TR_F)": { + "key": "TR_AT", + "label": "@", + } + "ALGR(TR_I)": { + "key": "TR_PILC", + "label": "¶", + } + "ALGR(TR_D)": { + "key": "TR_YEN", + "label": "¥", + } + "ALGR(TR_H)": { + "key": "TR_OSTR", + "label": "Ø", + } + "ALGR(TR_P)": { + "key": "TR_PND", + "label": "£", + } + "ALGR(TR_Q)": { + "key": "TR_DIAE", + "label": "¨ (dead)", + } + "ALGR(TR_W)": { + "key": "TR_TILD", + "label": "~ (dead)", + } + "ALGR(TR_U)": { + "key": "TR_AE", + "label": "Æ", + } + "ALGR(TR_IDOT)": { + "key": "TR_SS", + "label": "ß", + } + "ALGR(TR_E)": { + "key": "TR_EURO", + "label": "€", + } + "ALGR(TR_T)": { + "key": "TR_LIRA", + "label": "₺", + } + "ALGR(TR_Y)": { + "key": "TR_ACUT", + "label": "´ (dead)", + } + "ALGR(TR_X)": { + "key": "TR_GRV", + "label": "` (dead)", + } + "ALGR(TR_J)": { + "key": "TR_LDAQ", + "label": "«", + } + "ALGR(TR_ODIA)": { + "key": "TR_RDAQ", + "label": "»", + } + "ALGR(TR_V)": { + "key": "TR_CENT", + "label": "¢", + } + "ALGR(TR_S)": { + "key": "TR_MICR", + "label": "µ", + } + "ALGR(TR_B)": { + "key": "TR_MUL", + "label": "×", + } + "ALGR(TR_DOT)": { + "key": "TR_DIV", + "label": "÷", + } + "ALGR(TR_COMM)": { + "key": "TR_SHYP", + "label": " (soft hyphen)", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ │ ³ │ ¤ │ │ │ │ │ │ │ ¿ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ ® │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ § │ │ ª │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ ¦ │ │ │ © │ │ │ │ º │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(TR_3))": { + "key": "TR_SUP3", + "label": "³", + } + "S(ALGR(TR_4))": { + "key": "TR_CURR", + "label": "¤", + } + "S(ALGR(TR_SLSH))": { + "key": "TR_IQUE", + "label": "¿", + } + "S(ALGR(TR_I))": { + "key": "TR_REGD", + "label": "®", + } + "S(ALGR(TR_IDOT))": { + "key": "TR_SECT", + "label": "§", + } + "S(ALGR(TR_A))": { + "key": "TR_FORD", + "label": "ª", + } + "S(ALGR(TR_LABK))": { + "key": "TR_BRKP", + "label": "¦", + } + "S(ALGR(TR_V))": { + "key": "TR_COPY", + "label": "©", + } + "S(ALGR(TR_S))": { + "key": "TR_MORD", + "label": "º", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_turkish_q_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_turkish_q_0.0.1.hjson new file mode 100644 index 0000000000..e00cee9ce3 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_turkish_q_0.0.1.hjson @@ -0,0 +1,375 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ " │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ * │ - │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ğ │ Ü │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ş │ İ │ , │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ Ö │ Ç │ . │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "TR_DQUO", + "label": "\"", + } + "KC_1": { + "key": "TR_1", + "label": "1", + } + "KC_2": { + "key": "TR_2", + "label": "2", + } + "KC_3": { + "key": "TR_3", + "label": "3", + } + "KC_4": { + "key": "TR_4", + "label": "4", + } + "KC_5": { + "key": "TR_5", + "label": "5", + } + "KC_6": { + "key": "TR_6", + "label": "6", + } + "KC_7": { + "key": "TR_7", + "label": "7", + } + "KC_8": { + "key": "TR_8", + "label": "8", + } + "KC_9": { + "key": "TR_9", + "label": "9", + } + "KC_0": { + "key": "TR_0", + "label": "0", + } + "KC_MINS": { + "key": "TR_ASTR", + "label": "*", + } + "KC_EQL": { + "key": "TR_MINS", + "label": "-", + } + "KC_Q": { + "key": "TR_Q", + "label": "Q", + } + "KC_W": { + "key": "TR_W", + "label": "W", + } + "KC_E": { + "key": "TR_E", + "label": "E", + } + "KC_R": { + "key": "TR_R", + "label": "R", + } + "KC_T": { + "key": "TR_T", + "label": "T", + } + "KC_Y": { + "key": "TR_Y", + "label": "Y", + } + "KC_U": { + "key": "TR_U", + "label": "U", + } + "KC_I": { + "key": "TR_I", + "label": "I", + } + "KC_O": { + "key": "TR_O", + "label": "O", + } + "KC_P": { + "key": "TR_P", + "label": "P", + } + "KC_LBRC": { + "key": "TR_GBRV", + "label": "Ğ", + } + "KC_RBRC": { + "key": "TR_UDIA", + "label": "Ü", + } + "KC_A": { + "key": "TR_A", + "label": "A", + } + "KC_S": { + "key": "TR_S", + "label": "S", + } + "KC_D": { + "key": "TR_D", + "label": "D", + } + "KC_F": { + "key": "TR_F", + "label": "F", + } + "KC_G": { + "key": "TR_G", + "label": "G", + } + "KC_H": { + "key": "TR_H", + "label": "H", + } + "KC_J": { + "key": "TR_J", + "label": "J", + } + "KC_K": { + "key": "TR_K", + "label": "K", + } + "KC_L": { + "key": "TR_L", + "label": "L", + } + "KC_SCLN": { + "key": "TR_SCED", + "label": "Ş", + } + "KC_QUOT": { + "key": "TR_IDOT", + "label": "İ", + } + "KC_NUHS": { + "key": "TR_COMM", + "label": ",", + } + "KC_NUBS": { + "key": "TR_LABK", + "label": "<", + } + "KC_Z": { + "key": "TR_Z", + "label": "Z", + } + "KC_X": { + "key": "TR_X", + "label": "X", + } + "KC_C": { + "key": "TR_C", + "label": "C", + } + "KC_V": { + "key": "TR_V", + "label": "V", + } + "KC_B": { + "key": "TR_B", + "label": "B", + } + "KC_N": { + "key": "TR_N", + "label": "N", + } + "KC_M": { + "key": "TR_M", + "label": "M", + } + "KC_COMM": { + "key": "TR_ODIA", + "label": "Ö", + } + "KC_DOT": { + "key": "TR_CCED", + "label": "Ç", + } + "KC_SLSH": { + "key": "TR_DOT", + "label": ".", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ é │ ! │ ' │ ^ │ + │ % │ & │ / │ ( │ ) │ = │ ? │ _ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ │ │ ; │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ > │ │ │ │ │ │ │ │ │ │ : │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(TR_DQUO)": { + "key": "TR_EACU", + "label": "é", + } + "S(TR_1)": { + "key": "TR_EXLM", + "label": "!", + } + "S(TR_2)": { + "key": "TR_QUOT", + "label": "'", + } + "S(TR_3)": { + "key": "TR_CIRC", + "label": "^ (dead)", + } + "S(TR_4)": { + "key": "TR_PLUS", + "label": "+", + } + "S(TR_5)": { + "key": "TR_PERC", + "label": "%", + } + "S(TR_6)": { + "key": "TR_AMPR", + "label": "&", + } + "S(TR_7)": { + "key": "TR_SLSH", + "label": "/", + } + "S(TR_8)": { + "key": "TR_LPRN", + "label": "(", + } + "S(TR_9)": { + "key": "TR_RPRN", + "label": ")", + } + "S(TR_0)": { + "key": "TR_EQL", + "label": "=", + } + "S(TR_ASTR)": { + "key": "TR_QUES", + "label": "?", + } + "S(TR_MINS)": { + "key": "TR_UNDS", + "label": "_", + } + "S(TR_COMM)": { + "key": "TR_SCLN", + "label": ";", + } + "S(TR_LABK)": { + "key": "TR_RABK", + "label": ">", + } + "S(TR_DOT)": { + "key": "TR_COLN", + "label": ":", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ £ │ # │ $ │ ½ │ │ { │ [ │ ] │ } │ \ │ | │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ @ │ │ € │ │ ₺ │ │ │ │ │ │ ¨ │ ~ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ Æ │ ß │ │ │ │ │ │ │ │ ´ │ │ ` │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(TR_2)": { + "key": "TR_PND", + "label": "£", + } + "ALGR(TR_3)": { + "key": "TR_HASH", + "label": "#", + } + "ALGR(TR_4)": { + "key": "TR_DLR", + "label": "$", + } + "ALGR(TR_5)": { + "key": "TR_HALF", + "label": "½", + } + "ALGR(TR_7)": { + "key": "TR_LCBR", + "label": "{", + } + "ALGR(TR_8)": { + "key": "TR_LBRC", + "label": "[", + } + "ALGR(TR_9)": { + "key": "TR_RBRC", + "label": "]", + } + "ALGR(TR_0)": { + "key": "TR_RCBR", + "label": "}", + } + "ALGR(TR_ASTR)": { + "key": "TR_BSLS", + "label": "\\", + } + "ALGR(TR_MINS)": { + "key": "TR_PIPE", + "label": "|", + } + "ALGR(TR_Q)": { + "key": "TR_AT", + "label": "@", + } + "ALGR(TR_E)": { + "key": "TR_EURO", + "label": "€", + } + "ALGR(TR_T)": { + "key": "TR_LIRA", + "label": "₺", + } + "ALGR(TR_GBRV)": { + "key": "TR_DIAE", + "label": "¨ (dead)", + } + "ALGR(TR_UDIA)": { + "key": "TR_TILD", + "label": "~ (dead)", + } + "ALGR(TR_A)": { + "key": "TR_AE", + "label": "Æ", + } + "ALGR(TR_S)": { + "key": "TR_SS", + "label": "ß", + } + "ALGR(TR_SCED)": { + "key": "TR_ACUT", + "label": "´ (dead)", + } + "ALGR(TR_COMM)": { + "key": "TR_GRV", + "label": "` (dead)", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_uk_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_uk_0.0.1.hjson new file mode 100644 index 0000000000..006bf5c59e --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_uk_0.0.1.hjson @@ -0,0 +1,353 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ # │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ \ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "UK_GRV", + "label": "`" + }, + "KC_1": { + "key": "UK_1", + "label": "1" + }, + "KC_2": { + "key": "UK_2", + "label": "2" + }, + "KC_3": { + "key": "UK_3", + "label": "3" + }, + "KC_4": { + "key": "UK_4", + "label": "4" + }, + "KC_5": { + "key": "UK_5", + "label": "5" + }, + "KC_6": { + "key": "UK_6", + "label": "6" + }, + "KC_7": { + "key": "UK_7", + "label": "7" + }, + "KC_8": { + "key": "UK_8", + "label": "8" + }, + "KC_9": { + "key": "UK_9", + "label": "9" + }, + "KC_0": { + "key": "UK_0", + "label": "0" + }, + "KC_MINS": { + "key": "UK_MINS", + "label": "-" + }, + "KC_EQL": { + "key": "UK_EQL", + "label": "=" + }, + "KC_Q": { + "key": "UK_Q", + "label": "Q" + }, + "KC_W": { + "key": "UK_W", + "label": "W" + }, + "KC_E": { + "key": "UK_E", + "label": "E" + }, + "KC_R": { + "key": "UK_R", + "label": "R" + }, + "KC_T": { + "key": "UK_T", + "label": "T" + }, + "KC_Y": { + "key": "UK_Y", + "label": "Y" + }, + "KC_U": { + "key": "UK_U", + "label": "U" + }, + "KC_I": { + "key": "UK_I", + "label": "I" + }, + "KC_O": { + "key": "UK_O", + "label": "O" + }, + "KC_P": { + "key": "UK_P", + "label": "P" + }, + "KC_LBRC": { + "key": "UK_LBRC", + "label": "[" + }, + "KC_RBRC": { + "key": "UK_RBRC", + "label": "]" + }, + "KC_A": { + "key": "UK_A", + "label": "A" + }, + "KC_S": { + "key": "UK_S", + "label": "S" + }, + "KC_D": { + "key": "UK_D", + "label": "D" + }, + "KC_F": { + "key": "UK_F", + "label": "F" + }, + "KC_G": { + "key": "UK_G", + "label": "G" + }, + "KC_H": { + "key": "UK_H", + "label": "H" + }, + "KC_J": { + "key": "UK_J", + "label": "J" + }, + "KC_K": { + "key": "UK_K", + "label": "K" + }, + "KC_L": { + "key": "UK_L", + "label": "L" + }, + "KC_SCLN": { + "key": "UK_SCLN", + "label": ";" + }, + "KC_QUOT": { + "key": "UK_QUOT", + "label": "'" + }, + "KC_NUHS": { + "key": "UK_HASH", + "label": "#" + }, + "KC_NUBS": { + "key": "UK_BSLS", + "label": "\\" + }, + "KC_Z": { + "key": "UK_Z", + "label": "Z" + }, + "KC_X": { + "key": "UK_X", + "label": "X" + }, + "KC_C": { + "key": "UK_C", + "label": "C" + }, + "KC_V": { + "key": "UK_V", + "label": "V" + }, + "KC_B": { + "key": "UK_B", + "label": "B" + }, + "KC_N": { + "key": "UK_N", + "label": "N" + }, + "KC_M": { + "key": "UK_M", + "label": "M" + }, + "KC_COMM": { + "key": "UK_COMM", + "label": "," + }, + "KC_DOT": { + "key": "UK_DOT", + "label": "." + }, + "KC_SLSH": { + "key": "UK_SLSH", + "label": "/" + }, + +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¬ │ ! │ " │ £ │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ │ │ │ │ │ │ │ │ │ : │ @ │ ~ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ | │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(UK_GRV)": { + "key": "UK_NOT", + "label": "¬" + }, + "S(UK_1)": { + "key": "UK_EXLM", + "label": "!" + }, + "S(UK_2)": { + "key": "UK_DQUO", + "label": "\"" + }, + "S(UK_3)": { + "key": "UK_PND", + "label": "£" + }, + "S(UK_4)": { + "key": "UK_DLR", + "label": "$" + }, + "S(UK_5)": { + "key": "UK_PERC", + "label": "%" + }, + "S(UK_6)": { + "key": "UK_CIRC", + "label": "^" + }, + "S(UK_7)": { + "key": "UK_AMPR", + "label": "&" + }, + "S(UK_8)": { + "key": "UK_ASTR", + "label": "*" + }, + "S(UK_9)": { + "key": "UK_LPRN", + "label": "(" + }, + "S(UK_0)": { + "key": "UK_RPRN", + "label": ")" + }, + "S(UK_MINS)": { + "key": "UK_UNDS", + "label": "_" + }, + "S(UK_EQL)": { + "key": "UK_PLUS", + "label": "+" + }, + "S(UK_LBRC)": { + "key": "UK_LCBR", + "label": "{" + }, + "S(UK_RBRC)": { + "key": "UK_RCBR", + "label": "}" + }, + "S(UK_SCLN)": { + "key": "UK_COLN", + "label": ":" + }, + "S(UK_QUOT)": { + "key": "UK_AT", + "label": "@" + }, + "S(UK_HASH)": { + "key": "UK_TILD", + "label": "~" + }, + "S(UK_BSLS)": { + "key": "UK_PIPE", + "label": "|" + }, + "S(UK_COMM)": { + "key": "UK_LABK", + "label": "<" + }, + "S(UK_DOT)": { + "key": "UK_RABK", + "label": ">" + }, + "S(UK_SLSH)": { + "key": "UK_QUES", + "label": "?" + }, + +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ¦ │ │ │ │ € │ │ │ │ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ É │ │ │ │ Ú │ à │ Ó │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ + * │ │ à │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(UK_GRV)": { + "key": "UK_BRKP", + "label": "¦" + }, + "ALGR(UK_4)": { + "key": "UK_EURO", + "label": "€" + }, + "ALGR(KC_E)": { + "key": "UK_EACU", + "label": "É" + }, + "ALGR(KC_U)": { + "key": "UK_UACU", + "label": "Ú" + }, + "ALGR(KC_I)": { + "key": "UK_IACU", + "label": "Ã" + }, + "ALGR(KC_O)": { + "key": "UK_OACU", + "label": "Ó" + }, + "ALGR(KC_A)": { + "key": "UK_AACU", + "label": "Ã" + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_ukrainian_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_ukrainian_0.0.1.hjson new file mode 100644 index 0000000000..2e8629f58b --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_ukrainian_0.0.1.hjson @@ -0,0 +1,295 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ' │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Й │ Ц │ У │ К │ Е │ Р│ Г │ Ш │ Щ │ З │ Ð¥ │ Ї │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ Ф │ І │ Ð’ │ Р│ П │ Р│ О │ Л │ Д │ Ж │ Є │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Я │ Ч │ С │ Ðœ │ И │ Т │ Ь │ Б │ Ю │ . │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "UA_QUOT", + "label": "'", + } + "KC_1": { + "key": "UA_1", + "label": "1", + } + "KC_2": { + "key": "UA_2", + "label": "2", + } + "KC_3": { + "key": "UA_3", + "label": "3", + } + "KC_4": { + "key": "UA_4", + "label": "4", + } + "KC_5": { + "key": "UA_5", + "label": "5", + } + "KC_6": { + "key": "UA_6", + "label": "6", + } + "KC_7": { + "key": "UA_7", + "label": "7", + } + "KC_8": { + "key": "UA_8", + "label": "8", + } + "KC_9": { + "key": "UA_9", + "label": "9", + } + "KC_0": { + "key": "UA_0", + "label": "0", + } + "KC_MINS": { + "key": "UA_MINS", + "label": "-", + } + "KC_EQL": { + "key": "UA_EQL", + "label": "=", + } + "KC_Q": { + "key": "UA_YOT", + "label": "Й", + } + "KC_W": { + "key": "UA_TSE", + "label": "Ц", + } + "KC_E": { + "key": "UA_U", + "label": "У", + } + "KC_R": { + "key": "UA_KA", + "label": "К", + } + "KC_T": { + "key": "UA_E", + "label": "Е", + } + "KC_Y": { + "key": "UA_EN", + "label": "Ð", + } + "KC_U": { + "key": "UA_HE", + "label": "Г", + } + "KC_I": { + "key": "UA_SHA", + "label": "Ш", + } + "KC_O": { + "key": "UA_SHCH", + "label": "Щ", + } + "KC_P": { + "key": "UA_ZE", + "label": "З", + } + "KC_LBRC": { + "key": "UA_KHA", + "label": "Ð¥", + } + "KC_RBRC": { + "key": "UA_YI", + "label": "Ї", + } + "KC_BSLS": { + "key": "UA_BSLS", + "label": "\\", + } + "KC_A": { + "key": "UA_EF", + "label": "Ф", + } + "KC_S": { + "key": "UA_I", + "label": "І", + } + "KC_D": { + "key": "UA_VE", + "label": "Ð’", + } + "KC_F": { + "key": "UA_A", + "label": "Ð", + } + "KC_G": { + "key": "UA_PE", + "label": "П", + } + "KC_H": { + "key": "UA_ER", + "label": "Ð ", + } + "KC_J": { + "key": "UA_O", + "label": "О", + } + "KC_K": { + "key": "UA_EL", + "label": "Л", + } + "KC_L": { + "key": "UA_DE", + "label": "Д", + } + "KC_SCLN": { + "key": "UA_ZHE", + "label": "Ж", + } + "KC_QUOT": { + "key": "UA_YE", + "label": "Є", + } + "KC_Z": { + "key": "UA_YA", + "label": "Я", + } + "KC_X": { + "key": "UA_CHE", + "label": "Ч", + } + "KC_C": { + "key": "UA_ES", + "label": "С", + } + "KC_V": { + "key": "UA_EM", + "label": "Ðœ", + } + "KC_B": { + "key": "UA_Y", + "label": "И", + } + "KC_N": { + "key": "UA_TE", + "label": "Т", + } + "KC_M": { + "key": "UA_SOFT", + "label": "Ь", + } + "KC_COMM": { + "key": "UA_BE", + "label": "Б", + } + "KC_DOT": { + "key": "UA_YU", + "label": "Ю", + } + "KC_SLSH": { + "key": "UA_DOT", + "label": ".", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ â‚´ │ ! │ " │ â„– │ ; │ % │ : │ ? │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ / │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ │ │ , │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(UA_QUOT)": { + "key": "UA_HRYV", + "label": "â‚´", + } + "S(UA_1)": { + "key": "UA_EXLM", + "label": "!", + } + "S(UA_2)": { + "key": "UA_DQUO", + "label": "\"", + } + "S(UA_3)": { + "key": "UA_NUM", + "label": "â„–", + } + "S(UA_4)": { + "key": "UA_SCLN", + "label": ";", + } + "S(UA_5)": { + "key": "UA_PERC", + "label": "%", + } + "S(UA_6)": { + "key": "UA_COLN", + "label": ":", + } + "S(UA_7)": { + "key": "UA_QUES", + "label": "?", + } + "S(UA_8)": { + "key": "UA_ASTR", + "label": "*", + } + "S(UA_9)": { + "key": "UA_LPRN", + "label": "(", + } + "S(UA_0)": { + "key": "UA_RPRN", + "label": ")", + } + "S(UA_MINS)": { + "key": "UA_UNDS", + "label": "_", + } + "S(UA_EQL)": { + "key": "UA_PLUS", + "label": "+", + } + "S(UA_BSLS)": { + "key": "UA_SLSH", + "label": "/", + } + "S(UA_DOT)": { + "key": "UA_COMM", + "label": ",", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ Ò‘ │ │ │ │ │ │ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(UA_HE)": { + "key": "UA_GE", + "label": "Ò‘", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_us_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_us_0.0.1.hjson new file mode 100644 index 0000000000..af7e462611 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_us_0.0.1.hjson @@ -0,0 +1,155 @@ +{ + "aliases": { +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(KC_GRAVE)": { + "key": "KC_TILD", + "label": "~", + "aliases": [ + "KC_TILDE" + ] + }, + "S(KC_1)": { + "key": "KC_EXLM", + "label": "!", + "aliases": [ + "KC_EXCLAIM" + ] + }, + "S(KC_2)": { + "key": "KC_AT", + "label": "@" + }, + "S(KC_3)": { + "key": "KC_HASH", + "label": "#" + }, + "S(KC_4)": { + "key": "KC_DLR", + "label": "$", + "aliases": [ + "KC_DOLLAR" + ] + }, + "S(KC_5)": { + "key": "KC_PERC", + "label": "%", + "aliases": [ + "KC_PERCENT" + ] + }, + "S(KC_6)": { + "key": "KC_CIRC", + "label": "^", + "aliases": [ + "KC_CIRCUMFLEX" + ] + }, + "S(KC_7)": { + "key": "KC_AMPR", + "label": "&", + "aliases": [ + "KC_AMPERSAND" + ] + }, + "S(KC_8)": { + "key": "KC_ASTR", + "label": "*", + "aliases": [ + "KC_ASTERISK" + ] + }, + "S(KC_9)": { + "key": "KC_LPRN", + "label": "(", + "aliases": [ + "KC_LEFT_PAREN" + ] + }, + "S(KC_0)": { + "key": "KC_RPRN", + "label": ")", + "aliases": [ + "KC_RIGHT_PAREN" + ] + }, + "S(KC_MINUS)": { + "key": "KC_UNDS", + "label": "_", + "aliases": [ + "KC_UNDERSCORE" + ] + }, + "S(KC_EQUAL)": { + "key": "KC_PLUS", + "label": "+" + }, + "S(KC_LEFT_BRACKET)": { + "key": "KC_LCBR", + "label": "{", + "aliases": [ + "KC_LEFT_CURLY_BRACE" + ] + }, + "S(KC_RIGHT_BRACKET)": { + "key": "KC_RCBR", + "label": "}", + "aliases": [ + "KC_RIGHT_CURLY_BRACE" + ] + }, + "S(KC_BACKSLASH)": { + "key": "KC_PIPE", + "label": "|" + }, + "S(KC_SEMICOLON)": { + "key": "KC_COLN", + "label": ":", + "aliases": [ + "KC_COLON" + ] + }, + "S(KC_QUOTE)": { + "key": "KC_DQUO", + "label": "\"", + "aliases": [ + "KC_DOUBLE_QUOTE", + "KC_DQT" + ] + }, + "S(KC_COMMA)": { + "key": "KC_LABK", + "label": "<", + "aliases": [ + "KC_LEFT_ANGLE_BRACKET", + "KC_LT" + ] + }, + "S(KC_DOT)": { + "key": "KC_RABK", + "label": ">", + "aliases": [ + "KC_RIGHT_ANGLE_BRACKET", + "KC_GT" + ] + }, + "S(KC_SLASH)": { + "key": "KC_QUES", + "label": "?", + "aliases": [ + "KC_QUESTION" + ] + } + } +} diff --git a/data/constants/keycodes/extras/keycodes_us_extended_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_us_extended_0.0.1.hjson new file mode 100644 index 0000000000..ecac6ca161 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_us_extended_0.0.1.hjson @@ -0,0 +1,588 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "US_GRV", + "label": "`", + } + "KC_1": { + "key": "US_1", + "label": "1", + } + "KC_2": { + "key": "US_2", + "label": "2", + } + "KC_3": { + "key": "US_3", + "label": "3", + } + "KC_4": { + "key": "US_4", + "label": "4", + } + "KC_5": { + "key": "US_5", + "label": "5", + } + "KC_6": { + "key": "US_6", + "label": "6", + } + "KC_7": { + "key": "US_7", + "label": "7", + } + "KC_8": { + "key": "US_8", + "label": "8", + } + "KC_9": { + "key": "US_9", + "label": "9", + } + "KC_0": { + "key": "US_0", + "label": "0", + } + "KC_MINS": { + "key": "US_MINS", + "label": "-", + } + "KC_EQL": { + "key": "US_EQL", + "label": "=", + } + "KC_Q": { + "key": "US_Q", + "label": "Q", + } + "KC_W": { + "key": "US_W", + "label": "W", + } + "KC_E": { + "key": "US_E", + "label": "E", + } + "KC_R": { + "key": "US_R", + "label": "R", + } + "KC_T": { + "key": "US_T", + "label": "T", + } + "KC_Y": { + "key": "US_Y", + "label": "Y", + } + "KC_U": { + "key": "US_U", + "label": "U", + } + "KC_I": { + "key": "US_I", + "label": "I", + } + "KC_O": { + "key": "US_O", + "label": "O", + } + "KC_P": { + "key": "US_P", + "label": "P", + } + "KC_LBRC": { + "key": "US_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "US_RBRC", + "label": "]", + } + "KC_BSLS": { + "key": "US_BSLS", + "label": "\\", + } + "KC_A": { + "key": "US_A", + "label": "A", + } + "KC_S": { + "key": "US_S", + "label": "S", + } + "KC_D": { + "key": "US_D", + "label": "D", + } + "KC_F": { + "key": "US_F", + "label": "F", + } + "KC_G": { + "key": "US_G", + "label": "G", + } + "KC_H": { + "key": "US_H", + "label": "H", + } + "KC_J": { + "key": "US_J", + "label": "J", + } + "KC_K": { + "key": "US_K", + "label": "K", + } + "KC_L": { + "key": "US_L", + "label": "L", + } + "KC_SCLN": { + "key": "US_SCLN", + "label": ";", + } + "KC_QUOT": { + "key": "US_QUOT", + "label": "'", + } + "KC_Z": { + "key": "US_Z", + "label": "Z", + } + "KC_X": { + "key": "US_X", + "label": "X", + } + "KC_C": { + "key": "US_C", + "label": "C", + } + "KC_V": { + "key": "US_V", + "label": "V", + } + "KC_B": { + "key": "US_B", + "label": "B", + } + "KC_N": { + "key": "US_N", + "label": "N", + } + "KC_M": { + "key": "US_M", + "label": "M", + } + "KC_COMM": { + "key": "US_COMM", + "label": ",", + } + "KC_DOT": { + "key": "US_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "US_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(US_GRV)": { + "key": "US_TILD", + "label": "~", + } + "S(US_1)": { + "key": "US_EXLM", + "label": "!", + } + "S(US_2)": { + "key": "US_AT", + "label": "@", + } + "S(US_3)": { + "key": "US_HASH", + "label": "#", + } + "S(US_4)": { + "key": "US_DLR", + "label": "$", + } + "S(US_5)": { + "key": "US_PERC", + "label": "%", + } + "S(US_6)": { + "key": "US_CIRC", + "label": "^", + } + "S(US_7)": { + "key": "US_AMPR", + "label": "&", + } + "S(US_8)": { + "key": "US_ASTR", + "label": "*", + } + "S(US_9)": { + "key": "US_LPRN", + "label": "(", + } + "S(US_0)": { + "key": "US_RPRN", + "label": ")", + } + "S(US_MINS)": { + "key": "US_UNDS", + "label": "_", + } + "S(US_EQL)": { + "key": "US_PLUS", + "label": "+", + } + "S(US_LBRC)": { + "key": "US_LCBR", + "label": "{", + } + "S(US_RBRC)": { + "key": "US_RCBR", + "label": "}", + } + "S(US_BSLS)": { + "key": "US_PIPE", + "label": "|", + } + "S(US_SCLN)": { + "key": "US_COLN", + "label": ":", + } + "S(US_QUOT)": { + "key": "US_DQUO", + "label": "\"", + } + "S(US_COMM)": { + "key": "US_LABK", + "label": "<", + } + "S(US_DOT)": { + "key": "US_RABK", + "label": ">", + } + "S(US_SLSH)": { + "key": "US_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ ¹ │ ² │ ³ │ ¤ │ € │ ^ │ Ì› │ ¾ │ ‘ │ ’ │ Â¥ │ × │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Ä │ Ã… │ É │ ® │ Þ │ Ãœ │ Ú │ à │ Ó │ Ö │ « │ » │ ¬ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ à │ ß │ à │ │ │ │ à │ Å’ │ Ø │ ¶ │ ' │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Æ │ │ © │ │ │ Ñ │ µ │ Ç │ Ë™ │ ¿ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(US_GRV)": { + "key": "US_DGRV", + "label": "` (dead)", + } + "ALGR(US_1)": { + "key": "US_SUP1", + "label": "¹", + } + "ALGR(US_2)": { + "key": "US_SUP2", + "label": "²", + } + "ALGR(US_3)": { + "key": "US_SUP3", + "label": "³", + } + "ALGR(US_4)": { + "key": "US_CURR", + "label": "¤", + } + "ALGR(US_5)": { + "key": "US_EURO", + "label": "€", + } + "ALGR(US_6)": { + "key": "US_DCIR", + "label": "^ (dead)", + } + "ALGR(US_7)": { + "key": "US_HORN", + "label": "Ì› (dead)", + } + "ALGR(US_8)": { + "key": "US_OGON", + "label": "Ë› (dead)", + } + "ALGR(US_9)": { + "key": "US_LSQU", + "label": "‘", + } + "ALGR(US_0)": { + "key": "US_RSQU", + "label": "’", + } + "ALGR(US_MINS)": { + "key": "US_YEN", + "label": "Â¥", + } + "ALGR(US_EQL)": { + "key": "US_MUL", + "label": "×", + } + "ALGR(US_Q)": { + "key": "US_ADIA", + "label": "Ä", + } + "ALGR(US_W)": { + "key": "US_ARNG", + "label": "Ã…", + } + "ALGR(US_E)": { + "key": "US_EACU", + "label": "É", + } + "ALGR(US_R)": { + "key": "US_EDIA", + "label": "Ë", + } + "ALGR(US_T)": { + "key": "US_THRN", + "label": "Þ", + } + "ALGR(US_Y)": { + "key": "US_UDIA", + "label": "Ãœ", + } + "ALGR(US_U)": { + "key": "US_UACU", + "label": "Ú", + } + "ALGR(US_I)": { + "key": "US_IACU", + "label": "Ã", + } + "ALGR(US_O)": { + "key": "US_OACU", + "label": "Ó", + } + "ALGR(US_P)": { + "key": "US_ODIA", + "label": "Ö", + } + "ALGR(US_LBRC)": { + "key": "US_LDAQ", + "label": "«", + } + "ALGR(US_RBRC)": { + "key": "US_RDAQ", + "label": "»", + } + "ALGR(US_BSLS)": { + "key": "US_NOT", + "label": "¬", + } + "ALGR(US_A)": { + "key": "US_AACU", + "label": "Ã", + } + "ALGR(US_S)": { + "key": "US_SS", + "label": "ß", + } + "ALGR(US_D)": { + "key": "US_ETH", + "label": "Ã", + } + "ALGR(US_J)": { + "key": "US_IDIA", + "label": "Ã", + } + "ALGR(US_K)": { + "key": "US_OE", + "label": "Å’", + } + "ALGR(US_L)": { + "key": "US_OSTR", + "label": "Ø", + } + "ALGR(US_SCLN)": { + "key": "US_PILC", + "label": "¶", + } + "ALGR(US_QUOT)": { + "key": "US_ACUT", + "label": "´ (dead)", + } + "ALGR(US_Z)": { + "key": "US_AE", + "label": "Æ", + } + "ALGR(US_X)": { + "key": "US_OE_2", + "label": "Å’", + } + "ALGR(US_C)": { + "key": "US_COPY", + "label": "©", + } + "ALGR(US_V)": { + "key": "US_REGD", + "label": "®", + } + "ALGR(US_N)": { + "key": "US_NTIL", + "label": "Ñ", + } + "ALGR(US_M)": { + "key": "US_MICR", + "label": "µ", + } + "ALGR(US_COMM)": { + "key": "US_CCED", + "label": "Ç", + } + "ALGR(US_DOT)": { + "key": "US_DOTA", + "label": "Ë™ (dead)", + } + "ALGR(US_SLSH)": { + "key": "US_IQUE", + "label": "¿", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ¡ │ Ë â”‚ ¯ │ £ │ ¸ │ ¼ │ ½ │ ¾ │ ˘ │ ° │ Ì£ │ ÷ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ “ │ †│ ¦ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ § │ │ │ │ │ │ │ │ ° │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ ¢ │ │ │ │ │ │ ˇ │ ̉ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(US_GRV))": { + "key": "US_DTIL", + "label": "~ (dead)", + } + "S(ALGR(US_1))": { + "key": "US_IEXL", + "label": "¡", + } + "S(ALGR(US_2))": { + "key": "US_DACU", + "label": "Ë (dead)", + } + "S(ALGR(US_3))": { + "key": "US_MACR", + "label": "¯ (dead)", + } + "S(ALGR(US_4))": { + "key": "US_PND", + "label": "£", + } + "S(ALGR(US_5))": { + "key": "US_CEDL", + "label": "¸ (dead)", + } + "S(ALGR(US_6))": { + "key": "US_QRTR", + "label": "¼", + } + "S(ALGR(US_7))": { + "key": "US_HALF", + "label": "½", + } + "S(ALGR(US_8))": { + "key": "US_TQTR", + "label": "¾", + } + "S(ALGR(US_9))": { + "key": "US_BREV", + "label": "˘ (dead)", + } + "S(ALGR(US_0))": { + "key": "US_RNGA", + "label": "° (dead)", + } + "S(ALGR(US_MINS))": { + "key": "US_DOTB", + "label": "Ì£ (dead)", + } + "S(ALGR(US_EQL))": { + "key": "US_DIV", + "label": "÷", + } + "S(ALGR(US_LBRC))": { + "key": "US_LDQU", + "label": "“", + } + "S(ALGR(US_RBRC))": { + "key": "US_RDQU", + "label": "â€", + } + "S(ALGR(US_BSLS))": { + "key": "US_BRKP", + "label": "¦", + } + "S(ALGR(US_S))": { + "key": "US_SECT", + "label": "§", + } + "S(ALGR(US_SCLN))": { + "key": "US_DEG", + "label": "°", + } + "S(ALGR(US_QUOT))": { + "key": "US_DIAE", + "label": "¨ (dead)", + } + "S(ALGR(US_C))": { + "key": "US_CENT", + "label": "¢", + } + "S(ALGR(US_DOT))": { + "key": "US_CARN", + "label": "ˇ (dead)", + } + "S(ALGR(US_SLSH))": { + "key": "US_HOKA", + "label": "̉ (dead)", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_us_international_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_us_international_0.0.1.hjson new file mode 100644 index 0000000000..36a574a4ad --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_us_international_0.0.1.hjson @@ -0,0 +1,508 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ´ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "US_DGRV", + "label": "` (dead)", + } + "KC_1": { + "key": "US_1", + "label": "1", + } + "KC_2": { + "key": "US_2", + "label": "2", + } + "KC_3": { + "key": "US_3", + "label": "3", + } + "KC_4": { + "key": "US_4", + "label": "4", + } + "KC_5": { + "key": "US_5", + "label": "5", + } + "KC_6": { + "key": "US_6", + "label": "6", + } + "KC_7": { + "key": "US_7", + "label": "7", + } + "KC_8": { + "key": "US_8", + "label": "8", + } + "KC_9": { + "key": "US_9", + "label": "9", + } + "KC_0": { + "key": "US_0", + "label": "0", + } + "KC_MINS": { + "key": "US_MINS", + "label": "-", + } + "KC_EQL": { + "key": "US_EQL", + "label": "=", + } + "KC_Q": { + "key": "US_Q", + "label": "Q", + } + "KC_W": { + "key": "US_W", + "label": "W", + } + "KC_E": { + "key": "US_E", + "label": "E", + } + "KC_R": { + "key": "US_R", + "label": "R", + } + "KC_T": { + "key": "US_T", + "label": "T", + } + "KC_Y": { + "key": "US_Y", + "label": "Y", + } + "KC_U": { + "key": "US_U", + "label": "U", + } + "KC_I": { + "key": "US_I", + "label": "I", + } + "KC_O": { + "key": "US_O", + "label": "O", + } + "KC_P": { + "key": "US_P", + "label": "P", + } + "KC_LBRC": { + "key": "US_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "US_RBRC", + "label": "]", + } + "KC_BSLS": { + "key": "US_BSLS", + "label": "\\", + } + "KC_A": { + "key": "US_A", + "label": "A", + } + "KC_S": { + "key": "US_S", + "label": "S", + } + "KC_D": { + "key": "US_D", + "label": "D", + } + "KC_F": { + "key": "US_F", + "label": "F", + } + "KC_G": { + "key": "US_G", + "label": "G", + } + "KC_H": { + "key": "US_H", + "label": "H", + } + "KC_J": { + "key": "US_J", + "label": "J", + } + "KC_K": { + "key": "US_K", + "label": "K", + } + "KC_L": { + "key": "US_L", + "label": "L", + } + "KC_SCLN": { + "key": "US_SCLN", + "label": ";", + } + "KC_QUOT": { + "key": "US_ACUT", + "label": "´ (dead)", + } + "KC_Z": { + "key": "US_Z", + "label": "Z", + } + "KC_X": { + "key": "US_X", + "label": "X", + } + "KC_C": { + "key": "US_C", + "label": "C", + } + "KC_V": { + "key": "US_V", + "label": "V", + } + "KC_B": { + "key": "US_B", + "label": "B", + } + "KC_N": { + "key": "US_N", + "label": "N", + } + "KC_M": { + "key": "US_M", + "label": "M", + } + "KC_COMM": { + "key": "US_COMM", + "label": ",", + } + "KC_DOT": { + "key": "US_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "US_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ ¨ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(US_DGRV)": { + "key": "US_DTIL", + "label": "~ (dead)", + } + "S(US_1)": { + "key": "US_EXLM", + "label": "!", + } + "S(US_2)": { + "key": "US_AT", + "label": "@", + } + "S(US_3)": { + "key": "US_HASH", + "label": "#", + } + "S(US_4)": { + "key": "US_DLR", + "label": "$", + } + "S(US_5)": { + "key": "US_PERC", + "label": "%", + } + "S(US_6)": { + "key": "US_DCIR", + "label": "^ (dead)", + } + "S(US_7)": { + "key": "US_AMPR", + "label": "&", + } + "S(US_8)": { + "key": "US_ASTR", + "label": "*", + } + "S(US_9)": { + "key": "US_LPRN", + "label": "(", + } + "S(US_0)": { + "key": "US_RPRN", + "label": ")", + } + "S(US_MINS)": { + "key": "US_UNDS", + "label": "_", + } + "S(US_EQL)": { + "key": "US_PLUS", + "label": "+", + } + "S(US_LBRC)": { + "key": "US_LCBR", + "label": "{", + } + "S(US_RBRC)": { + "key": "US_RCBR", + "label": "}", + } + "S(US_BSLS)": { + "key": "US_PIPE", + "label": "|", + } + "S(US_SCLN)": { + "key": "US_COLN", + "label": ":", + } + "S(US_ACUT)": { + "key": "US_DIAE", + "label": "¨ (dead)", + } + "S(US_COMM)": { + "key": "US_LABK", + "label": "<", + } + "S(US_DOT)": { + "key": "US_RABK", + "label": ">", + } + "S(US_SLSH)": { + "key": "US_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ¡ │ ² │ ³ │ ¤ │ € │ ¼ │ ½ │ ¾ │ ‘ │ ’ │ Â¥ │ × │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Ä │ Ã… │ É │ ® │ Þ │ Ãœ │ Ú │ à │ Ó │ Ö │ « │ » │ ¬ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ à │ ß │ à │ │ │ │ │ │ Ø │ ¶ │ ´ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Æ │ │ © │ │ │ Ñ │ µ │ Ç │ │ ¿ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(US_1)": { + "key": "US_IEXL", + "label": "¡", + } + "ALGR(US_2)": { + "key": "US_SUP2", + "label": "²", + } + "ALGR(US_3)": { + "key": "US_SUP3", + "label": "³", + } + "ALGR(US_4)": { + "key": "US_CURR", + "label": "¤", + } + "ALGR(US_5)": { + "key": "US_EURO", + "label": "€", + } + "ALGR(US_6)": { + "key": "US_QRTR", + "label": "¼", + } + "ALGR(US_7)": { + "key": "US_HALF", + "label": "½", + } + "ALGR(US_8)": { + "key": "US_TQTR", + "label": "¾", + } + "ALGR(US_9)": { + "key": "US_LSQU", + "label": "‘", + } + "ALGR(US_0)": { + "key": "US_RSQU", + "label": "’", + } + "ALGR(US_MINS)": { + "key": "US_YEN", + "label": "Â¥", + } + "ALGR(US_EQL)": { + "key": "US_MUL", + "label": "×", + } + "ALGR(US_Q)": { + "key": "US_ADIA", + "label": "Ä", + } + "ALGR(US_W)": { + "key": "US_ARNG", + "label": "Ã…", + } + "ALGR(US_E)": { + "key": "US_EACU", + "label": "É", + } + "ALGR(US_R)": { + "key": "US_REGD", + "label": "®", + } + "ALGR(US_T)": { + "key": "US_THRN", + "label": "Þ", + } + "ALGR(US_Y)": { + "key": "US_UDIA", + "label": "Ãœ", + } + "ALGR(US_U)": { + "key": "US_UACU", + "label": "Ú", + } + "ALGR(US_I)": { + "key": "US_IACU", + "label": "Ã", + } + "ALGR(US_O)": { + "key": "US_OACU", + "label": "Ó", + } + "ALGR(US_P)": { + "key": "US_ODIA", + "label": "Ö", + } + "ALGR(US_LBRC)": { + "key": "US_LDAQ", + "label": "«", + } + "ALGR(US_RBRC)": { + "key": "US_RDAQ", + "label": "»", + } + "ALGR(US_BSLS)": { + "key": "US_NOT", + "label": "¬", + } + "ALGR(US_A)": { + "key": "US_AACU", + "label": "Ã", + } + "ALGR(US_S)": { + "key": "US_SS", + "label": "ß", + } + "ALGR(US_D)": { + "key": "US_ETH", + "label": "Ã", + } + "ALGR(US_L)": { + "key": "US_OSTR", + "label": "Ø", + } + "ALGR(US_SCLN)": { + "key": "US_PILC", + "label": "¶", + } + "ALGR(US_ACUT)": { + "key": "US_NDAC", + "label": "´", + } + "ALGR(US_Z)": { + "key": "US_AE", + "label": "Æ", + } + "ALGR(US_C)": { + "key": "US_COPY", + "label": "©", + } + "ALGR(US_N)": { + "key": "US_NTIL", + "label": "Ñ", + } + "ALGR(US_M)": { + "key": "US_MICR", + "label": "µ", + } + "ALGR(US_COMM)": { + "key": "US_CCED", + "label": "Ç", + } + "ALGR(US_SLSH)": { + "key": "US_IQUE", + "label": "¿", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ │ ¹ │ │ │ £ │ │ │ │ │ │ │ │ ÷ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ │ │ ¦ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ § │ │ │ │ │ │ │ │ ° │ ¨ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ ¢ │ │ │ │ │ │ │ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(US_1))": { + "key": "US_SUP1", + "label": "¹", + } + "S(ALGR(US_4))": { + "key": "US_PND", + "label": "£", + } + "S(ALGR(US_EQL))": { + "key": "US_DIV", + "label": "÷", + } + "S(ALGR(US_BSLS))": { + "key": "US_BRKP", + "label": "¦", + } + "S(ALGR(US_S))": { + "key": "US_SECT", + "label": "§", + } + "S(ALGR(US_SCLN))": { + "key": "US_DEG", + "label": "°", + } + "S(ALGR(US_ACUT))": { + "key": "US_NDDR", + "label": "¨", + } + "S(ALGR(US_C))": { + "key": "US_CENT", + "label": "¢", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_us_international_linux_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_us_international_linux_0.0.1.hjson new file mode 100644 index 0000000000..d6bdf2e02d --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_us_international_linux_0.0.1.hjson @@ -0,0 +1,576 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ´ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "US_DGRV", + "label": "` (dead)", + } + "KC_1": { + "key": "US_1", + "label": "1", + } + "KC_2": { + "key": "US_2", + "label": "2", + } + "KC_3": { + "key": "US_3", + "label": "3", + } + "KC_4": { + "key": "US_4", + "label": "4", + } + "KC_5": { + "key": "US_5", + "label": "5", + } + "KC_6": { + "key": "US_6", + "label": "6", + } + "KC_7": { + "key": "US_7", + "label": "7", + } + "KC_8": { + "key": "US_8", + "label": "8", + } + "KC_9": { + "key": "US_9", + "label": "9", + } + "KC_0": { + "key": "US_0", + "label": "0", + } + "KC_MINS": { + "key": "US_MINS", + "label": "-", + } + "KC_EQL": { + "key": "US_EQL", + "label": "=", + } + "KC_Q": { + "key": "US_Q", + "label": "Q", + } + "KC_W": { + "key": "US_W", + "label": "W", + } + "KC_E": { + "key": "US_E", + "label": "E", + } + "KC_R": { + "key": "US_R", + "label": "R", + } + "KC_T": { + "key": "US_T", + "label": "T", + } + "KC_Y": { + "key": "US_Y", + "label": "Y", + } + "KC_U": { + "key": "US_U", + "label": "U", + } + "KC_I": { + "key": "US_I", + "label": "I", + } + "KC_O": { + "key": "US_O", + "label": "O", + } + "KC_P": { + "key": "US_P", + "label": "P", + } + "KC_LBRC": { + "key": "US_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "US_RBRC", + "label": "]", + } + "KC_BSLS": { + "key": "US_BSLS", + "label": "\\", + } + "KC_A": { + "key": "US_A", + "label": "A", + } + "KC_S": { + "key": "US_S", + "label": "S", + } + "KC_D": { + "key": "US_D", + "label": "D", + } + "KC_F": { + "key": "US_F", + "label": "F", + } + "KC_G": { + "key": "US_G", + "label": "G", + } + "KC_H": { + "key": "US_H", + "label": "H", + } + "KC_J": { + "key": "US_J", + "label": "J", + } + "KC_K": { + "key": "US_K", + "label": "K", + } + "KC_L": { + "key": "US_L", + "label": "L", + } + "KC_SCLN": { + "key": "US_SCLN", + "label": ";", + } + "KC_QUOT": { + "key": "US_ACUT", + "label": "´ (dead)", + } + "KC_Z": { + "key": "US_Z", + "label": "Z", + } + "KC_X": { + "key": "US_X", + "label": "X", + } + "KC_C": { + "key": "US_C", + "label": "C", + } + "KC_V": { + "key": "US_V", + "label": "V", + } + "KC_B": { + "key": "US_B", + "label": "B", + } + "KC_N": { + "key": "US_N", + "label": "N", + } + "KC_M": { + "key": "US_M", + "label": "M", + } + "KC_COMM": { + "key": "US_COMM", + "label": ",", + } + "KC_DOT": { + "key": "US_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "US_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ ¨ │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(US_DGRV)": { + "key": "US_DTIL", + "label": "~ (dead)", + } + "S(US_1)": { + "key": "US_EXLM", + "label": "!", + } + "S(US_2)": { + "key": "US_AT", + "label": "@", + } + "S(US_3)": { + "key": "US_HASH", + "label": "#", + } + "S(US_4)": { + "key": "US_DLR", + "label": "$", + } + "S(US_5)": { + "key": "US_PERC", + "label": "%", + } + "S(US_6)": { + "key": "US_DCIR", + "label": "^ (dead)", + } + "S(US_7)": { + "key": "US_AMPR", + "label": "&", + } + "S(US_8)": { + "key": "US_ASTR", + "label": "*", + } + "S(US_9)": { + "key": "US_LPRN", + "label": "(", + } + "S(US_0)": { + "key": "US_RPRN", + "label": ")", + } + "S(US_MINS)": { + "key": "US_UNDS", + "label": "_", + } + "S(US_EQL)": { + "key": "US_PLUS", + "label": "+", + } + "S(US_LBRC)": { + "key": "US_LCBR", + "label": "{", + } + "S(US_RBRC)": { + "key": "US_RCBR", + "label": "}", + } + "S(US_BSLS)": { + "key": "US_PIPE", + "label": "|", + } + "S(US_SCLN)": { + "key": "US_COLN", + "label": ":", + } + "S(US_ACUT)": { + "key": "US_DIAE", + "label": "¨ (dead)", + } + "S(US_COMM)": { + "key": "US_LABK", + "label": "<", + } + "S(US_DOT)": { + "key": "US_RABK", + "label": ">", + } + "S(US_SLSH)": { + "key": "US_QUES", + "label": "?", + } +/* AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ ¡ │ ² │ ³ │ ¤ │ € │ ¼ │ ½ │ ¾ │ ‘ │ ’ │ Â¥ │ × │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Ä │ Ã… │ É │ ® │ Þ │ Ãœ │ Ú │ à │ Ó │ Ö │ « │ » │ ¬ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ à │ ß │ à │ │ │ │ │ Å’ │ Ø │ ¶ │ ' │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Æ │ │ © │ │ │ Ñ │ µ │ Ç │ Ë™ │ ¿ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "ALGR(US_DGRV)": { + "key": "US_GRV", + "label": "`", + } + "ALGR(US_1)": { + "key": "US_IEXL", + "label": "¡", + } + "ALGR(US_2)": { + "key": "US_SUP2", + "label": "²", + } + "ALGR(US_3)": { + "key": "US_SUP3", + "label": "³", + } + "ALGR(US_4)": { + "key": "US_CURR", + "label": "¤", + } + "ALGR(US_5)": { + "key": "US_EURO", + "label": "€", + } + "ALGR(US_6)": { + "key": "US_QRTR", + "label": "¼", + } + "ALGR(US_7)": { + "key": "US_HALF", + "label": "½", + } + "ALGR(US_8)": { + "key": "US_TQTR", + "label": "¾", + } + "ALGR(US_9)": { + "key": "US_LSQU", + "label": "‘", + } + "ALGR(US_0)": { + "key": "US_RSQU", + "label": "’", + } + "ALGR(US_MINS)": { + "key": "US_YEN", + "label": "Â¥", + } + "ALGR(US_EQL)": { + "key": "US_MUL", + "label": "×", + } + "ALGR(US_Q)": { + "key": "US_ADIA", + "label": "Ä", + } + "ALGR(US_W)": { + "key": "US_ARNG", + "label": "Ã…", + } + "ALGR(US_E)": { + "key": "US_EACU", + "label": "É", + } + "ALGR(US_R)": { + "key": "US_REGD", + "label": "®", + } + "ALGR(US_T)": { + "key": "US_THRN", + "label": "Þ", + } + "ALGR(US_Y)": { + "key": "US_UDIA", + "label": "Ãœ", + } + "ALGR(US_U)": { + "key": "US_UACU", + "label": "Ú", + } + "ALGR(US_I)": { + "key": "US_IACU", + "label": "Ã", + } + "ALGR(US_O)": { + "key": "US_OACU", + "label": "Ó", + } + "ALGR(US_P)": { + "key": "US_ODIA", + "label": "Ö", + } + "ALGR(US_LBRC)": { + "key": "US_LDAQ", + "label": "«", + } + "ALGR(US_RBRC)": { + "key": "US_RDAQ", + "label": "»", + } + "ALGR(US_BSLS)": { + "key": "US_NOT", + "label": "¬", + } + "ALGR(US_A)": { + "key": "US_AACU", + "label": "Ã", + } + "ALGR(US_S)": { + "key": "US_SS", + "label": "ß", + } + "ALGR(US_D)": { + "key": "US_ETH", + "label": "Ã", + } + "ALGR(US_K)": { + "key": "US_OE", + "label": "Å’", + } + "ALGR(US_L)": { + "key": "US_OSTR", + "label": "Ø", + } + "ALGR(US_SCLN)": { + "key": "US_PILC", + "label": "¶", + } + "ALGR(US_ACUT)": { + "key": "US_QUOT", + "label": "'", + } + "ALGR(US_Z)": { + "key": "US_AE", + "label": "Æ", + } + "ALGR(US_C)": { + "key": "US_COPY", + "label": "©", + } + "ALGR(US_N)": { + "key": "US_NTIL", + "label": "Ñ", + } + "ALGR(US_M)": { + "key": "US_MICR", + "label": "µ", + } + "ALGR(US_COMM)": { + "key": "US_CCED", + "label": "Ç", + } + "ALGR(US_DOT)": { + "key": "US_DOTA", + "label": "Ë™ (dead)", + } + "ALGR(US_SLSH)": { + "key": "US_IQUE", + "label": "¿", + } +/* Shift+AltGr symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ¹ │ Ë â”‚ ¯ │ £ │ ¸ │ ^ │ Ì› │ Ë› │ ˘ │ ° │ Ì£ │ ÷ │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ “ │ †│ ¦ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ § │ │ │ │ │ │ │ │ ° │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ ¢ │ │ │ │ │ │ ˇ │ ̉ │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(ALGR(US_DGRV))": { + "key": "US_TILD", + "label": "~", + } + "S(ALGR(US_1))": { + "key": "US_SUP1", + "label": "¹", + } + "S(ALGR(US_2))": { + "key": "US_DACU", + "label": "Ë (dead)", + } + "S(ALGR(US_3))": { + "key": "US_MACR", + "label": "¯ (dead)", + } + "S(ALGR(US_4))": { + "key": "US_PND", + "label": "£", + } + "S(ALGR(US_5))": { + "key": "US_CEDL", + "label": "¸ (dead)", + } + "S(ALGR(US_6))": { + "key": "US_CIRC", + "label": "^", + } + "S(ALGR(US_7))": { + "key": "US_HORN", + "label": "Ì› (dead)", + } + "S(ALGR(US_8))": { + "key": "US_OGON", + "label": "Ë› (dead)", + } + "S(ALGR(US_9))": { + "key": "US_BREV", + "label": "˘ (dead)", + } + "S(ALGR(US_0))": { + "key": "US_RNGA", + "label": "° (dead)", + } + "S(ALGR(US_MINS))": { + "key": "US_DOTB", + "label": "Ì£ (dead)", + } + "S(ALGR(US_EQL))": { + "key": "US_DIV", + "label": "÷", + } + "S(ALGR(US_LBRC))": { + "key": "US_LDQU", + "label": "“", + } + "S(ALGR(US_RBRC))": { + "key": "US_RDQU", + "label": "â€", + } + "S(ALGR(US_BSLS))": { + "key": "US_BRKP", + "label": "¦", + } + "S(ALGR(US_S))": { + "key": "US_SECT", + "label": "§", + } + "S(ALGR(US_SCLN))": { + "key": "US_DEG", + "label": "°", + } + "S(ALGR(US_ACUT))": { + "key": "US_DQUO", + "label": "\"", + } + "S(ALGR(US_C))": { + "key": "US_CENT", + "label": "¢", + } + "S(ALGR(US_DOT))": { + "key": "US_CARN", + "label": "ˇ (dead)", + } + "S(ALGR(US_SLSH))": { + "key": "US_HOKA", + "label": "̉ (dead)", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_workman_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_workman_0.0.1.hjson new file mode 100644 index 0000000000..27471a15e4 --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_workman_0.0.1.hjson @@ -0,0 +1,302 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ D │ R │ W │ B │ J │ F │ U │ P │ ; │ [ │ ] │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ S │ H │ T │ G │ Y │ N │ E │ O │ I │ ' │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Z │ X │ M │ C │ V │ K │ L │ , │ . │ / │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "WK_GRV", + "label": "`", + } + "KC_1": { + "key": "WK_1", + "label": "1", + } + "KC_2": { + "key": "WK_2", + "label": "2", + } + "KC_3": { + "key": "WK_3", + "label": "3", + } + "KC_4": { + "key": "WK_4", + "label": "4", + } + "KC_5": { + "key": "WK_5", + "label": "5", + } + "KC_6": { + "key": "WK_6", + "label": "6", + } + "KC_7": { + "key": "WK_7", + "label": "7", + } + "KC_8": { + "key": "WK_8", + "label": "8", + } + "KC_9": { + "key": "WK_9", + "label": "9", + } + "KC_0": { + "key": "WK_0", + "label": "0", + } + "KC_MINS": { + "key": "WK_MINS", + "label": "-", + } + "KC_EQL": { + "key": "WK_EQL", + "label": "=", + } + "KC_Q": { + "key": "WK_Q", + "label": "Q", + } + "KC_W": { + "key": "WK_D", + "label": "D", + } + "KC_E": { + "key": "WK_R", + "label": "R", + } + "KC_R": { + "key": "WK_W", + "label": "W", + } + "KC_T": { + "key": "WK_B", + "label": "B", + } + "KC_Y": { + "key": "WK_J", + "label": "J", + } + "KC_U": { + "key": "WK_F", + "label": "F", + } + "KC_I": { + "key": "WK_U", + "label": "U", + } + "KC_O": { + "key": "WK_P", + "label": "P", + } + "KC_P": { + "key": "WK_SCLN", + "label": ";", + } + "KC_LBRC": { + "key": "WK_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "WK_RBRC", + "label": "]", + } + "KC_BSLS": { + "key": "WK_BSLS", + "label": "\\", + } + "KC_A": { + "key": "WK_A", + "label": "A", + } + "KC_S": { + "key": "WK_S", + "label": "S", + } + "KC_D": { + "key": "WK_H", + "label": "H", + } + "KC_F": { + "key": "WK_T", + "label": "T", + } + "KC_G": { + "key": "WK_G", + "label": "G", + } + "KC_H": { + "key": "WK_Y", + "label": "Y", + } + "KC_J": { + "key": "WK_N", + "label": "N", + } + "KC_K": { + "key": "WK_E", + "label": "E", + } + "KC_L": { + "key": "WK_O", + "label": "O", + } + "KC_SCLN": { + "key": "WK_I", + "label": "I", + } + "KC_QUOT": { + "key": "WK_QUOT", + "label": "'", + } + "KC_Z": { + "key": "WK_Z", + "label": "Z", + } + "KC_X": { + "key": "WK_X", + "label": "X", + } + "KC_C": { + "key": "WK_M", + "label": "M", + } + "KC_V": { + "key": "WK_C", + "label": "C", + } + "KC_B": { + "key": "WK_V", + "label": "V", + } + "KC_N": { + "key": "WK_K", + "label": "K", + } + "KC_M": { + "key": "WK_L", + "label": "L", + } + "KC_COMM": { + "key": "WK_COMM", + "label": ",", + } + "KC_DOT": { + "key": "WK_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "WK_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(WK_GRV)": { + "key": "WK_TILD", + "label": "~", + } + "S(WK_1)": { + "key": "WK_EXLM", + "label": "!", + } + "S(WK_2)": { + "key": "WK_AT", + "label": "@", + } + "S(WK_3)": { + "key": "WK_HASH", + "label": "#", + } + "S(WK_4)": { + "key": "WK_DLR", + "label": "$", + } + "S(WK_5)": { + "key": "WK_PERC", + "label": "%", + } + "S(WK_6)": { + "key": "WK_CIRC", + "label": "^", + } + "S(WK_7)": { + "key": "WK_AMPR", + "label": "&", + } + "S(WK_8)": { + "key": "WK_ASTR", + "label": "*", + } + "S(WK_9)": { + "key": "WK_LPRN", + "label": "(", + } + "S(WK_0)": { + "key": "WK_RPRN", + "label": ")", + } + "S(WK_MINS)": { + "key": "WK_UNDS", + "label": "_", + } + "S(WK_EQL)": { + "key": "WK_PLUS", + "label": "+", + } + "S(WK_SCLN)": { + "key": "WK_COLN", + "label": ":", + } + "S(WK_LBRC)": { + "key": "WK_LCBR", + "label": "{", + } + "S(WK_RBRC)": { + "key": "WK_RCBR", + "label": "}", + } + "S(WK_BSLS)": { + "key": "WK_PIPE", + "label": "|", + } + "S(WK_QUOT)": { + "key": "WK_DQUO", + "label": "\"", + } + "S(WK_COMM)": { + "key": "WK_LABK", + "label": "<", + } + "S(WK_DOT)": { + "key": "WK_RABK", + "label": ">", + } + "S(WK_SLSH)": { + "key": "WK_QUES", + "label": "?", + } + } +}
\ No newline at end of file diff --git a/data/constants/keycodes/extras/keycodes_workman_zxcvm_0.0.1.hjson b/data/constants/keycodes/extras/keycodes_workman_zxcvm_0.0.1.hjson new file mode 100644 index 0000000000..86f6a5bffb --- /dev/null +++ b/data/constants/keycodes/extras/keycodes_workman_zxcvm_0.0.1.hjson @@ -0,0 +1,302 @@ +{ + "aliases": { +/* + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ Q │ D │ R │ W │ B │ J │ F │ U │ P │ ; │ [ │ ] │ \ │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ A │ S │ H │ T │ G │ Y │ N │ E │ O │ I │ ' │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ Z │ X │ C │ V │ M │ K │ L │ , │ . │ / │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "KC_GRV": { + "key": "WK_GRV", + "label": "`", + } + "KC_1": { + "key": "WK_1", + "label": "1", + } + "KC_2": { + "key": "WK_2", + "label": "2", + } + "KC_3": { + "key": "WK_3", + "label": "3", + } + "KC_4": { + "key": "WK_4", + "label": "4", + } + "KC_5": { + "key": "WK_5", + "label": "5", + } + "KC_6": { + "key": "WK_6", + "label": "6", + } + "KC_7": { + "key": "WK_7", + "label": "7", + } + "KC_8": { + "key": "WK_8", + "label": "8", + } + "KC_9": { + "key": "WK_9", + "label": "9", + } + "KC_0": { + "key": "WK_0", + "label": "0", + } + "KC_MINS": { + "key": "WK_MINS", + "label": "-", + } + "KC_EQL": { + "key": "WK_EQL", + "label": "=", + } + "KC_Q": { + "key": "WK_Q", + "label": "Q", + } + "KC_W": { + "key": "WK_D", + "label": "D", + } + "KC_E": { + "key": "WK_R", + "label": "R", + } + "KC_R": { + "key": "WK_W", + "label": "W", + } + "KC_T": { + "key": "WK_B", + "label": "B", + } + "KC_Y": { + "key": "WK_J", + "label": "J", + } + "KC_U": { + "key": "WK_F", + "label": "F", + } + "KC_I": { + "key": "WK_U", + "label": "U", + } + "KC_O": { + "key": "WK_P", + "label": "P", + } + "KC_P": { + "key": "WK_SCLN", + "label": ";", + } + "KC_LBRC": { + "key": "WK_LBRC", + "label": "[", + } + "KC_RBRC": { + "key": "WK_RBRC", + "label": "]", + } + "KC_BSLS": { + "key": "WK_BSLS", + "label": "\\", + } + "KC_A": { + "key": "WK_A", + "label": "A", + } + "KC_S": { + "key": "WK_S", + "label": "S", + } + "KC_D": { + "key": "WK_H", + "label": "H", + } + "KC_F": { + "key": "WK_T", + "label": "T", + } + "KC_G": { + "key": "WK_G", + "label": "G", + } + "KC_H": { + "key": "WK_Y", + "label": "Y", + } + "KC_J": { + "key": "WK_N", + "label": "N", + } + "KC_K": { + "key": "WK_E", + "label": "E", + } + "KC_L": { + "key": "WK_O", + "label": "O", + } + "KC_SCLN": { + "key": "WK_I", + "label": "I", + } + "KC_QUOT": { + "key": "WK_QUOT", + "label": "'", + } + "KC_Z": { + "key": "WK_Z", + "label": "Z", + } + "KC_X": { + "key": "WK_X", + "label": "X", + } + "KC_C": { + "key": "WK_C", + "label": "C", + } + "KC_V": { + "key": "WK_V", + "label": "V", + } + "KC_B": { + "key": "WK_M", + "label": "M", + } + "KC_N": { + "key": "WK_K", + "label": "K", + } + "KC_M": { + "key": "WK_L", + "label": "L", + } + "KC_COMM": { + "key": "WK_COMM", + "label": ",", + } + "KC_DOT": { + "key": "WK_DOT", + "label": ".", + } + "KC_SLSH": { + "key": "WK_SLSH", + "label": "/", + } +/* Shifted symbols + * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠+ * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ + * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ + * │ │ │ │ │ │ │ │ │ │ │ : │ { │ } │ | │ + * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ + * │ │ │ │ │ │ │ │ │ │ │ │ " │ │ + * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ + * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ + * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ + * │ │ │ │ │ │ │ │ │ + * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ + */ + "S(WK_GRV)": { + "key": "WK_TILD", + "label": "~", + } + "S(WK_1)": { + "key": "WK_EXLM", + "label": "!", + } + "S(WK_2)": { + "key": "WK_AT", + "label": "@", + } + "S(WK_3)": { + "key": "WK_HASH", + "label": "#", + } + "S(WK_4)": { + "key": "WK_DLR", + "label": "$", + } + "S(WK_5)": { + "key": "WK_PERC", + "label": "%", + } + "S(WK_6)": { + "key": "WK_CIRC", + "label": "^", + } + "S(WK_7)": { + "key": "WK_AMPR", + "label": "&", + } + "S(WK_8)": { + "key": "WK_ASTR", + "label": "*", + } + "S(WK_9)": { + "key": "WK_LPRN", + "label": "(", + } + "S(WK_0)": { + "key": "WK_RPRN", + "label": ")", + } + "S(WK_MINS)": { + "key": "WK_UNDS", + "label": "_", + } + "S(WK_EQL)": { + "key": "WK_PLUS", + "label": "+", + } + "S(WK_SCLN)": { + "key": "WK_COLN", + "label": ":", + } + "S(WK_LBRC)": { + "key": "WK_LCBR", + "label": "{", + } + "S(WK_RBRC)": { + "key": "WK_RCBR", + "label": "}", + } + "S(WK_BSLS)": { + "key": "WK_PIPE", + "label": "|", + } + "S(WK_QUOT)": { + "key": "WK_DQUO", + "label": "\"", + } + "S(WK_COMM)": { + "key": "WK_LABK", + "label": "<", + } + "S(WK_DOT)": { + "key": "WK_RABK", + "label": ">", + } + "S(WK_SLSH)": { + "key": "WK_QUES", + "label": "?", + } + } +}
\ No newline at end of file diff --git a/data/mappings/info_config.hjson b/data/mappings/info_config.hjson index c1c01ff70f..7645598c77 100644 --- a/data/mappings/info_config.hjson +++ b/data/mappings/info_config.hjson @@ -18,6 +18,10 @@ "BACKLIGHT_ON_STATE": {"info_key": "backlight.on_state", "value_type": "int"}, "BACKLIGHT_PIN": {"info_key": "backlight.pin"}, "BACKLIGHT_PINS": {"info_key": "backlight.pins", "value_type": "array"}, + "BOOTMAGIC_LITE_ROW": {"info_key": "bootmagic.matrix.0", "value_type": "int"}, + "BOOTMAGIC_LITE_COLUMN": {"info_key": "bootmagic.matrix.1", "value_type": "int"}, + "BOOTMAGIC_LITE_ROW_RIGHT": {"info_key": "split.bootmagic.matrix.0", "value_type": "int"}, + "BOOTMAGIC_LITE_COLUMN_RIGHT": {"info_key": "split.bootmagic.matrix.1", "value_type": "int"}, "BOTH_SHIFTS_TURNS_ON_CAPS_WORD": {"info_key": "caps_word.both_shifts_turns_on", "value_type": "bool"}, "CAPS_WORD_IDLE_TIMEOUT": {"info_key": "caps_word.idle_timeout", "value_type": "int"}, "COMBO_COUNT": {"info_key": "combo.count", "value_type": "int"}, @@ -28,8 +32,6 @@ "FORCE_NKRO": {"info_key": "usb.force_nkro", "value_type": "bool"}, "DYNAMIC_KEYMAP_EEPROM_MAX_ADDR": {"info_key": "dynamic_keymap.eeprom_max_addr", "value_type": "int"}, "DYNAMIC_KEYMAP_LAYER_COUNT": {"info_key": "dynamic_keymap.layer_count", "value_type": "int"}, - "IGNORE_MOD_TAP_INTERRUPT": {"info_key": "tapping.ignore_mod_tap_interrupt", "value_type": "bool"}, - "IGNORE_MOD_TAP_INTERRUPT_PER_KEY": {"info_key": "tapping.ignore_mod_tap_interrupt_per_key", "value_type": "bool"}, "HOLD_ON_OTHER_KEY_PRESS": {"info_key": "tapping.hold_on_other_key_press", "value_type": "bool"}, "HOLD_ON_OTHER_KEY_PRESS_PER_KEY": {"info_key": "tapping.hold_on_other_key_press_per_key", "value_type": "bool"}, "LAYOUTS": {"info_key": "layout_aliases", "value_type": "mapping"}, @@ -51,6 +53,7 @@ "LED_MATRIX_VAL_STEP": {"info_key": "led_matrix.val_steps", "value_type": "int"}, "LED_MATRIX_SPD_STEP": {"info_key": "led_matrix.speed_steps", "value_type": "int"}, "MATRIX_HAS_GHOST": {"info_key": "matrix_pins.ghost", "value_type": "bool"}, + "MATRIX_INPUT_PRESSED_STATE": {"info_key": "matrix_pins.input_pressed_state", "value_type": "int"}, "MATRIX_IO_DELAY": {"info_key": "matrix_pins.io_delay", "value_type": "int"}, "MOUSEKEY_DELAY": {"info_key": "mousekey.delay", "value_type": "int"}, "MOUSEKEY_INTERVAL": {"info_key": "mousekey.interval", "value_type": "int"}, @@ -106,8 +109,6 @@ "SOFT_SERIAL_SPEED": {"info_key": "split.soft_serial_speed"}, "TAP_CODE_DELAY": {"info_key": "qmk.tap_keycode_delay", "value_type": "int"}, "TAP_HOLD_CAPS_DELAY": {"info_key": "qmk.tap_capslock_delay", "value_type": "int"}, - "TAPPING_FORCE_HOLD": {"info_key": "tapping.force_hold", "value_type": "bool"}, - "TAPPING_FORCE_HOLD_PER_KEY": {"info_key": "tapping.force_hold_per_key", "value_type": "bool"}, "TAPPING_TERM": {"info_key": "tapping.term", "value_type": "int"}, "TAPPING_TERM_PER_KEY": {"info_key": "tapping.term_per_key", "value_type": "bool"}, "TAPPING_TOGGLE": {"info_key": "tapping.toggle", "value_type": "int"}, @@ -122,8 +123,12 @@ "DEBOUNCING_DELAY": {"info_key": "_invalid.debouncing_delay", "invalid": true, "replace_with": "DEBOUNCE"}, "PREVENT_STUCK_MODIFIERS": {"info_key": "_invalid.prevent_stuck_mods", "invalid": true}, "UNUSED_PINS": {"info_key": "_invalid.unused_pins", "deprecated": true}, - "RGBLIGHT_ANIMATIONS": {"info_key": "rgblight.animations.all", "value_type": "bool", "deprecated": true}, + "RGBLIGHT_ANIMATIONS": {"info_key": "_invalid.rgblight.animations.all", "value_type": "bool", "invalid": true}, "QMK_KEYS_PER_SCAN": {"info_key": "qmk.keys_per_scan", "value_type": "int", "deprecated": true}, + "TAPPING_FORCE_HOLD": {"info_key": "tapping.force_hold", "value_type": "bool", "deprecated": true}, + "TAPPING_FORCE_HOLD_PER_KEY": {"info_key": "tapping.force_hold_per_key", "value_type": "bool", "deprecated": true}, + "IGNORE_MOD_TAP_INTERRUPT": {"info_key": "_deprecated.ignore_mod_tap_interrupt", "value_type": "bool", "deprecated": true}, + "IGNORE_MOD_TAP_INTERRUPT_PER_KEY": {"info_key": "_invalid.ignore_mod_tap_interrupt_per_key", "invalid": true} // USB params, need to mark as failure when specified in config.h, rather than deprecated "PRODUCT_ID": {"info_key": "usb.pid", "value_type": "hex", "deprecated": true, "replace_with": "`usb.pid` in info.json"}, diff --git a/data/mappings/info_rules.hjson b/data/mappings/info_rules.hjson index 2f8656c4bf..b020d0c813 100644 --- a/data/mappings/info_rules.hjson +++ b/data/mappings/info_rules.hjson @@ -12,6 +12,7 @@ // replace_with: use with a key marked deprecated or invalid to designate a replacement "BOARD": {"info_key": "board"}, "BOOTLOADER": {"info_key": "bootloader", "warn_duplicate": false}, + "BOOTMAGIC_ENABLE": {"info_key": "bootmagic.enabled", "value_type": "bool"}, "BLUETOOTH_DRIVER": {"info_key": "bluetooth.driver"}, "CAPS_WORD_ENABLE": {"info_key": "caps_word.enabled", "value_type": "bool"}, "DEBOUNCE_TYPE": {"info_key": "build.debounce_type"}, diff --git a/data/schemas/keyboard.jsonschema b/data/schemas/keyboard.jsonschema index 921726a5e9..513564a643 100644 --- a/data/schemas/keyboard.jsonschema +++ b/data/schemas/keyboard.jsonschema @@ -131,6 +131,22 @@ } } }, + "bootmagic":{ + "type": "object", + "additionalProperties": false, + "properties": { + "enabled": {"type": "boolean"}, + "matrix": { + "type": "array", + "minItems": 2, + "maxItems": 2, + "items": { + "type": "integer", + "minimum": 0 + } + } + } + }, "board": { "type": "string", "minLength": 2, @@ -288,6 +304,7 @@ "custom": {"type": "boolean"}, "custom_lite": {"type": "boolean"}, "ghost": {"type": "boolean"}, + "input_pressed_state": {"$ref": "qmk.definitions.v1#/unsigned_int"}, "io_delay": {"$ref": "qmk.definitions.v1#/unsigned_int"}, "direct": { "type": "array", @@ -511,6 +528,21 @@ "additionalProperties": false, "properties": { "enabled": {"type": "boolean"}, + "bootmagic":{ + "type": "object", + "additionalProperties": false, + "properties": { + "matrix": { + "type": "array", + "minItems": 2, + "maxItems": 2, + "items": { + "type": "integer", + "minimum": 0 + } + } + } + }, "matrix_grid": { "type": "array", "items": {"$ref": "qmk.definitions.v1#/mcu_pin"} @@ -588,7 +620,6 @@ "force_hold": {"type": "boolean"}, "force_hold_per_key": {"type": "boolean"}, "ignore_mod_tap_interrupt": {"type": "boolean"}, - "ignore_mod_tap_interrupt_per_key": {"type": "boolean"}, "hold_on_other_key_press": {"type": "boolean"}, "hold_on_other_key_press_per_key": {"type": "boolean"}, "permissive_hold": {"type": "boolean"}, diff --git a/platforms/chibios/boards/keyboard-config-templates/board.h b/data/templates/config-overrides/chibios/board.h index 5b840c389c..5b840c389c 100644 --- a/platforms/chibios/boards/keyboard-config-templates/board.h +++ b/data/templates/config-overrides/chibios/board.h diff --git a/platforms/chibios/boards/keyboard-config-templates/chconf.h b/data/templates/config-overrides/chibios/chconf.h index fca444747c..fca444747c 100644 --- a/platforms/chibios/boards/keyboard-config-templates/chconf.h +++ b/data/templates/config-overrides/chibios/chconf.h diff --git a/platforms/chibios/boards/keyboard-config-templates/halconf.h b/data/templates/config-overrides/chibios/halconf.h index 456020f16a..456020f16a 100644 --- a/platforms/chibios/boards/keyboard-config-templates/halconf.h +++ b/data/templates/config-overrides/chibios/halconf.h diff --git a/platforms/chibios/boards/keyboard-config-templates/mcuconf.h b/data/templates/config-overrides/chibios/mcuconf.h index c690b02f4b..c690b02f4b 100644 --- a/platforms/chibios/boards/keyboard-config-templates/mcuconf.h +++ b/data/templates/config-overrides/chibios/mcuconf.h diff --git a/data/templates/config-overrides/common/lv_conf.h b/data/templates/config-overrides/common/lv_conf.h new file mode 100644 index 0000000000..5c003a6a10 --- /dev/null +++ b/data/templates/config-overrides/common/lv_conf.h @@ -0,0 +1,10 @@ +// Copyright 2022 Nick Brassel (@tzarc) +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +// #define LV_DITHER_GRADIENT 1 + +#include_next <lv_conf.h> + +// #undef LV_COLOR_16_SWAP +// #define LV_COLOR_16_SWAP 0 diff --git a/docs/ChangeLog/20230226/PR15741.md b/docs/ChangeLog/20230226/PR15741.md new file mode 100644 index 0000000000..385816d65b --- /dev/null +++ b/docs/ChangeLog/20230226/PR15741.md @@ -0,0 +1,43 @@ +`IGNORE_MOD_TAP_INTERRUPT_PER_KEY` has been removed and `IGNORE_MOD_TAP_INTERRUPT` deprecated as a stepping stone towards making `IGNORE_MOD_TAP_INTERRUPT` the new default behavior for mod-taps in the future. + +In place of the now removed `IGNORE_MOD_TAP_INTERRUPT_PER_KEY`, one must use the pre-existing `HOLD_ON_OTHER_KEY_PRESS` option. + +In most cases, updating `get_ignore_mod_tap_interrupt` to `get_hold_on_other_key_press` is simply a matter of renaming the function and swapping every `true` by `false` and vice versa. The one subtlety you may need to look out for is that the `get_ignore_mod_tap_interrupt` was only ever called with mod-taps passed in as the `keycode` argument, while the `keycode` argument of `get_hold_on_other_key_press` can be any dual-role key. This includes not only mod-taps, but also layer-taps, one shot keys, `TT(layer)` and more. This has an impact on the effect of the `default` case in a typical per-key configuration making use of a `switch(keycode)` statement. + +To illustrate, let's take the example of a configuration where we'd want all mod-taps to activate the modifier if another key is pressed while held with the exception of `LCTL_T(KC_A)`, which should ignore keys pressed while it is held and activate the modifier only if it has been held for longer than the tapping term. In addition, we would like to keep the default "ignore-interrupt" behavior of layer taps. + +An old way to do this would be via the following code: + +```c +bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { + switch(keycode) { + case LCTL_T(KC_A): + return true; + default: + return false; + } +} +``` + +The correct way to update this code without accidentally changing how the layer-taps work would be the following: + +```c +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { + switch(keycode) { + // Capture all mod-tap keycodes. + case QK_MOD_TAP ... QK_MOD_TAP_MAX: + if (keycode == LCTL_T(KC_A)) { + // Disable HOLD_ON_OTHER_KEY_PRESS for LCTL_T(KC_A) + // aka enable IGNORE_MOD_TAP_INTERRUPT for LCTL_T(KC_A). + return false; + } else { + // Enable HOLD_ON_OTHER_KEY_PRESS for every other mod-tap keycode. + return true; + } + default: + return false; + } +} +``` + +For more information, you are invited to read the sections on [IGNORE_MOD_TAP_INTERRUPT](tap_hold.md#ignore-mod-tap-interrupt) and [HOLD_ON_OTHER_KEY_PRESS](tap_hold.md#hold-on-other-key-press) in the page on [Tap-Hold configuration options](tap_hold.md). diff --git a/docs/ChangeLog/20230226/PR17007.md b/docs/ChangeLog/20230226/PR17007.md new file mode 100644 index 0000000000..bea04994b5 --- /dev/null +++ b/docs/ChangeLog/20230226/PR17007.md @@ -0,0 +1,31 @@ +`TAPPING_FORCE_HOLD` feature is now replaced by `QUICK_TAP_TERM`. Instead of turning off auto-repeat completely, user will have the option to configure a `QUICK_TAP_TERM` in milliseconds. When the user holds a tap-hold key after tapping it within `QUICK_TAP_TERM`, QMK will send the tap keycode to the host, enabling auto-repeat. + +Its value is set to `TAPPING_TERM` by default and it can be reduced to match typing habits to avoid false triggers. To disable auto-repeat completely, set `QUICK_TAP_TERM` to zero. + +`TAPPING_FORCE_HOLD_PER_KEY` is also deprecated and replaced by `QUICK_TAP_TERM_PER_KEY`. The old granular control function for tapping force hold is: + +```c +bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { + switch (keycode) { + case LT(1, KC_BSPC): + return true; + default: + return false; + } +} +``` + +That function can be replaced with: + +```c +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { + switch (keycode) { + case SFT_T(KC_SPC): + return 0; + default: + return QUICK_TAP_TERM; + } +} +``` + +For more details, please read the updated documentation section on [Quick Tap Term](tap_hold.md#quick-tap-term). diff --git a/docs/_summary.md b/docs/_summary.md index 738c24ee42..d2d4bb9b32 100644 --- a/docs/_summary.md +++ b/docs/_summary.md @@ -85,6 +85,7 @@ * [Key Overrides](feature_key_overrides.md) * [Layers](feature_layers.md) * [One Shot Keys](one_shot_keys.md) + * [OS Detection](feature_os_detection.md) * [Raw HID](feature_rawhid.md) * [Secure](feature_secure.md) * [Send String](feature_send_string.md) @@ -99,6 +100,7 @@ * Hardware Features * Displays * [Quantum Painter](quantum_painter.md) + * [Quantum Painter LVGL Integration](quantum_painter_lvgl.md) * [HD44780 LCD Driver](feature_hd44780.md) * [ST7565 LCD Driver](feature_st7565.md) * [OLED Driver](feature_oled_driver.md) diff --git a/docs/config_options.md b/docs/config_options.md index 6b1f83214c..7a91160bcd 100644 --- a/docs/config_options.md +++ b/docs/config_options.md @@ -169,14 +169,18 @@ If you define these options you will enable the associated feature, which may in * `#define IGNORE_MOD_TAP_INTERRUPT` * makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the `TAPPING_TERM` for both keys. * See [Ignore Mod Tap Interrupt](tap_hold.md#ignore-mod-tap-interrupt) for details -* `#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY` - * enables handling for per key `IGNORE_MOD_TAP_INTERRUPT` settings -* `#define TAPPING_FORCE_HOLD` - * makes it possible to use a dual role key as modifier shortly after having been tapped - * See [Tapping Force Hold](tap_hold.md#tapping-force-hold) - * Breaks any Tap Toggle functionality (`TT` or the One Shot Tap Toggle) -* `#define TAPPING_FORCE_HOLD_PER_KEY` - * enables handling for per key `TAPPING_FORCE_HOLD` settings +* `#define QUICK_TAP_TERM 100` + * tap-then-hold timing to use a dual role key to repeat keycode + * See [Quick Tap Term](tap_hold.md#quick-tap-term) + * Changes the timing of Tap Toggle functionality (`TT` or the One Shot Tap Toggle) + * Defaults to `TAPPING_TERM` if not defined +* `#define QUICK_TAP_TERM_PER_KEY` + * enables handling for per key `QUICK_TAP_TERM` settings +* `#define HOLD_ON_OTHER_KEY_PRESS` + * selects the hold action of a dual-role key as soon as the tap of the dual-role key is interrupted by the press of another key. + * See "[hold on other key press](tap_hold.md#hold-on-other-key-press)" for details +* `#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY` + * enables handling for per key `HOLD_ON_OTHER_KEY_PRESS` settings * `#define LEADER_TIMEOUT 300` * how long before the leader key times out * If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the `LEADER_PER_KEY_TIMING` option, which resets the timeout after each key is tapped. diff --git a/docs/feature_auto_shift.md b/docs/feature_auto_shift.md index d3437a9c60..1719807e26 100644 --- a/docs/feature_auto_shift.md +++ b/docs/feature_auto_shift.md @@ -281,16 +281,7 @@ Tap Hold Configurations work a little differently when using Retro Shift. Referencing `TAPPING_TERM` makes little sense, as holding longer would result in shifting one of the keys. -`IGNORE_MOD_TAP_INTERRUPT` changes *only* rolling from a mod tap (releasing it -first), sending both keys instead of the modifier on the second. Its effects on -nested presses are ignored. - -As nested taps were changed to act as though `PERMISSIVE_HOLD` is set unless only -`IGNORE_MOD_TAP_INTERRUPT` is (outside of Retro Shift), and Retro Shift ignores -`IGNORE_MOD_TAP_INTERRUPT`, `PERMISSIVE_HOLD` has no effect on Mod Taps. - -Nested taps will *always* act as though the `TAPPING_TERM` was exceeded for both -Mod and Layer Tap keys. +`RETRO_SHIFT` enables [`PERMISSIVE_HOLD`-like behaviour](tap_hold.md#permissive-hold) (even if not explicitly enabled) on all mod-taps for which `RETRO_SHIFT` applies. ## Using Auto Shift Setup diff --git a/docs/feature_leader_key.md b/docs/feature_leader_key.md index e285d10597..4e7a487be7 100644 --- a/docs/feature_leader_key.md +++ b/docs/feature_leader_key.md @@ -93,18 +93,18 @@ While, this may be fine for most, if you want to specify the whole keycode (eg, ## Customization -The Leader Key feature has some additional customization to how the Leader Key feature works. It has two functions that can be called at certain parts of the process. Namely `leader_start()` and `leader_end()`. +The Leader Key feature has some additional customization to how the Leader Key feature works. It has two functions that can be called at certain parts of the process. Namely `leader_start_user()` and `leader_end_user()`. -The `leader_start()` function is called when you tap the `QK_LEAD` key, and the `leader_end()` function is called when either the leader sequence is completed, or the leader timeout is hit. +The `leader_start_user()` function is called when you tap the `QK_LEAD` key, and the `leader_end_user()` function is called when either the leader sequence is completed, or the leader timeout is hit. You can add these functions to your code (`keymap.c` usually) to add feedback to the Leader sequences (such as beeping or playing music). ```c -void leader_start(void) { +void leader_start_user(void) { // sequence started } -void leader_end(void) { +void leader_end_user(void) { // sequence ended (no success/failure detection) } ``` @@ -139,13 +139,13 @@ void matrix_scan_user(void) { } } -void leader_start(void) { +void leader_start_user(void) { #ifdef AUDIO_ENABLE PLAY_SONG(leader_start); #endif } -void leader_end(void) { +void leader_end_user(void) { if (did_leader_succeed) { #ifdef AUDIO_ENABLE PLAY_SONG(leader_succeed); diff --git a/docs/feature_led_indicators.md b/docs/feature_led_indicators.md index d89562a377..1f71cdb1c8 100644 --- a/docs/feature_led_indicators.md +++ b/docs/feature_led_indicators.md @@ -19,7 +19,7 @@ There are three ways to get the lock LED state: Two deprecated functions that provide the LED state as `uint8_t`: -* `uint8_t led_set_kb(uint8_t usb_led)` and `_user(uint8_t usb_led)` +* `uint8_t led_set_user(uint8_t usb_led)` * `uint8_t host_keyboard_leds()` ## Configuration Options diff --git a/docs/feature_os_detection.md b/docs/feature_os_detection.md new file mode 100644 index 0000000000..f32e419807 --- /dev/null +++ b/docs/feature_os_detection.md @@ -0,0 +1,77 @@ +# OS Detection + +This feature makes a best guess at the host OS based on OS specific behavior during USB setup. It may not always get the correct OS, and shouldn't be relied on as for critical functionality. + +Using it you can have OS specific key mappings or combos which work differently on different devices. + +It is available for keyboards which use ChibiOS, LUFA and V-USB. + +## Usage + +In your `rules.mk` add: + +```make +OS_DETECTION_ENABLE = yes +``` + +Include `"os_detection.h"` in your `keymap.c`. +It declares `os_variant_t detected_host_os(void);` which you can call to get detected OS. + +It returns one of the following values: + +```c +enum { + OS_UNSURE, + OS_LINUX, + OS_WINDOWS, + OS_MACOS, + OS_IOS, +} os_variant_t; +``` + +?> Note that it takes some time after firmware is booted to detect the OS. +This time is quite short, probably hundreds of milliseconds, but this data may be not ready in keyboard and layout setup functions which run very early during firmware startup. + +## Debug + +If OS is guessed incorrectly, you may want to collect data about USB setup packets to refine the detection logic. + +To do so in your `rules.mk` add: + +```make +OS_DETECTION_DEBUG_ENABLE = yes +CONSOLE_ENABLE = yes +``` + +And also include `"os_detection.h"` in your `keymap.c`. + +Then you can define custom keycodes to store data about USB setup packets in EEPROM (persistent memory) and to print it later on host where you can run `qmk console`: + +```c +enum custom_keycodes { + STORE_SETUPS = SAFE_RANGE, + PRINT_SETUPS, +}; + +bool process_record_user(uint16_t keycode, keyrecord_t *record) { + switch (keycode) { + case STORE_SETUPS: + if (record->event.pressed) { + store_setups_in_eeprom(); + } + return false; + case PRINT_SETUPS: + if (record->event.pressed) { + print_stored_setups(); + } + return false; + } +} +``` + +Then please open an issue on Github with this information and tell what OS was not detected correctly and if you have any intermediate devices between keyboard and your computer. + + +## Credits + +Original idea is coming from [FingerprintUSBHost](https://github.com/keyboardio/FingerprintUSBHost) project. diff --git a/docs/feature_pointing_device.md b/docs/feature_pointing_device.md index be984dd5a5..ecb7ee42cb 100644 --- a/docs/feature_pointing_device.md +++ b/docs/feature_pointing_device.md @@ -22,11 +22,11 @@ POINTING_DEVICE_DRIVER = adns5050 The ADNS 5050 sensor uses a serial type protocol for communication, and requires an additional light source. -| Setting | Description | Default | -| ------------------- | ------------------------------------------------------------------- | -------------------------- | -| `ADNS5050_SCLK_PIN` | (Required) The pin connected to the clock pin of the sensor. | `POINTING_DEVICE_SCLK_PIN` | -| `ADNS5050_SDIO_PIN` | (Required) The pin connected to the data pin of the sensor. | `POINTING_DEVICE_SDIO_PIN` | -| `ADNS5050_CS_PIN` | (Required) The pin connected to the cable select pin of the sensor. | `POINTING_DEVICE_CS_PIN` | +| Setting | Description | Default | +| ------------------- | ------------------------------------------------------------------ | -------------------------- | +| `ADNS5050_SCLK_PIN` | (Required) The pin connected to the clock pin of the sensor. | `POINTING_DEVICE_SCLK_PIN` | +| `ADNS5050_SDIO_PIN` | (Required) The pin connected to the data pin of the sensor. | `POINTING_DEVICE_SDIO_PIN` | +| `ADNS5050_CS_PIN` | (Required) The pin connected to the Chip Select pin of the sensor. | `POINTING_DEVICE_CS_PIN` | @@ -48,7 +48,7 @@ The ADNS 9800 is an SPI driven optical sensor, that uses laser output for surfac | `ADNS9800_SPI_LSBFIRST` | (Optional) Sets the Least/Most Significant Byte First setting for SPI. | `false` | | `ADNS9800_SPI_MODE` | (Optional) Sets the SPI Mode for the sensor. | `3` | | `ADNS9800_SPI_DIVISOR` | (Optional) Sets the SPI Divisor used for SPI communication. | _varies_ | -| `ADNS9800_CS_PIN` | (Required) Sets the Cable Select pin connected to the sensor. | `POINTING_DEVICE_CS_PIN` | +| `ADNS9800_CS_PIN` | (Required) Sets the Chip Select pin connected to the sensor. | `POINTING_DEVICE_CS_PIN` | The CPI range is 800-8200, in increments of 200. Defaults to 1800 CPI. @@ -124,7 +124,7 @@ Default attenuation is set to 4X, although if you are using a thicker overlay (s | `CIRQUE_PINNACLE_SPI_LSBFIRST` | (Optional) Sets the Least/Most Significant Byte First setting for SPI. | `false` | | `CIRQUE_PINNACLE_SPI_MODE` | (Optional) Sets the SPI Mode for the sensor. | `1` | | `CIRQUE_PINNACLE_SPI_DIVISOR` | (Optional) Sets the SPI Divisor used for SPI communication. | _varies_ | -| `CIRQUE_PINNACLE_SPI_CS_PIN` | (Required) Sets the Cable Select pin connected to the sensor. | `POINTING_DEVICE_CS_PIN` | +| `CIRQUE_PINNACLE_SPI_CS_PIN` | (Required) Sets the Chip Select pin connected to the sensor. | `POINTING_DEVICE_CS_PIN` | Default Scaling is 1024. Actual CPI depends on trackpad diameter. @@ -218,11 +218,14 @@ POINTING_DEVICE_DRIVER = pmw3389 The CPI range is 50-16000, in increments of 50. Defaults to 2000 CPI. Both PMW 3360 and PMW 3389 are SPI driven optical sensors, that use a built in IR LED for surface tracking. +If you have different CS wiring on each half you can use `PMW33XX_CS_PIN_RIGHT` or `PMW33XX_CS_PINS_RIGHT` in combination with `PMW33XX_CS_PIN` or `PMW33XX_CS_PINS` to configure both sides independently. If `_RIGHT` values aren't provided, they default to be the same as the left ones. | Setting | Description | Default | | ---------------------------- | ------------------------------------------------------------------------------------------- | ------------------------ | -| `PMW33XX_CS_PIN` | (Required) Sets the Cable Select pin connected to the sensor. | `POINTING_DEVICE_CS_PIN` | -| `PMW33XX_CS_PINS` | (Alternative) Sets the Cable Select pins connected to multiple sensors. | _not defined_ | +| `PMW33XX_CS_PIN` | (Required) Sets the Chip Select pin connected to the sensor. | `POINTING_DEVICE_CS_PIN` | +| `PMW33XX_CS_PINS` | (Alternative) Sets the Chip Select pins connected to multiple sensors. | `{PMW33XX_CS_PIN}` | +| `PMW33XX_CS_PIN_RIGHT` | (Optional) Sets the Chip Select pin connected to the sensor on the right half. | `PMW33XX_CS_PIN` | +| `PMW33XX_CS_PINS_RIGHT` | (Optional) Sets the Chip Select pins connected to multiple sensors on the right half. | `{PMW33XX_CS_PIN_RIGHT}` | | `PMW33XX_CPI` | (Optional) Sets counts per inch sensitivity of the sensor. | _varies_ | | `PMW33XX_CLOCK_SPEED` | (Optional) Sets the clock speed that the sensor runs at. | `2000000` | | `PMW33XX_SPI_DIVISOR` | (Optional) Sets the SPI Divisor used for SPI communication. | _varies_ | diff --git a/docs/feature_tap_dance.md b/docs/feature_tap_dance.md index 1062e32243..b7d8a5528f 100644 --- a/docs/feature_tap_dance.md +++ b/docs/feature_tap_dance.md @@ -64,7 +64,7 @@ enum { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Escape, twice for Caps Lock [TD_ESC_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS), }; @@ -96,14 +96,14 @@ enum { #### Example 1: Send "Safety Dance!" After 100 Taps :id=example-1 ```c -void dance_egg(qk_tap_dance_state_t *state, void *user_data) { +void dance_egg(tap_dance_state_t *state, void *user_data) { if (state->count >= 100) { SEND_STRING("Safety dance!"); reset_tap_dance(state); } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [CT_EGG] = ACTION_TAP_DANCE_FN(dance_egg), }; ``` @@ -113,7 +113,7 @@ qk_tap_dance_action_t tap_dance_actions[] = { ```c // On each tap, light up one LED, from right to left // On the fourth tap, turn them off from right to left -void dance_flsh_each(qk_tap_dance_state_t *state, void *user_data) { +void dance_flsh_each(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: ergodox_right_led_3_on(); @@ -134,14 +134,14 @@ void dance_flsh_each(qk_tap_dance_state_t *state, void *user_data) { } // On the fourth tap, set the keyboard on flash state -void dance_flsh_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_flsh_finished(tap_dance_state_t *state, void *user_data) { if (state->count >= 4) { reset_keyboard(); } } // If the flash state didn't happen, then turn off LEDs, left to right -void dance_flsh_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_flsh_reset(tap_dance_state_t *state, void *user_data) { ergodox_right_led_1_off(); wait_ms(50); ergodox_right_led_2_off(); @@ -150,7 +150,7 @@ void dance_flsh_reset(qk_tap_dance_state_t *state, void *user_data) { } // All tap dances now put together. Example 2 is "CT_FLSH" -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESC_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS), [CT_EGG] = ACTION_TAP_DANCE_FN(dance_egg), [CT_FLSH] = ACTION_TAP_DANCE_FN_ADVANCED(dance_flsh_each, dance_flsh_finished, dance_flsh_reset) @@ -169,7 +169,7 @@ typedef struct { } tap_dance_tap_hold_t; bool process_record_user(uint16_t keycode, keyrecord_t *record) { - qk_tap_dance_action_t *action; + tap_dance_action_t *action; switch (keycode) { case TD(CT_CLN): // list all tap dance keycodes with tap-hold configurations @@ -182,7 +182,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -void tap_dance_tap_hold_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_tap_hold_finished(tap_dance_state_t *state, void *user_data) { tap_dance_tap_hold_t *tap_hold = (tap_dance_tap_hold_t *)user_data; if (state->pressed) { @@ -200,7 +200,7 @@ void tap_dance_tap_hold_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void tap_dance_tap_hold_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_tap_hold_reset(tap_dance_state_t *state, void *user_data) { tap_dance_tap_hold_t *tap_hold = (tap_dance_tap_hold_t *)user_data; if (tap_hold->held) { @@ -212,7 +212,7 @@ void tap_dance_tap_hold_reset(qk_tap_dance_state_t *state, void *user_data) { #define ACTION_TAP_DANCE_TAP_HOLD(tap, hold) \ { .fn = {NULL, tap_dance_tap_hold_finished, tap_dance_tap_hold_reset}, .user_data = (void *)&((tap_dance_tap_hold_t){tap, hold, 0}), } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [CT_CLN] = ACTION_TAP_DANCE_TAP_HOLD(KC_COLN, KC_SCLN), }; ``` @@ -256,11 +256,11 @@ enum { SOME_OTHER_DANCE }; -td_state_t cur_dance(qk_tap_dance_state_t *state); +td_state_t cur_dance(tap_dance_state_t *state); // For the x tap dance. Put it here so it can be used in any keymap -void x_finished(qk_tap_dance_state_t *state, void *user_data); -void x_reset(qk_tap_dance_state_t *state, void *user_data); +void x_finished(tap_dance_state_t *state, void *user_data); +void x_reset(tap_dance_state_t *state, void *user_data); ``` Now, at the bottom of your `keymap.c` file, you'll need to add the following: @@ -293,7 +293,7 @@ Now, at the bottom of your `keymap.c` file, you'll need to add the following: * For the third point, there does exist the 'TD_DOUBLE_SINGLE_TAP', however this is not fully tested * */ -td_state_t cur_dance(qk_tap_dance_state_t *state) { +td_state_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return TD_SINGLE_TAP; // Key has not been interrupted, but the key is still held. Means you want to send a 'HOLD'. @@ -322,7 +322,7 @@ static td_tap_t xtap_state = { .state = TD_NONE }; -void x_finished(qk_tap_dance_state_t *state, void *user_data) { +void x_finished(tap_dance_state_t *state, void *user_data) { xtap_state.state = cur_dance(state); switch (xtap_state.state) { case TD_SINGLE_TAP: register_code(KC_X); break; @@ -337,7 +337,7 @@ void x_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void x_reset(qk_tap_dance_state_t *state, void *user_data) { +void x_reset(tap_dance_state_t *state, void *user_data) { switch (xtap_state.state) { case TD_SINGLE_TAP: unregister_code(KC_X); break; case TD_SINGLE_HOLD: unregister_code(KC_LCTL); break; @@ -349,7 +349,7 @@ void x_reset(qk_tap_dance_state_t *state, void *user_data) { xtap_state.state = TD_NONE; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [X_CTL] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished, x_reset) }; ``` @@ -385,18 +385,18 @@ static td_state_t td_state; // Declare your tapdance functions: // Function to determine the current tapdance state -td_state_t cur_dance(qk_tap_dance_state_t *state); +td_state_t cur_dance(tap_dance_state_t *state); // `finished` and `reset` functions for each tapdance keycode -void altlp_finished(qk_tap_dance_state_t *state, void *user_data); -void altlp_reset(qk_tap_dance_state_t *state, void *user_data); +void altlp_finished(tap_dance_state_t *state, void *user_data); +void altlp_reset(tap_dance_state_t *state, void *user_data); ``` Below your `LAYOUT`, define each of the tapdance functions: ```c // Determine the tapdance state to return -td_state_t cur_dance(qk_tap_dance_state_t *state) { +td_state_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return TD_SINGLE_TAP; else return TD_SINGLE_HOLD; @@ -408,7 +408,7 @@ td_state_t cur_dance(qk_tap_dance_state_t *state) { // Handle the possible states for each tapdance keycode you define: -void altlp_finished(qk_tap_dance_state_t *state, void *user_data) { +void altlp_finished(tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case TD_SINGLE_TAP: @@ -426,7 +426,7 @@ void altlp_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void altlp_reset(qk_tap_dance_state_t *state, void *user_data) { +void altlp_reset(tap_dance_state_t *state, void *user_data) { switch (td_state) { case TD_SINGLE_TAP: unregister_code16(KC_LPRN); @@ -443,7 +443,7 @@ void altlp_reset(qk_tap_dance_state_t *state, void *user_data) { } // Define `ACTION_TAP_DANCE_FN_ADVANCED()` for each tapdance keycode, passing in `finished` and `reset` functions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ALT_LP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altlp_finished, altlp_reset) }; ``` @@ -478,18 +478,18 @@ enum { // Declare the functions to be used with your tap dance key(s) // Function associated with all tap dances -td_state_t cur_dance(qk_tap_dance_state_t *state); +td_state_t cur_dance(tap_dance_state_t *state); // Functions associated with individual tap dances -void ql_finished(qk_tap_dance_state_t *state, void *user_data); -void ql_reset(qk_tap_dance_state_t *state, void *user_data); +void ql_finished(tap_dance_state_t *state, void *user_data); +void ql_reset(tap_dance_state_t *state, void *user_data); ``` Towards the bottom of your `keymap.c`, include the following code: ```c // Determine the current tap dance state -td_state_t cur_dance(qk_tap_dance_state_t *state) { +td_state_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (!state->pressed) return TD_SINGLE_TAP; else return TD_SINGLE_HOLD; @@ -504,7 +504,7 @@ static td_tap_t ql_tap_state = { }; // Functions that control what our tap dance key does -void ql_finished(qk_tap_dance_state_t *state, void *user_data) { +void ql_finished(tap_dance_state_t *state, void *user_data) { ql_tap_state.state = cur_dance(state); switch (ql_tap_state.state) { case TD_SINGLE_TAP: @@ -528,7 +528,7 @@ void ql_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void ql_reset(qk_tap_dance_state_t *state, void *user_data) { +void ql_reset(tap_dance_state_t *state, void *user_data) { // If the key was held down and now is released then switch off the layer if (ql_tap_state.state == TD_SINGLE_HOLD) { layer_off(_MY_LAYER); @@ -537,7 +537,7 @@ void ql_reset(qk_tap_dance_state_t *state, void *user_data) { } // Associate our tap dance key with its functionality -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [QUOT_LAYR] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ql_finished, ql_reset) }; diff --git a/docs/feature_unicode.md b/docs/feature_unicode.md index a93e9ad2ba..1ea411191e 100644 --- a/docs/feature_unicode.md +++ b/docs/feature_unicode.md @@ -83,7 +83,7 @@ UCIS_ENABLE = yes Then define a table like this in your keymap file: ```c -const qk_ucis_symbol_t ucis_symbol_table[] = UCIS_TABLE( +const ucis_symbol_t ucis_symbol_table[] = UCIS_TABLE( UCIS_SYM("poop", 0x1F4A9), // 💩 UCIS_SYM("rofl", 0x1F923), // 🤣 UCIS_SYM("cuba", 0x1F1E8, 0x1F1FA), // 🇨🇺 @@ -93,15 +93,15 @@ const qk_ucis_symbol_t ucis_symbol_table[] = UCIS_TABLE( By default, each table entry may be up to 3 code points long. This number can be changed by adding `#define UCIS_MAX_CODE_POINTS n` to your `config.h` file. -To use UCIS input, call `qk_ucis_start()`. Then, type the mnemonic for the character (such as "rofl") and hit Space, Enter or Esc. QMK should erase the "rofl" text and insert the laughing emoji. +To use UCIS input, call `ucis_start()`. Then, type the mnemonic for the character (such as "rofl") and hit Space, Enter or Esc. QMK should erase the "rofl" text and insert the laughing emoji. #### Customization There are several functions that you can define in your keymap to customize the functionality of this feature. -* `void qk_ucis_start_user(void)` – This runs when you call the "start" function, and can be used to provide feedback. By default, it types out a keyboard emoji. -* `void qk_ucis_success(uint8_t symbol_index)` – This runs when the input has matched something and has completed. By default, it doesn't do anything. -* `void qk_ucis_symbol_fallback (void)` – This runs when the input doesn't match anything. By default, it falls back to trying that input as a Unicode code. +* `void ucis_start_user(void)` – This runs when you call the "start" function, and can be used to provide feedback. By default, it types out a keyboard emoji. +* `void ucis_success(uint8_t symbol_index)` – This runs when the input has matched something and has completed. By default, it doesn't do anything. +* `void ucis_symbol_fallback (void)` – This runs when the input doesn't match anything. By default, it falls back to trying that input as a Unicode code. You can find the default implementations of these functions in [`process_ucis.c`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_ucis.c). diff --git a/docs/hardware_keyboard_guidelines.md b/docs/hardware_keyboard_guidelines.md index 6df86fb0fb..247ec9982f 100644 --- a/docs/hardware_keyboard_guidelines.md +++ b/docs/hardware_keyboard_guidelines.md @@ -188,7 +188,7 @@ The following functions are typically defined in this file: * `void matrix_init_kb(void)` * `void matrix_scan_kb(void)` * `bool process_record_kb(uint16_t keycode, keyrecord_t *record)` -* `void led_set_kb(uint8_t usb_led)` +* `bool led_update_kb(led_t led_state)` ### `<keyboard_name.h>` diff --git a/docs/ja/config_options.md b/docs/ja/config_options.md index c95753bd5d..6135721a42 100644 --- a/docs/ja/config_options.md +++ b/docs/ja/config_options.md @@ -162,8 +162,6 @@ QMK ã§ã®å…¨ã¦ã®åˆ©ç”¨å¯èƒ½ãªè¨å®šã«ã¯ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆãŒã‚ã‚Šã¾ã™ã€‚ã * `#define IGNORE_MOD_TAP_INTERRUPT` * 両方ã®ã‚ー㫠`TAPPING_TERM` ã‚’é©ç”¨ã™ã‚‹ã“ã¨ã§ã€ãƒ›ãƒ¼ãƒ«ãƒ‰æ™‚ã«ä»–ã®ã‚ーã«å¤‰æ›ã™ã‚‹ã‚ーを使ã£ã¦ãƒãƒ¼ãƒªãƒ³ã‚°ã‚³ãƒ³ãƒœ (zx) ã‚’ã™ã‚‹ã“ã¨ãŒã§ãるよã†ã«ã—ã¾ã™ * 詳細㯠[Ignore Mod Tap Interrupt](ja/tap_hold.md#ignore-mod-tap-interrupt) を見ã¦ãã ã•ã„ -* `#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY` - * ã‚ーã”ã¨ã® `IGNORE_MOD_TAP_INTERRUPT` è¨å®šã®å‡¦ç†ã‚’有効ã«ã—ã¾ã™ * `#define TAPPING_FORCE_HOLD` * タップã•ã‚ŒãŸç›´å¾Œã«ã€ãƒ‡ãƒ¥ã‚¢ãƒ«ãƒãƒ¼ãƒ«ã‚ーを修飾åã¨ã—ã¦ä½¿ç”¨ã§ãるよã†ã«ã—ã¾ã™ * [Tapping Force Hold](ja/tap_hold.md#tapping-force-hold)を見ã¦ãã ã•ã„ diff --git a/docs/ja/feature_grave_esc.md b/docs/ja/feature_grave_esc.md index 8c6680d74d..746e9e5d14 100644 --- a/docs/ja/feature_grave_esc.md +++ b/docs/ja/feature_grave_esc.md @@ -9,7 +9,7 @@ ## 使用法 -ã‚ーマップ内㮠`KC_GRAVE` ã‚ー (通常ã¯`1` ã‚ーã®å·¦)ã‚’ `KC_GESC` ã«ç½®ãæ›ãˆã¾ã™ã€‚ã»ã¨ã‚“ã©ã®å ´åˆã€ã“ã®ã‚ーã¯æŠ¼ã•ã‚ŒãŸæ™‚ã« `KC_ESC` を出力ã—ã¾ã™ã€‚ãŸã ã—ã€Shift ã‚ã‚‹ã„㯠GUI を押ã—ãŸã¾ã¾ã«ã™ã‚‹ã¨ã€ä»£ã‚ã‚Šã« `KC_GRV` を出力ã—ã¾ã™ã€‚ +ã‚ーマップ内㮠`KC_GRAVE` ã‚ー (通常ã¯`1` ã‚ーã®å·¦)ã‚’ `QK_GESC` ã«ç½®ãæ›ãˆã¾ã™ã€‚ã»ã¨ã‚“ã©ã®å ´åˆã€ã“ã®ã‚ーã¯æŠ¼ã•ã‚ŒãŸæ™‚ã« `KC_ESC` を出力ã—ã¾ã™ã€‚ãŸã ã—ã€Shift ã‚ã‚‹ã„㯠GUI を押ã—ãŸã¾ã¾ã«ã™ã‚‹ã¨ã€ä»£ã‚ã‚Šã« `KC_GRV` を出力ã—ã¾ã™ã€‚ ## OS ã«è¦‹ãˆã‚‹ã‚‚ã® @@ -19,7 +19,7 @@ | ã‚ー | エイリアス | 説明 | |---------|-----------|------------------------------------------------------------------| -| `KC_GESC` | `GRAVE_ESC` | 押ã•ã‚ŒãŸå ´åˆã« Escape。Shift ã‚ã‚‹ã„㯠GUI ãŒæŠ¼ã•ã‚ŒãŸã¾ã¾ã®å ´åˆã¯ <code>`</code> | +| `QK_GESC` | `GRAVE_ESC` | 押ã•ã‚ŒãŸå ´åˆã« Escape。Shift ã‚ã‚‹ã„㯠GUI ãŒæŠ¼ã•ã‚ŒãŸã¾ã¾ã®å ´åˆã¯ <code>`</code> | ### 注æ„äº‹é … diff --git a/docs/ja/feature_led_indicators.md b/docs/ja/feature_led_indicators.md index 764b478c31..94ee063234 100644 --- a/docs/ja/feature_led_indicators.md +++ b/docs/ja/feature_led_indicators.md @@ -22,7 +22,7 @@ QMK 㯠HID 仕様ã§å®šç¾©ã•ã‚ŒãŸ5ã¤ã® LED ã®èªã¿å–りメソッドをæ LED ã®çŠ¶æ…‹ã‚’ `uint8_t` ã¨ã—ã¦æä¾›ã™ã‚‹2ã¤ã®éžæŽ¨å¥¨ã®é–¢æ•°ãŒã‚ã‚Šã¾ã™: -* `uint8_t led_set_kb(uint8_t usb_led)` 㨠`_user(uint8_t usb_led)` +* `uint8_t led_set_user(uint8_t usb_led)` * `uint8_t host_keyboard_leds()` ## è¨å®šã‚ªãƒ—ション :id=configuration-options diff --git a/docs/ja/hardware_keyboard_guidelines.md b/docs/ja/hardware_keyboard_guidelines.md index c0e7c18be0..ef5f6df2b9 100644 --- a/docs/ja/hardware_keyboard_guidelines.md +++ b/docs/ja/hardware_keyboard_guidelines.md @@ -165,7 +165,7 @@ Clueboard ã¯ã€ã‚µãƒ–フォルダをã¾ã¨ã‚ã‚‹ãŸã‚ã¨ã‚ーボードã®ãƒªã * `void matrix_init_kb(void)` * `void matrix_scan_kb(void)` * `bool process_record_kb(uint16_t keycode, keyrecord_t *record)` -* `void led_set_kb(uint8_t usb_led)` +* `bool led_update_kb(led_t led_state)` ### `<keyboard_name.h>` diff --git a/docs/ja/tap_hold.md b/docs/ja/tap_hold.md index 07242821a9..ac64fe6ce3 100644 --- a/docs/ja/tap_hold.md +++ b/docs/ja/tap_hold.md @@ -110,25 +110,6 @@ bool get_permissive_hold(uint16_t keycode, keyrecord_t *record) { ?> `許容ホールド`を有効ã«ã™ã‚‹ã¨ã€ã“ã‚Œã¯ä¸¡æ–¹ãŒã©ã®ã‚ˆã†ã«å‹•ä½œã™ã‚‹ã‹ã‚’変更ã—ã¾ã™ã€‚通常ã®ã‚ーã«ã¯ã€æœ€åˆã®ã‚ーãŒæœ€åˆã«æ”¾ã•ã‚ŒãŸå ´åˆã€ã‚ã‚‹ã„ã¯ä¸¡æ–¹ã®ã‚ー㌠`TAPPING_TERM` より長ãホールドã•ã‚ŒãŸå ´åˆã«ã€ä¿®é£¾ã‚ーãŒè¿½åŠ ã•ã‚Œã¾ã™ã€‚ -ã“ã®æ©Ÿèƒ½ã‚’より細ã‹ã制御ã™ã‚‹ãŸã‚ã«ã€ä»¥ä¸‹ã‚’ `config.h` ã«è¿½åŠ ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™: - -```c -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY -``` - -ãã—ã¦ã€ä»¥ä¸‹ã®é–¢æ•°ã‚’ã‚ーマップã«è¿½åŠ ã—ã¾ã™: - -```c -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { - switch (keycode) { - case SFT_T(KC_SPC): - return true; - default: - return false; - } -} -``` - ## タッピング強制ホールド `タッピング強制ホールド` を有効ã«ã™ã‚‹ã«ã¯ã€ä»¥ä¸‹ã‚’ `config.h` ã«è¿½åŠ ã—ã¾ã™: diff --git a/docs/newbs_building_firmware.md b/docs/newbs_building_firmware.md index 6163c6b02e..de9217e9f0 100644 --- a/docs/newbs_building_firmware.md +++ b/docs/newbs_building_firmware.md @@ -28,7 +28,7 @@ If you did not configure your environment, or you have multiple keyboards, you c Look at the output from that command, you should see something like this: - Ψ <github_username> keymap directory created in: /home/me/qmk_firmware/keyboards/clueboard/66/rev3/keymaps/<github_username> + Ψ Created a new keymap called <github_username> in: /home/me/qmk_firmware/keyboards/clueboard/66/rev3/keymaps/<github_username>. This is the location of your new `keymap.c` file. diff --git a/docs/platformdev_rp2040.md b/docs/platformdev_rp2040.md index 3a6f1a1683..11a93edd89 100644 --- a/docs/platformdev_rp2040.md +++ b/docs/platformdev_rp2040.md @@ -38,8 +38,8 @@ QMK RP2040 support builds upon ChibiOS and thus follows their convention for act | RP2040 Peripheral | `mcuconf.h` values | `I2C_DRIVER` | | ----------------- | ------------------ | ------------ | -| `I2C0` | `RP_I2C_USE_I2C0` | `I2CD1` | -| `I2C1` | `RP_I2C_USE_I2C1` | `I2CD2` | +| `I2C0` | `RP_I2C_USE_I2C0` | `I2CD0` | +| `I2C1` | `RP_I2C_USE_I2C1` | `I2CD1` | To configure the I2C driver please read the [ChibiOS/ARM](i2c_driver.md#arm-configuration) section. @@ -74,7 +74,7 @@ This is the default board that is chosen, unless any other RP2040 board is selec | Driver configuration define | Value | | -------------------------------------------------------------------------- | ------------------------------------ | | **I2C driver** | | -| `I2C_DRIVER` | `I2CD2` | +| `I2C_DRIVER` | `I2CD1` | | `I2C1_SDA_PIN` | `GP2` | | `I2C1_SCL_PIN` | `GP3` | | **SPI driver** | | diff --git a/docs/quantum_painter_lvgl.md b/docs/quantum_painter_lvgl.md new file mode 100644 index 0000000000..3edb37fbce --- /dev/null +++ b/docs/quantum_painter_lvgl.md @@ -0,0 +1,55 @@ +# Quantum Painter LVGL Integration :id=lvgl + +LVGL (Light and Versatile Graphics Library) is an open-source graphics library providing everything you need to create an embedded GUI for your board with easy-to-use graphical elements. + +LVGL integrates with [Quantum Painter's](quantum_painter.md) API and drivers to render to the display, the hardware supported by Quantum Painter is also supported by LVGL. + +?> Keep in mind that enabling the LVGL integration has a big impact in firmware size, it is recommeded to use a supported MCU with >256 kB of flash space. + +To learn more about LVGL and how to use it please take a look at their [official documentation](https://docs.lvgl.io/8.2/intro/) + +## Enabling LVGL :id=lvgl-enabling +To enable LVGL to be built into your firmware, add the following to `rules.mk`: + +```make +QUANTUM_PAINTER_ENABLE = yes +QUANTUM_PAINTER_DRIVERS = ...... +QUANTUM_PAINTER_LVGL_INTEGRATION = yes +``` +To configure the Quantum Painter Display Drivers please read the [Quantum Painter Display Drivers](quantum_painter.md#quantum-painter-drivers) section. + +## Quantum Painter LVGL API :id=lvgl-api + +### Quantum Painter LVGL Attach :id=lvgl-api-init + +```c +bool qp_lvgl_attach(painter_device_t device); +``` + +The `qp_lvgl_attach` function is used to set up LVGL with the supplied display, and requires an already configured display. + +```c +static painter_device_t display; +void keyboard_post_init_kb(void) { + display = qp_make_.......; // Create the display + qp_init(display, QP_ROTATION_0); // Initialise the display + + if (qp_lvgl_attach(display)) { // Attach LVGL to the display + ...Your code to draw // Run LVGL specific code to draw + } +} +``` +To init. the display please read the [Display Initialisation](quantum_painter.md#quantum-painter-api-init) section. + +!> Attaching LVGL to a display means LVGL subsequently "owns" the display. Using standard Quantum Painter drawing operations with the display after LVGL attachment will likely result in display artifacts. +### Quantum Painter LVGL Detach :id=lvgl-api-init + +```c +void qp_lvgl_detach() +``` + +The `qp_lvgl_detach` function stops the internal LVGL ticks and releases resources related to it. + +## Enabling/Disabling LVGL features :id=lvgl-configuring + +You can overwrite LVGL specific features in your `lv_conf.h` file. diff --git a/docs/reference_info_json.md b/docs/reference_info_json.md index d5469c835a..354863f507 100644 --- a/docs/reference_info_json.md +++ b/docs/reference_info_json.md @@ -113,6 +113,20 @@ Example: } ``` +### Additional Options + +* `input_pressed_state` + * This configures state of the GPIO pins when the key is pressed - `1` for high, `0` for low + * Default: `0` + +Example: + +```json + "matrix_pins": { + "input_pressed_state": 1, +}, +``` + ## Non-RGB LED Lighting This section controls basic 2-pin LEDs, which typically pass through keyswitches and are soldered into the PCB, or are placed in PCB sockets. @@ -333,3 +347,24 @@ Example: } } ``` + +## Bootmagic + +This section configures [Bootmagic Lite](feature_bootmagic.md) support. + +The following options can be configured: + +|Key |Description | +|---------|-----------------------------------------------------------------------------| +|`matrix` | A two item list describing the row and column location for the trigger key. | + +Example: + +```json +{ + "bootmagic": { + "enabled": true, + "matrix": [0, 0] + }, +} +``` diff --git a/docs/tap_hold.md b/docs/tap_hold.md index 8914b730b3..348e2655eb 100644 --- a/docs/tap_hold.md +++ b/docs/tap_hold.md @@ -118,7 +118,7 @@ The reason is that `TAPPING_TERM` is a macro that expands to a constant integer The code which decides between the tap and hold actions of dual-role keys supports three different modes, in increasing order of preference for the hold action: -1. The default mode selects the hold action only if the dual-role key is held down longer than the tapping term. In this mode pressing other keys while the dual-role key is held down does not influence the tap-or-hold decision. +1. The default mode selects the hold action only if the dual-role key is held down longer than the tapping term. In this mode pressing other keys while the dual-role key is held down does not influence the tap-or-hold decision. In other words, this mode ignores interrupts. 2. The “permissive hold†mode, in addition to the default behavior, immediately selects the hold action when another key is tapped (pressed and then released) while the dual-role key is held down, even if this happens earlier than the tapping term. If another key is just pressed, but then the dual-role key is released before that other key (and earlier than the tapping term), this mode will still select the tap action. @@ -126,6 +126,73 @@ The code which decides between the tap and hold actions of dual-role keys suppor Note that until the tap-or-hold decision completes (which happens when either the dual-role key is released, or the tapping term has expired, or the extra condition for the selected decision mode is satisfied), key events are delayed and not transmitted to the host immediately. The default mode gives the most delay (if the dual-role key is held down, this mode always waits for the whole tapping term), and the other modes may give less delay when other keys are pressed, because the hold action may be selected earlier. +### Comparison :id=comparison + +To better illustrate the tap-or-hold decision modes, let us compare the expected output of each decision mode in a handful of tapping scenarios involving a mod-tap key (`LSFT_T(KC_A)`) and a regular key (`KC_B`) with the `TAPPING_TERM` set to 200ms. + +By default, mod-taps behave like `HOLD_ON_OTHER_KEY_PRESS`, while layer-taps behave like "Ignore Interrupt" out of the box. If you want "Ignore Interrupt"-like behaviour for mod-taps, you must enable `IGNORE_MOD_TAP_INTERRUPT`, or return `false` in the `get_hold_on_other_key_press` function for all mod-taps. + +Note: "`kc` held" in the "Physical key event" column means that the key wasn't physically released yet at this point in time. + +#### Distinct taps (AABB) :id=distinct-taps + +| Time | Physical key event |Ignore Interrupt| `PERMISSIVE_HOLD` | `HOLD_ON_OTHER_KEY_PRESS` | +|------|--------------------|----------------|-------------------|----------------------------| +| 0 | `LSFT_T(KC_A)` down| | | | +| 199 | `LSFT_T(KC_A)` up | a | a | a | +| 210 | `KC_B` down | ab | ab | ab | +| 220 | `KC_B` up | ab | ab | ab | + +| Time | Physical key event |Ignore Interrupt| `PERMISSIVE_HOLD` | `HOLD_ON_OTHER_KEY_PRESS` | +|------|--------------------|----------------|-------------------|----------------------------| +| 0 | `LSFT_T(KC_A)` down| | | | +| 200 | `LSFT_T(KC_A)` held|<kbd>Shift</kbd>| <kbd>Shift</kbd> | <kbd>Shift</kbd> | +| 201 | `LSFT_T(KC_A)` up |<kbd>Shift</kbd>| <kbd>Shift</kbd> | <kbd>Shift</kbd> | +| 205 | `KC_B` down | b | b | b | +| 210 | `KC_B` up | b | b | b | + +#### Nested tap (ABBA) :id=nested-tap + +| Time | Physical key event |Ignore Interrupt| `PERMISSIVE_HOLD` | `HOLD_ON_OTHER_KEY_PRESS` | +|------|--------------------|----------------|-------------------|----------------------------| +| 0 | `LSFT_T(KC_A)` down| | | | +| 110 | `KC_B` down | | | B | +| 120 | `KC_B` up | | B | B | +| 199 | `LSFT_T(KC_A)` up | ab | B | B | + +| Time | Physical key event |Ignore Interrupt| `PERMISSIVE_HOLD` | `HOLD_ON_OTHER_KEY_PRESS` | +|------|--------------------|----------------|-------------------|----------------------------| +| 0 | `LSFT_T(KC_A)` down| | | | +| 110 | `KC_B` down | | | B | +| 120 | `KC_B` up | | B | B | +| 200 | `LSFT_T(KC_A)` held| B | B | B | +| 210 | `LSFT_T(KC_A)` up | B | B | B | + +| Time | Physical key event |Ignore Interrupt| `PERMISSIVE_HOLD` | `HOLD_ON_OTHER_KEY_PRESS` | +|------|--------------------|----------------|-------------------|----------------------------| +| 0 | `LSFT_T(KC_A)` down| | | | +| 200 | `LSFT_T(KC_A)` held|<kbd>Shift</kbd>| <kbd>Shift</kbd> | <kbd>Shift</kbd> | +| 205 | `KC_B` down | B | B | B | +| 210 | `KC_B` up | B | B | B | +| 220 | `LSFT_T(KC_A)` up | B | B | B | + +#### Rolling keys (ABAB) :id=rolling-keys + +| Time | Physical key event |Ignore Interrupt| `PERMISSIVE_HOLD` | `HOLD_ON_OTHER_KEY_PRESS` | +|------|--------------------|----------------|-------------------|----------------------------| +| 0 | `LSFT_T(KC_A)` down| | | | +| 110 | `KC_B` down | | | B | +| 130 | `LSFT_T(KC_A)` up | ab | ab | B | +| 140 | `KC_B` up | ab | ab | B | + +| Time | Physical key event |Ignore Interrupt| `PERMISSIVE_HOLD` | `HOLD_ON_OTHER_KEY_PRESS` | +|------|--------------------|----------------|-------------------|----------------------------| +| 0 | `LSFT_T(KC_A)` down| | | | +| 110 | `KC_B` down | | | B | +| 200 | `LSFT_T(KC_A)` held| B | B | B | +| 205 | `LSFT_T(KC_A)` up | B | B | B | +| 210 | `KC_B` up | B | B | B | + ### Default Mode Example sequence 1 (the `L` key is also mapped to `KC_RGHT` on layer 2): @@ -179,8 +246,6 @@ since `SFT_T(KC_A)` is NOT held longer than the `TAPPING_TERM`. However, the actual output would be capital `X` (`SHIFT` + `x`) due to reasons explained under [Ignore Mod Tap Interrupt](#ignore-mod-tap-interrupt). - - ### Permissive Hold The “permissive hold†mode can be enabled for all dual-role keys by adding the corresponding option to `config.h`: @@ -212,7 +277,7 @@ An example of a sequence that is affected by the “permissive hold†mode: +---------------------------|--------+ ``` -Normally, if you do all this within the `TAPPING_TERM` (default: 200ms), this will be registered as `al` by the firmware and host system. With the `PERMISSIVE_HOLD` option enabled, the Layer Tap key is considered as a layer switch if another key is tapped, and the above sequence would be registered as `KC_RGHT` (the mapping of `L` on layer 2). We could describe this sequence as a “nested press†(the modified key's key down and key up events are “nested†between the dual-role key's key down and key up events). +Normally, if you do all this within the `TAPPING_TERM` (default: 200ms), this will be registered as `al` by the firmware and host system. With the `PERMISSIVE_HOLD` option enabled, the Layer Tap key is considered as a layer switch if another key is tapped, and the above sequence would be registered as `KC_RGHT` (the mapping of `L` on layer 2). We could describe this sequence as a “nested tap†(the modified key's key down and key up events are “nested†between the dual-role key's key down and key up events). However, this slightly different sequence will not be affected by the “permissive hold†mode: @@ -235,7 +300,7 @@ However, this slightly different sequence will not be affected by the “permiss In the sequence above the dual-role key is released before the other key is released, and if that happens within the tapping term, the “permissive hold†mode will still choose the tap action for the dual-role key, and the sequence will be registered as `al` by the host. We could describe this as a “rolling press†(the two keys' key down and key up events behave as if you were rolling a ball across the two keys, first pressing each key down in sequence and then releasing them in the same order). -?> The `PERMISSIVE_HOLD` option also affects Mod Tap keys, but this may not be noticeable if you do not also enable the `IGNORE_MOD_TAP_INTERRUPT` option for those keys, because the default handler for Mod Tap keys also considers both the “nested press†and “rolling press†sequences like shown above as a modifier hold, not the tap action. If you do not enable `IGNORE_MOD_TAP_INTERRUPT`, the effect of `PERMISSIVE_HOLD` on Mod Tap keys would be limited to reducing the delay before the key events are made visible to the host. +?> The `PERMISSIVE_HOLD` option is not noticeable if you also enable `HOLD_ON_OTHER_KEY_PRESS` because the latter option considers both the “nested tap†and “rolling press†sequences like shown above as a hold action, not the tap action. `HOLD_ON_OTHER_KEY_PRESS` makes the Tap-Or-Hold decision earlier in the chain of key events, thus taking a precedence over `PERMISSIVE_HOLD`. This remark also applies to default mod-taps. For more granular control of this feature, you can add the following to your `config.h`: @@ -291,7 +356,7 @@ An example of a sequence that is affected by the “hold on other key press†m Normally, if you do all this within the `TAPPING_TERM` (default: 200ms), this will be registered as `al` by the firmware and host system. With the `HOLD_ON_OTHER_KEY_PRESS` option enabled, the Layer Tap key is considered as a layer switch if another key is pressed, and the above sequence would be registered as `KC_RGHT` (the mapping of `L` on layer 2). -?> The `HOLD_ON_OTHER_KEY_PRESS` option also affects Mod Tap keys, but this may not be noticeable if you do not also enable the `IGNORE_MOD_TAP_INTERRUPT` option for those keys, because the default handler for Mod Tap keys also considers the “rolling press†sequence like shown above as a modifier hold, not the tap action. If you do not enable `IGNORE_MOD_TAP_INTERRUPT`, the effect of `HOLD_ON_OTHER_KEY_PRESS` on Mod Tap keys would be limited to reducing the delay before the key events are made visible to the host. +?> The `HOLD_ON_OTHER_KEY_PRESS` option is essentially redundant with the default mod-tap behaviour. The only notable difference is that `HOLD_ON_OTHER_KEY_PRESS` reduces the delay before the key events are made visible to the host. For more granular control of this feature, you can add the following to your `config.h`: @@ -355,69 +420,76 @@ However, if the `HOLD_ON_OTHER_KEY_PRESS` option is enabled in addition to `IGNO For more granular control of this feature, you can add the following to your `config.h`: ```c -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY +#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY ``` +?> This option affects *all* dual-role keys. + You can then add the following function to your keymap: ```c -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case SFT_T(KC_SPC): // Do not force the mod-tap key press to be handled as a modifier // if any other key was pressed while the mod-tap key is held down. - return true; + return false; default: - // Force the mod-tap key press to be handled as a modifier if any + // Force the dual-role key press to be handled as a modifier if any // other key was pressed while the mod-tap key is held down. - return false; + return true; } } ``` -## Tapping Force Hold +Note that you must return `false` in `get_hold_on_other_key_press` in order to apply `IGNORE_MOD_TAP_INTERRUPT` for a certain mod-tap key. -To enable `tapping force hold`, add the following to your `config.h`: +?> `IGNORE_MOD_TAP_INTERRUPT[_PER_KEY]` is being progressively phased out to align the (default) behavior and configuration of mod-taps with the rest of dual-role keys. + +## Quick Tap Term + +When the user holds a key after tapping it, the tapping function is repeated by default, rather than activating the hold function. This allows keeping the ability to auto-repeat the tapping function of a dual-role key. `QUICK_TAP_TERM` enables fine tuning of that ability. If set to `0`, it will remove the auto-repeat ability and activate the hold function instead. + +`QUICK_TAP_TERM` is set to `TAPPING_TERM` by default, which is the maximum allowed value for `QUICK_TAP_TERM`. To override its value (in milliseconds) add the following to your `config.h`: ```c -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 120 ``` -When the user holds a key after tapping it, the tapping function is repeated by default, rather than activating the hold function. This allows keeping the ability to auto-repeat the tapping function of a dual-role key. `TAPPING_FORCE_HOLD` removes that ability to let the user activate the hold function instead, in the case of holding the dual-role key after having tapped it. - Example: - `SFT_T(KC_A)` Down - `SFT_T(KC_A)` Up - `SFT_T(KC_A)` Down -- wait until the tapping term expires... -- `SFT_T(KC_A)` Up +- (wait until tapping term expires...) -With default settings, `a` will be sent on the first release, then `a` will be sent on the second press allowing the computer to trigger its auto-repeat function. +With default settings, `a` will be sent on the first release, then `a` will be sent on the second press allowing the computer to trigger its auto repeat function until the key is released. -With `TAPPING_FORCE_HOLD`, the second press will be interpreted as a Shift, allowing to use it as a modifier shortly after having used it as a tap. +With `QUICK_TAP_TERM` configured, the timing between `SFT_T(KC_A)` up and `SFT_T(KC_A)` down must be within `QUICK_TAP_TERM` to trigger auto repeat. Otherwise the second press will be sent as a Shift. If `QUICK_TAP_TERM` is set to `0`, the second press will always be sent as a Shift, effectively disabling auto-repeat. -!> `TAPPING_FORCE_HOLD` will break anything that uses tapping toggles (Such as the `TT` layer keycode, and the One Shot Tap Toggle). +!> `QUICK_TAP_TERM` timing will also impact anything that uses tapping toggles (Such as the `TT` layer keycode, and the One Shot Tap Toggle). For more granular control of this feature, you can add the following to your `config.h`: ```c -#define TAPPING_FORCE_HOLD_PER_KEY +#define QUICK_TAP_TERM_PER_KEY ``` You can then add the following function to your keymap: ```c -bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { switch (keycode) { - case LT(1, KC_BSPC): - return true; + case SFT_T(KC_SPC): + return QUICK_TAP_TERM - 20; default: - return false; + return QUICK_TAP_TERM; } } ``` +?> If `QUICK_TAP_TERM` is set higher than `TAPPING_TERM`, it will default to `TAPPING_TERM`. + ## Retro Tapping To enable `retro tapping`, add the following to your `config.h`: diff --git a/docs/zh-cn/feature_grave_esc.md b/docs/zh-cn/feature_grave_esc.md index f57dabeaff..1795a508ef 100644 --- a/docs/zh-cn/feature_grave_esc.md +++ b/docs/zh-cn/feature_grave_esc.md @@ -11,7 +11,7 @@ ## 使用方法 -在é…列ä¸ä½¿ç”¨ `KC_GESC` æ›¿æ¢ `KC_GRAVE` （一般都在`1`键左边）。默认点击会输出 `KC_ESC`，按下Shift或GUI键时，点击会输出 `KC_GRV` +在é…列ä¸ä½¿ç”¨ `QK_GESC` æ›¿æ¢ `KC_GRAVE` （一般都在`1`键左边）。默认点击会输出 `KC_ESC`，按下Shift或GUI键时，点击会输出 `KC_GRV` ## æ“作系统视角 @@ -21,7 +21,7 @@ |é”® |别å |æè¿° | |---------|-----------|------------------------------------------------------------------| -|`KC_GESC`|`GRAVE_ESC`|å•å‡»è¾“出Escape, 按ä½Shift或GUI时输出<code>`</code> | +|`QK_GESC`|`GRAVE_ESC`|å•å‡»è¾“出Escape, 按ä½Shift或GUI时输出<code>`</code> | ### é¡»ç•™æ„ diff --git a/drivers/sensors/pmw3360.c b/drivers/sensors/pmw3360.c index 2c6d91d588..81dca002e2 100644 --- a/drivers/sensors/pmw3360.c +++ b/drivers/sensors/pmw3360.c @@ -9,8 +9,6 @@ #include "pmw33xx_common.h" #include "progmem.h" -extern const size_t pmw33xx_number_of_sensors; - uint16_t pmw33xx_get_cpi(uint8_t sensor) { if (sensor >= pmw33xx_number_of_sensors) { return 0; diff --git a/drivers/sensors/pmw3389.c b/drivers/sensors/pmw3389.c index cba94d6c65..c5781a5ffe 100644 --- a/drivers/sensors/pmw3389.c +++ b/drivers/sensors/pmw3389.c @@ -8,8 +8,6 @@ #include "pmw33xx_common.h" #include "progmem.h" -extern const size_t pmw33xx_number_of_sensors; - uint16_t pmw33xx_get_cpi(uint8_t sensor) { if (sensor >= pmw33xx_number_of_sensors) { return 0; diff --git a/drivers/sensors/pmw33xx_common.c b/drivers/sensors/pmw33xx_common.c index b8d4e532ca..82a7ec3297 100644 --- a/drivers/sensors/pmw33xx_common.c +++ b/drivers/sensors/pmw33xx_common.c @@ -1,3 +1,4 @@ +// Copyright 2022 Pablo Martinez (@elpekenin) // Copyright 2022 Daniel Kao (dkao) // Copyright 2022 Stefan Kerkmann (KarlK90) // Copyright 2022 Ulrich Spörlein (@uqs) @@ -17,10 +18,11 @@ extern const uint8_t pmw33xx_firmware_data[PMW33XX_FIRMWARE_LENGTH] PROGMEM; extern const uint8_t pmw33xx_firmware_signature[3] PROGMEM; -static const pin_t cs_pins[] = PMW33XX_CS_PINS; -static bool in_burst[ARRAY_SIZE(cs_pins)] = {0}; +static const pin_t cs_pins_left[] = PMW33XX_CS_PINS; +static const pin_t cs_pins_right[] = PMW33XX_CS_PINS_RIGHT; -const size_t pmw33xx_number_of_sensors = ARRAY_SIZE(cs_pins); +static bool in_burst_left[ARRAY_SIZE(cs_pins_left)] = {0}; +static bool in_burst_right[ARRAY_SIZE(cs_pins_right)] = {0}; bool __attribute__((cold)) pmw33xx_upload_firmware(uint8_t sensor); bool __attribute__((cold)) pmw33xx_check_signature(uint8_t sensor); diff --git a/drivers/sensors/pmw33xx_common.h b/drivers/sensors/pmw33xx_common.h index c725e80f24..88523b8420 100644 --- a/drivers/sensors/pmw33xx_common.h +++ b/drivers/sensors/pmw33xx_common.h @@ -1,3 +1,4 @@ +// Copyright 2022 Pablo Martinez (@elpekenin) // Copyright 2022 Daniel Kao (dkao) // Copyright 2022 Stefan Kerkmann (KarlK90) // Copyright 2022 Ulrich Spörlein (@uqs) @@ -9,6 +10,7 @@ #pragma once +#include "quantum.h" //to get is_keyboard_left #include <stdint.h> #include "spi_master.h" #include "util.h" @@ -79,6 +81,20 @@ _Static_assert(sizeof((pmw33xx_report_t){0}.motion) == 1, "pmw33xx_report_t.moti # endif #endif +// Support single spelling and default to be the same as left side +#if !defined(PMW33XX_CS_PINS_RIGHT) +# if !defined(PMW33XX_CS_PIN_RIGHT) +# define PMW33XX_CS_PIN_RIGHT PMW33XX_CS_PIN +# endif +# define PMW33XX_CS_PINS_RIGHT \ + { PMW33XX_CS_PIN_RIGHT } +#endif + +// Defines so the old variable names are swapped by the appropiate value on each half +#define cs_pins (is_keyboard_left() ? cs_pins_left : cs_pins_right) +#define in_burst (is_keyboard_left() ? in_burst_left : in_burst_right) +#define pmw33xx_number_of_sensors (is_keyboard_left() ? ARRAY_SIZE((pin_t[])PMW33XX_CS_PINS) : ARRAY_SIZE((pin_t[])PMW33XX_CS_PINS_RIGHT)) + #if PMW33XX_CPI > PMW33XX_CPI_MAX || PMW33XX_CPI < PMW33XX_CPI_MIN || (PMW33XX_CPI % PMW33XX_CPI_STEP) != 0U # pragma message "PMW33XX_CPI has to be in the range of " STR(PMW33XX_CPI_MAX) "-" STR(PMW33XX_CPI_MIN) " in increments of " STR(PMW33XX_CPI_STEP) ". But it is " STR(PMW33XX_CPI) "." # error Use correct PMW33XX_CPI value. diff --git a/keyboards/1k/keymaps/tap_dance/keymap.c b/keyboards/1k/keymaps/tap_dance/keymap.c index c2a8cf1aea..1044924978 100644 --- a/keyboards/1k/keymaps/tap_dance/keymap.c +++ b/keyboards/1k/keymaps/tap_dance/keymap.c @@ -11,7 +11,7 @@ enum { TD_AB = 0 }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_AB] = ACTION_TAP_DANCE_DOUBLE(KC_A, KC_B) }; diff --git a/keyboards/1upkeyboards/pi40/config.h b/keyboards/1upkeyboards/pi40/config.h index 5e0d0e12ae..ce63293269 100644 --- a/keyboards/1upkeyboards/pi40/config.h +++ b/keyboards/1upkeyboards/pi40/config.h @@ -11,7 +11,7 @@ # define OLED_DISPLAY_128X32 #define I2C1_SCL_PIN GP17 #define I2C1_SDA_PIN GP16 -#define I2C_DRIVER I2CD1 +#define I2C_DRIVER I2CD0 #define OLED_BRIGHTNESS 128 #define OLED_FONT_H "keyboards/1upkeyboards/pi40/lib/glcdfont.c" #endif @@ -96,4 +96,4 @@ /* Bootmagic Lite key configuration */ #define BOOTMAGIC_LITE_ROW 0 -#define BOOTMAGIC_LITE_COLUMN 0
\ No newline at end of file +#define BOOTMAGIC_LITE_COLUMN 0 diff --git a/keyboards/1upkeyboards/sweet16/keymaps/ridingintraffic/keymap.c b/keyboards/1upkeyboards/sweet16/keymaps/ridingintraffic/keymap.c index eeca552657..2e7505ec1c 100644 --- a/keyboards/1upkeyboards/sweet16/keymaps/ridingintraffic/keymap.c +++ b/keyboards/1upkeyboards/sweet16/keymaps/ridingintraffic/keymap.c @@ -155,32 +155,32 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { /* tap dance time */ -void tdexample1(qk_tap_dance_state_t *state, void *user_data) { +void tdexample1(tap_dance_state_t *state, void *user_data) { if (state->count >= 2) { SEND_STRING(EXAMPLESTRING1); reset_tap_dance (state); } } -void tdexample2(qk_tap_dance_state_t *state, void *user_data) { +void tdexample2(tap_dance_state_t *state, void *user_data) { if (state->count >= 2) { SEND_STRING(EXAMPLESTRING2); reset_tap_dance (state); } } -void tdexample3(qk_tap_dance_state_t *state, void *user_data) { +void tdexample3(tap_dance_state_t *state, void *user_data) { if (state->count >= 2) { SEND_STRING(EXAMPLESTRING3); reset_tap_dance (state); } } -void tdexample4(qk_tap_dance_state_t *state, void *user_data) { +void tdexample4(tap_dance_state_t *state, void *user_data) { if (state->count >= 2) { SEND_STRING(EXAMPLESTRING4); reset_tap_dance (state); } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_EXAMPLE1] = ACTION_TAP_DANCE_FN(tdexample1), [TD_EXAMPLE2] = ACTION_TAP_DANCE_FN(tdexample2), [TD_EXAMPLE3] = ACTION_TAP_DANCE_FN(tdexample3), diff --git a/keyboards/25keys/zinc/rev1/config.h b/keyboards/25keys/zinc/rev1/config.h index 947f5ccfb1..c2322556bc 100644 --- a/keyboards/25keys/zinc/rev1/config.h +++ b/keyboards/25keys/zinc/rev1/config.h @@ -17,7 +17,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #pragma once -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 /* Use I2C or Serial */ diff --git a/keyboards/25keys/zinc/reva/config.h b/keyboards/25keys/zinc/reva/config.h index 54a26cd5bc..d8c12a726e 100644 --- a/keyboards/25keys/zinc/reva/config.h +++ b/keyboards/25keys/zinc/reva/config.h @@ -17,7 +17,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #pragma once -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 /* Use I2C or Serial */ diff --git a/keyboards/40percentclub/gherkin/keymaps/mjt/keymap.c b/keyboards/40percentclub/gherkin/keymaps/mjt/keymap.c index f17cc50a7b..312fbfaf57 100644 --- a/keyboards/40percentclub/gherkin/keymaps/mjt/keymap.c +++ b/keyboards/40percentclub/gherkin/keymaps/mjt/keymap.c @@ -203,7 +203,7 @@ void matrix_scan_user(void) { } //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Esc, twice for Caps Lock [TD_Z_LCTL] = ACTION_TAP_DANCE_DOUBLE(KC_Z, KC_LCTL), [TD_X_LGUI] = ACTION_TAP_DANCE_DOUBLE(KC_X, KC_LGUI), diff --git a/keyboards/40percentclub/gherkin/keymaps/pierrec83/config.h b/keyboards/40percentclub/gherkin/keymaps/pierrec83/config.h index a635e944c1..bde9ec2055 100644 --- a/keyboards/40percentclub/gherkin/keymaps/pierrec83/config.h +++ b/keyboards/40percentclub/gherkin/keymaps/pierrec83/config.h @@ -28,4 +28,4 @@ #define TAPPING_TERM 200 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 diff --git a/keyboards/40percentclub/gherkin/keymaps/stevexyz/config.h b/keyboards/40percentclub/gherkin/keymaps/stevexyz/config.h index bd6fd9d1d0..243b953f68 100644 --- a/keyboards/40percentclub/gherkin/keymaps/stevexyz/config.h +++ b/keyboards/40percentclub/gherkin/keymaps/stevexyz/config.h @@ -16,7 +16,7 @@ #define IGNORE_MOD_TAP_INTERRUPT // makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the TAPPING_TERM for both keys. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // makes it possible to use a dual role key as modifier shortly after having been tapped (see Hold after tap) // Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) diff --git a/keyboards/40percentclub/half_n_half/keymaps/Boy_314/keymap.c b/keyboards/40percentclub/half_n_half/keymaps/Boy_314/keymap.c index e874cc3fea..128802ca59 100644 --- a/keyboards/40percentclub/half_n_half/keymaps/Boy_314/keymap.c +++ b/keyboards/40percentclub/half_n_half/keymaps/Boy_314/keymap.c @@ -108,7 +108,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { ) }; -void tap_dance_choose_layer (qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_choose_layer (tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: layer_on(_LOWER); @@ -119,7 +119,7 @@ void tap_dance_choose_layer (qk_tap_dance_state_t *state, void *user_data) { } } -void tap_dance_choose_layer_reset (qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_choose_layer_reset (tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: layer_off(_LOWER); @@ -138,7 +138,7 @@ void tap_dance_choose_layer_reset (qk_tap_dance_state_t *state, void *user_data) } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SWAP_LAYERS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tap_dance_choose_layer, tap_dance_choose_layer_reset) }; diff --git a/keyboards/40percentclub/sixpack/keymaps/fkeys/keymap.c b/keyboards/40percentclub/sixpack/keymaps/fkeys/keymap.c index 8ca5a5a27b..4164620b5c 100644 --- a/keyboards/40percentclub/sixpack/keymaps/fkeys/keymap.c +++ b/keyboards/40percentclub/sixpack/keymaps/fkeys/keymap.c @@ -26,7 +26,7 @@ enum { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for F13 to F18, twice for F19 to F24 [F13F19] = ACTION_TAP_DANCE_DOUBLE(KC_F13, KC_F19), [F14F20] = ACTION_TAP_DANCE_DOUBLE(KC_F14, KC_F20), [F15F21] = ACTION_TAP_DANCE_DOUBLE(KC_F15, KC_F21), [F16F22] = ACTION_TAP_DANCE_DOUBLE(KC_F16, KC_F22), [F17F23] = ACTION_TAP_DANCE_DOUBLE(KC_F17, KC_F23), [F18F24] = ACTION_TAP_DANCE_DOUBLE(KC_F18, KC_F24) diff --git a/keyboards/9key/keymaps/tap_dance/keymap.c b/keyboards/9key/keymaps/tap_dance/keymap.c index dc9b49f9af..d8b2945dc5 100644 --- a/keyboards/9key/keymaps/tap_dance/keymap.c +++ b/keyboards/9key/keymaps/tap_dance/keymap.c @@ -45,7 +45,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ENT_5] = ACTION_TAP_DANCE_DOUBLE(KC_5, KC_ENT), [ZERO_7] = ACTION_TAP_DANCE_DOUBLE(KC_7, KC_0) }; diff --git a/keyboards/adelheid/keymaps/floookay/keymap.c b/keyboards/adelheid/keymaps/floookay/keymap.c index 607ee58bb6..3abe75e023 100644 --- a/keyboards/adelheid/keymaps/floookay/keymap.c +++ b/keyboards/adelheid/keymaps/floookay/keymap.c @@ -64,7 +64,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { // Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for first parameter, twice for second [_TD_CTGU] = ACTION_TAP_DANCE_DOUBLE(KC_LCTL, KC_LGUI), [_TD_PGUP] = ACTION_TAP_DANCE_DOUBLE(KC_PGUP, LCTL(KC_PGUP)), diff --git a/keyboards/adm42/rev4/keymaps/default/config.h b/keyboards/adm42/rev4/keymaps/default/config.h index 38c012e938..abfaf9af78 100644 --- a/keyboards/adm42/rev4/keymaps/default/config.h +++ b/keyboards/adm42/rev4/keymaps/default/config.h @@ -1,3 +1,2 @@ #define HOLD_ON_OTHER_KEY_PRESS_PER_KEY -#define TAPPING_FORCE_HOLD_PER_KEY -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY +#define QUICK_TAP_TERM_PER_KEY diff --git a/keyboards/adm42/rev4/keymaps/default/keymap.c b/keyboards/adm42/rev4/keymaps/default/keymap.c index 109796f7ae..154073beb7 100644 --- a/keyboards/adm42/rev4/keymaps/default/keymap.c +++ b/keyboards/adm42/rev4/keymaps/default/keymap.c @@ -93,34 +93,28 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { ), }; -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { - switch (keycode) { - case RC_QUT: - return true; - default: +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { + // Special if-condition outside the switch because `RC_QUT` overlaps with + // the `QK_MOD_TAP ... QK_MOD_TAP_MAX` range. + if (keycode == RC_QUT) { return false; } -} - -bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { switch (keycode) { - case LLS_ESC: - case LLS_RALT: - case LLE_ENT: - case LLA_DEL: + case QK_MOD_TAP ... QK_MOD_TAP_MAX: + case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: return true; default: return false; } } -bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case LLS_ESC: case LLS_RALT: - return true; + return 0; default: - return false; + return QUICK_TAP_TERM; } } diff --git a/keyboards/anavi/knob1/config.h b/keyboards/anavi/knob1/config.h index f677aa9b23..178e0f45ca 100644 --- a/keyboards/anavi/knob1/config.h +++ b/keyboards/anavi/knob1/config.h @@ -23,7 +23,7 @@ #define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 500U -#define I2C_DRIVER I2CD2 +#define I2C_DRIVER I2CD1 #define I2C1_SDA_PIN GP6 #define I2C1_SCL_PIN GP7 diff --git a/keyboards/arabica37/keymaps/default/config.h b/keyboards/arabica37/keymaps/default/config.h index eed6b7221b..57ce4cc0c1 100644 --- a/keyboards/arabica37/keymaps/default/config.h +++ b/keyboards/arabica37/keymaps/default/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 170 #undef RGBLED_NUM diff --git a/keyboards/arisu/keymaps/fate/keymap.c b/keyboards/arisu/keymaps/fate/keymap.c index 55de2dc86f..9db8fcdbd1 100644 --- a/keyboards/arisu/keymaps/fate/keymap.c +++ b/keyboards/arisu/keymaps/fate/keymap.c @@ -59,7 +59,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for L-Alt, twice for L-GUI [TD_LALT_LGUI] = ACTION_TAP_DANCE_DOUBLE(KC_LALT, KC_LGUI), // Tap once for R-Alt, twice for R-GUI diff --git a/keyboards/atreus/keymaps/kejadlen/config.h b/keyboards/atreus/keymaps/kejadlen/config.h index 437bfa326e..5a9573c57f 100644 --- a/keyboards/atreus/keymaps/kejadlen/config.h +++ b/keyboards/atreus/keymaps/kejadlen/config.h @@ -8,6 +8,6 @@ #define DIODE_DIRECTION COL2ROW #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define USB_MAX_POWER_CONSUMPTION 50 diff --git a/keyboards/atreus/keymaps/replicaJunction/config.h b/keyboards/atreus/keymaps/replicaJunction/config.h deleted file mode 100644 index a02f9a95db..0000000000 --- a/keyboards/atreus/keymaps/replicaJunction/config.h +++ /dev/null @@ -1,51 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once - -// Do not allow one macro to contain the other macro -#define DYNAMIC_MACRO_NO_NESTING - -// "THE most important tap hold configuration setting" -// https://precondition.github.io/home-row-mods#ignore-mod-tap-interrupt -// https://docs.qmk.fm/#/tap_hold?id=ignore-mod-tap-interrupt -#define IGNORE_MOD_TAP_INTERRUPT - -// This one is a style choice. Play with it both on and off to see which -// one suits you better. -// https://precondition.github.io/home-row-mods#permissive-hold -// https://docs.qmk.fm/#/tap_hold?id=permissive-hold -#define PERMISSIVE_HOLD - -// If you press a dual-role key for longer than TAPPING_TERM, then -// release it without pressing another key, without this setting nothing -// would happen. With this setting, it sends the key's tap function. -// https://precondition.github.io/home-row-mods#retro-tapping -#define RETRO_TAPPING - -// Disable some unused features to save space -#undef LOCKING_SUPPORT_ENABLE -#undef LOCKING_RESYNC_ENABLE - -///// -// Flags for stuff in my userspace - -#define USER_INCLUDE_GAMING_LAYER -#define USER_INCLUDE_MACRO_LAYER - -// "Super Alt-Tab" -// https://docs.qmk.fm/#/feature_macros?id=super-alt%E2%86%AFtab -#define USER_SUPER_ALT_TAB_TIMEOUT 500 diff --git a/keyboards/atreus/keymaps/replicaJunction/keymap.c b/keyboards/atreus/keymaps/replicaJunction/keymap.c deleted file mode 100644 index fbefb52df6..0000000000 --- a/keyboards/atreus/keymaps/replicaJunction/keymap.c +++ /dev/null @@ -1,95 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include QMK_KEYBOARD_H -#include "replicaJunction.h" - -#define BSP_SYM LT(L_SYMBOLS, KC_BSPC) -#define SPC_NAV LT(L_NAVIGATION, KC_SPC) -#define EQL_FUN LT(L_FN, KC_EQL) - -#define ESC_SFT LSFT_T(KC_ESC) -#define TAB_SFT RSFT_T(KC_TAB) - -#define DF_TYPE DF(L_BASE) -#define DF_GAME DF(L_GAMING) - -const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - -[L_BASE] = LAYOUT( - KC_Q, KC_W, KC_F, KC_P, KC_B, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, - KC_A, KC_R, KC_S, KC_T, KC_G, KC_M, KC_N, KC_E, KC_I, KC_O, - KC_Z, KC_X, KC_C, KC_D, KC_V, KC_K, KC_H, KC_COMM,KC_DOT, KC_SLSH, - KC_ESC, KC_LGUI,KC_TAB, ESC_SFT,BSP_SYM,CTL_DEL,ALT_ENT,SPC_NAV,TAB_SFT,KC_MINS,KC_QUOT,EQL_FUN -), - -[L_GAMING] = LAYOUT( - _______,_______,_______,_______,_______, _______,_______,_______,_______,_______, - _______,_______,_______,_______,_______, _______,_______,_______,_______,_______, - _______,_______,KC_C, KC_D, _______, _______,_______,_______,_______,_______, - _______,KC_TAB, KC_LALT,KC_LSFT,KC_SPC, KC_LCTL,KC_LALT,KC_BSPC,KC_BTN1,KC_BTN2,KC_BTN3,_______ -), - -[L_NUMBERS] = LAYOUT( - _______,_______,_______,_______,_______, KC_HASH,KC_7, KC_8, KC_9, KC_SLSH, - _______,_______,_______,_______,_______, KC_PLUS,KC_4, KC_5, KC_6, KC_ASTR, - _______,_______,_______,_______,_______, KC_MINS,KC_1, KC_2, KC_3, KC_BSLS, - _______,_______,_______,_______,_______,_______,_______,_______,KC_0, KC_0, KC_DOT, KC_ENT -), - -[L_SYMBOLS] = LAYOUT( - KC_AT, KC_LT, KC_DLR, KC_GT, XXXXXXX, XXXXXXX,KC_LBRC,KC_UNDS,KC_RBRC,XXXXXXX, - KC_BSLS,KC_LPRN,KC_DQUO,KC_RPRN,KC_HASH, KC_PERC,KC_LCBR,KC_EQL, KC_RCBR,KC_PIPE, - KC_EXLM,KC_COLN,KC_ASTR,KC_PLUS,XXXXXXX, XXXXXXX,KC_AMPR,KC_CIRC,KC_TILD,KC_GRV, - _______,_______,_______,_______,ooooooo,_______,_______,ooooooo,CAPWORD,_______,_______,_______ -), - -[L_NAVIGATION] = LAYOUT( - OS_UNDO,OS_CUT, OS_PAST,OS_COPY,OS_SALL, KC_PGUP,KC_HOME,KC_UP, KC_END, KC_DEL, - KC_LGUI,KC_LALT,KC_LSFT,KC_LCTL,_______, KC_PGDN,KC_LEFT,KC_DOWN,KC_RGHT,KC_BSPC, - WIN_V, _______,_______,OS_FIND,SEARCH, _______,SFT_TAB,KC_TAB, KC_APP, KC_PSCR, - _______,_______,_______,NUMWORD,ooooooo,_______,_______,ooooooo,_______,_______,_______,_______ -), - -[L_FN] = LAYOUT( - QK_BOOT, _______,_______,_______,_______, KC_VOLU,KC_F9, KC_F10, KC_F11, KC_F12, - MS_JIGL,_______,_______,_______,_______, KC_MUTE,KC_F5, KC_F6, KC_F7, KC_F8, - _______,K_SECR1,K_SECR2,K_SECR3,K_SECR4, KC_VOLD,KC_F1, KC_F2, KC_F3, KC_F4, - DF_TYPE,DF_GAME,_______,_______,_______,KC_LCTL,KC_LALT,_______,_______,_______,_______,ooooooo -), - -[L_MACROS] = LAYOUT( - QK_MAKE,_______,DM_REC2,DM_REC1,DM_RSTP, _______,SHEBANG,_______,_______,_______, - QK_FLSH,_______,DM_PLY2,DM_PLY1,_______, PRG_NE, PRG_EQ, PRG_GEQ,PRG_LEQ,PRG_ARR, - QK_VERS,_______,_______,_______,_______, _______,PS_ITEM,FS_PIPE,_______,FS_ARR, - _______,_______,_______,_______,ooooooo,_______,_______,ooooooo,_______,_______,_______,_______ -) - - -// Template -// [L_FUNC] = LAYOUT( -// _______,_______,_______,_______,_______, _______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______, _______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______ -// ), - -}; - -layer_state_t layer_state_set_user(layer_state_t state) { - return update_tri_layer_state(state, L_SYMBOLS, L_NAVIGATION, L_MACROS); -} - diff --git a/keyboards/atreus/keymaps/replicaJunction/readme.md b/keyboards/atreus/keymaps/replicaJunction/readme.md deleted file mode 100644 index 6aa356f4f7..0000000000 --- a/keyboards/atreus/keymaps/replicaJunction/readme.md +++ /dev/null @@ -1,7 +0,0 @@ -# replicaJunction - Atreus Layout - -I no longer actively use this keyboard. I've replaced it with the [Keyboardio Atreus](../../../keyboardio/atreus/keymaps/replicaJunction/readme.md). - -I still try to make sure the layout compiles, but I'm no longer tweaking it or adding new features. - -Most of the interesting features in this layout are defined in [my userspace folder](../../../../users/replicaJunction/readme.md). Refer to the documentation and code there for more details. diff --git a/keyboards/atreus/keymaps/replicaJunction/rules.mk b/keyboards/atreus/keymaps/replicaJunction/rules.mk deleted file mode 100644 index 13730aec65..0000000000 --- a/keyboards/atreus/keymaps/replicaJunction/rules.mk +++ /dev/null @@ -1,28 +0,0 @@ -# Userspace options -USER_CAPS_WORD_ENABLE = yes -USER_MOUSE_JIGGLE_ENABLE = yes -USER_NUM_WORD_ENABLE = yes -USER_SECRETS_ENABLE = yes - -DYNAMIC_MACRO_ENABLE = yes - -# Extra features that are nice but takes space. Enable only if they're -# used in the layout. -WPM_ENABLE = no -# EXTRAKEY_ENABLE = no # For volume keys and similar -# MOUSEKEY_ENABLE = no # Them mouse keys yo -KEY_OVERRIDE_ENABLE = no -LEADER_ENABLE = no -TAP_DANCE_ENABLE = no -# RGBLIGHT_ENABLE = no # Keyboard RGB underglow -RGB_MATRIX_ENABLE = no - -# Features I definitely don't care aboud -LTO_ENABLE = yes -CONSOLE_ENABLE = no -VERBOSE = no -DEBUG_MATRIX_SCAN_RATE = no -DEBUG_MATRIX = no -MAGIC_ENABLE = no -SPACE_CADET_ENABLE = no -GRAVE_ESC_ENABLE = no diff --git a/keyboards/atreus62/keymaps/194h/keymap.c b/keyboards/atreus62/keymaps/194h/keymap.c index 31d286bfff..557b43cd8c 100644 --- a/keyboards/atreus62/keymaps/194h/keymap.c +++ b/keyboards/atreus62/keymaps/194h/keymap.c @@ -84,7 +84,7 @@ enum { }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for semicolon, twice for ø [SCLN_OE] = ACTION_TAP_DANCE_DOUBLE(NO_SCLN, NO_OE), //Tap once for single quote, twice for æ diff --git a/keyboards/b_sides/rev41lp/keymaps/namnlos/config.h b/keyboards/b_sides/rev41lp/keymaps/namnlos/config.h index b6f2866c46..1ad3156afa 100644 --- a/keyboards/b_sides/rev41lp/keymaps/namnlos/config.h +++ b/keyboards/b_sides/rev41lp/keymaps/namnlos/config.h @@ -26,7 +26,7 @@ #define UNICODE_SELECTED_MODES UNICODE_MODE_WINCOMPOSE, UNICODE_MODE_WINDOWS, UNICODE_MODE_MACOS, UNICODE_MODE_LINUX -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define TAPPING_TERM_PER_KEY diff --git a/keyboards/b_sides/rev41lp/keymaps/namnlos/keymap.c b/keyboards/b_sides/rev41lp/keymaps/namnlos/keymap.c index f942cd3484..0642cdc333 100644 --- a/keyboards/b_sides/rev41lp/keymaps/namnlos/keymap.c +++ b/keyboards/b_sides/rev41lp/keymaps/namnlos/keymap.c @@ -101,7 +101,7 @@ enum dances { TD_DASH_USCR, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Shift, twice for Caps Lock [TD_SHFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), [TD_COM_SCL] = ACTION_TAP_DANCE_DOUBLE(KC_COMM, SE_SCLN), diff --git a/keyboards/basekeys/slice/keymaps/default/config.h b/keyboards/basekeys/slice/keymaps/default/config.h index 3dc07fdac1..f1d6eef419 100644 --- a/keyboards/basekeys/slice/keymaps/default/config.h +++ b/keyboards/basekeys/slice/keymaps/default/config.h @@ -18,5 +18,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/basekeys/slice/keymaps/default_split_left_space/config.h b/keyboards/basekeys/slice/keymaps/default_split_left_space/config.h index 3dc07fdac1..f1d6eef419 100644 --- a/keyboards/basekeys/slice/keymaps/default_split_left_space/config.h +++ b/keyboards/basekeys/slice/keymaps/default_split_left_space/config.h @@ -18,5 +18,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/basekeys/slice/rev1/keymaps/2moons/config.h b/keyboards/basekeys/slice/rev1/keymaps/2moons/config.h index 8f38938b10..3807c29fa7 100644 --- a/keyboards/basekeys/slice/rev1/keymaps/2moons/config.h +++ b/keyboards/basekeys/slice/rev1/keymaps/2moons/config.h @@ -18,6 +18,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 //#define MASTER_RIGHT diff --git a/keyboards/basekeys/slice/rev1/keymaps/2moons/keymap.c b/keyboards/basekeys/slice/rev1/keymaps/2moons/keymap.c index ea7c329bd2..7d84ce3ae0 100644 --- a/keyboards/basekeys/slice/rev1/keymaps/2moons/keymap.c +++ b/keyboards/basekeys/slice/rev1/keymaps/2moons/keymap.c @@ -45,7 +45,7 @@ enum tapdances{ TD_ESQW, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESFL] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _FLOCK), [TD_ESQW] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _QWERTY), }; diff --git a/keyboards/basekeys/slice/rev1/keymaps/default_all/config.h b/keyboards/basekeys/slice/rev1/keymaps/default_all/config.h index 3dc07fdac1..f1d6eef419 100644 --- a/keyboards/basekeys/slice/rev1/keymaps/default_all/config.h +++ b/keyboards/basekeys/slice/rev1/keymaps/default_all/config.h @@ -18,5 +18,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/basekeys/slice/rev1/keymaps/default_split_backspace/config.h b/keyboards/basekeys/slice/rev1/keymaps/default_split_backspace/config.h index 3dc07fdac1..f1d6eef419 100644 --- a/keyboards/basekeys/slice/rev1/keymaps/default_split_backspace/config.h +++ b/keyboards/basekeys/slice/rev1/keymaps/default_split_backspace/config.h @@ -18,5 +18,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/basekeys/slice/rev1/keymaps/via/config.h b/keyboards/basekeys/slice/rev1/keymaps/via/config.h index 3dc07fdac1..f1d6eef419 100644 --- a/keyboards/basekeys/slice/rev1/keymaps/via/config.h +++ b/keyboards/basekeys/slice/rev1/keymaps/via/config.h @@ -18,5 +18,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/basekeys/slice/rev1_rgb/keymaps/2moons_rgb/config.h b/keyboards/basekeys/slice/rev1_rgb/keymaps/2moons_rgb/config.h index 8f38938b10..3807c29fa7 100644 --- a/keyboards/basekeys/slice/rev1_rgb/keymaps/2moons_rgb/config.h +++ b/keyboards/basekeys/slice/rev1_rgb/keymaps/2moons_rgb/config.h @@ -18,6 +18,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 //#define MASTER_RIGHT diff --git a/keyboards/basekeys/slice/rev1_rgb/keymaps/2moons_rgb/keymap.c b/keyboards/basekeys/slice/rev1_rgb/keymaps/2moons_rgb/keymap.c index 39ba3bb9c6..220b319ff6 100644 --- a/keyboards/basekeys/slice/rev1_rgb/keymaps/2moons_rgb/keymap.c +++ b/keyboards/basekeys/slice/rev1_rgb/keymaps/2moons_rgb/keymap.c @@ -38,7 +38,7 @@ enum tapdances{ TD_ESQW, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESFL] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _FLOCK), [TD_ESQW] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _QWERTY), }; diff --git a/keyboards/bastardkb/charybdis/3x5/keymaps/bstiq/config.h b/keyboards/bastardkb/charybdis/3x5/keymaps/bstiq/config.h index cceba7c1fb..0d11c53e88 100644 --- a/keyboards/bastardkb/charybdis/3x5/keymaps/bstiq/config.h +++ b/keyboards/bastardkb/charybdis/3x5/keymaps/bstiq/config.h @@ -43,7 +43,7 @@ * * See docs.qmk.fm/using-qmk/software-features/tap_hold#tapping-force-hold */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 /* * Tap-or-Hold decision modes. diff --git a/keyboards/bastardkb/dilemma/3x5_2/keymaps/bstiq/config.h b/keyboards/bastardkb/dilemma/3x5_2/keymaps/bstiq/config.h index cbe8e7bba7..2390d10ca5 100644 --- a/keyboards/bastardkb/dilemma/3x5_2/keymaps/bstiq/config.h +++ b/keyboards/bastardkb/dilemma/3x5_2/keymaps/bstiq/config.h @@ -41,7 +41,7 @@ * * See docs.qmk.fm/using-qmk/software-features/tap_hold#tapping-force-hold */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 /* * Tap-or-Hold decision modes. diff --git a/keyboards/bastardkb/dilemma/3x5_3/keymaps/bstiq/config.h b/keyboards/bastardkb/dilemma/3x5_3/keymaps/bstiq/config.h index 139b1f06ea..fce6c3a1f6 100644 --- a/keyboards/bastardkb/dilemma/3x5_3/keymaps/bstiq/config.h +++ b/keyboards/bastardkb/dilemma/3x5_3/keymaps/bstiq/config.h @@ -37,7 +37,7 @@ * Enable rapid switch from tap to hold. Disable auto-repeat when pressing key * twice, except for one-shot keys. */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 /* * Tap-or-Hold decision modes. diff --git a/keyboards/bastardkb/scylla/keymaps/cykedev/config.h b/keyboards/bastardkb/scylla/keymaps/cykedev/config.h index 3b2fa15b96..6119f2738b 100644 --- a/keyboards/bastardkb/scylla/keymaps/cykedev/config.h +++ b/keyboards/bastardkb/scylla/keymaps/cykedev/config.h @@ -28,15 +28,12 @@ #define TAPPING_TERM 200 -// Prevent normal rollover on alphas from accidentally triggering mods. -// #define IGNORE_MOD_TAP_INTERRUPT - // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -// #define TAPPING_FORCE_HOLD +// #define QUICK_TAP_TERM 0 // Apply the modifier on keys that are tapped during a short hold of a modtap // #define PERMISSIVE_HOLD -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY +#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY -#define FORCE_NKRO
\ No newline at end of file +#define FORCE_NKRO diff --git a/keyboards/bastardkb/scylla/keymaps/cykedev/keymap.c b/keyboards/bastardkb/scylla/keymaps/cykedev/keymap.c index 9f497e2c14..a51f5b9d38 100644 --- a/keyboards/bastardkb/scylla/keymaps/cykedev/keymap.c +++ b/keyboards/bastardkb/scylla/keymaps/cykedev/keymap.c @@ -169,12 +169,13 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { ) }; -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { - switch (keycode) { - case CM_SPAR: - return true; - default: - return false; +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { + if (keycode == CM_SPAR) { + return false; + } else if (QK_MOD_TAP <= keycode && keycode <= QK_MOD_TAP_MAX) { + return true; + } else { + return false; } } diff --git a/keyboards/bastardkb/scylla/keymaps/xyverz/config.h b/keyboards/bastardkb/scylla/keymaps/xyverz/config.h index d7baf99376..335f968e2a 100644 --- a/keyboards/bastardkb/scylla/keymaps/xyverz/config.h +++ b/keyboards/bastardkb/scylla/keymaps/xyverz/config.h @@ -25,7 +25,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 300 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/bastardkb/tbk/keymaps/xyverz/config.h b/keyboards/bastardkb/tbk/keymaps/xyverz/config.h index d7baf99376..335f968e2a 100644 --- a/keyboards/bastardkb/tbk/keymaps/xyverz/config.h +++ b/keyboards/bastardkb/tbk/keymaps/xyverz/config.h @@ -25,7 +25,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 300 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/bioi/f60/readme.md b/keyboards/bioi/f60/readme.md index 9b5c8e8591..8c32c7e7f9 100644 --- a/keyboards/bioi/f60/readme.md +++ b/keyboards/bioi/f60/readme.md @@ -21,5 +21,5 @@ See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_to ## Bootloader * **Bootmagic reset**: Hold down the top left key (ESC) and plug in the keyboard -* **Physical reset button**: Short the two small pads labeled "QK_BOOT" the back of the PCB +* **Physical reset button**: Short the two small pads labeled `RESET` the back of the PCB * **Keycode in layout**: Press the key mapped to `QK_BOOT` if it is available diff --git a/keyboards/bioi/main.c b/keyboards/bioi/main.c index bba54dfab1..eb149eb7cd 100644 --- a/keyboards/bioi/main.c +++ b/keyboards/bioi/main.c @@ -56,7 +56,7 @@ extern keymap_config_t keymap_config; #include "virtser.h" #endif -#if (defined(RGB_MIDI) | defined(RGBLIGHT_ANIMATIONS)) & defined(RGBLIGHT_ENABLE) +#if defined(RGBLIGHT_ENABLE) #include "rgblight.h" #endif diff --git a/keyboards/boardsource/lulu/rp2040/config.h b/keyboards/boardsource/lulu/rp2040/config.h index d579c06c6d..4f50a586df 100644 --- a/keyboards/boardsource/lulu/rp2040/config.h +++ b/keyboards/boardsource/lulu/rp2040/config.h @@ -6,7 +6,7 @@ #define SERIAL_USART_FULL_DUPLEX #define SERIAL_USART_TX_PIN GP0 #define SERIAL_USART_RX_PIN GP1 -#define I2C_DRIVER I2CD2 +#define I2C_DRIVER I2CD1 #define I2C1_SDA_PIN GP22 #define I2C1_SCL_PIN GP23 #define RGB_DI_PIN GP29 diff --git a/keyboards/bobpad/readme.md b/keyboards/bobpad/readme.md index 75e6e03202..c69f2e9d99 100644 --- a/keyboards/bobpad/readme.md +++ b/keyboards/bobpad/readme.md @@ -19,7 +19,7 @@ Flashing example for this keyboard: ## Bootloader Enter the bootloader in 3 ways: -* **Physical reset button**: Briefly short the pad connected to QK_BOOT and GND on the back +* **Physical reset button**: Briefly short the pad connected to *RESET* and *GND* on the back * **Keycode in layout**: Press the key mapped to `QK_BOOT`, this is the recommened method See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/bpiphany/kitten_paw/keymaps/ickerwx/keymap.c b/keyboards/bpiphany/kitten_paw/keymaps/ickerwx/keymap.c index 3f858734c9..7d4c53c61f 100644 --- a/keyboards/bpiphany/kitten_paw/keymaps/ickerwx/keymap.c +++ b/keyboards/bpiphany/kitten_paw/keymaps/ickerwx/keymap.c @@ -95,13 +95,13 @@ void matrix_scan_user(void) { current_layer_global = layer; // unset CAPSLOCK and SCROLL LOCK LEDs - led_set_kb(host_keyboard_leds() & ~(1<<USB_LED_CAPS_LOCK)); - led_set_kb(host_keyboard_leds() & ~(1<<USB_LED_SCROLL_LOCK)); + led_set(host_keyboard_leds() & ~(1<<USB_LED_CAPS_LOCK)); + led_set(host_keyboard_leds() & ~(1<<USB_LED_SCROLL_LOCK)); // set SCROLL LOCK LED when the mouse layer is active, CAPS LOCK when PROG layer is active if (layer == MOUSE1 || layer == MOUSE2) { - led_set_kb(host_keyboard_leds() | (1<<USB_LED_SCROLL_LOCK)); + led_set(host_keyboard_leds() | (1<<USB_LED_SCROLL_LOCK)); } else if (layer == PROG1 || layer == PROG2) { - led_set_kb(host_keyboard_leds() | (1<<USB_LED_CAPS_LOCK)); + led_set(host_keyboard_leds() | (1<<USB_LED_CAPS_LOCK)); } } } diff --git a/keyboards/bpiphany/pegasushoof/keymaps/citadel/keymap.c b/keyboards/bpiphany/pegasushoof/keymaps/citadel/keymap.c index 552dbb5a11..bcce86973c 100644 --- a/keyboards/bpiphany/pegasushoof/keymaps/citadel/keymap.c +++ b/keyboards/bpiphany/pegasushoof/keymaps/citadel/keymap.c @@ -112,7 +112,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { _______,_______,_______, _______, _______,_______,_______,_______, _______,_______,_______), }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { /* Tap once: nothing. Tap twice: Alt+F4 */ [AF4] = ACTION_TAP_DANCE_DOUBLE(XXXXXXX,A(F4)), }; diff --git a/keyboards/buzzard/keymaps/crehmann/config.h b/keyboards/buzzard/keymaps/crehmann/config.h index d5d9a9bb83..c5638c767d 100644 --- a/keyboards/buzzard/keymaps/crehmann/config.h +++ b/keyboards/buzzard/keymaps/crehmann/config.h @@ -10,7 +10,7 @@ #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // Apply the modifier on keys that are tapped during a short hold of a modtap #define PERMISSIVE_HOLD diff --git a/keyboards/buzzard/keymaps/default/config.h b/keyboards/buzzard/keymaps/default/config.h index 76294cf78a..0f1db48977 100644 --- a/keyboards/buzzard/keymaps/default/config.h +++ b/keyboards/buzzard/keymaps/default/config.h @@ -10,7 +10,7 @@ #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // Apply the modifier on keys that are tapped during a short hold of a modtap #define PERMISSIVE_HOLD diff --git a/keyboards/cannonkeys/ortho60v2/config.h b/keyboards/cannonkeys/ortho60v2/config.h new file mode 100644 index 0000000000..2af75a1715 --- /dev/null +++ b/keyboards/cannonkeys/ortho60v2/config.h @@ -0,0 +1,23 @@ +/* +Copyright 2022 CannonKeys + +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/>. +*/ +#pragma once + +#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET // Activates the double-tap behavior +#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 200U // Timeout window in ms in which the double tap can occur. + +#define BACKLIGHT_PWM_DRIVER PWMD6 +#define BACKLIGHT_PWM_CHANNEL RP2040_PWM_CHANNEL_A diff --git a/tests/tap_hold_configurations/ignore_mod_tap_interrupt/config.h b/keyboards/cannonkeys/ortho60v2/halconf.h index 5955b8600a..cef26f106c 100644 --- a/tests/tap_hold_configurations/ignore_mod_tap_interrupt/config.h +++ b/keyboards/cannonkeys/ortho60v2/halconf.h @@ -1,4 +1,5 @@ -/* Copyright 2021 Stefan Kerkmann + /* + * Copyright Andrew Kannan 2022 * * 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 @@ -14,8 +15,9 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. */ + #pragma once -#include "test_common.h" +#define HAL_USE_PWM TRUE -#define IGNORE_MOD_TAP_INTERRUPT
\ No newline at end of file +#include_next <halconf.h> diff --git a/keyboards/cannonkeys/ortho60v2/info.json b/keyboards/cannonkeys/ortho60v2/info.json new file mode 100644 index 0000000000..08f5321d84 --- /dev/null +++ b/keyboards/cannonkeys/ortho60v2/info.json @@ -0,0 +1,105 @@ +{ + "keyboard_name": "Ortho60 v2", + "maintainer": "awkannan", + "manufacturer": "CannonKeys", + "processor": "RP2040", + "bootloader": "rp2040", + "usb": { + "vid": "0xCA04", + "pid": "0x0019", + "device_version": "0.0.1" + }, + "url": "https://cannonkeys.com", + "diode_direction": "COL2ROW", + "matrix_pins": { + "cols": ["GP7", "GP6", "GP5", "GP4", "GP3", "GP2", "GP1", "GP0", "GP13", "GP24", "GP23", "GP22"], + "rows": ["GP27", "GP18", "GP19", "GP25", "GP26"] + }, + "features": { + "bootmagic": true, + "command": false, + "console": false, + "extrakey": true, + "mousekey": true, + "nkro": true, + "backlight": true, + "encoder": true + }, + "encoder": { + "rotary": [ + { "pin_a": "GP28", "pin_b": "GP29" } + ] + }, + "backlight": { + "breathing": true, + "breathing_period": 5, + "levels": 15, + "pin": "GP12" + }, + "layouts": { + "LAYOUT_ortho_5x12": { + "layout": [ + { "label": "`", "matrix": [0, 0], "x": 0.0, "y": 0.0 }, + { "label": "1", "matrix": [0, 1], "x": 1.0, "y": 0.0 }, + { "label": "2", "matrix": [0, 2], "x": 2.0, "y": 0.0 }, + { "label": "3", "matrix": [0, 3], "x": 3.0, "y": 0.0 }, + { "label": "4", "matrix": [0, 4], "x": 4.0, "y": 0.0 }, + { "label": "5", "matrix": [0, 5], "x": 5.0, "y": 0.0 }, + { "label": "6", "matrix": [0, 6], "x": 6.0, "y": 0.0 }, + { "label": "7", "matrix": [0, 7], "x": 7.0, "y": 0.0 }, + { "label": "8", "matrix": [0, 8], "x": 8.0, "y": 0.0 }, + { "label": "9", "matrix": [0, 9], "x": 9.0, "y": 0.0 }, + { "label": "0", "matrix": [0, 10], "x": 10.0, "y": 0.0 }, + { "label": "Del", "matrix": [0, 11], "x": 11.0, "y": 0.0 }, + { "label": "Tab", "matrix": [1, 0], "x": 0.0, "y": 1.0 }, + { "label": "Q", "matrix": [1, 1], "x": 1.0, "y": 1.0 }, + { "label": "W", "matrix": [1, 2], "x": 2.0, "y": 1.0 }, + { "label": "E", "matrix": [1, 3], "x": 3.0, "y": 1.0 }, + { "label": "R", "matrix": [1, 4], "x": 4.0, "y": 1.0 }, + { "label": "T", "matrix": [1, 5], "x": 5.0, "y": 1.0 }, + { "label": "Y", "matrix": [1, 6], "x": 6.0, "y": 1.0 }, + { "label": "U", "matrix": [1, 7], "x": 7.0, "y": 1.0 }, + { "label": "I", "matrix": [1, 8], "x": 8.0, "y": 1.0 }, + { "label": "O", "matrix": [1, 9], "x": 9.0, "y": 1.0 }, + { "label": "P", "matrix": [1, 10], "x": 10.0, "y": 1.0 }, + { "label": "Back Space", "matrix": [1, 11], "x": 11.0, "y": 1.0 }, + { "label": "Esc", "matrix": [2, 0], "x": 0.0, "y": 2.0 }, + { "label": "A", "matrix": [2, 1], "x": 1.0, "y": 2.0 }, + { "label": "S", "matrix": [2, 2], "x": 2.0, "y": 2.0 }, + { "label": "D", "matrix": [2, 3], "x": 3.0, "y": 2.0 }, + { "label": "F", "matrix": [2, 4], "x": 4.0, "y": 2.0 }, + { "label": "G", "matrix": [2, 5], "x": 5.0, "y": 2.0 }, + { "label": "H", "matrix": [2, 6], "x": 6.0, "y": 2.0 }, + { "label": "J", "matrix": [2, 7], "x": 7.0, "y": 2.0 }, + { "label": "K", "matrix": [2, 8], "x": 8.0, "y": 2.0 }, + { "label": "L", "matrix": [2, 9], "x": 9.0, "y": 2.0 }, + { "label": ";", "matrix": [2, 10], "x": 10.0, "y": 2.0 }, + { "label": "'", "matrix": [2, 11], "x": 11.0, "y": 2.0 }, + { "label": "Shift", "matrix": [3, 0], "x": 0.0, "y": 3.0 }, + { "label": "Z", "matrix": [3, 1], "x": 1.0, "y": 3.0 }, + { "label": "X", "matrix": [3, 2], "x": 2.0, "y": 3.0 }, + { "label": "C", "matrix": [3, 3], "x": 3.0, "y": 3.0 }, + { "label": "V", "matrix": [3, 4], "x": 4.0, "y": 3.0 }, + { "label": "B", "matrix": [3, 5], "x": 5.0, "y": 3.0 }, + { "label": "N", "matrix": [3, 6], "x": 6.0, "y": 3.0 }, + { "label": "M", "matrix": [3, 7], "x": 7.0, "y": 3.0 }, + { "label": ",", "matrix": [3, 8], "x": 8.0, "y": 3.0 }, + { "label": ".", "matrix": [3, 9], "x": 9.0, "y": 3.0 }, + { "label": "/", "matrix": [3, 10], "x": 10.0, "y": 3.0 }, + { "label": "Return", "matrix": [3, 11], "x": 11.0, "y": 3.0 }, + { "matrix": [4, 0], "x": 0.0, "y": 4.0 }, + { "label": "Ctrl", "matrix": [4, 1], "x": 1.0, "y": 4.0 }, + { "label": "Alt", "matrix": [4, 2], "x": 2.0, "y": 4.0 }, + { "label": "Super", "matrix": [4, 3], "x": 3.0, "y": 4.0 }, + { "label": "Lower", "matrix": [4, 4], "x": 4.0, "y": 4.0 }, + { "matrix": [4, 5], "x": 5.0, "y": 4.0 }, + { "matrix": [4, 6], "x": 6.0, "y": 4.0 }, + { "label": "Raise", "matrix": [4, 7], "x": 7.0, "y": 4.0 }, + { "label": "←", "matrix": [4, 8], "x": 8.0, "y": 4.0 }, + { "label": "↓", "matrix": [4, 9], "x": 9.0, "y": 4.0 }, + { "label": "↑", "matrix": [4, 10], "x": 10.0, "y": 4.0 }, + { "label": "→", "matrix": [4, 11], "x": 11.0, "y": 4.0 } + ] + } + } +} diff --git a/keyboards/cannonkeys/ortho60v2/keymaps/default/keymap.c b/keyboards/cannonkeys/ortho60v2/keymaps/default/keymap.c new file mode 100644 index 0000000000..1f042bdd20 --- /dev/null +++ b/keyboards/cannonkeys/ortho60v2/keymaps/default/keymap.c @@ -0,0 +1,99 @@ +/* +Copyright 2012,2013 Jun Wako <wakojun@gmail.com> + +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/>. +*/ +#include QMK_KEYBOARD_H + + +// Each layer gets a name for readability, which is then used in the keymap matrix below. +// The underscores don't mean anything - you can have a layer called STUFF or any other name. +// Layer names don't all need to be of the same length, obviously, and you can also skip them +// entirely and just use numbers. +enum custom_layers { + _BASE, + _RAISE, + _LOWER, +}; + +enum custom_keycodes { + QWERTY = SAFE_RANGE, + LOWER, + RAISE +}; + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + +/* Qwerty + * ,-----------------------------------------------------------------------------------. + * | ` | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | Bksp | + * |------+------+------+------+------+------+------+------+------+------+------+------| + * | Tab | Q | W | E | R | T | Y | U | I | O | P | Del | + * |------+------+------+------+------+-------------+------+------+------+------+------| + * | Esc | A | S | D | F | G | H | J | K | L | ; | " | + * |------+------+------+------+------+------|------+------+------+------+------+------| + * | Shift| Z | X | C | V | B | N | M | , | . | / |Enter | + * |------+------+------+------+------+------+------+------+------+------+------+------| + * | Brite| Ctrl | Alt | GUI |Lower | Space |Raise | Left | Down | Up |Right | + * `-----------------------------------------------------------------------------------' + */ +[_BASE] = LAYOUT_ortho_5x12( + KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, + KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_DEL, + KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, + KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT, + BL_TOGG, KC_LCTL, KC_LALT, KC_LGUI, MO(_LOWER), KC_SPC, KC_SPC, MO(_RAISE), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT +), +/* Lower + * ,-----------------------------------------------------------------------------------. + * | ~ | ! | @ | # | $ | % | ^ | & | * | ( | ) | Bksp | + * |------+------+------+------+------+-------------+------+------+------+------+------| + * | ~ | ! | @ | # | $ | % | ^ | & | * | ( | ) | Del | + * |------+------+------+------+------+-------------+------+------+------+------+------| + * | Del | F1 | F2 | F3 | F4 | F5 | F6 | _ | + | { | } | | | + * |------+------+------+------+------+------|------+------+------+------+------+------| + * | | F7 | F8 | F9 | F10 | F11 | F12 |ISO ~ |ISO | | | | | + * |------+------+------+------+------+------+------+------+------+------+------+------| + * | | | | | | | | Next | Vol- | Vol+ | Play | + * `-----------------------------------------------------------------------------------' + */ +[_LOWER] = LAYOUT_ortho_5x12( + KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC, + KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_DEL, + KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, + _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,S(KC_NUHS),S(KC_NUBS),KC_HOME, KC_END, _______, + QK_BOOT, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY +), + +/* Raise + * ,-----------------------------------------------------------------------------------. + * | ` | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | Bksp | + * |------+------+------+------+------+------+------+------+------+------+------+------| + * | ` | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | Del | + * |------+------+------+------+------+-------------+------+------+------+------+------| + * | Del | F1 | F2 | F3 | F4 | F5 | F6 | - | = | [ | ] | \ | + * |------+------+------+------+------+------|------+------+------+------+------+------| + * | | F7 | F8 | F9 | F10 | F11 | F12 |ISO # |ISO / | | | | + * |------+------+------+------+------+------+------+------+------+------+------+------| + * | | | | | | | | Next | Vol- | Vol+ | Play | + * `-----------------------------------------------------------------------------------' + */ +[_RAISE] = LAYOUT_ortho_5x12( + KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, + KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, + KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, + _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, KC_PGUP, KC_PGDN, _______, + RGB_TOG, RGB_MOD, BL_INC, BL_DEC, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY +) +}; diff --git a/keyboards/cannonkeys/ortho60v2/keymaps/via/keymap.c b/keyboards/cannonkeys/ortho60v2/keymaps/via/keymap.c new file mode 100644 index 0000000000..8d0060d015 --- /dev/null +++ b/keyboards/cannonkeys/ortho60v2/keymaps/via/keymap.c @@ -0,0 +1,53 @@ +/* +Copyright 2012,2013 Jun Wako <wakojun@gmail.com> + +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/>. +*/ +#include QMK_KEYBOARD_H + + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + +[0] = LAYOUT_ortho_5x12( + KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, + KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_DEL, + KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, + KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT, + BL_TOGG, KC_LCTL, KC_LALT, KC_LGUI, MO(1), KC_SPC, KC_SPC, MO(2), KC_LEFT, KC_DOWN, KC_UP, KC_RGHT +), + +[1] = LAYOUT_ortho_5x12( + KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC, + KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_DEL, + KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, + _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,S(KC_NUHS),S(KC_NUBS),KC_HOME, KC_END, _______, + QK_BOOT, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY +), + +[2] = LAYOUT_ortho_5x12( + KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, + KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, + KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, + _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, KC_PGUP, KC_PGDN, _______, + RGB_TOG, RGB_MOD, BL_INC, BL_DEC, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY +), + +[3] = LAYOUT_ortho_5x12( + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS +) +}; diff --git a/keyboards/xelus/xs60/keymaps/via/rules.mk b/keyboards/cannonkeys/ortho60v2/keymaps/via/rules.mk index 1e5b99807c..1e5b99807c 100644 --- a/keyboards/xelus/xs60/keymaps/via/rules.mk +++ b/keyboards/cannonkeys/ortho60v2/keymaps/via/rules.mk diff --git a/keyboards/cannonkeys/ortho60v2/mcuconf.h b/keyboards/cannonkeys/ortho60v2/mcuconf.h new file mode 100644 index 0000000000..533c3f1e23 --- /dev/null +++ b/keyboards/cannonkeys/ortho60v2/mcuconf.h @@ -0,0 +1,9 @@ +// Copyright 2022 Andrew Kannan +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include_next "mcuconf.h" + +#undef RP_PWM_USE_PWM6 +#define RP_PWM_USE_PWM6 TRUE diff --git a/keyboards/cannonkeys/ortho60v2/ortho60v2.c b/keyboards/cannonkeys/ortho60v2/ortho60v2.c new file mode 100644 index 0000000000..0fc9239ee8 --- /dev/null +++ b/keyboards/cannonkeys/ortho60v2/ortho60v2.c @@ -0,0 +1,31 @@ +/* +Copyright 2022 CannonKeys + +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/>. +*/ +#include "ortho60v2.h" + +#ifdef ENCODER_ENABLE +bool encoder_update_kb(uint8_t index, bool clockwise) { + if (!encoder_update_user(index, clockwise)) { + return false; + } + if (clockwise) { + tap_code_delay(KC_VOLU, 10); + } else { + tap_code_delay(KC_VOLD, 10); + } + return true; +} +#endif diff --git a/quantum/logging/nodebug.h b/keyboards/cannonkeys/ortho60v2/ortho60v2.h index 0b176684bd..a9ca3d7e47 100644 --- a/quantum/logging/nodebug.h +++ b/keyboards/cannonkeys/ortho60v2/ortho60v2.h @@ -1,5 +1,5 @@ /* -Copyright 2013 Jun Wako <wakojun@gmail.com> +Copyright 2022 CannonKeys 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 @@ -14,13 +14,6 @@ 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/>. */ - #pragma once -#ifndef NO_DEBUG -# define NO_DEBUG -# include "debug.h" -# undef NO_DEBUG -#else -# include "debug.h" -#endif +#include "quantum.h" diff --git a/keyboards/cannonkeys/ortho60v2/readme.md b/keyboards/cannonkeys/ortho60v2/readme.md new file mode 100644 index 0000000000..e02e0f0914 --- /dev/null +++ b/keyboards/cannonkeys/ortho60v2/readme.md @@ -0,0 +1,22 @@ +# Ortho60 v2 + +A 5x12 Ortholinear keyboard powered by an onboard RP2040 + +* Keyboard Maintainer: [Andrew Kannan](https://github.com/awkannan1) +* Hardware Supported: RP2040 +* Hardware Availability: [CannonKeys](https://cannonkeys.com) + +Make example for this keyboard (after setting up your build environment): + + make cannonkeys/ortho60v2:default + +See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). + + +## Bootloader + +Enter the bootloader in 3 ways: + +* **Bootmagic reset**: Hold down the key at (0,0) in the matrix (usually the top left key or Escape) and plug in the keyboard +* **Physical reset button**: Swap the boot switch on the back of the PCB to "1" and hit the reset button. Or double tap the reset button quickly while the boot switch is set to "0". +* **Keycode in layout**: Press the key mapped to `RESET` if it is available diff --git a/keyboards/cannonkeys/ortho60v2/rules.mk b/keyboards/cannonkeys/ortho60v2/rules.mk new file mode 100644 index 0000000000..59f8593f18 --- /dev/null +++ b/keyboards/cannonkeys/ortho60v2/rules.mk @@ -0,0 +1,2 @@ +EEPROM_DRIVER = wear_leveling +WEAR_LEVELING_DRIVER = rp2040_flash diff --git a/keyboards/clickety_split/leeloo/keymaps/default/config.h b/keyboards/clickety_split/leeloo/keymaps/default/config.h index 7a8d0f5bd6..c944579972 100644 --- a/keyboards/clickety_split/leeloo/keymaps/default/config.h +++ b/keyboards/clickety_split/leeloo/keymaps/default/config.h @@ -26,7 +26,7 @@ #undef TAPPING_TERM #define IGNORE_MOD_TAP_INTERRUPT - #define TAPPING_FORCE_HOLD + #define QUICK_TAP_TERM 0 #define TAPPING_TERM 150 #endif diff --git a/keyboards/contra/keymaps/erovia/keymap.c b/keyboards/contra/keymaps/erovia/keymap.c index 7063a85509..ed7c2873c6 100644 --- a/keyboards/contra/keymaps/erovia/keymap.c +++ b/keyboards/contra/keymaps/erovia/keymap.c @@ -22,7 +22,7 @@ enum { TD_SPACE_CADET_ENTER = 1 }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SPACE_CADET_SHIFT] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_LPRN), [TD_SPACE_CADET_ENTER] = ACTION_TAP_DANCE_DOUBLE(KC_ENT, KC_RPRN) }; diff --git a/keyboards/contra/keymaps/ryanm101/keymap.c b/keyboards/contra/keymaps/ryanm101/keymap.c index 27c12bfa44..ff33043632 100644 --- a/keyboards/contra/keymaps/ryanm101/keymap.c +++ b/keyboards/contra/keymaps/ryanm101/keymap.c @@ -141,7 +141,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Parantheses -void paranthesis_dance (qk_tap_dance_state_t *state, void *user_data) { +void paranthesis_dance (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) { @@ -151,7 +151,7 @@ void paranthesis_dance (qk_tap_dance_state_t *state, void *user_data) { } } -void curly_dance (qk_tap_dance_state_t *state, void *user_data) { +void curly_dance (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) { @@ -161,7 +161,7 @@ void curly_dance (qk_tap_dance_state_t *state, void *user_data) { } } -void square_dance (qk_tap_dance_state_t *state, void *user_data) { +void square_dance (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) { @@ -171,7 +171,7 @@ void square_dance (qk_tap_dance_state_t *state, void *user_data) { } } -void angular_dance (qk_tap_dance_state_t *state, void *user_data) { +void angular_dance (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) { @@ -181,7 +181,7 @@ void angular_dance (qk_tap_dance_state_t *state, void *user_data) { } } -void tmux_dance (qk_tap_dance_state_t *state, void *user_data) { +void tmux_dance (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { SEND_STRING("tmux"); register_code(KC_ENT); unregister_code(KC_ENT); } else if (state->count == 2) { @@ -194,7 +194,7 @@ void tmux_dance (qk_tap_dance_state_t *state, void *user_data) { } } -void cmd_dance (qk_tap_dance_state_t *state, void *user_data) { +void cmd_dance (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_mods(MOD_BIT(KC_LCTL)); register_mods(MOD_BIT(KC_LALT)); @@ -219,7 +219,7 @@ void cmd_dance (qk_tap_dance_state_t *state, void *user_data) { } } -void cmd_sft_slash_pipe_down (qk_tap_dance_state_t *state, void *user_data) { +void cmd_sft_slash_pipe_down (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || state->pressed==0) { register_code (KC_NONUS_BACKSLASH); @@ -232,7 +232,7 @@ void cmd_sft_slash_pipe_down (qk_tap_dance_state_t *state, void *user_data) { } } -void cmd_sft_slash_pipe_up (qk_tap_dance_state_t *state, void *user_data) { +void cmd_sft_slash_pipe_up (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (keyboard_report->mods & MOD_BIT(KC_LSFT)) { unregister_code (KC_LSFT); @@ -246,7 +246,7 @@ void cmd_sft_slash_pipe_up (qk_tap_dance_state_t *state, void *user_data) { } //All tap dance functions would go here. Only showing this one. - qk_tap_dance_action_t tap_dance_actions[] = { + tap_dance_action_t tap_dance_actions[] = { [CLN] = ACTION_TAP_DANCE_DOUBLE (KC_SCLN, S(KC_SCLN )) ,[QUOT] = ACTION_TAP_DANCE_DOUBLE (KC_QUOT, S(KC_2)) ,[CAD_CAE] = ACTION_TAP_DANCE_FN_ADVANCED( NULL, NULL, cmd_dance ) diff --git a/keyboards/controllerworks/mini36/config.h b/keyboards/controllerworks/mini36/config.h index 0903534838..c4f428d366 100644 --- a/keyboards/controllerworks/mini36/config.h +++ b/keyboards/controllerworks/mini36/config.h @@ -33,6 +33,6 @@ #define SPLIT_LED_STATE_ENABLE #define SPLIT_MODS_ENABLE -#define I2C_DRIVER I2CD1 +#define I2C_DRIVER I2CD0 #define I2C1_SCL_PIN GP25 #define I2C1_SDA_PIN GP24 diff --git a/keyboards/controllerworks/mini42/config.h b/keyboards/controllerworks/mini42/config.h index 420e616ad2..ad01588e55 100644 --- a/keyboards/controllerworks/mini42/config.h +++ b/keyboards/controllerworks/mini42/config.h @@ -27,7 +27,7 @@ #define SPLIT_MODS_ENABLE #undef I2C_DRIVER -#define I2C_DRIVER I2CD1 +#define I2C_DRIVER I2CD0 #undef I2C1_SCL_PIN #define I2C1_SCL_PIN GP25 #undef I2C1_SDA_PIN diff --git a/keyboards/converter/usb_usb/custom_matrix.cpp b/keyboards/converter/usb_usb/custom_matrix.cpp index a92feeb6c1..e94b6b07fb 100644 --- a/keyboards/converter/usb_usb/custom_matrix.cpp +++ b/keyboards/converter/usb_usb/custom_matrix.cpp @@ -233,6 +233,7 @@ extern "C" { if (kbd2.isReady()) kbd2.SetReport(0, 0, 2, 0, 1, &usb_led); if (kbd3.isReady()) kbd3.SetReport(0, 0, 2, 0, 1, &usb_led); if (kbd4.isReady()) kbd4.SetReport(0, 0, 2, 0, 1, &usb_led); - led_set_kb(usb_led); + led_set_user(usb_led); + led_update_kb((led_t){.raw = usb_led}); } } diff --git a/keyboards/converter/usb_usb/keymaps/chriskopher/config.h b/keyboards/converter/usb_usb/keymaps/chriskopher/config.h index 7714f713bd..04066edc02 100644 --- a/keyboards/converter/usb_usb/keymaps/chriskopher/config.h +++ b/keyboards/converter/usb_usb/keymaps/chriskopher/config.h @@ -18,8 +18,7 @@ #define TAPPING_TERM 200 // Delay for tap modifiers until it is considered a hold -#define IGNORE_MOD_TAP_INTERRUPT // Enable ignore mod tap interrupt: https://docs.qmk.fm/#/tap_hold?id=ignore-mod-tap-interrupt -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY // Allows configuration of ignore mod tap interrupt per key in keymap.c +#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY // Allows configuration of hold on other key press per key in keymap.c #define COMBO_COUNT 2 // Number of defined combos #define COMBO_TERM 20 // Delay for combo keys to be chained together diff --git a/keyboards/converter/usb_usb/keymaps/chriskopher/keymap.c b/keyboards/converter/usb_usb/keymaps/chriskopher/keymap.c index 4113cdc67c..76cf311462 100644 --- a/keyboards/converter/usb_usb/keymaps/chriskopher/keymap.c +++ b/keyboards/converter/usb_usb/keymaps/chriskopher/keymap.c @@ -174,13 +174,13 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // clang-format on -// Configure ignore mod tap interrupt per key -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { +// Configure hold on other key press per key +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { switch (keycode) { - // I don't like how mod tap interrupt feels with these keys specifically when I'm typing + // I don't like how ignore interrupt feels with these keys specifically when I'm typing case LCTL_T(KC_ESC): - return false; - default: return true; + default: + return false; } } diff --git a/keyboards/converter/usb_usb/keymaps/chriskopher/tap_dance.c b/keyboards/converter/usb_usb/keymaps/chriskopher/tap_dance.c index 8600d83996..51a677a588 100644 --- a/keyboards/converter/usb_usb/keymaps/chriskopher/tap_dance.c +++ b/keyboards/converter/usb_usb/keymaps/chriskopher/tap_dance.c @@ -31,7 +31,7 @@ static int espc_r_tap_state = 0; static int scln_cln_tap_state = 0; // Watch the state of the tap dance -int cur_dance(qk_tap_dance_state_t *state) { +int cur_dance(tap_dance_state_t *state) { if (state->pressed) { return SINGLE_HOLD; } @@ -49,7 +49,7 @@ int cur_dance(qk_tap_dance_state_t *state) { } // Extended Space Cadet Shift - Left ================================== -void espc_l_finished(qk_tap_dance_state_t *state, void *user_data) { +void espc_l_finished(tap_dance_state_t *state, void *user_data) { espc_l_tap_state = cur_dance(state); switch (espc_l_tap_state) { case SINGLE_TAP: // ( @@ -69,7 +69,7 @@ void espc_l_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void espc_l_reset(qk_tap_dance_state_t *state, void *user_data) { +void espc_l_reset(tap_dance_state_t *state, void *user_data) { switch (espc_l_tap_state) { case SINGLE_TAP: // ( unregister_code16(LSFT(KC_9)); @@ -89,7 +89,7 @@ void espc_l_reset(qk_tap_dance_state_t *state, void *user_data) { // ====================================================================// // Extended Space Cadet Shift - Right ================================== -void espc_r_finished(qk_tap_dance_state_t *state, void *user_data) { +void espc_r_finished(tap_dance_state_t *state, void *user_data) { espc_r_tap_state = cur_dance(state); switch (espc_r_tap_state) { case SINGLE_TAP: // ) @@ -109,7 +109,7 @@ void espc_r_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void espc_r_reset(qk_tap_dance_state_t *state, void *user_data) { +void espc_r_reset(tap_dance_state_t *state, void *user_data) { switch (espc_r_tap_state) { case SINGLE_TAP: // ) unregister_code16(LSFT(KC_0)); @@ -129,7 +129,7 @@ void espc_r_reset(qk_tap_dance_state_t *state, void *user_data) { // ====================================================================// // Semicolon - Colon ================================================== -void scln_cln_finished(qk_tap_dance_state_t *state, void *user_data) { +void scln_cln_finished(tap_dance_state_t *state, void *user_data) { scln_cln_tap_state = cur_dance(state); switch (scln_cln_tap_state) { case SINGLE_TAP: // ; @@ -141,7 +141,7 @@ void scln_cln_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void scln_cln_reset(qk_tap_dance_state_t *state, void *user_data) { +void scln_cln_reset(tap_dance_state_t *state, void *user_data) { switch (scln_cln_tap_state) { case SINGLE_TAP: // ; unregister_code16(KC_SCLN); @@ -154,7 +154,7 @@ void scln_cln_reset(qk_tap_dance_state_t *state, void *user_data) { // ====================================================================// // Associate tap dance with defined functionality -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Extended space cadet shift left: Hold - Shift, One - (, Two - {, Three - [ [ESPC_L] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, espc_l_finished, espc_l_reset), // Extended space cadet shift right: Hold - Shift, One - ), Two - }, Three - ] diff --git a/keyboards/creatkeebs/glacier/readme.md b/keyboards/creatkeebs/glacier/readme.md index 0a38629863..0f13b6857d 100644 --- a/keyboards/creatkeebs/glacier/readme.md +++ b/keyboards/creatkeebs/glacier/readme.md @@ -16,7 +16,7 @@ A 80% keyboard Enter the bootloader in 2 ways: -* Physical reset button: Press the `QK_BOOT` button on the back of the PCB. +* Physical reset button: Press the `RESET` button on the back of the PCB. * Keycode in layout: Press the key mapped to `QK_BOOT` if it is available. ### Building the Firmware diff --git a/keyboards/creatkeebs/thera/readme.md b/keyboards/creatkeebs/thera/readme.md index 2f78a154fd..2990f9a3b0 100644 --- a/keyboards/creatkeebs/thera/readme.md +++ b/keyboards/creatkeebs/thera/readme.md @@ -18,7 +18,7 @@ A 75% keyboard Enter the bootloader in 2 ways: -* Physical reset button: Press the `QK_BOOT` button on the back of the PCB. +* Physical reset button: Press the `RESET` button on the back of the PCB. * Keycode in layout: Press the key mapped to `QK_BOOT` if it is available. ### Building the Firmware diff --git a/keyboards/crkbd/keymaps/ajarov/config.h b/keyboards/crkbd/keymaps/ajarov/config.h index 4c408112bd..d993e8e659 100644 --- a/keyboards/crkbd/keymaps/ajarov/config.h +++ b/keyboards/crkbd/keymaps/ajarov/config.h @@ -27,7 +27,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 //#define TAPPING_TERM 100 #ifdef RGBLIGHT_ENABLE diff --git a/keyboards/crkbd/keymaps/antosha417/config.h b/keyboards/crkbd/keymaps/antosha417/config.h index 4b6e86fd6b..bfe2b143d2 100644 --- a/keyboards/crkbd/keymaps/antosha417/config.h +++ b/keyboards/crkbd/keymaps/antosha417/config.h @@ -10,7 +10,7 @@ #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #ifdef RGBLIGHT_ENABLE #undef RGBLED_NUM diff --git a/keyboards/crkbd/keymaps/ardakilic/config.h b/keyboards/crkbd/keymaps/ardakilic/config.h index 7a3bb76b38..95e7ddb329 100644 --- a/keyboards/crkbd/keymaps/ardakilic/config.h +++ b/keyboards/crkbd/keymaps/ardakilic/config.h @@ -31,7 +31,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/crkbd/keymaps/armand1m/config.h b/keyboards/crkbd/keymaps/armand1m/config.h index 095879a190..f4b8c08a3f 100644 --- a/keyboards/crkbd/keymaps/armand1m/config.h +++ b/keyboards/crkbd/keymaps/armand1m/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -// #define TAPPING_FORCE_HOLD +// #define QUICK_TAP_TERM 0 // #define PERMISSIVE_HOLD #define TAPPING_TERM 300 #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/crkbd/keymaps/benrestech/config.h b/keyboards/crkbd/keymaps/benrestech/config.h index b112aed743..f700899883 100644 --- a/keyboards/crkbd/keymaps/benrestech/config.h +++ b/keyboards/crkbd/keymaps/benrestech/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 175 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/crkbd/keymaps/bermeo/config.h b/keyboards/crkbd/keymaps/bermeo/config.h index cadb397834..188f717aba 100644 --- a/keyboards/crkbd/keymaps/bermeo/config.h +++ b/keyboards/crkbd/keymaps/bermeo/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -// #define TAPPING_FORCE_HOLD +// #define QUICK_TAP_TERM 0 #define TAPPING_TERM 150 // #define RETRO_TAPPING // #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/crkbd/keymaps/blipson/config.h b/keyboards/crkbd/keymaps/blipson/config.h index 1994795836..ca69ac3873 100644 --- a/keyboards/crkbd/keymaps/blipson/config.h +++ b/keyboards/crkbd/keymaps/blipson/config.h @@ -25,7 +25,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #ifdef RGBLIGHT_ENABLE diff --git a/keyboards/crkbd/keymaps/colemad/config.h b/keyboards/crkbd/keymaps/colemad/config.h index 6d2050e148..b52c669ea9 100644 --- a/keyboards/crkbd/keymaps/colemad/config.h +++ b/keyboards/crkbd/keymaps/colemad/config.h @@ -2,7 +2,7 @@ // SPDX-License-Identifier: GPL-2.0-or-later #pragma once -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #ifdef RGB_MATRIX_ENABLE diff --git a/keyboards/crkbd/keymaps/colemad/tap_dances.c b/keyboards/crkbd/keymaps/colemad/tap_dances.c index fc47cfd8d1..c0d83b94d0 100644 --- a/keyboards/crkbd/keymaps/colemad/tap_dances.c +++ b/keyboards/crkbd/keymaps/colemad/tap_dances.c @@ -2,6 +2,6 @@ // SPDX-License-Identifier: GPL-2.0-or-later #include "tap_dances.h" -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LSFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS) }; diff --git a/keyboards/crkbd/keymaps/crkdves/config.h b/keyboards/crkbd/keymaps/crkdves/config.h index 52d4fdd93a..ca025830b4 100644 --- a/keyboards/crkbd/keymaps/crkdves/config.h +++ b/keyboards/crkbd/keymaps/crkdves/config.h @@ -26,7 +26,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 // #define RETRO_TAPPING // #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/crkbd/keymaps/crkqwes/config.h b/keyboards/crkbd/keymaps/crkqwes/config.h index 878f9a74e1..bf33cc90aa 100644 --- a/keyboards/crkbd/keymaps/crkqwes/config.h +++ b/keyboards/crkbd/keymaps/crkqwes/config.h @@ -32,7 +32,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #undef USE_I2C #undef SSD1306OLED -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 // #define RETRO_TAPPING // #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/crkbd/keymaps/default/config.h b/keyboards/crkbd/keymaps/default/config.h index 8f4d73ca22..4e70141dad 100644 --- a/keyboards/crkbd/keymaps/default/config.h +++ b/keyboards/crkbd/keymaps/default/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 //#define TAPPING_TERM 100 #ifdef RGBLIGHT_ENABLE diff --git a/keyboards/crkbd/keymaps/devdev/config.h b/keyboards/crkbd/keymaps/devdev/config.h index 14067d1e74..337a86df8e 100644 --- a/keyboards/crkbd/keymaps/devdev/config.h +++ b/keyboards/crkbd/keymaps/devdev/config.h @@ -34,7 +34,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define CUSTOM_LAYER_READ //if you remove this it causes issues - needs better guarding -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define RGBLIGHT_SLEEP diff --git a/keyboards/crkbd/keymaps/edvorakjp/config.h b/keyboards/crkbd/keymaps/edvorakjp/config.h index 8787ba88d3..ee4e7388be 100644 --- a/keyboards/crkbd/keymaps/edvorakjp/config.h +++ b/keyboards/crkbd/keymaps/edvorakjp/config.h @@ -8,7 +8,7 @@ #define SWAP_SCLN -// #define TAPPING_FORCE_HOLD +// #define QUICK_TAP_TERM 0 #define TAPPING_TERM 300 #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/crkbd/keymaps/hvp/config.h b/keyboards/crkbd/keymaps/hvp/config.h index e569a59bc9..a926f67537 100644 --- a/keyboards/crkbd/keymaps/hvp/config.h +++ b/keyboards/crkbd/keymaps/hvp/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 //#define TAPPING_TERM 100 #define TAPPING_TERM 150 diff --git a/keyboards/crkbd/keymaps/jarred/config.h b/keyboards/crkbd/keymaps/jarred/config.h index c6c80469ed..c95deb1abb 100644 --- a/keyboards/crkbd/keymaps/jarred/config.h +++ b/keyboards/crkbd/keymaps/jarred/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 //#define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/crkbd/keymaps/julian_turner/config.h b/keyboards/crkbd/keymaps/julian_turner/config.h index fbe5277c40..3b875235a8 100644 --- a/keyboards/crkbd/keymaps/julian_turner/config.h +++ b/keyboards/crkbd/keymaps/julian_turner/config.h @@ -29,6 +29,6 @@ #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 //#define OLED_FONT_H "keyboards/crkbd/lib/glcdfont.c" diff --git a/keyboards/crkbd/keymaps/kidbrazil/config.h b/keyboards/crkbd/keymaps/kidbrazil/config.h index 74f8a0823b..33655b4c9d 100644 --- a/keyboards/crkbd/keymaps/kidbrazil/config.h +++ b/keyboards/crkbd/keymaps/kidbrazil/config.h @@ -29,7 +29,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 150 #undef PRODUCT #define PRODUCT "CRKBD Loose Transistor Ed." diff --git a/keyboards/crkbd/keymaps/madhatter/config.h b/keyboards/crkbd/keymaps/madhatter/config.h index 599bbc27c3..afdaf1c1fd 100644 --- a/keyboards/crkbd/keymaps/madhatter/config.h +++ b/keyboards/crkbd/keymaps/madhatter/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #ifdef RGBLIGHT_ENABLE diff --git a/keyboards/crkbd/keymaps/nimishgautam/config.h b/keyboards/crkbd/keymaps/nimishgautam/config.h index b09d858898..53b5f1b834 100644 --- a/keyboards/crkbd/keymaps/nimishgautam/config.h +++ b/keyboards/crkbd/keymaps/nimishgautam/config.h @@ -19,7 +19,7 @@ #define EXTRA_SHORT_COMBOS //Tapping values -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define IGNORE_MOD_TAP_INTERRUPT #define PERMISSIVE_HOLD_PER_KEY diff --git a/keyboards/crkbd/keymaps/nimishgautam/keymap.c b/keyboards/crkbd/keymaps/nimishgautam/keymap.c index e8a476cfc5..0c0a3e3544 100644 --- a/keyboards/crkbd/keymaps/nimishgautam/keymap.c +++ b/keyboards/crkbd/keymaps/nimishgautam/keymap.c @@ -375,7 +375,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -void dance_left_finished (qk_tap_dance_state_t *state, void *user_data) { +void dance_left_finished (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { //1 tap, move to line left keymap_config.raw = eeconfig_read_keymap(); if(keymap_config.swap_lctl_lgui){ //Linux @@ -388,7 +388,7 @@ void dance_left_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_right_finished (qk_tap_dance_state_t *state, void *user_data) { +void dance_right_finished (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { // 1 tap, move line right keymap_config.raw = eeconfig_read_keymap(); if(keymap_config.swap_lctl_lgui){ //Linux @@ -402,7 +402,7 @@ void dance_right_finished (qk_tap_dance_state_t *state, void *user_data) { } //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_MOVE_BEGIN_LINE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_left_finished, NULL), [TD_MOVE_END_LINE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_right_finished, NULL), [TD_PERIOD_COMMA] = ACTION_TAP_DANCE_DOUBLE(KC_DOT, KC_COMMA), diff --git a/keyboards/crkbd/keymaps/ninjonas/config.h b/keyboards/crkbd/keymaps/ninjonas/config.h index 174c678769..fa3711ce8f 100644 --- a/keyboards/crkbd/keymaps/ninjonas/config.h +++ b/keyboards/crkbd/keymaps/ninjonas/config.h @@ -24,7 +24,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define MASTER_LEFT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #ifdef RGB_MATRIX_ENABLE #define RGB_MATRIX_MAXIMUM_BRIGHTNESS 120 diff --git a/keyboards/crkbd/keymaps/oled_sample/config.h b/keyboards/crkbd/keymaps/oled_sample/config.h index cd24f74744..14718b26d1 100644 --- a/keyboards/crkbd/keymaps/oled_sample/config.h +++ b/keyboards/crkbd/keymaps/oled_sample/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/crkbd/keymaps/ollyhayes/config.h b/keyboards/crkbd/keymaps/ollyhayes/config.h index 4c51005181..9ad1ce2c58 100644 --- a/keyboards/crkbd/keymaps/ollyhayes/config.h +++ b/keyboards/crkbd/keymaps/ollyhayes/config.h @@ -18,7 +18,7 @@ #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #define NO_ACTION_ONESHOT diff --git a/keyboards/crkbd/keymaps/oo/config.h b/keyboards/crkbd/keymaps/oo/config.h index 8dc71430a1..814d227d7d 100644 --- a/keyboards/crkbd/keymaps/oo/config.h +++ b/keyboards/crkbd/keymaps/oo/config.h @@ -22,7 +22,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define SPLIT_USB_DETECT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #define OLED_FONT_H "keyboards/crkbd/lib/glcdfont.c" diff --git a/keyboards/crkbd/keymaps/rarick/config.h b/keyboards/crkbd/keymaps/rarick/config.h index 3dc4003f75..4a033596a8 100644 --- a/keyboards/crkbd/keymaps/rarick/config.h +++ b/keyboards/crkbd/keymaps/rarick/config.h @@ -27,7 +27,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #ifdef RGBLIGHT_ENABLE diff --git a/keyboards/crkbd/keymaps/rjhilgefort/config.h b/keyboards/crkbd/keymaps/rjhilgefort/config.h index 41d709d3a5..a7eb8b2a4f 100644 --- a/keyboards/crkbd/keymaps/rjhilgefort/config.h +++ b/keyboards/crkbd/keymaps/rjhilgefort/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 // 200 is default #ifdef RGBLIGHT_ENABLE diff --git a/keyboards/crkbd/keymaps/rs/config.h b/keyboards/crkbd/keymaps/rs/config.h index 85b9b95a23..bbdb0d8106 100644 --- a/keyboards/crkbd/keymaps/rs/config.h +++ b/keyboards/crkbd/keymaps/rs/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 300 #undef RGBLED_NUM diff --git a/keyboards/crkbd/keymaps/sharkby7e/config.h b/keyboards/crkbd/keymaps/sharkby7e/config.h index b1896bea90..0ff3549ba9 100644 --- a/keyboards/crkbd/keymaps/sharkby7e/config.h +++ b/keyboards/crkbd/keymaps/sharkby7e/config.h @@ -27,7 +27,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/crkbd/keymaps/snowe/config.h b/keyboards/crkbd/keymaps/snowe/config.h index 8bceb729d8..57a253428b 100644 --- a/keyboards/crkbd/keymaps/snowe/config.h +++ b/keyboards/crkbd/keymaps/snowe/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define IGNORE_MOD_TAP_INTERRUPT @@ -57,7 +57,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // fix for me putting alt under A and being a fast typist #define IGNORE_MOD_TAP_INTERRUPT -//#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY #define LAYER_STATE_8BIT #define SPLIT_WPM_ENABLE diff --git a/keyboards/crkbd/keymaps/snowe/keymap.c b/keyboards/crkbd/keymaps/snowe/keymap.c index 685491903e..91f0ceafeb 100644 --- a/keyboards/crkbd/keymaps/snowe/keymap.c +++ b/keyboards/crkbd/keymaps/snowe/keymap.c @@ -198,12 +198,14 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { // } //} // -// bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { +// bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { +// if (keycode == ALT_T(KC_A) || keycode == SH_BKSP) { +// return false; +// } // switch (keycode) { -// case ALT_T(KC_A): -// case SH_BKSP: +// case QK_MOD_TAP ... QK_MOD_TAP_MAX: // return true; // default: // return false; // } -//}
\ No newline at end of file +//} diff --git a/keyboards/crkbd/keymaps/soundmonster/config.h b/keyboards/crkbd/keymaps/soundmonster/config.h index 7cd9ecaed9..6cd090f9fd 100644 --- a/keyboards/crkbd/keymaps/soundmonster/config.h +++ b/keyboards/crkbd/keymaps/soundmonster/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -// #define TAPPING_FORCE_HOLD +// #define QUICK_TAP_TERM 0 #define TAPPING_TERM 150 #define RETRO_TAPPING #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/crkbd/keymaps/thumb_ctrl/config.h b/keyboards/crkbd/keymaps/thumb_ctrl/config.h index 6e54150c17..4191a14524 100755 --- a/keyboards/crkbd/keymaps/thumb_ctrl/config.h +++ b/keyboards/crkbd/keymaps/thumb_ctrl/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 150 #undef RGBLED_NUM diff --git a/keyboards/crkbd/keymaps/thunderbird2086/tap_dances.c b/keyboards/crkbd/keymaps/thunderbird2086/tap_dances.c index 1cf6fdf092..dbfe3c5b3d 100644 --- a/keyboards/crkbd/keymaps/thunderbird2086/tap_dances.c +++ b/keyboards/crkbd/keymaps/thunderbird2086/tap_dances.c @@ -4,7 +4,7 @@ #include QMK_KEYBOARD_H #include "tap_dances.h" -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESC_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS), [TD_TAB_CTRLTAB] = ACTION_TAP_DANCE_DOUBLE(KC_TAB, LCTL(KC_TAB)), [TD_GRV_CTRLGRV] = ACTION_TAP_DANCE_DOUBLE(KC_GRV, LGUI(KC_GRV)), diff --git a/keyboards/crkbd/keymaps/toinux/config.h b/keyboards/crkbd/keymaps/toinux/config.h index 2ee5a4e182..c033076a5a 100644 --- a/keyboards/crkbd/keymaps/toinux/config.h +++ b/keyboards/crkbd/keymaps/toinux/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 //#define TAPPING_TERM 100 #ifdef RGBLIGHT_ENABLE diff --git a/keyboards/crkbd/keymaps/vayashiko/config.h b/keyboards/crkbd/keymaps/vayashiko/config.h index 85a5412851..01a1210c81 100644 --- a/keyboards/crkbd/keymaps/vayashiko/config.h +++ b/keyboards/crkbd/keymaps/vayashiko/config.h @@ -30,7 +30,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/crkbd/keymaps/vlukash_trackpad_left/config.h b/keyboards/crkbd/keymaps/vlukash_trackpad_left/config.h index 4a370ef43c..8ff7589a9d 100644 --- a/keyboards/crkbd/keymaps/vlukash_trackpad_left/config.h +++ b/keyboards/crkbd/keymaps/vlukash_trackpad_left/config.h @@ -5,7 +5,7 @@ #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/crkbd/keymaps/vlukash_trackpad_right/config.h b/keyboards/crkbd/keymaps/vlukash_trackpad_right/config.h index 257c9df97b..cddd09e5b6 100644 --- a/keyboards/crkbd/keymaps/vlukash_trackpad_right/config.h +++ b/keyboards/crkbd/keymaps/vlukash_trackpad_right/config.h @@ -12,7 +12,7 @@ /* Select hand configuration */ #define MASTER_RIGHT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 300 #undef RGBLED_NUM diff --git a/keyboards/crkbd/keymaps/vxid/config.h b/keyboards/crkbd/keymaps/vxid/config.h index 5b18de236e..1960e13194 100644 --- a/keyboards/crkbd/keymaps/vxid/config.h +++ b/keyboards/crkbd/keymaps/vxid/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/crkbd/keymaps/xyverz/config.h b/keyboards/crkbd/keymaps/xyverz/config.h index 47a18105bd..2ccbb229b8 100644 --- a/keyboards/crkbd/keymaps/xyverz/config.h +++ b/keyboards/crkbd/keymaps/xyverz/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 300 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/crkbd/rev1/keymaps/dvorak_42_key/config.h b/keyboards/crkbd/rev1/keymaps/dvorak_42_key/config.h index d4d7a264d3..fcf6befb16 100644 --- a/keyboards/crkbd/rev1/keymaps/dvorak_42_key/config.h +++ b/keyboards/crkbd/rev1/keymaps/dvorak_42_key/config.h @@ -11,7 +11,7 @@ #define MASTER_RIGHT // #define EE_HANDS -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 //#define TAPPING_TERM 100 // #define DOUBLE_TAP_SHIFT_TURNS_ON_CAPS_WORD diff --git a/keyboards/duck/octagon/v1/v1.c b/keyboards/duck/octagon/v1/v1.c index e9e88c70d0..575847f588 100644 --- a/keyboards/duck/octagon/v1/v1.c +++ b/keyboards/duck/octagon/v1/v1.c @@ -40,7 +40,11 @@ void backlight_set(uint8_t level) { level & BACKLIGHT_RGBBLUE ? (PORTD |= 0b00010000) : (PORTD &= ~0b00010000); } -void led_set_kb(uint8_t usb_led) { - backlight_os_state & (1<<USB_LED_CAPS_LOCK) ? (PORTB &= ~0b00000001) : (PORTB |= 0b00000001); - backlight_os_state & (1<<USB_LED_SCROLL_LOCK) ? (PORTB &= ~0b00010000) : (PORTB |= 0b00010000); +bool led_update_kb(led_t led_state) { + bool res = led_update_user(led_state); + if(res) { + backlight_os_state & (1<<USB_LED_CAPS_LOCK) ? (PORTB &= ~0b00000001) : (PORTB |= 0b00000001); + backlight_os_state & (1<<USB_LED_SCROLL_LOCK) ? (PORTB &= ~0b00010000) : (PORTB |= 0b00010000); + } + return res; } diff --git a/keyboards/duck/octagon/v2/v2.c b/keyboards/duck/octagon/v2/v2.c index 23e92b2769..19bef7f877 100644 --- a/keyboards/duck/octagon/v2/v2.c +++ b/keyboards/duck/octagon/v2/v2.c @@ -97,17 +97,21 @@ void backlight_set(uint8_t level) { } // Port from backlight_update_state -void led_set_kb(uint8_t usb_led) { +bool led_update_kb(led_t led_state) { + bool res = led_update_user(led_state); + if(res) { bool status[7] = { - backlight_os_state & (1<<USB_LED_CAPS_LOCK), - backlight_os_state & (1<<USB_LED_SCROLL_LOCK), - backlight_os_state & (1<<USB_LED_NUM_LOCK), - backlight_layer_state & (1<<1), - backlight_layer_state & (1<<2), - backlight_layer_state & (1<<3), - backlight_layer_state & (1<<4) - }; - indicator_leds_set(status); - backlight_os_state & (1<<USB_LED_CAPS_LOCK) ? (PORTB &= ~0b00000001) : (PORTB |= 0b00000001); - backlight_os_state & (1<<USB_LED_SCROLL_LOCK) ? (PORTB &= ~0b00010000) : (PORTB |= 0b00010000); + backlight_os_state & (1<<USB_LED_CAPS_LOCK), + backlight_os_state & (1<<USB_LED_SCROLL_LOCK), + backlight_os_state & (1<<USB_LED_NUM_LOCK), + backlight_layer_state & (1<<1), + backlight_layer_state & (1<<2), + backlight_layer_state & (1<<3), + backlight_layer_state & (1<<4) + }; + indicator_leds_set(status); + backlight_os_state & (1<<USB_LED_CAPS_LOCK) ? (PORTB &= ~0b00000001) : (PORTB |= 0b00000001); + backlight_os_state & (1<<USB_LED_SCROLL_LOCK) ? (PORTB &= ~0b00010000) : (PORTB |= 0b00010000); + } + return res; } diff --git a/keyboards/duck/tcv3/tcv3.c b/keyboards/duck/tcv3/tcv3.c index 4d52d22c11..805d2b75d5 100644 --- a/keyboards/duck/tcv3/tcv3.c +++ b/keyboards/duck/tcv3/tcv3.c @@ -100,19 +100,23 @@ void backlight_set(uint8_t level) { } // // Port from backlight_update_state -// void led_set_kb(uint8_t usb_led) { -// bool status[7] = { -// backlight_os_state & (1<<USB_LED_CAPS_LOCK), -// backlight_os_state & (1<<USB_LED_SCROLL_LOCK), -// backlight_os_state & (1<<USB_LED_NUM_LOCK), -// backlight_layer_state & (1<<1), -// backlight_layer_state & (1<<2), -// backlight_layer_state & (1<<3), -// backlight_layer_state & (1<<4) -// }; -// indicator_leds_set(status); -// backlight_os_state & (1<<USB_LED_CAPS_LOCK) ? (PORTB &= ~0b00000001) : (PORTB |= 0b00000001); -// backlight_os_state & (1<<USB_LED_SCROLL_LOCK) ? (PORTB &= ~0b00010000) : (PORTB |= 0b00010000); +// bool led_update_kb(led_t led_state) { +// bool res = led_update_user(led_state); +// if(res) { +// bool status[7] = { +// backlight_os_state & (1<<USB_LED_CAPS_LOCK), +// backlight_os_state & (1<<USB_LED_SCROLL_LOCK), +// backlight_os_state & (1<<USB_LED_NUM_LOCK), +// backlight_layer_state & (1<<1), +// backlight_layer_state & (1<<2), +// backlight_layer_state & (1<<3), +// backlight_layer_state & (1<<4) +// }; +// indicator_leds_set(status); +// backlight_os_state & (1<<USB_LED_CAPS_LOCK) ? (PORTB &= ~0b00000001) : (PORTB |= 0b00000001); +// backlight_os_state & (1<<USB_LED_SCROLL_LOCK) ? (PORTB &= ~0b00010000) : (PORTB |= 0b00010000); +// } +// return res; // } // U5 Pin 1, 2, 3 connected to top left LEDs diff --git a/keyboards/dz60/keymaps/LEdiodes/keymap.c b/keyboards/dz60/keymaps/LEdiodes/keymap.c index cec6e859f5..79f0133d5d 100644 --- a/keyboards/dz60/keymaps/LEdiodes/keymap.c +++ b/keyboards/dz60/keymaps/LEdiodes/keymap.c @@ -101,7 +101,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for space, tap twice for enter [TD_SPC_ENT] = ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT), diff --git a/keyboards/dz60/keymaps/jdelkins/keymap.c b/keyboards/dz60/keymaps/jdelkins/keymap.c index 4e80724159..5555a0113f 100644 --- a/keyboards/dz60/keymaps/jdelkins/keymap.c +++ b/keyboards/dz60/keymaps/jdelkins/keymap.c @@ -35,10 +35,10 @@ enum { int ctl_state = 0; -void ctl_finished(qk_tap_dance_state_t *state, void *user_data) { +void ctl_finished(tap_dance_state_t *state, void *user_data) { ctl_state = cur_dance(state); switch (ctl_state) { - case SINGLE_TAP: qk_leader_start(); break; + case SINGLE_TAP: leader_start(); break; case SINGLE_HOLD: register_code(KC_LCTL); break; case DOUBLE_TAP: tap_code(KC_RCTL); break; case DOUBLE_HOLD: register_code(KC_RCTL); break; @@ -47,7 +47,7 @@ void ctl_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void ctl_reset(qk_tap_dance_state_t *state, void *user_data) { +void ctl_reset(tap_dance_state_t *state, void *user_data) { switch (ctl_state) { case SINGLE_HOLD: unregister_code(KC_LCTL); break; case DOUBLE_HOLD: @@ -56,7 +56,7 @@ void ctl_reset(qk_tap_dance_state_t *state, void *user_data) { ctl_state = 0; } -void g_finished(qk_tap_dance_state_t *state, void *user_data) { +void g_finished(tap_dance_state_t *state, void *user_data) { switch (cur_dance(state)) { case SINGLE_TAP: tap_code16(C(KC_END)); @@ -69,7 +69,7 @@ void g_finished(qk_tap_dance_state_t *state, void *user_data) { int kp_state = 0; -void kp_finished(qk_tap_dance_state_t *state, void *user_data) { +void kp_finished(tap_dance_state_t *state, void *user_data) { kp_state = hold_cur_dance(state); switch (kp_state) { case SINGLE_TAP: @@ -81,7 +81,7 @@ void kp_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void kp_reset(qk_tap_dance_state_t *state, void *user_data) { +void kp_reset(tap_dance_state_t *state, void *user_data) { switch (kp_state) { case SINGLE_HOLD: case DOUBLE_HOLD: @@ -97,7 +97,7 @@ enum { TD_KP, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LDCTL] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ctl_finished, ctl_reset), [TD_G] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, g_finished, NULL), [TD_KP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, kp_finished, kp_reset), diff --git a/keyboards/dztech/dz60rgb/keymaps/kgreulich/config.h b/keyboards/dztech/dz60rgb/keymaps/kgreulich/config.h index 7b408ba7bd..a5235259ff 100644 --- a/keyboards/dztech/dz60rgb/keymaps/kgreulich/config.h +++ b/keyboards/dztech/dz60rgb/keymaps/kgreulich/config.h @@ -19,7 +19,7 @@ #endif // !NO_PRINT #define NO_ACTION_ONESHOT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define IGNORE_MOD_TAP_INTERRUPT // #include "config_led.h" diff --git a/keyboards/dztech/dz60rgb/keymaps/matthewrobo/config.h b/keyboards/dztech/dz60rgb/keymaps/matthewrobo/config.h index 786360c5a2..4ea0d150ea 100644 --- a/keyboards/dztech/dz60rgb/keymaps/matthewrobo/config.h +++ b/keyboards/dztech/dz60rgb/keymaps/matthewrobo/config.h @@ -65,7 +65,7 @@ #endif // !NO_PRINT #define NO_ACTION_ONESHOT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define IGNORE_MOD_TAP_INTERRUPT // #include "config_led.h" diff --git a/keyboards/dztech/dz60rgb/keymaps/xunz/config.h b/keyboards/dztech/dz60rgb/keymaps/xunz/config.h index 2fdb3e5f4c..c302214061 100644 --- a/keyboards/dztech/dz60rgb/keymaps/xunz/config.h +++ b/keyboards/dztech/dz60rgb/keymaps/xunz/config.h @@ -49,5 +49,5 @@ // #define RGB_MATRIX_KEYRELEASES #define NO_ACTION_ONESHOT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/dztech/dz65rgb/keymaps/drootz/keymap.c b/keyboards/dztech/dz65rgb/keymaps/drootz/keymap.c index d0d22f28b4..123cf71853 100644 --- a/keyboards/dztech/dz65rgb/keymaps/drootz/keymap.c +++ b/keyboards/dztech/dz65rgb/keymaps/drootz/keymap.c @@ -708,11 +708,11 @@ void matrix_scan_user(void) } } -void leader_start(void) { +void leader_start_user(void) { isLeader = true; } -void leader_end(void) { +void leader_end_user(void) { isLeader = false; } diff --git a/keyboards/dztech/dz65rgb/keymaps/matthewrobo/config.h b/keyboards/dztech/dz65rgb/keymaps/matthewrobo/config.h index 6586ab58e4..93e6990950 100644 --- a/keyboards/dztech/dz65rgb/keymaps/matthewrobo/config.h +++ b/keyboards/dztech/dz65rgb/keymaps/matthewrobo/config.h @@ -59,7 +59,7 @@ #endif // !NO_PRINT #define NO_ACTION_ONESHOT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define IGNORE_MOD_TAP_INTERRUPT // #include "config_led.h" diff --git a/keyboards/dztech/tofu/ii/v1/config.h b/keyboards/dztech/tofu/ii/v1/config.h index 6343bb9e9d..67a4c757af 100644 --- a/keyboards/dztech/tofu/ii/v1/config.h +++ b/keyboards/dztech/tofu/ii/v1/config.h @@ -17,7 +17,7 @@ #pragma once #define I2C1_SDA_PIN GP2 #define I2C1_SCL_PIN GP3 -#define I2C_DRIVER I2CD2 +#define I2C_DRIVER I2CD1 #define RP2040_BOOTLOADER_DOUBLE_TAP_RESET #define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 500U diff --git a/keyboards/dztech/tofu/jr/v1/config.h b/keyboards/dztech/tofu/jr/v1/config.h index 9c157e366c..a05cdacf79 100644 --- a/keyboards/dztech/tofu/jr/v1/config.h +++ b/keyboards/dztech/tofu/jr/v1/config.h @@ -17,7 +17,7 @@ #pragma once #define I2C1_SDA_PIN GP2 #define I2C1_SCL_PIN GP3 -#define I2C_DRIVER I2CD2 +#define I2C_DRIVER I2CD1 #define RP2040_BOOTLOADER_DOUBLE_TAP_RESET #define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 500U diff --git a/keyboards/emptystring/nqg/keymaps/default/keymap.c b/keyboards/emptystring/nqg/keymaps/default/keymap.c index eec249187b..9b87225f19 100644 --- a/keyboards/emptystring/nqg/keymaps/default/keymap.c +++ b/keyboards/emptystring/nqg/keymaps/default/keymap.c @@ -29,7 +29,7 @@ enum tapdances{ #define KC_ESLO LT(_LOWER, KC_ESC) -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SCCL] = ACTION_TAP_DANCE_DOUBLE(KC_SCLN, KC_QUOT), [TD_ENSL] = ACTION_TAP_DANCE_DOUBLE(KC_SLSH, KC_ENT), [TD_N0BS] = ACTION_TAP_DANCE_DOUBLE(KC_0, KC_BSLS), diff --git a/keyboards/ergodox_ez/keymaps/bepo_tm_style/keymap.c b/keyboards/ergodox_ez/keymaps/bepo_tm_style/keymap.c index 6949261980..45a101ec81 100755 --- a/keyboards/ergodox_ez/keymaps/bepo_tm_style/keymap.c +++ b/keyboards/ergodox_ez/keymaps/bepo_tm_style/keymap.c @@ -196,7 +196,7 @@ layer_state_t layer_state_set_user(layer_state_t state); // Method called at the end of the tap dance on the TAP_MACRO key. That key is // used to start recording a macro (double tap or more), to stop recording (any // number of tap), or to play the recorded macro (1 tap). -void macro_tapdance_fn(qk_tap_dance_state_t *state, void *user_data) { +void macro_tapdance_fn(tap_dance_state_t *state, void *user_data) { uint16_t keycode; keyrecord_t record; dprintf("macro_tap_dance_fn %d\n", state->count); @@ -219,7 +219,7 @@ void macro_tapdance_fn(qk_tap_dance_state_t *state, void *user_data) { } // The definition of the tap dance actions: -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // This Tap dance plays the macro 1 on TAP and records it on double tap. [TAP_MACRO] = ACTION_TAP_DANCE_FN(macro_tapdance_fn), }; diff --git a/keyboards/ergodox_ez/keymaps/bpruitt-goddard/keymap.c b/keyboards/ergodox_ez/keymaps/bpruitt-goddard/keymap.c index b2065bca83..87ad7e63e4 100644 --- a/keyboards/ergodox_ez/keymaps/bpruitt-goddard/keymap.c +++ b/keyboards/ergodox_ez/keymaps/bpruitt-goddard/keymap.c @@ -104,7 +104,7 @@ layer_state_t layer_state_set_user(layer_state_t state); // Method called at the end of the tap dance on the TAP_MACRO key. That key is // used to start recording a macro (double tap or more), to stop recording (any // number of tap), or to play the recorded macro (1 tap). -void macro_tapdance_fn(qk_tap_dance_state_t *state, void *user_data) { +void macro_tapdance_fn(tap_dance_state_t *state, void *user_data) { uint16_t keycode; keyrecord_t record; dprintf("macro_tap_dance_fn %d\n", state->count); @@ -127,7 +127,7 @@ void macro_tapdance_fn(qk_tap_dance_state_t *state, void *user_data) { } // The definition of the tap dance actions: -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // This Tap dance plays the macro 1 on TAP and records it on double tap. [TAP_MACRO] = ACTION_TAP_DANCE_FN(macro_tapdance_fn) }; diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/config.h b/keyboards/ergodox_ez/keymaps/hacker_dvorak/config.h index acd3a44e16..3f8c68ceb7 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/config.h +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/config.h @@ -78,7 +78,7 @@ // #define NO_PRINT // #define RETRO_TAPPING -// #define TAPPING_FORCE_HOLD +// #define QUICK_TAP_TERM 0 // #define AUTO_SHIFT_TIMEOUT 150 // #define NO_AUTO_SHIFT_SPECIAL diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/dot_comm.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/dot_comm.c index cbfbcdaf9f..e96c7c275e 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/dot_comm.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/dot_comm.c @@ -4,7 +4,7 @@ static tap dot_comm_state = { .state = 0 }; -void dot_comm_finished(qk_tap_dance_state_t *state, void *user_data) { +void dot_comm_finished(tap_dance_state_t *state, void *user_data) { dot_comm_state.state = current_dance(state); switch (dot_comm_state.state) { case SINGLE_TAP: @@ -22,7 +22,7 @@ void dot_comm_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dot_comm_reset(qk_tap_dance_state_t *state, void *user_data) { +void dot_comm_reset(tap_dance_state_t *state, void *user_data) { switch (dot_comm_state.state) { case SINGLE_TAP: unregister_code(KC_DOT); diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/h_mouse_gui.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/h_mouse_gui.c index 76dda6eb32..0589128a58 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/h_mouse_gui.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/h_mouse_gui.c @@ -4,7 +4,7 @@ static tap h_mouse_gui_state = { .state = 0 }; -void h_mouse_gui_finished(qk_tap_dance_state_t *state, void *user_data) { +void h_mouse_gui_finished(tap_dance_state_t *state, void *user_data) { h_mouse_gui_state.state = current_dance(state); switch (h_mouse_gui_state.state) { case SINGLE_TAP: @@ -21,7 +21,7 @@ void h_mouse_gui_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void h_mouse_gui_reset(qk_tap_dance_state_t *state, void *user_data) { +void h_mouse_gui_reset(tap_dance_state_t *state, void *user_data) { switch (h_mouse_gui_state.state) { case SINGLE_TAP: unregister_code(KC_H); diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/j_media_meh.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/j_media_meh.c index daf7be1f6f..a1400236dc 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/j_media_meh.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/j_media_meh.c @@ -4,7 +4,7 @@ static tap j_media_meh_state = { .state = 0 }; -void j_media_meh_finished(qk_tap_dance_state_t *state, void *user_data) { +void j_media_meh_finished(tap_dance_state_t *state, void *user_data) { j_media_meh_state.state = current_dance(state); switch (j_media_meh_state.state) { case SINGLE_TAP: @@ -23,7 +23,7 @@ void j_media_meh_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void j_media_meh_reset(qk_tap_dance_state_t *state, void *user_data) { +void j_media_meh_reset(tap_dance_state_t *state, void *user_data) { switch (j_media_meh_state.state) { case SINGLE_TAP: unregister_code(KC_J); diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/k_numpad_hyper.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/k_numpad_hyper.c index 609e9f5539..c405e65091 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/k_numpad_hyper.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/k_numpad_hyper.c @@ -4,7 +4,7 @@ static tap k_numpad_hyper_state = { .state = 0 }; -void k_numpad_hyper_finished(qk_tap_dance_state_t *state, void *user_data) { +void k_numpad_hyper_finished(tap_dance_state_t *state, void *user_data) { k_numpad_hyper_state.state = current_dance(state); switch (k_numpad_hyper_state.state) { case SINGLE_TAP: @@ -24,7 +24,7 @@ void k_numpad_hyper_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void k_numpad_hyper_reset(qk_tap_dance_state_t *state, void *user_data) { +void k_numpad_hyper_reset(tap_dance_state_t *state, void *user_data) { switch (k_numpad_hyper_state.state) { case SINGLE_TAP: unregister_code(KC_K); diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/m_chords_hyper.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/m_chords_hyper.c index e7df3aef14..736074e751 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/m_chords_hyper.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/m_chords_hyper.c @@ -4,7 +4,7 @@ static tap m_chords_hyper_state = { .state = 0 }; -void m_chords_hyper_finished(qk_tap_dance_state_t *state, void *user_data) { +void m_chords_hyper_finished(tap_dance_state_t *state, void *user_data) { m_chords_hyper_state.state = current_dance(state); switch (m_chords_hyper_state.state) { case SINGLE_TAP: @@ -24,7 +24,7 @@ void m_chords_hyper_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void m_chords_hyper_reset(qk_tap_dance_state_t *state, void *user_data) { +void m_chords_hyper_reset(tap_dance_state_t *state, void *user_data) { switch (m_chords_hyper_state.state) { case SINGLE_TAP: unregister_code(KC_M); diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/none_lead.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/none_lead.c index 0ba31cec81..a553f874cc 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/none_lead.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/none_lead.c @@ -4,7 +4,7 @@ static tap none_lead_state = { .state = 0 }; -void none_lead_finished(qk_tap_dance_state_t *state, void *user_data) { +void none_lead_finished(tap_dance_state_t *state, void *user_data) { none_lead_state.state = current_dance(state); switch (none_lead_state.state) { case SINGLE_TAP: @@ -17,12 +17,12 @@ void none_lead_finished(qk_tap_dance_state_t *state, void *user_data) { break; case DOUBLE_TAP: - qk_leader_start(); + leader_start(); break; } } -void none_lead_reset(qk_tap_dance_state_t *state, void *user_data) { +void none_lead_reset(tap_dance_state_t *state, void *user_data) { switch (none_lead_state.state) { case SINGLE_TAP: unregister_code(KC_NO); diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/quot_dquot.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/quot_dquot.c index ac6da9e00e..8b1af61cac 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/quot_dquot.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/quot_dquot.c @@ -4,7 +4,7 @@ static tap quot_dquot_state = { .state = 0 }; -void quot_dquot_finished(qk_tap_dance_state_t *state, void *user_data) { +void quot_dquot_finished(tap_dance_state_t *state, void *user_data) { quot_dquot_state.state = current_dance(state); switch (quot_dquot_state.state) { case SINGLE_TAP: @@ -22,7 +22,7 @@ void quot_dquot_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void quot_dquot_reset(qk_tap_dance_state_t *state, void *user_data) { +void quot_dquot_reset(tap_dance_state_t *state, void *user_data) { switch (quot_dquot_state.state) { case SINGLE_TAP: unregister_code(KC_QUOT); diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/scln_coln.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/scln_coln.c index 513c932663..8cc3b6dfe1 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/scln_coln.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/scln_coln.c @@ -4,7 +4,7 @@ static tap scln_coln_state = { .state = 0 }; -void scln_coln_finished(qk_tap_dance_state_t *state, void *user_data) { +void scln_coln_finished(tap_dance_state_t *state, void *user_data) { scln_coln_state.state = current_dance(state); switch (scln_coln_state.state) { case SINGLE_TAP: @@ -23,7 +23,7 @@ void scln_coln_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void scln_coln_reset(qk_tap_dance_state_t *state, void *user_data) { +void scln_coln_reset(tap_dance_state_t *state, void *user_data) { switch (scln_coln_state.state) { case SINGLE_TAP: unregister_code(KC_SCLN); diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/u_arrows_gui.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/u_arrows_gui.c index e57502a790..b9a213ef08 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/u_arrows_gui.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/u_arrows_gui.c @@ -4,7 +4,7 @@ static tap u_arrows_gui_state = { .state = 0 }; -void u_arrows_gui_finished(qk_tap_dance_state_t *state, void *user_data) { +void u_arrows_gui_finished(tap_dance_state_t *state, void *user_data) { u_arrows_gui_state.state = current_dance(state); switch (u_arrows_gui_state.state) { case SINGLE_TAP: @@ -21,7 +21,7 @@ void u_arrows_gui_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void u_arrows_gui_reset(qk_tap_dance_state_t *state, void *user_data) { +void u_arrows_gui_reset(tap_dance_state_t *state, void *user_data) { switch (u_arrows_gui_state.state) { case SINGLE_TAP: unregister_code(KC_U); diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/w_media_meh.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/w_media_meh.c index c26980526c..5f2bb2a69a 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/w_media_meh.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/mod_tap_layer_dances/w_media_meh.c @@ -4,7 +4,7 @@ static tap w_media_meh_state = { .state = 0 }; -void w_media_meh_finished(qk_tap_dance_state_t *state, void *user_data) { +void w_media_meh_finished(tap_dance_state_t *state, void *user_data) { w_media_meh_state.state = current_dance(state); switch (w_media_meh_state.state) { case SINGLE_TAP: @@ -23,7 +23,7 @@ void w_media_meh_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void w_media_meh_reset(qk_tap_dance_state_t *state, void *user_data) { +void w_media_meh_reset(tap_dance_state_t *state, void *user_data) { switch (w_media_meh_state.state) { case SINGLE_TAP: unregister_code(KC_W); diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/tap_dance_actions.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/tap_dance_actions.c index 1d5e1cee00..fe13023d45 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/tap_dance_actions.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/tap_dance_actions.c @@ -1,5 +1,5 @@ // Register the double tap dances: -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [EQL_PLUS] = ACTION_TAP_DANCE_DOUBLE(KC_EQL, KC_PLUS), [MINS_UNDS] = ACTION_TAP_DANCE_DOUBLE(KC_MINS, KC_UNDS), [SLSH_BSLS] = ACTION_TAP_DANCE_DOUBLE(KC_SLSH, KC_BSLS), diff --git a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/tap_dance_setup.c b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/tap_dance_setup.c index 340ccca133..d733123230 100644 --- a/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/tap_dance_setup.c +++ b/keyboards/ergodox_ez/keymaps/hacker_dvorak/tap_dance/tap_dance_setup.c @@ -41,7 +41,7 @@ enum { * For the third point, there does exist the 'DOUBLE_SINGLE_TAP', however this is not fully tested * */ -int current_dance(qk_tap_dance_state_t *state) { +int current_dance(tap_dance_state_t *state) { int current_state = 0; if (state->count == 1) { if (state->interrupted || !state->pressed) { diff --git a/keyboards/ergodox_ez/keymaps/nathanvercaemert/keymap.c b/keyboards/ergodox_ez/keymaps/nathanvercaemert/keymap.c index a568ce30fc..6d466cc0de 100644 --- a/keyboards/ergodox_ez/keymaps/nathanvercaemert/keymap.c +++ b/keyboards/ergodox_ez/keymaps/nathanvercaemert/keymap.c @@ -53,15 +53,15 @@ static td_state_t td_state; // declare your tapdance functions: // function to determine the current tapdance state -int cur_dance (qk_tap_dance_state_t *state); +int cur_dance (tap_dance_state_t *state); // `finished` and `reset` functions for each tapdance keycode -void ctrlto12_finished (qk_tap_dance_state_t *state, void *user_data); -void ctrlto12_reset (qk_tap_dance_state_t *state, void *user_data); -void altto11_finished (qk_tap_dance_state_t *state, void *user_data); -void altto11_reset (qk_tap_dance_state_t *state, void *user_data); -void shiftto13_finished (qk_tap_dance_state_t *state, void *user_data); -void shiftto13_reset (qk_tap_dance_state_t *state, void *user_data); +void ctrlto12_finished (tap_dance_state_t *state, void *user_data); +void ctrlto12_reset (tap_dance_state_t *state, void *user_data); +void altto11_finished (tap_dance_state_t *state, void *user_data); +void altto11_reset (tap_dance_state_t *state, void *user_data); +void shiftto13_finished (tap_dance_state_t *state, void *user_data); +void shiftto13_reset (tap_dance_state_t *state, void *user_data); const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { @@ -257,7 +257,7 @@ layer_state_t layer_state_set_user(layer_state_t state) { }; // determine the tapdance state to return -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted && state->pressed && state->interrupting_keycode == KC_MS_BTN1) {return SINGLE_HOLD;} if (state->interrupted && state->pressed && state->interrupting_keycode == 22273) {return SINGLE_HOLD;} @@ -277,7 +277,7 @@ int cur_dance (qk_tap_dance_state_t *state) { else { return 2; } // any number higher than the maximum state value you return above } // /* Backup in case previous code is hard to piece together. */ -// int cur_dance (qk_tap_dance_state_t *state) { +// int cur_dance (tap_dance_state_t *state) { // if (state->count == 1) { // if (state->interrupted || !state->pressed) { return SINGLE_TAP; } // else { return SINGLE_HOLD; } @@ -285,7 +285,7 @@ int cur_dance (qk_tap_dance_state_t *state) { // else { return 2; } // any number higher than the maximum state value you return above // } -void ctrlto12_finished (qk_tap_dance_state_t *state, void *user_data) { +void ctrlto12_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -304,7 +304,7 @@ void ctrlto12_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void ctrlto12_reset (qk_tap_dance_state_t *state, void *user_data) { +void ctrlto12_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: break; @@ -321,7 +321,7 @@ void ctrlto12_reset (qk_tap_dance_state_t *state, void *user_data) { } } -void shiftto13_finished (qk_tap_dance_state_t *state, void *user_data) { +void shiftto13_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -340,7 +340,7 @@ void shiftto13_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void shiftto13_reset (qk_tap_dance_state_t *state, void *user_data) { +void shiftto13_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: break; @@ -357,7 +357,7 @@ void shiftto13_reset (qk_tap_dance_state_t *state, void *user_data) { } } -void altto11_finished (qk_tap_dance_state_t *state, void *user_data) { +void altto11_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -372,7 +372,7 @@ void altto11_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void altto11_reset (qk_tap_dance_state_t *state, void *user_data) { +void altto11_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: break; @@ -386,7 +386,7 @@ void altto11_reset (qk_tap_dance_state_t *state, void *user_data) { } // define `ACTION_TAP_DANCE_FN_ADVANCED()` for each tapdance keycode, passing in `finished` and `reset` functions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [CTRL_TO12] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ctrlto12_finished, ctrlto12_reset), [SHIFT_TO13] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, shiftto13_finished, shiftto13_reset), [ALT_TO11] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altto11_finished, altto11_reset), diff --git a/keyboards/ergodox_ez/keymaps/pvinis/keymap.c b/keyboards/ergodox_ez/keymaps/pvinis/keymap.c index c69621ab98..dcdaa7098b 100644 --- a/keyboards/ergodox_ez/keymaps/pvinis/keymap.c +++ b/keyboards/ergodox_ez/keymaps/pvinis/keymap.c @@ -268,7 +268,7 @@ layer_state_t layer_state_set_user_keymap(layer_state_t state) { // tap dances // flash keyboard on 4x tap, with leds -// void flash_each_tap(qk_tap_dance_state_t *state, void *user_data) { +// void flash_each_tap(tap_dance_state_t *state, void *user_data) { // switch (state->count) { // case 1: // ergodox_right_led_3_on(); @@ -289,14 +289,14 @@ layer_state_t layer_state_set_user_keymap(layer_state_t state) { // } // } -// void flash_dance_finished(qk_tap_dance_state_t *state, void *user_data) { +// void flash_dance_finished(tap_dance_state_t *state, void *user_data) { // if (state->count >= 4) { // reset_keyboard(); // reset_tap_dance(state); // } // } -// void flash_dance_reset(qk_tap_dance_state_t *state, void *user_data) { +// void flash_dance_reset(tap_dance_state_t *state, void *user_data) { // ergodox_right_led_1_off(); // wait_ms(50); // ergodox_right_led_2_off(); @@ -305,7 +305,7 @@ layer_state_t layer_state_set_user_keymap(layer_state_t state) { // } // SYSCTL on first tap, MOUSE ON second tap -// void layers_dance_finished(qk_tap_dance_state_t *state, void *user_data) { +// void layers_dance_finished(tap_dance_state_t *state, void *user_data) { // uint8_t layer = get_highest_layer(layer_state); // switch(state->count) { @@ -328,7 +328,7 @@ layer_state_t layer_state_set_user_keymap(layer_state_t state) { // } // } -// qk_tap_dance_action_t tap_dance_actions[] = { +// tap_dance_action_t tap_dance_actions[] = { // [TD_FLSH] = ACTION_TAP_DANCE_FN_ADVANCED( flash_each_tap, flash_dance_finished, flash_dance_reset ), // [TD_LAYR] = ACTION_TAP_DANCE_FN_ADVANCED( NULL, layers_dance_finished, NULL ), // }; diff --git a/keyboards/ergodox_ez/keymaps/stamm/config.h b/keyboards/ergodox_ez/keymaps/stamm/config.h index e1db3d9002..1262ce6559 100644 --- a/keyboards/ergodox_ez/keymaps/stamm/config.h +++ b/keyboards/ergodox_ez/keymaps/stamm/config.h @@ -29,11 +29,11 @@ #define PERMISSIVE_HOLD /* #define PERMISSIVE_HOLD_PER_KEY */ -#define IGNORE_MOD_TAP_INTERRUPT -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY +#define HOLD_ON_OTHER_KEY_PRESS +#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY -#define TAPPING_FORCE_HOLD -#define TAPPING_FORCE_HOLD_PER_KEY +#define QUICK_TAP_TERM 0 +#define QUICK_TAP_TERM_PER_KEY /* #define RETRO_TAPPING */ #undef LED_BRIGHTNESS_DEFAULT diff --git a/keyboards/ergodox_ez/keymaps/stamm/keymap.c b/keyboards/ergodox_ez/keymaps/stamm/keymap.c index 2b0aff6362..8a3e30f5f6 100644 --- a/keyboards/ergodox_ez/keymaps/stamm/keymap.c +++ b/keyboards/ergodox_ez/keymaps/stamm/keymap.c @@ -206,7 +206,7 @@ uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { return TAPPING_TERM; } } -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case E_NUMBERS: case R_MOUSE: @@ -219,34 +219,31 @@ bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { case RCTL_T(KC_L): case RSFT_T(KC_SEMICOLON): case ARROWS: - return true; + return false; default: return false; } } - -bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { - switch (keycode) { - case LT(_1_NUMBERS, KC_E): - case R_MOUSE: - case LSFT_T(KC_A): - case LCTL_T(KC_S): - case LALT_T(KC_D): - case LGUI_T(KC_F): - case RGUI_T(KC_J): - case RALT_T(KC_K): - case RCTL_T(KC_L): - case RSFT_T(KC_SEMICOLON): - case ARROWS: - return false; - default: - return true; - } +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { + switch (keycode) { + case LT(_1_NUMBERS, KC_E): + case R_MOUSE: + case LSFT_T(KC_A): + case LCTL_T(KC_S): + case LALT_T(KC_D): + case LGUI_T(KC_F): + case RGUI_T(KC_J): + case RALT_T(KC_K): + case RCTL_T(KC_L): + case RSFT_T(KC_SEMICOLON): + case ARROWS: + return QUICK_TAP_TERM; + default: + return 0; + } } - - LEADER_EXTERNS(); void matrix_scan_user(void) { diff --git a/keyboards/exclusive/e6v2/oe/oe.c b/keyboards/exclusive/e6v2/oe/oe.c index 3c6627894f..abff40c0b2 100644 --- a/keyboards/exclusive/e6v2/oe/oe.c +++ b/keyboards/exclusive/e6v2/oe/oe.c @@ -1,32 +1,15 @@ #include "oe.h" -void led_set_kb(uint8_t usb_led) { - // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here - DDRB |= (1<<6); - if (usb_led & (1<<USB_LED_CAPS_LOCK)) { - // output low - DDRB |= (1<<2); - PORTB &= ~(1<<2); - } else { - // Hi-Z - DDRB &= ~(1<<2); - PORTB &= ~(1<<2); - } - // DDRB |= (1<<7); - // DDRB |= (1<<1); - // DDRB |= (1<<3); - // DDRE |= (1<<6); - if (usb_led == 0){ - PORTB |= (1<<6); - // PORTB |= (1<<7); - // PORTB |= (1<<1); - // PORTB |= (1<<3); - // PORTE |= (1<<6); - } - else{ - PORTB &= ~(1<<6); - // PORTB &= ~(1<<7); - } - - led_set_user(usb_led); +void led_init_ports(void) { + setPinOutput(B2); + setPinOutput(B6); +} + +bool led_update_kb(led_t led_state) { + bool res = led_update_user(led_state); + if(res) { + writePin(B2, !led_state.caps_lock); + writePin(B6, led_state.raw == 0); + } + return res; } diff --git a/keyboards/eyeohdesigns/babyv/keymaps/melonbred/keymap.c b/keyboards/eyeohdesigns/babyv/keymaps/melonbred/keymap.c index e550aed864..23a8563595 100644 --- a/keyboards/eyeohdesigns/babyv/keymaps/melonbred/keymap.c +++ b/keyboards/eyeohdesigns/babyv/keymaps/melonbred/keymap.c @@ -30,7 +30,7 @@ enum { }; // Tap Dance Definition -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for minus, tap twice for divide [TD_M_D] = ACTION_TAP_DANCE_DOUBLE(KC_PMNS, KC_PSLS), //Tap once for plus, tap twice for multiply diff --git a/keyboards/ferris/keymaps/bruun-baer/config.h b/keyboards/ferris/keymaps/bruun-baer/config.h index 4f63ee544f..5c2377be1e 100644 --- a/keyboards/ferris/keymaps/bruun-baer/config.h +++ b/keyboards/ferris/keymaps/bruun-baer/config.h @@ -36,4 +36,4 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define TAPPING_TERM 200 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 diff --git a/keyboards/ferris/keymaps/default/config.h b/keyboards/ferris/keymaps/default/config.h index 1937b64ffa..b10555bb0d 100644 --- a/keyboards/ferris/keymaps/default/config.h +++ b/keyboards/ferris/keymaps/default/config.h @@ -36,7 +36,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define TAPPING_TERM 200 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // Underglow configuration #ifdef RGBLIGHT_ENABLE diff --git a/keyboards/ferris/keymaps/madhatter/keymap.c b/keyboards/ferris/keymaps/madhatter/keymap.c index db6928918b..7b0c2e82bf 100644 --- a/keyboards/ferris/keymaps/madhatter/keymap.c +++ b/keyboards/ferris/keymaps/madhatter/keymap.c @@ -51,7 +51,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Q, twice for ESC [TD_Q_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_ESC) }; diff --git a/keyboards/ferris/keymaps/pierrec83/config.h b/keyboards/ferris/keymaps/pierrec83/config.h index 1937b64ffa..b10555bb0d 100644 --- a/keyboards/ferris/keymaps/pierrec83/config.h +++ b/keyboards/ferris/keymaps/pierrec83/config.h @@ -36,7 +36,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define TAPPING_TERM 200 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // Underglow configuration #ifdef RGBLIGHT_ENABLE diff --git a/keyboards/flehrad/bigswitch/keymaps/333fred/keymap.c b/keyboards/flehrad/bigswitch/keymaps/333fred/keymap.c index c2de6318dd..d323bcc2c4 100644 --- a/keyboards/flehrad/bigswitch/keymaps/333fred/keymap.c +++ b/keyboards/flehrad/bigswitch/keymaps/333fred/keymap.c @@ -69,7 +69,7 @@ void dance_cycle(bool override_timer) { } } -void dance_finished(qk_tap_dance_state_t *state, void* user_data) { +void dance_finished(tap_dance_state_t *state, void* user_data) { // Determine the current state switch (state->count) { @@ -127,12 +127,12 @@ void dance_finished(qk_tap_dance_state_t *state, void* user_data) { } } -void dance_reset(qk_tap_dance_state_t *state, void* user_data) +void dance_reset(tap_dance_state_t *state, void* user_data) { tap_dance_active = false; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_KEY] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_finished, dance_reset) }; diff --git a/keyboards/gboards/gergoplex/keymaps/georgepetri/keymap.c b/keyboards/gboards/gergoplex/keymaps/georgepetri/keymap.c index 8b832cbac8..44c570b42c 100644 --- a/keyboards/gboards/gergoplex/keymaps/georgepetri/keymap.c +++ b/keyboards/gboards/gergoplex/keymaps/georgepetri/keymap.c @@ -46,10 +46,10 @@ enum { GAME }; -td_state_t cur_dance(qk_tap_dance_state_t *state); +td_state_t cur_dance(tap_dance_state_t *state); -void ql_finished(qk_tap_dance_state_t *state, void *user_data); -void ql_reset(qk_tap_dance_state_t *state, void *user_data); +void ql_finished(tap_dance_state_t *state, void *user_data); +void ql_reset(tap_dance_state_t *state, void *user_data); #define KC_CTL_A MT(MOD_LCTL, KC_A) // Tap for A, hold for Control #define KC_SFT_Z MT(MOD_RSFT, KC_Z) // Tap for Z, hold for Shift @@ -158,7 +158,7 @@ bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { } } -td_state_t cur_dance(qk_tap_dance_state_t *state) { +td_state_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) return TD_SINGLE_TAP; if (state->count == 2) @@ -173,7 +173,7 @@ static td_tap_t ql_tap_state = { .state = TD_NONE }; -void ql_finished(qk_tap_dance_state_t *state, void *user_data) { +void ql_finished(tap_dance_state_t *state, void *user_data) { ql_tap_state.state = cur_dance(state); switch (ql_tap_state.state) { case TD_SINGLE_TAP: @@ -194,11 +194,11 @@ void ql_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void ql_reset(qk_tap_dance_state_t *state, void *user_data) { +void ql_reset(tap_dance_state_t *state, void *user_data) { ql_tap_state.state = TD_NONE; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [GAME] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ql_finished, ql_reset) }; diff --git a/keyboards/gh60/satan/keymaps/dkrieger/keymap.c b/keyboards/gh60/satan/keymaps/dkrieger/keymap.c index 4848def85d..2dce640755 100644 --- a/keyboards/gh60/satan/keymaps/dkrieger/keymap.c +++ b/keyboards/gh60/satan/keymaps/dkrieger/keymap.c @@ -21,7 +21,7 @@ typedef struct { int state; } tap; -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->interrupted == false || state->pressed) { if (state->count < 2) return SINGLE_HOLD; if (state->count < 3) return DOUBLE_HOLD; @@ -36,7 +36,7 @@ static tap fn_tap_state = { .state = 0 }; -void fn_finished (qk_tap_dance_state_t *state, void *user_data) { +void fn_finished (tap_dance_state_t *state, void *user_data) { fn_tap_state.state = cur_dance(state); switch (fn_tap_state.state) { /* case SINGLE_HOLD: register_code(MO(_FN)); break; */ @@ -46,7 +46,7 @@ void fn_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void fn_reset (qk_tap_dance_state_t *state, void *user_data) { +void fn_reset (tap_dance_state_t *state, void *user_data) { switch (fn_tap_state.state) { case SINGLE_HOLD: layer_off(_FN); break; case DOUBLE_HOLD: layer_off(_MOUSE); layer_off(_MOUSESHIFT); break; @@ -54,7 +54,7 @@ void fn_reset (qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [SUPER_FN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, fn_finished, fn_reset) }; diff --git a/keyboards/gh60/satan/keymaps/lepa/keymap.c b/keyboards/gh60/satan/keymaps/lepa/keymap.c index 90a0236cd1..88196862a8 100644 --- a/keyboards/gh60/satan/keymaps/lepa/keymap.c +++ b/keyboards/gh60/satan/keymaps/lepa/keymap.c @@ -61,7 +61,7 @@ typedef struct { int state; } tap; -int cur_dance(qk_tap_dance_state_t *state) { +int cur_dance(tap_dance_state_t *state) { switch (state->count) { case 1: if (state->interrupted || state->pressed == 0) { @@ -87,7 +87,7 @@ static tap N ## _state = { \ .state = 0 \ }; \ \ -void N ## _finished(qk_tap_dance_state_t *state, void *user_data) { \ +void N ## _finished(tap_dance_state_t *state, void *user_data) { \ N ## _state.state = cur_dance(state); \ switch (N ## _state.state) { \ case SINGLE_TAP: case SINGLE_HOLD: \ @@ -100,7 +100,7 @@ void N ## _finished(qk_tap_dance_state_t *state, void *user_data) { \ } \ } \ \ -void N ## _reset(qk_tap_dance_state_t *state, void *user_data) { \ +void N ## _reset(tap_dance_state_t *state, void *user_data) { \ switch (N ## _state.state) { \ case SINGLE_TAP: case SINGLE_HOLD: \ unregister_code(K0); \ @@ -134,7 +134,7 @@ my_dance_combo_1(rcg, KC_RCTL, KC_RGUI) my_dance_combo_3(lsh, KC_LSFT, KC_LCTL, KC_LALT, KC_LGUI) my_dance_combo_3(rsh, KC_RSFT, KC_RCTL, KC_RALT, KC_RGUI) -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LCTL_ALT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, lca_finished, lca_reset), [TD_RCTL_ALT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, rca_finished, rca_reset), [TD_LGUI_ALT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, lga_finished, lga_reset), diff --git a/keyboards/gl516/a52gl/keymaps/salicylic/config.h b/keyboards/gl516/a52gl/keymaps/salicylic/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/gl516/a52gl/keymaps/salicylic/config.h +++ b/keyboards/gl516/a52gl/keymaps/salicylic/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/gl516/j73gl/keymaps/via_rgb_matrix/config.h b/keyboards/gl516/j73gl/keymaps/via_rgb_matrix/config.h index b0360ac95d..0f71fedd0e 100644 --- a/keyboards/gl516/j73gl/keymaps/via_rgb_matrix/config.h +++ b/keyboards/gl516/j73gl/keymaps/via_rgb_matrix/config.h @@ -18,7 +18,7 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #ifdef RGBLED_NUM diff --git a/keyboards/gl516/n51gl/keymaps/salicylic/config.h b/keyboards/gl516/n51gl/keymaps/salicylic/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/gl516/n51gl/keymaps/salicylic/config.h +++ b/keyboards/gl516/n51gl/keymaps/salicylic/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/gl516/n51gl/keymaps/via/config.h b/keyboards/gl516/n51gl/keymaps/via/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/gl516/n51gl/keymaps/via/config.h +++ b/keyboards/gl516/n51gl/keymaps/via/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/gmmk/pro/rev1/ansi/keymaps/andrebrait/rules.mk b/keyboards/gmmk/pro/rev1/ansi/keymaps/andrebrait/rules.mk index 8983ba87c3..d5942a2e90 100644 --- a/keyboards/gmmk/pro/rev1/ansi/keymaps/andrebrait/rules.mk +++ b/keyboards/gmmk/pro/rev1/ansi/keymaps/andrebrait/rules.mk @@ -2,3 +2,22 @@ # Disabling MouseKey because it breaks my KVM switch MOUSEKEY_ENABLE = no + +# Cherry MX-style switches and diodes are not susceptible to noise, no need for noise-resistant algorithms. +# This significantly reduces latency. +# +# The matrix scan frequency seems to be around 1820 Hz, so even sym_defer_g would perform ok, +# but the "defer" part would mean we would wait DEBOUNCE ms before sending any events. +# Using "asym_eager_defer_pk" does not seem to benefit us in anything. +# The GMMK Pro has more then enough system resources for a per-key algorithm. +# Using an "eager" algorithm leads to extremely low latency while also reducing the chances of chattering +# due to it's "post-event" debouncing (of sorts). +# +# I have observed zero chattering or double-keypress issues on my Gateron Yellow switches. +# Most chattering issues on the GMMK Pro seem to be related to its proprietary hot-swap sockets anyway. +DEBOUNCE_TYPE = sym_eager_pk + +# Useful for debugging +# CONSOLE_ENABLE = yes +# DEBUG_MATRIX_SCAN_RATE_ENABLE = yes +# DEBUG_MATRIX_SCAN_RATE = yes diff --git a/keyboards/gmmk/pro/rev1/ansi/keymaps/coryginsberg/keymap.c b/keyboards/gmmk/pro/rev1/ansi/keymaps/coryginsberg/keymap.c index b71d18d481..49e2050ea0 100644 --- a/keyboards/gmmk/pro/rev1/ansi/keymaps/coryginsberg/keymap.c +++ b/keyboards/gmmk/pro/rev1/ansi/keymaps/coryginsberg/keymap.c @@ -17,7 +17,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #include QMK_KEYBOARD_H -void dance_media(qk_tap_dance_state_t *state, void *user_data) { +void dance_media(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code(KC_MPLY); } else if (state->count == 2) { @@ -29,7 +29,7 @@ void dance_media(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for shift, twice for Caps Lock [0] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), [1] = ACTION_TAP_DANCE_FN(dance_media)}; diff --git a/keyboards/h0oni/deskpad/keymaps/default/keymap.c b/keyboards/h0oni/deskpad/keymaps/default/keymap.c index 54172f2986..c3eba7c4a9 100644 --- a/keyboards/h0oni/deskpad/keymaps/default/keymap.c +++ b/keyboards/h0oni/deskpad/keymaps/default/keymap.c @@ -46,15 +46,15 @@ enum custom_keycodes { VSCODE, }; -td_state_t cur_dance(qk_tap_dance_state_t *state); +td_state_t cur_dance(tap_dance_state_t *state); /* Quad layer switching */ -void layer_finished(qk_tap_dance_state_t *state, void *user_data); -void layer_reset(qk_tap_dance_state_t *state, void *user_data); +void layer_finished(tap_dance_state_t *state, void *user_data); +void layer_reset(tap_dance_state_t *state, void *user_data); /* Copy, paste, select all, cut */ -void cvxa_finished(qk_tap_dance_state_t *state, void *user_data); -void cvxa_reset(qk_tap_dance_state_t *state, void *user_data); +void cvxa_finished(tap_dance_state_t *state, void *user_data); +void cvxa_reset(tap_dance_state_t *state, void *user_data); static td_tap_t layerTap_state = { .is_press_action = true, @@ -67,7 +67,7 @@ static td_tap_t cvxa_state = { }; // Determine the current tap dance state -td_state_t cur_dance(qk_tap_dance_state_t *state) { +td_state_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return TD_SINGLE_TAP; // Key has not been interrupted, but the key is still held. Means you want to send a 'HOLD'. @@ -79,7 +79,7 @@ td_state_t cur_dance(qk_tap_dance_state_t *state) { } else return TD_UNKNOWN; } -void layer_finished(qk_tap_dance_state_t *state, void *user_data) { +void layer_finished(tap_dance_state_t *state, void *user_data) { layerTap_state.state = cur_dance(state); layer_off(get_highest_layer(layer_state)); switch (layerTap_state.state) { @@ -91,11 +91,11 @@ void layer_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void layer_reset(qk_tap_dance_state_t *state, void *user_data) { +void layer_reset(tap_dance_state_t *state, void *user_data) { layerTap_state.state = TD_NONE; } -void cvxa_finished(qk_tap_dance_state_t *state, void *user_data) { +void cvxa_finished(tap_dance_state_t *state, void *user_data) { cvxa_state.state = cur_dance(state); register_mods(MOD_BIT(KC_LCTL)); switch (cvxa_state.state) { @@ -108,12 +108,12 @@ void cvxa_finished(qk_tap_dance_state_t *state, void *user_data) { unregister_mods(MOD_BIT(KC_LCTL)); } -void cvxa_reset(qk_tap_dance_state_t *state, void *user_data) { +void cvxa_reset(tap_dance_state_t *state, void *user_data) { cvxa_state.state = TD_NONE; } // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_CUT_REDO] = ACTION_TAP_DANCE_DOUBLE(C(KC_Z), S(C(KC_Z))), [TD_PLAY_PAUSE_MUTE] = ACTION_TAP_DANCE_DOUBLE(KC_MPLY, KC_MUTE), [TD_MNXT_RIGHT] = ACTION_TAP_DANCE_DOUBLE(KC_MNXT, KC_RIGHT), diff --git a/keyboards/h0oni/deskpad/keymaps/via/keymap.c b/keyboards/h0oni/deskpad/keymaps/via/keymap.c index 54172f2986..c3eba7c4a9 100644 --- a/keyboards/h0oni/deskpad/keymaps/via/keymap.c +++ b/keyboards/h0oni/deskpad/keymaps/via/keymap.c @@ -46,15 +46,15 @@ enum custom_keycodes { VSCODE, }; -td_state_t cur_dance(qk_tap_dance_state_t *state); +td_state_t cur_dance(tap_dance_state_t *state); /* Quad layer switching */ -void layer_finished(qk_tap_dance_state_t *state, void *user_data); -void layer_reset(qk_tap_dance_state_t *state, void *user_data); +void layer_finished(tap_dance_state_t *state, void *user_data); +void layer_reset(tap_dance_state_t *state, void *user_data); /* Copy, paste, select all, cut */ -void cvxa_finished(qk_tap_dance_state_t *state, void *user_data); -void cvxa_reset(qk_tap_dance_state_t *state, void *user_data); +void cvxa_finished(tap_dance_state_t *state, void *user_data); +void cvxa_reset(tap_dance_state_t *state, void *user_data); static td_tap_t layerTap_state = { .is_press_action = true, @@ -67,7 +67,7 @@ static td_tap_t cvxa_state = { }; // Determine the current tap dance state -td_state_t cur_dance(qk_tap_dance_state_t *state) { +td_state_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return TD_SINGLE_TAP; // Key has not been interrupted, but the key is still held. Means you want to send a 'HOLD'. @@ -79,7 +79,7 @@ td_state_t cur_dance(qk_tap_dance_state_t *state) { } else return TD_UNKNOWN; } -void layer_finished(qk_tap_dance_state_t *state, void *user_data) { +void layer_finished(tap_dance_state_t *state, void *user_data) { layerTap_state.state = cur_dance(state); layer_off(get_highest_layer(layer_state)); switch (layerTap_state.state) { @@ -91,11 +91,11 @@ void layer_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void layer_reset(qk_tap_dance_state_t *state, void *user_data) { +void layer_reset(tap_dance_state_t *state, void *user_data) { layerTap_state.state = TD_NONE; } -void cvxa_finished(qk_tap_dance_state_t *state, void *user_data) { +void cvxa_finished(tap_dance_state_t *state, void *user_data) { cvxa_state.state = cur_dance(state); register_mods(MOD_BIT(KC_LCTL)); switch (cvxa_state.state) { @@ -108,12 +108,12 @@ void cvxa_finished(qk_tap_dance_state_t *state, void *user_data) { unregister_mods(MOD_BIT(KC_LCTL)); } -void cvxa_reset(qk_tap_dance_state_t *state, void *user_data) { +void cvxa_reset(tap_dance_state_t *state, void *user_data) { cvxa_state.state = TD_NONE; } // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_CUT_REDO] = ACTION_TAP_DANCE_DOUBLE(C(KC_Z), S(C(KC_Z))), [TD_PLAY_PAUSE_MUTE] = ACTION_TAP_DANCE_DOUBLE(KC_MPLY, KC_MUTE), [TD_MNXT_RIGHT] = ACTION_TAP_DANCE_DOUBLE(KC_MNXT, KC_RIGHT), diff --git a/keyboards/halokeys/elemental75/keymaps/default/keymap.c b/keyboards/halokeys/elemental75/keymaps/default/keymap.c index f34220b6f9..1dd7ea7862 100644 --- a/keyboards/halokeys/elemental75/keymaps/default/keymap.c +++ b/keyboards/halokeys/elemental75/keymaps/default/keymap.c @@ -35,7 +35,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -void dance_cln_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_cln_finished(tap_dance_state_t *state, void *user_data) { uprintf("Tap Dance count: %u", state->count); if (state->count == 1) { tap_code(KC_MPLY); @@ -47,7 +47,7 @@ void dance_cln_finished(qk_tap_dance_state_t *state, void *user_data) { } /* All tap dance functions would go here. Only showing this one. */ -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_PLAY_FORWARD_BACK] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_cln_finished, NULL), }; diff --git a/keyboards/halokeys/elemental75/keymaps/via/keymap.c b/keyboards/halokeys/elemental75/keymaps/via/keymap.c index 59b9211d83..69f2779681 100644 --- a/keyboards/halokeys/elemental75/keymaps/via/keymap.c +++ b/keyboards/halokeys/elemental75/keymaps/via/keymap.c @@ -32,7 +32,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -void dance_cln_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_cln_finished(tap_dance_state_t *state, void *user_data) { uprintf("Tap Dance count: %u", state->count); if (state->count == 1) { tap_code(KC_MPLY); @@ -44,7 +44,7 @@ void dance_cln_finished(qk_tap_dance_state_t *state, void *user_data) { } /* All tap dance functions would go here. Only showing this one. */ -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_PLAY_FORWARD_BACK] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_cln_finished, NULL), }; diff --git a/keyboards/handwired/2x5keypad/keymaps/default_tapdance/keymap.c b/keyboards/handwired/2x5keypad/keymaps/default_tapdance/keymap.c index c70ecd5562..945613f987 100644 --- a/keyboards/handwired/2x5keypad/keymaps/default_tapdance/keymap.c +++ b/keyboards/handwired/2x5keypad/keymaps/default_tapdance/keymap.c @@ -49,48 +49,48 @@ void send_french_unicode_char(uint8_t count, uint32_t once, uint32_t twice) register_unicode(twice); } -void dance_a_q(qk_tap_dance_state_t *state, void *user_data) +void dance_a_q(tap_dance_state_t *state, void *user_data) { send_french_unicode_char(state->count, FR_A_GRAVE, FR_L_QUOTE); } -void dance_e_q(qk_tap_dance_state_t *state, void *user_data) +void dance_e_q(tap_dance_state_t *state, void *user_data) { send_french_unicode_char(state->count, FR_E_AIGU, FR_R_QUOTE); } -void dance_e_u(qk_tap_dance_state_t *state, void *user_data) +void dance_e_u(tap_dance_state_t *state, void *user_data) { send_french_unicode_char(state->count, FR_E_GRAVE, FR_U_GRAVE); } -void dance_e_e(qk_tap_dance_state_t *state, void *user_data) +void dance_e_e(tap_dance_state_t *state, void *user_data) { send_french_unicode_char(state->count, FR_E_HAT, FR_E_UMLAUT); } -void dance_a_y(qk_tap_dance_state_t *state, void *user_data) +void dance_a_y(tap_dance_state_t *state, void *user_data) { send_french_unicode_char(state->count, FR_A_HAT, FR_Y_UMLAUT); } -void dance_i_i(qk_tap_dance_state_t *state, void *user_data) +void dance_i_i(tap_dance_state_t *state, void *user_data) { send_french_unicode_char(state->count, FR_I_HAT, FR_I_UMLAUT); } -void dance_o_c(qk_tap_dance_state_t *state, void *user_data) +void dance_o_c(tap_dance_state_t *state, void *user_data) { send_french_unicode_char(state->count, FR_O_HAT, FR_C_CIRCUM); } -void dance_u_u(qk_tap_dance_state_t *state, void *user_data) +void dance_u_u(tap_dance_state_t *state, void *user_data) { send_french_unicode_char(state->count, FR_U_HAT, FR_U_UMLAUT); } /* Define the tap dance actions for the french characters */ -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [A_Q] = ACTION_TAP_DANCE_FN(dance_a_q), [E_Q] = ACTION_TAP_DANCE_FN(dance_e_q), [E_U] = ACTION_TAP_DANCE_FN(dance_e_u), diff --git a/keyboards/handwired/aranck/keymaps/turkishish/config.h b/keyboards/handwired/aranck/keymaps/turkishish/config.h index 0810a3b23f..69c1beb03c 100644 --- a/keyboards/handwired/aranck/keymaps/turkishish/config.h +++ b/keyboards/handwired/aranck/keymaps/turkishish/config.h @@ -21,4 +21,4 @@ #define RETRO_TAPPING #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD
\ No newline at end of file +#define QUICK_TAP_TERM 0
\ No newline at end of file diff --git a/keyboards/handwired/axon/readme.md b/keyboards/handwired/axon/readme.md index d48297b4f7..ca422130ef 100644 --- a/keyboards/handwired/axon/readme.md +++ b/keyboards/handwired/axon/readme.md @@ -15,8 +15,8 @@ Make example for this keyboard (after setting up your build environment): ## To reset into bootloader mode: 1. While plugged in, press and hold `BOOT` switch -2. While holding `BOOT`, press `QK_BOOT` and hold it for a second or two -3. Release `QK_BOOT` +2. While holding `BOOT`, press `RESET` and hold it for a second or two +3. Release `RESET` 4. Release `BOOT` 5. The keyboard should now be recognized as a USBasp programmer device. diff --git a/keyboards/handwired/brain/config.h b/keyboards/handwired/brain/config.h index 317d25f5f5..9aba789cc2 100644 --- a/keyboards/handwired/brain/config.h +++ b/keyboards/handwired/brain/config.h @@ -93,7 +93,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. //#define TAPPING_TERM 150 //#define IGNORE_MOD_TAP_INTERRUPT -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 #define BOOTMAGIC_LITE_ROW 0 #define BOOTMAGIC_LITE_COLUMN 6 diff --git a/keyboards/handwired/concertina/64key/keymaps/default/keymap.c b/keyboards/handwired/concertina/64key/keymaps/default/keymap.c index edc0f7d3cf..aced9d13c6 100644 --- a/keyboards/handwired/concertina/64key/keymaps/default/keymap.c +++ b/keyboards/handwired/concertina/64key/keymaps/default/keymap.c @@ -29,7 +29,7 @@ enum taps { PNX, // Play/pause; next track. }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [PNX] = ACTION_TAP_DANCE_DOUBLE(KC_MEDIA_PLAY_PAUSE, KC_MEDIA_NEXT_TRACK), }; diff --git a/keyboards/handwired/dactyl_manuform/3x5_3/keymaps/dlford/config.h b/keyboards/handwired/dactyl_manuform/3x5_3/keymaps/dlford/config.h index 1e6e6e58c6..b8df581b72 100644 --- a/keyboards/handwired/dactyl_manuform/3x5_3/keymaps/dlford/config.h +++ b/keyboards/handwired/dactyl_manuform/3x5_3/keymaps/dlford/config.h @@ -27,7 +27,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define TAPPING_TERM_PER_KEY // milliseconds from tap to hold for mod tap per key #define IGNORE_MOD_TAP_INTERRUPT // ignore hold mod if another tap occurs within tapping term #define PERMISSIVE_HOLD_PER_KEY // activate mod top hold earlier if another key is pressed AND released per key -#define TAPPING_FORCE_HOLD_PER_KEY // disable double tap hold key repeat per key +#define QUICK_TAP_TERM_PER_KEY // disable double tap hold key repeat per key #undef MOUSEKEY_INTERVAL #undef MOUSEKEY_DELAY #undef MOUSEKEY_TIME_TO_MAX diff --git a/keyboards/handwired/dactyl_manuform/3x5_3/keymaps/dlford/keymap.c b/keyboards/handwired/dactyl_manuform/3x5_3/keymaps/dlford/keymap.c index b5a8c82c4a..7df7897ae9 100644 --- a/keyboards/handwired/dactyl_manuform/3x5_3/keymaps/dlford/keymap.c +++ b/keyboards/handwired/dactyl_manuform/3x5_3/keymaps/dlford/keymap.c @@ -55,15 +55,15 @@ bool get_permissive_hold(uint16_t keycode, keyrecord_t *record) { } // Tapping force hold per key -bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { - switch (keycode) { - case LT(3, KC_SPC): - return true; // Enable force hold - case LT(2, KC_TAB): - return true; - default: - return false; // Disable force hold - } +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { + switch (keycode) { + case LT(3, KC_SPC): + return 0; // Enable force hold + case LT(2, KC_TAB): + return 0; + default: + return QUICK_TAP_TERM; // Disable force hold + } } // Tapping term per key diff --git a/keyboards/handwired/dactyl_manuform/5x6_5/keymaps/cykedev/config.h b/keyboards/handwired/dactyl_manuform/5x6_5/keymaps/cykedev/config.h index 5a94cd1760..6a28251c6b 100644 --- a/keyboards/handwired/dactyl_manuform/5x6_5/keymaps/cykedev/config.h +++ b/keyboards/handwired/dactyl_manuform/5x6_5/keymaps/cykedev/config.h @@ -45,12 +45,9 @@ // Configure the global tapping term (default: 200ms) #define TAPPING_TERM 200 -// Prevent normal rollover on alphas from accidentally triggering mods. -#define IGNORE_MOD_TAP_INTERRUPT -//#define IGNORE_MOD_TAP_INTERRUPT -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY +#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define FORCE_NKRO diff --git a/keyboards/handwired/dactyl_manuform/5x6_5/keymaps/cykedev/keymap.c b/keyboards/handwired/dactyl_manuform/5x6_5/keymaps/cykedev/keymap.c index 413fa70492..9687e77d88 100644 --- a/keyboards/handwired/dactyl_manuform/5x6_5/keymaps/cykedev/keymap.c +++ b/keyboards/handwired/dactyl_manuform/5x6_5/keymaps/cykedev/keymap.c @@ -195,18 +195,18 @@ layer_state_t layer_state_set_user(layer_state_t state) { return update_tri_layer_state(state, _LOWER, _RAISE, _ADJUST); } -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case SPC_L: - return false; - case SPC_R: return true; - case ENT_L: + case SPC_R: return false; + case ENT_L: + return true; case ENT_R: - return false; - default: return true; + default: + return false; } } diff --git a/keyboards/handwired/heisenberg/keymaps/turkishish/config.h b/keyboards/handwired/heisenberg/keymaps/turkishish/config.h index 0810a3b23f..69c1beb03c 100644 --- a/keyboards/handwired/heisenberg/keymaps/turkishish/config.h +++ b/keyboards/handwired/heisenberg/keymaps/turkishish/config.h @@ -21,4 +21,4 @@ #define RETRO_TAPPING #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD
\ No newline at end of file +#define QUICK_TAP_TERM 0
\ No newline at end of file diff --git a/keyboards/handwired/jscotto/scotto36/keymaps/default/keymap.c b/keyboards/handwired/jscotto/scotto36/keymaps/default/keymap.c index cd9b1599a5..3c6e61aea0 100644 --- a/keyboards/handwired/jscotto/scotto36/keymaps/default/keymap.c +++ b/keyboards/handwired/jscotto/scotto36/keymaps/default/keymap.c @@ -26,7 +26,7 @@ enum { TD_ESC_WINDOWS_EMOJI }; -void td_esc_spotlight_emoji (qk_tap_dance_state_t *state, void *user_data) { +void td_esc_spotlight_emoji (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code(KC_ESC); } else if (state->count == 2) { @@ -36,7 +36,7 @@ void td_esc_spotlight_emoji (qk_tap_dance_state_t *state, void *user_data) { } } -void td_esc_windows_emoji (qk_tap_dance_state_t *state, void *user_data) { +void td_esc_windows_emoji (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code(KC_ESC); } else if (state->count == 2) { @@ -47,7 +47,7 @@ void td_esc_windows_emoji (qk_tap_dance_state_t *state, void *user_data) { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESC_SPOTLIGHT_EMOJI] = ACTION_TAP_DANCE_FN(td_esc_spotlight_emoji), [TD_ESC_WINDOWS_EMOJI] = ACTION_TAP_DANCE_FN(td_esc_windows_emoji) }; diff --git a/keyboards/handwired/jscotto/scotto9/info.json b/keyboards/handwired/jscotto/scotto9/info.json index 09ae9eea77..d29ccc3fd1 100644 --- a/keyboards/handwired/jscotto/scotto9/info.json +++ b/keyboards/handwired/jscotto/scotto9/info.json @@ -31,12 +31,12 @@ "layout": [ { "matrix": [0, 0], "x": 0, "y": 0 }, { "matrix": [0, 1], "x": 1, "y": 0 }, - { "matrix": [0, 2], "x": 2, "y": 0 } + { "matrix": [0, 2], "x": 2, "y": 0 }, // Row 2 { "matrix": [1, 0], "x": 0, "y": 1 }, { "matrix": [1, 1], "x": 1, "y": 1 }, - { "matrix": [1, 2], "x": 2, "y": 1 } + { "matrix": [1, 2], "x": 2, "y": 1 }, // Row 3 { "matrix": [2, 0], "x": 0, "y": 2 }, diff --git a/keyboards/handwired/jscotto/scottocmd/keymaps/default/keymap.c b/keyboards/handwired/jscotto/scottocmd/keymaps/default/keymap.c index 398178bf5b..97d2c206a8 100644 --- a/keyboards/handwired/jscotto/scottocmd/keymaps/default/keymap.c +++ b/keyboards/handwired/jscotto/scottocmd/keymaps/default/keymap.c @@ -26,7 +26,7 @@ enum { TD_ESC_WINDOWS_EMOJI }; -void td_esc_spotlight_emoji (qk_tap_dance_state_t *state, void *user_data) { +void td_esc_spotlight_emoji (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code(KC_ESC); } else if (state->count == 2) { @@ -36,7 +36,7 @@ void td_esc_spotlight_emoji (qk_tap_dance_state_t *state, void *user_data) { } } -void td_esc_windows_emoji (qk_tap_dance_state_t *state, void *user_data) { +void td_esc_windows_emoji (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code(KC_ESC); } else if (state->count == 2) { @@ -47,7 +47,7 @@ void td_esc_windows_emoji (qk_tap_dance_state_t *state, void *user_data) { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESC_SPOTLIGHT_EMOJI] = ACTION_TAP_DANCE_FN(td_esc_spotlight_emoji), [TD_ESC_WINDOWS_EMOJI] = ACTION_TAP_DANCE_FN(td_esc_windows_emoji) }; diff --git a/keyboards/handwired/jscotto/scottostarter/info.json b/keyboards/handwired/jscotto/scottostarter/info.json index 5bc3c14cc7..08bccff0d3 100644 --- a/keyboards/handwired/jscotto/scottostarter/info.json +++ b/keyboards/handwired/jscotto/scottostarter/info.json @@ -87,8 +87,8 @@ { "matrix": [4, 2], "x": 2, "y": 4}, { "matrix": [4, 4], "x": 4, "y": 4}, { "matrix": [4, 7], "x": 7, "y": 4}, - { "matrix": [4, 8], "x": 8, "y": 4 } - { "matrix": [4, 9], "x": 9, "y": 4 } + { "matrix": [4, 8], "x": 8, "y": 4 }, + { "matrix": [4, 9], "x": 9, "y": 4 }, { "matrix": [4, 10], "x": 10, "y": 4 } ] } diff --git a/keyboards/handwired/k_numpad17/keymaps/karlssn/keymap.c b/keyboards/handwired/k_numpad17/keymaps/karlssn/keymap.c index c2f314116b..fdbc3c8a39 100644 --- a/keyboards/handwired/k_numpad17/keymaps/karlssn/keymap.c +++ b/keyboards/handwired/k_numpad17/keymaps/karlssn/keymap.c @@ -6,7 +6,7 @@ enum { }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Esc, twice for Caps Lock [TD_DOT_COMMAS] = ACTION_TAP_DANCE_DOUBLE(KC_DOT, KC_COMMA) // Other declarations would go here, separated by commas, if you have them diff --git a/keyboards/handwired/lagrange/keymaps/dpapavas/keymap.c b/keyboards/handwired/lagrange/keymaps/dpapavas/keymap.c index 5f221904e9..8d2ecd9c79 100644 --- a/keyboards/handwired/lagrange/keymaps/dpapavas/keymap.c +++ b/keyboards/handwired/lagrange/keymaps/dpapavas/keymap.c @@ -78,7 +78,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { #define CHOREOGRAPH(DANCE, PRESS, RELEASE, TAP, DOUBLETAP) \ static bool dance_ ## DANCE ## _pressed; \ \ - void dance_ ## DANCE ## _finished(qk_tap_dance_state_t *state, void *user_data) { \ + void dance_ ## DANCE ## _finished(tap_dance_state_t *state, void *user_data) { \ if (state->count == 1) { \ if (state->pressed) { \ dance_ ## DANCE ## _pressed = true; \ @@ -93,7 +93,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { } \ } \ \ - void dance_ ## DANCE ## _reset(qk_tap_dance_state_t *state, void *user_data) { \ + void dance_ ## DANCE ## _reset(tap_dance_state_t *state, void *user_data) { \ if (state->count == 1) { \ if (dance_ ## DANCE ## _pressed) { \ RELEASE; \ @@ -138,7 +138,7 @@ CHOREOGRAPH(TD_C_X, SEND_STRING(SS_UP(X_LCTL)), SEND_STRING(SS_DOWN(X_LCTL) SS_TAP(X_X) SS_UP(X_LCTL)),); -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { STEPS(TD_LEFT), STEPS(TD_RGHT), STEPS(TD_C_X) }; diff --git a/keyboards/handwired/myskeeb/keymaps/default/keymap.c b/keyboards/handwired/myskeeb/keymaps/default/keymap.c index ee0ead3664..d3a8ba20e8 100644 --- a/keyboards/handwired/myskeeb/keymaps/default/keymap.c +++ b/keyboards/handwired/myskeeb/keymaps/default/keymap.c @@ -12,7 +12,7 @@ enum { }; // Tap Dance Functions -void tri_open(qk_tap_dance_state_t *state, void *user_data) { +void tri_open(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(KC_LPRN); } else if (state->count == 2) { @@ -22,7 +22,7 @@ void tri_open(qk_tap_dance_state_t *state, void *user_data) { } } -void tri_close(qk_tap_dance_state_t *state, void *user_data) { +void tri_close(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(KC_RPRN); } else if (state->count == 2) { @@ -32,7 +32,7 @@ void tri_close(qk_tap_dance_state_t *state, void *user_data) { } } -void dquote(qk_tap_dance_state_t *state, void *user_data) { +void dquote(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted) tap_code(KC_QUOT); @@ -44,7 +44,7 @@ void dquote(qk_tap_dance_state_t *state, void *user_data) { } } -void tilded(qk_tap_dance_state_t *state, void *user_data) { +void tilded(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted) tap_code16(KC_TILD); @@ -55,7 +55,7 @@ void tilded(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [OP_QT] = ACTION_TAP_DANCE_FN(tri_open), [CL_QT] = ACTION_TAP_DANCE_FN(tri_close), [TD_DQ] = ACTION_TAP_DANCE_FN(dquote), diff --git a/keyboards/handwired/onekey/kb2040/config.h b/keyboards/handwired/onekey/kb2040/config.h index c6c6dbe2cf..20a41b1624 100644 --- a/keyboards/handwired/onekey/kb2040/config.h +++ b/keyboards/handwired/onekey/kb2040/config.h @@ -16,7 +16,7 @@ // settings for the oled keyboard demo with Adafruit 0.91" OLED display on the Stemma QT port #define OLED_DISPLAY_128X32 -#define I2C_DRIVER I2CD1 +#define I2C_DRIVER I2CD0 #define I2C1_SDA_PIN GP12 #define I2C1_SCL_PIN GP13 diff --git a/keyboards/handwired/onekey/keymaps/backlight/keymap.c b/keyboards/handwired/onekey/keymaps/backlight/keymap.c index 1fbbc632da..746e4619de 100644 --- a/keyboards/handwired/onekey/keymaps/backlight/keymap.c +++ b/keyboards/handwired/onekey/keymaps/backlight/keymap.c @@ -5,11 +5,11 @@ enum { TD_BL = 0 }; -void dance_cln_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_cln_finished(tap_dance_state_t *state, void *user_data) { // noop } -void dance_cln_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_cln_reset(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: // single tap - step through backlight @@ -30,7 +30,7 @@ void dance_cln_reset(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_BL] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_cln_finished, dance_cln_reset) }; diff --git a/keyboards/handwired/onekey/keymaps/lvgl/config.h b/keyboards/handwired/onekey/keymaps/lvgl/config.h new file mode 100644 index 0000000000..38bb5d0cf3 --- /dev/null +++ b/keyboards/handwired/onekey/keymaps/lvgl/config.h @@ -0,0 +1,15 @@ +// Copyright 2022 Jose Pablo Ramirez (@jpe230) +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +/* SPI pins */ +#define SPI_DRIVER SPID0 +#define SPI_SCK_PIN GP18 +#define SPI_MOSI_PIN GP19 +#define SPI_MISO_PIN GP20 + +/* LCD Configuration */ +#define LCD_RST_PIN GP0 +#define LCD_DC_PIN GP1 +#define LCD_CS_PIN GP2 diff --git a/keyboards/handwired/onekey/keymaps/lvgl/halconf.h b/keyboards/handwired/onekey/keymaps/lvgl/halconf.h new file mode 100644 index 0000000000..27646bb3f5 --- /dev/null +++ b/keyboards/handwired/onekey/keymaps/lvgl/halconf.h @@ -0,0 +1,12 @@ +// Copyright 2022 Jose Pablo Ramirez (@jpe230) +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include_next <halconf.h> + +#undef HAL_USE_SPI +#define HAL_USE_SPI TRUE + +#undef SPI_USE_WAIT +#define SPI_USE_WAIT TRUE diff --git a/keyboards/handwired/onekey/keymaps/lvgl/keymap.c b/keyboards/handwired/onekey/keymaps/lvgl/keymap.c new file mode 100644 index 0000000000..be1ba48cf9 --- /dev/null +++ b/keyboards/handwired/onekey/keymaps/lvgl/keymap.c @@ -0,0 +1,50 @@ +// Copyright 2022 Jose Pablo Ramirez (@jpe230) +// SPDX-License-Identifier: GPL-2.0-or-later + +#include QMK_KEYBOARD_H +#include "qp.h" + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + LAYOUT_ortho_1x1(JS_BUTTON0) +}; + +painter_device_t lcd; + +void lv_example_arc_2(void); + +void keyboard_post_init_user(void) { + lcd = qp_gc9a01_make_spi_device(240, 240, LCD_CS_PIN, LCD_DC_PIN, LCD_RST_PIN, 4, 0); + qp_init(lcd, QP_ROTATION_0); + qp_rect(lcd, 0, 0, 239, 319, 0, 255, 255, true); + + if (qp_lvgl_attach(lcd)) { + lv_example_arc_2(); + } +} + +static void set_angle(void* obj, int32_t v) { + lv_arc_set_value(obj, v); +} + +/** + * Create an arc which acts as a loader. + */ +void lv_example_arc_2(void) { + /*Create an Arc*/ + lv_obj_t* arc = lv_arc_create(lv_scr_act()); + lv_arc_set_rotation(arc, 270); + lv_arc_set_bg_angles(arc, 0, 360); + lv_obj_remove_style(arc, NULL, LV_PART_KNOB); /*Be sure the knob is not displayed*/ + lv_obj_clear_flag(arc, LV_OBJ_FLAG_CLICKABLE); /*To not allow adjusting by click*/ + lv_obj_center(arc); + + static lv_anim_t a; + lv_anim_init(&a); + lv_anim_set_var(&a, arc); + lv_anim_set_exec_cb(&a, set_angle); + lv_anim_set_time(&a, 1000); + lv_anim_set_repeat_count(&a, LV_ANIM_REPEAT_INFINITE); /*Just for the demo*/ + lv_anim_set_repeat_delay(&a, 500); + lv_anim_set_values(&a, 0, 100); + lv_anim_start(&a); +} diff --git a/keyboards/handwired/onekey/keymaps/lvgl/mcuconf.h b/keyboards/handwired/onekey/keymaps/lvgl/mcuconf.h new file mode 100644 index 0000000000..bff74867ff --- /dev/null +++ b/keyboards/handwired/onekey/keymaps/lvgl/mcuconf.h @@ -0,0 +1,9 @@ +// Copyright 2022 Jose Pablo Ramirez (@jpe230) +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include_next <mcuconf.h> + +#undef RP_SPI_USE_SPI0 +#define RP_SPI_USE_SPI0 TRUE diff --git a/keyboards/handwired/onekey/keymaps/lvgl/rules.mk b/keyboards/handwired/onekey/keymaps/lvgl/rules.mk new file mode 100644 index 0000000000..872d12ad6f --- /dev/null +++ b/keyboards/handwired/onekey/keymaps/lvgl/rules.mk @@ -0,0 +1,3 @@ +QUANTUM_PAINTER_ENABLE = yes +QUANTUM_PAINTER_LVGL_INTEGRATION = yes +QUANTUM_PAINTER_DRIVERS = gc9a01_spi diff --git a/keyboards/handwired/onekey/keymaps/oled/keymap.c b/keyboards/handwired/onekey/keymaps/oled/keymap.c index 244dc4facb..120ab80fa5 100644 --- a/keyboards/handwired/onekey/keymaps/oled/keymap.c +++ b/keyboards/handwired/onekey/keymaps/oled/keymap.c @@ -63,7 +63,7 @@ static void stop_scrolling(void) { } } -static void dance_oled_finished(qk_tap_dance_state_t *state, void *user_data) { +static void dance_oled_finished(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: if (state->pressed) { @@ -155,7 +155,7 @@ static void dance_oled_finished(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = {[TD_OLED] = ACTION_TAP_DANCE_FN(dance_oled_finished)}; +tap_dance_action_t tap_dance_actions[] = {[TD_OLED] = ACTION_TAP_DANCE_FN(dance_oled_finished)}; const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {LAYOUT_ortho_1x1(TD(TD_OLED))}; diff --git a/keyboards/handwired/ortho5x14/keymaps/2u/keymap.c b/keyboards/handwired/ortho5x14/keymaps/2u/keymap.c index cfd176a9d5..568427e52c 100644 --- a/keyboards/handwired/ortho5x14/keymaps/2u/keymap.c +++ b/keyboards/handwired/ortho5x14/keymaps/2u/keymap.c @@ -108,11 +108,11 @@ enum { // // Alt held down, then use as normal. // // Alt tapped, then hold Alt, -int cur_dance (qk_tap_dance_state_t *state); -void alt_finished (qk_tap_dance_state_t *state, void *user_data); -void alt_reset (qk_tap_dance_state_t *state, void *user_data); +int cur_dance (tap_dance_state_t *state); +void alt_finished (tap_dance_state_t *state, void *user_data); +void alt_reset (tap_dance_state_t *state, void *user_data); -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->pressed) return SINGLE_HOLD; else return SINGLE_TAP; @@ -133,7 +133,7 @@ static tap alttap_state = { .state = 0 }; -void alt_finished (qk_tap_dance_state_t *state, void *user_data) { +void alt_finished (tap_dance_state_t *state, void *user_data) { alttap_state.state = cur_dance(state); switch (alttap_state.state) { case SINGLE_TAP: set_oneshot_layer(_ALT, ONESHOT_START); clear_oneshot_layer_state(ONESHOT_PRESSED); break; @@ -146,7 +146,7 @@ void alt_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void alt_reset (qk_tap_dance_state_t *state, void *user_data) { +void alt_reset (tap_dance_state_t *state, void *user_data) { switch (alttap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: unregister_code(KC_LALT); break; @@ -157,15 +157,15 @@ void alt_reset (qk_tap_dance_state_t *state, void *user_data) { } // Ctrl tapped, then hold Ctrl, -void ctl_finished (qk_tap_dance_state_t *state, void *user_data); -void ctl_reset (qk_tap_dance_state_t *state, void *user_data); +void ctl_finished (tap_dance_state_t *state, void *user_data); +void ctl_reset (tap_dance_state_t *state, void *user_data); static tap ctltap_state = { .is_press_action = true, .state = 0 }; -void ctl_finished (qk_tap_dance_state_t *state, void *user_data) { +void ctl_finished (tap_dance_state_t *state, void *user_data) { ctltap_state.state = cur_dance(state); switch (ctltap_state.state) { case SINGLE_TAP: set_oneshot_mods(MOD_BIT(KC_LCTL)); break; @@ -176,7 +176,7 @@ void ctl_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void ctl_reset (qk_tap_dance_state_t *state, void *user_data) { +void ctl_reset (tap_dance_state_t *state, void *user_data) { switch (ctltap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: unregister_code(KC_LCTL); break; @@ -189,15 +189,15 @@ void ctl_reset (qk_tap_dance_state_t *state, void *user_data) { // Layer Down tap dance -void layerDown_finished (qk_tap_dance_state_t *state, void *user_data); -void layerDown_reset (qk_tap_dance_state_t *state, void *user_data); +void layerDown_finished (tap_dance_state_t *state, void *user_data); +void layerDown_reset (tap_dance_state_t *state, void *user_data); static tap layerdn_tap_state = { .is_press_action = true, .state = 0 }; -void layerDown_finished (qk_tap_dance_state_t *state, void *user_data) { +void layerDown_finished (tap_dance_state_t *state, void *user_data) { layerdn_tap_state.state = cur_dance(state); switch (layerdn_tap_state.state) { case SINGLE_TAP: break; @@ -208,7 +208,7 @@ void layerDown_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void layerDown_reset (qk_tap_dance_state_t *state, void *user_data) { +void layerDown_reset (tap_dance_state_t *state, void *user_data) { switch (layerdn_tap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: layer_off(_LOWER); break; @@ -219,15 +219,15 @@ void layerDown_reset (qk_tap_dance_state_t *state, void *user_data) { } // Layer Up tap dance -void layerUp_finished (qk_tap_dance_state_t *state, void *user_data); -void layerUp_reset (qk_tap_dance_state_t *state, void *user_data); +void layerUp_finished (tap_dance_state_t *state, void *user_data); +void layerUp_reset (tap_dance_state_t *state, void *user_data); static tap layerup_tap_state = { .is_press_action = true, .state = 0 }; -void layerUp_finished (qk_tap_dance_state_t *state, void *user_data) { +void layerUp_finished (tap_dance_state_t *state, void *user_data) { layerup_tap_state.state = cur_dance(state); switch (layerup_tap_state.state) { case SINGLE_TAP: break; @@ -238,7 +238,7 @@ void layerUp_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void layerUp_reset (qk_tap_dance_state_t *state, void *user_data) { +void layerUp_reset (tap_dance_state_t *state, void *user_data) { switch (layerup_tap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: layer_off(_RAISE); break; @@ -255,16 +255,16 @@ void layerUp_reset (qk_tap_dance_state_t *state, void *user_data) { // Shift tapped, then Capitlize next keystroke only. // Shift double-tapped, then CAPSLOCK // Shift double-tapped again, CAPS UNLOCKED -// void dance_onshot_lsft(qk_tap_dance_state_t *state, void *user_data) { -void lshift_finished (qk_tap_dance_state_t *state, void *user_data); -void lshift_reset (qk_tap_dance_state_t *state, void *user_data); +// void dance_onshot_lsft(tap_dance_state_t *state, void *user_data) { +void lshift_finished (tap_dance_state_t *state, void *user_data); +void lshift_reset (tap_dance_state_t *state, void *user_data); static tap lshifttap_state = { .is_press_action = true, .state = 0 }; -void lshift_finished (qk_tap_dance_state_t *state, void *user_data) { +void lshift_finished (tap_dance_state_t *state, void *user_data) { lshifttap_state.state = cur_dance(state); switch (lshifttap_state.state) { case SINGLE_TAP: set_oneshot_mods(MOD_BIT(KC_LSFT)); break; @@ -274,7 +274,7 @@ void lshift_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void lshift_reset (qk_tap_dance_state_t *state, void *user_data) { +void lshift_reset (tap_dance_state_t *state, void *user_data) { switch (lshifttap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: unregister_code(KC_LSFT); break; @@ -285,15 +285,15 @@ void lshift_reset (qk_tap_dance_state_t *state, void *user_data) { } //TD_LSPACE -void lspace_finished (qk_tap_dance_state_t *state, void *user_data); -void lspace_reset (qk_tap_dance_state_t *state, void *user_data); +void lspace_finished (tap_dance_state_t *state, void *user_data); +void lspace_reset (tap_dance_state_t *state, void *user_data); static tap lspacetap_state = { .is_press_action = true, .state = 0 }; -void lspace_finished (qk_tap_dance_state_t *state, void *user_data) { +void lspace_finished (tap_dance_state_t *state, void *user_data) { lspacetap_state.state = cur_dance(state); switch (lspacetap_state.state) { case SINGLE_TAP: tap_code (KC_SPACE); break; @@ -303,7 +303,7 @@ void lspace_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void lspace_reset (qk_tap_dance_state_t *state, void *user_data) { +void lspace_reset (tap_dance_state_t *state, void *user_data) { switch (lspacetap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: layer_off(_LOWER); break; @@ -318,7 +318,7 @@ void lspace_reset (qk_tap_dance_state_t *state, void *user_data) { //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_DEL_BSPC] = ACTION_TAP_DANCE_DOUBLE(KC_DEL, KC_BSPC), [TD_ESC_GRAVE] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_GRAVE), [TD_TAB_TILDE] = ACTION_TAP_DANCE_DOUBLE(KC_TAB, KC_TILDE), diff --git a/keyboards/handwired/ortho5x14/keymaps/default/keymap.c b/keyboards/handwired/ortho5x14/keymaps/default/keymap.c index 25ae840b79..d3fd18ec4e 100644 --- a/keyboards/handwired/ortho5x14/keymaps/default/keymap.c +++ b/keyboards/handwired/ortho5x14/keymaps/default/keymap.c @@ -63,7 +63,7 @@ enum { // Shift tapped, then Capitlize next keystroke only. // Shift double-tapped, then CAPSLOCK // Shift double-tapped again, CAPS UNLOCKED -void dance_onshot_lsft(qk_tap_dance_state_t *state, void *user_data) { +void dance_onshot_lsft(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: // => set_oneshot_mods (MOD_LSFT); @@ -76,7 +76,7 @@ void dance_onshot_lsft(qk_tap_dance_state_t *state, void *user_data) { } //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_DEL_BSPC] = ACTION_TAP_DANCE_DOUBLE(KC_DEL, KC_BSPC), [TD_ESC_GRAVE] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_GRAVE), [TD_TAB_TILDE] = ACTION_TAP_DANCE_DOUBLE(KC_TAB, KC_TILDE), diff --git a/keyboards/handwired/ortho5x14/keymaps/split1/keymap.c b/keyboards/handwired/ortho5x14/keymaps/split1/keymap.c index a5bb69ef24..733e3f3d4b 100644 --- a/keyboards/handwired/ortho5x14/keymaps/split1/keymap.c +++ b/keyboards/handwired/ortho5x14/keymaps/split1/keymap.c @@ -104,11 +104,11 @@ enum { // // Alt held down, then use as normal. // // Alt tapped, then hold Alt, -int cur_dance (qk_tap_dance_state_t *state); -void alt_finished (qk_tap_dance_state_t *state, void *user_data); -void alt_reset (qk_tap_dance_state_t *state, void *user_data); +int cur_dance (tap_dance_state_t *state); +void alt_finished (tap_dance_state_t *state, void *user_data); +void alt_reset (tap_dance_state_t *state, void *user_data); -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->pressed) return SINGLE_HOLD; else return SINGLE_TAP; @@ -129,7 +129,7 @@ static tap alttap_state = { .state = 0 }; -void alt_finished (qk_tap_dance_state_t *state, void *user_data) { +void alt_finished (tap_dance_state_t *state, void *user_data) { alttap_state.state = cur_dance(state); switch (alttap_state.state) { case SINGLE_TAP: set_oneshot_layer(_ALT, ONESHOT_START); clear_oneshot_layer_state(ONESHOT_PRESSED); break; @@ -142,7 +142,7 @@ void alt_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void alt_reset (qk_tap_dance_state_t *state, void *user_data) { +void alt_reset (tap_dance_state_t *state, void *user_data) { switch (alttap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: unregister_code(KC_LALT); break; @@ -153,15 +153,15 @@ void alt_reset (qk_tap_dance_state_t *state, void *user_data) { } // Ctrl tapped, then hold Ctrl, -void ctl_finished (qk_tap_dance_state_t *state, void *user_data); -void ctl_reset (qk_tap_dance_state_t *state, void *user_data); +void ctl_finished (tap_dance_state_t *state, void *user_data); +void ctl_reset (tap_dance_state_t *state, void *user_data); static tap ctltap_state = { .is_press_action = true, .state = 0 }; -void ctl_finished (qk_tap_dance_state_t *state, void *user_data) { +void ctl_finished (tap_dance_state_t *state, void *user_data) { ctltap_state.state = cur_dance(state); switch (ctltap_state.state) { case SINGLE_TAP: set_oneshot_mods(MOD_BIT(KC_LCTL)); break; @@ -174,7 +174,7 @@ void ctl_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void ctl_reset (qk_tap_dance_state_t *state, void *user_data) { +void ctl_reset (tap_dance_state_t *state, void *user_data) { switch (ctltap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: unregister_code(KC_LCTL); break; @@ -186,15 +186,15 @@ void ctl_reset (qk_tap_dance_state_t *state, void *user_data) { // Layer Down tap dance -void layerDown_finished (qk_tap_dance_state_t *state, void *user_data); -void layerDown_reset (qk_tap_dance_state_t *state, void *user_data); +void layerDown_finished (tap_dance_state_t *state, void *user_data); +void layerDown_reset (tap_dance_state_t *state, void *user_data); static tap layerdn_tap_state = { .is_press_action = true, .state = 0 }; -void layerDown_finished (qk_tap_dance_state_t *state, void *user_data) { +void layerDown_finished (tap_dance_state_t *state, void *user_data) { layerdn_tap_state.state = cur_dance(state); switch (layerdn_tap_state.state) { case SINGLE_TAP: break; @@ -204,7 +204,7 @@ void layerDown_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void layerDown_reset (qk_tap_dance_state_t *state, void *user_data) { +void layerDown_reset (tap_dance_state_t *state, void *user_data) { switch (layerdn_tap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: layer_off(_LOWER); break; @@ -222,16 +222,16 @@ void layerDown_reset (qk_tap_dance_state_t *state, void *user_data) { // Shift tapped, then Capitlize next keystroke only. // Shift double-tapped, then CAPSLOCK // Shift double-tapped again, CAPS UNLOCKED -// void dance_onshot_lsft(qk_tap_dance_state_t *state, void *user_data) { -void lshift_finished (qk_tap_dance_state_t *state, void *user_data); -void lshift_reset (qk_tap_dance_state_t *state, void *user_data); +// void dance_onshot_lsft(tap_dance_state_t *state, void *user_data) { +void lshift_finished (tap_dance_state_t *state, void *user_data); +void lshift_reset (tap_dance_state_t *state, void *user_data); static tap lshifttap_state = { .is_press_action = true, .state = 0 }; -void lshift_finished (qk_tap_dance_state_t *state, void *user_data) { +void lshift_finished (tap_dance_state_t *state, void *user_data) { lshifttap_state.state = cur_dance(state); switch (lshifttap_state.state) { case SINGLE_TAP: set_oneshot_mods(MOD_BIT(KC_LSFT)); break; @@ -241,7 +241,7 @@ void lshift_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void lshift_reset (qk_tap_dance_state_t *state, void *user_data) { +void lshift_reset (tap_dance_state_t *state, void *user_data) { switch (lshifttap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: unregister_code(KC_LSFT); break; @@ -254,7 +254,7 @@ void lshift_reset (qk_tap_dance_state_t *state, void *user_data) { //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_DEL_BSPC] = ACTION_TAP_DANCE_DOUBLE(KC_DEL, KC_BSPC), [TD_ESC_GRAVE] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_GRAVE), [TD_TAB_TILDE] = ACTION_TAP_DANCE_DOUBLE(KC_TAB, KC_TILDE), diff --git a/keyboards/handwired/space_oddity/keymaps/default/keymap.c b/keyboards/handwired/space_oddity/keymaps/default/keymap.c index 4e8ee5ddca..5b61482344 100644 --- a/keyboards/handwired/space_oddity/keymaps/default/keymap.c +++ b/keyboards/handwired/space_oddity/keymaps/default/keymap.c @@ -35,7 +35,7 @@ enum { }; // Tap dance actions - double tap for Caps Lock. -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [SFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), diff --git a/keyboards/handwired/swiftrax/digicarp65/readme.md b/keyboards/handwired/swiftrax/digicarp65/readme.md index 34e0c0b755..a10c1b567a 100644 --- a/keyboards/handwired/swiftrax/digicarp65/readme.md +++ b/keyboards/handwired/swiftrax/digicarp65/readme.md @@ -17,5 +17,5 @@ See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_to Enter the bootloader in 3 ways: * **Bootmagic reset**: Hold down the key at (0,0) in the matrix (top left key)and plug in the keyboard -* **Physical reset button**: Briefly short the pad on the back of the PCB labeled QK_BOOT +* **Physical reset button**: Briefly short the pad on the back of the PCB labeled `RESET` * **Keycode in layout**: Press the key mapped to `QK_BOOT` if it is available diff --git a/keyboards/helix/pico/config.h b/keyboards/helix/pico/config.h index fadb3fe204..3e3eacdaa5 100644 --- a/keyboards/helix/pico/config.h +++ b/keyboards/helix/pico/config.h @@ -19,7 +19,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #pragma once -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 /* Soft Serial defines */ diff --git a/keyboards/helix/rev2/config.h b/keyboards/helix/rev2/config.h index f409d039c4..460dce69e5 100644 --- a/keyboards/helix/rev2/config.h +++ b/keyboards/helix/rev2/config.h @@ -19,7 +19,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #pragma once -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #define SPLIT_LAYER_STATE_ENABLE diff --git a/keyboards/helix/rev2/keymaps/edvorakjp/config.h b/keyboards/helix/rev2/keymaps/edvorakjp/config.h index ca3b73aa29..6854249be0 100644 --- a/keyboards/helix/rev2/keymaps/edvorakjp/config.h +++ b/keyboards/helix/rev2/keymaps/edvorakjp/config.h @@ -2,7 +2,7 @@ #define SWAP_SCLN -#undef TAPPING_FORCE_HOLD +#undef QUICK_TAP_TERM #undef TAPPING_TERM #define TAPPING_TERM 300 #define IGNORE_MOD_TAP_INTERRUPT @@ -11,13 +11,13 @@ // Selection of RGBLIGHT MODE to use. #if defined(LED_ANIMATIONS) -//# define RGBLIGHT_EFFECT_BREATHING -//# define RGBLIGHT_EFFECT_RAINBOW_MOOD -//# define RGBLIGHT_EFFECT_RAINBOW_SWIRL -//# define RGBLIGHT_EFFECT_SNAKE -//# define RGBLIGHT_EFFECT_KNIGHT -//# define RGBLIGHT_EFFECT_CHRISTMAS +// # define RGBLIGHT_EFFECT_BREATHING +// # define RGBLIGHT_EFFECT_RAINBOW_MOOD +// # define RGBLIGHT_EFFECT_RAINBOW_SWIRL +// # define RGBLIGHT_EFFECT_SNAKE +// # define RGBLIGHT_EFFECT_KNIGHT +// # define RGBLIGHT_EFFECT_CHRISTMAS # define RGBLIGHT_EFFECT_STATIC_GRADIENT -//# define RGBLIGHT_EFFECT_RGB_TEST -//# define RGBLIGHT_EFFECT_ALTERNATING -#endif // LED_ANIMATIONS +// # define RGBLIGHT_EFFECT_RGB_TEST +// # define RGBLIGHT_EFFECT_ALTERNATING +#endif // LED_ANIMATIONS diff --git a/keyboards/hidtech/bastyl/keymaps/xyverz/config.h b/keyboards/hidtech/bastyl/keymaps/xyverz/config.h index d7baf99376..335f968e2a 100644 --- a/keyboards/hidtech/bastyl/keymaps/xyverz/config.h +++ b/keyboards/hidtech/bastyl/keymaps/xyverz/config.h @@ -25,7 +25,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 300 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/hub16/keymaps/macro/keymap.c b/keyboards/hub16/keymaps/macro/keymap.c index 1da30d564f..5200cf35dd 100755 --- a/keyboards/hub16/keymaps/macro/keymap.c +++ b/keyboards/hub16/keymaps/macro/keymap.c @@ -25,11 +25,11 @@ enum keyboard_layers{ }; // Tap Dance Declarations -void td_ctrl (qk_tap_dance_state_t *state, void *user_data); +void td_ctrl (tap_dance_state_t *state, void *user_data); enum tap_dance { CTRL = 0, BASE = 1 }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for standard key on base layer, twice to toggle to control layer [CTRL] = ACTION_TAP_DANCE_FN(td_ctrl), [BASE] = ACTION_TAP_DANCE_LAYER_MOVE(_______, _BASE)}; @@ -105,7 +105,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { // Below works around TD() not running key press through process_record_user. // Fixes bug of CTRL layer move key not being wrapped in by modifier on single tap -void td_ctrl (qk_tap_dance_state_t *state, void *user_data) { +void td_ctrl (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code(KC_WRAP); tap_code(KC_P); diff --git a/keyboards/hub20/keymaps/macro/keymap.c b/keyboards/hub20/keymaps/macro/keymap.c index 5fb1891ea7..c9e735d389 100644 --- a/keyboards/hub20/keymaps/macro/keymap.c +++ b/keyboards/hub20/keymaps/macro/keymap.c @@ -25,14 +25,14 @@ enum keyboard_layers{ }; // Tap Dance stuff -void td_ctrl (qk_tap_dance_state_t *state, void *user_data); +void td_ctrl (tap_dance_state_t *state, void *user_data); enum tap_dance { CTRL = 0, BASE = 1 }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for standard key, twice to toggle layers [CTRL] = ACTION_TAP_DANCE_FN(td_ctrl), [BASE] = ACTION_TAP_DANCE_LAYER_MOVE(_______, _BASE) @@ -110,7 +110,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { } // Below works around TD() not running key press through process_record_user -void td_ctrl (qk_tap_dance_state_t *state, void *user_data) { +void td_ctrl (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code(KC_WRAP); tap_code(KC_D); diff --git a/keyboards/idobao/id75/keymaps/egstad/keymap.c b/keyboards/idobao/id75/keymaps/egstad/keymap.c index 99f358da0f..43d26f9b86 100644 --- a/keyboards/idobao/id75/keymaps/egstad/keymap.c +++ b/keyboards/idobao/id75/keymaps/egstad/keymap.c @@ -61,7 +61,7 @@ enum { }; // Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Left Brace, twice for Right Brace [TD_BRC] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_RBRC), //Tap once for Minus, twice for Equal diff --git a/keyboards/idobao/id75/keymaps/paryz/config.h b/keyboards/idobao/id75/keymaps/paryz/config.h new file mode 100644 index 0000000000..625ce7a257 --- /dev/null +++ b/keyboards/idobao/id75/keymaps/paryz/config.h @@ -0,0 +1,20 @@ +/* Copyright 2022 peepeetee + * + * 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/>. + */ + +#pragma once +#define RGBLIGHT_SLEEP +#define RGB_DISABLE_WHEN_USB_SUSPENDED +#define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 diff --git a/keyboards/idobao/id75/keymaps/paryz/keymap.c b/keyboards/idobao/id75/keymaps/paryz/keymap.c new file mode 100644 index 0000000000..2d03c205ae --- /dev/null +++ b/keyboards/idobao/id75/keymaps/paryz/keymap.c @@ -0,0 +1,144 @@ +/* ht 2018 Milton Griffin + * + * 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/>. + */ +#include QMK_KEYBOARD_H + +// Keyboard Layers +enum layers { + _QWERTY, + _FN, + _LOWER, + _RAISE +}; + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + +/* QWERTY + * .--------------------------------------------------------------------------------------------------------------------------------------. + * | ESC | 1 | 2 | 3 | 4 | 5 | - | ` | = | 6 | 7 | 8 | 9 | 0 | BACKSP | + * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------| + * | TAB | Q | W | E | R | T | [ | \ | ] | Y | U | I | O | P | ENTER | + * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+-----------------+--------| + * | CAPS | A | S | D | F | G | HOME | DEL | PG UP | H | J | K | L | ; | ' RAISE| + * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------------------------+--------| + * | LSHIFT | Z | X | C | V | B | END | UP | PG DN | N | M | , | . | UP |? RSHIFT| + * |--------+--------+--------+--------+--------+-----------------+--------+--------+--------+--------+-----------------+--------+--------| + * | CTRL | ADJUST | ALT | GUI | SPACE | SPACE | LEFT | DOWN | RIGHT | BSPACE | BSPACE | ALT | LEFT | DOWN | RIGHT | + * '--------------------------------------------------------------------------------------------------------------------------------------' + */ + + [_QWERTY] = LAYOUT_ortho_5x15( /* QWERTY */ + QK_GESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_MINS, KC_GRV, KC_EQL, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL, + KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_LBRC, KC_BSLS, KC_RBRC, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_ENT, + LT(_LOWER,KC_CAPS), KC_A, KC_S, KC_D, KC_F, KC_G, KC_HOME, KC_DEL, KC_PGUP, KC_H, KC_J, KC_K, KC_L, KC_SCLN, LT(_RAISE, KC_QUOT), + KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_END, KC_UP, KC_PGDN, KC_N, KC_M, KC_COMM, KC_DOT, KC_UP, RSFT_T(KC_SLSH), + KC_LCTL, MO(_FN),KC_LGUI, KC_LALT, KC_SPC, KC_SPC,KC_LEFT, KC_DOWN, KC_RGHT, KC_BSPC, KC_BSPC, KC_RALT, KC_LEFT, KC_DOWN, KC_RGHT + ), + + [_FN] = LAYOUT_ortho_5x15( + KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_NUM, KC_SLSH, KC_ASTR, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, + KC_PSCR, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_P7, KC_P8, KC_P9, KC_MINS, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS, + KC_MPRV, KC_MPLY, KC_MNXT, RGB_HUI, KC_NO, KC_NO, KC_P4, KC_P5, KC_P6, KC_PLUS, KC_NO, QK_BOOT, KC_NO, KC_NO, KC_TRNS, + KC_VOLD, KC_MUTE, KC_VOLU, RGB_SAI, RGB_SPD, RGB_RMOD,KC_P1, KC_P2, KC_P3, KC_PENT, KC_NO, KC_NO, KC_NO, KC_TRNS, KC_TRNS, + KC_TRNS, KC_NO, RGB_TOG, RGB_VAI, RGB_SPI, RGB_MOD, KC_P0, KC_NO, KC_PDOT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS + ), + + [_LOWER] = LAYOUT_ortho_5x15( + KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_NO, KC_SLSH, KC_ASTR, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, + KC_TRNS, KC_PGUP, KC_HOME, KC_UP, KC_END, KC_NO, KC_P7, KC_P8, KC_P9, KC_NO, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, + KC_TRNS, KC_PGDN, KC_LEFT, KC_DOWN, KC_RGHT, KC_NO, KC_P4, KC_P5, KC_P6, KC_NO, KC_NUHS, KC_NUBS, KC_NO, KC_NO, KC_TRNS, + KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_P1, KC_P2, KC_P3, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_P0, KC_NO, KC_PDOT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS +), + +[_RAISE] = LAYOUT_ortho_5x15( + KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_NO, KC_SLSH, KC_ASTR, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, + KC_TRNS, KC_NO, KC_HOME, KC_UP, KC_END, KC_NO, KC_P7, KC_P8, KC_P9, KC_NO, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, + KC_TRNS, KC_NO, KC_LEFT, KC_DOWN, KC_RGHT, KC_NO, KC_P4, KC_P5, KC_P6, KC_NO, KC_NUHS, KC_NUBS, KC_NO, KC_NO, KC_TRNS, + KC_TRNS, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_P1, KC_P2, KC_P3, KC_NO, KC_NO, KC_NO, KC_NO, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_P0, KC_NO, KC_PDOT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS +) +}; + +#ifdef RGB_MATRIX_ENABLE +void keyboard_post_init_user(void) { + g_led_config = (led_config_t){{ + // Key Matrix to LED Index + { 84, 83, 82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 72, 71, 70 }, + { 69, 68, 67, 66, 65, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55 }, + { 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40 }, + { 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25 }, + { 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10 } + }, { + // LED Index to Physical Position + {8, 12},{60, 12},{112, 12},{164, 12},{216, 12}, + {216, 60},{164, 60},{112, 60},{60, 60},{8, 60}, + {224, 64}, {208, 64}, {192, 64}, {176, 64}, {160, 64}, {144, 64}, {128, 64}, {112, 64}, {96, 64}, {80, 64}, {64, 64}, {48, 64}, {32, 64}, {16, 64}, {0, 64}, + {224, 48}, {208, 48}, {192, 48}, {176, 48}, {160, 48}, {144, 48}, {128, 48}, {112, 48}, {96, 48}, {80, 48}, {64, 48}, {48, 48}, {32, 48}, {16, 48}, {0, 48}, + {224, 32}, {208, 32}, {192, 32}, {176, 32}, {160, 32}, {144, 32}, {128, 32}, {112, 32}, {96, 32}, {80, 32}, {64, 32}, {48, 32}, {32, 32}, {16, 32}, {0, 32}, + {224, 16}, {208, 16}, {192, 16}, {176, 16}, {160, 16}, {144, 16}, {128, 16}, {112, 16}, {96, 16}, {80, 16}, {64, 16}, {48, 16}, {32, 16}, {16, 16}, {0, 16}, + {224, 0}, {208, 0}, {192, 0}, {176, 0}, {160, 0}, {144, 0}, {128, 0}, {112, 0}, {96, 0}, {80, 0}, {64, 0}, {48, 0}, {32, 0}, {16, 0}, {0, 0} + }, { + // LED Index to Flag + 2,2,2,2,2,2,2,2,2,2, + 1,1,1,1,4,4,9,9,9,4,4,1,1,1,1, + 1,4,4,4,4,4,9,9,9,4,4,4,4,4,1, + 1,4,4,4,4,4,9,9,9,4,4,4,4,4,1, + 1,4,4,4,4,4,9,9,9,4,4,4,4,4,1, + 1,4,4,4,4,4,9,9,9,4,4,4,4,4,1 + } + }; +}; + +bool rgb_matrix_indicators_advanced_user(uint8_t led_min, uint8_t led_max) { + if (host_keyboard_led_state().caps_lock) { + for (int i = 10; i <= 84; i++) { + if (g_led_config.flags[i] & LED_FLAG_MODIFIER) { + rgb_matrix_set_color(i, RGB_RED); + } + } + } + + if ( get_highest_layer(layer_state) > _QWERTY) { + HSV hsv = {0, 255, 255}; + + switch (get_highest_layer(layer_state)) { + case _FN: + hsv.h = 32; + break; + case _LOWER: + hsv.h = 116; + break; + case _RAISE: + hsv.h = 200; + break; + default: + break; + }; + + if (hsv.v > rgb_matrix_get_val()) { + hsv.v = RGB_MATRIX_MAXIMUM_BRIGHTNESS; + } + RGB rgb = hsv_to_rgb(hsv); + + for (int i = 10; i <= 84; i++) { + if ( g_led_config.flags[i] & LED_FLAG_INDICATOR) { + rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b); + } + }; + } + return false; +}; +#endif diff --git a/keyboards/idobao/id75/keymaps/paryz/rules.mk b/keyboards/idobao/id75/keymaps/paryz/rules.mk new file mode 100644 index 0000000000..8ce8a7d06e --- /dev/null +++ b/keyboards/idobao/id75/keymaps/paryz/rules.mk @@ -0,0 +1,2 @@ +VIA_ENABLE = yes +NKRO_ENABLE = yes diff --git a/keyboards/idobao/id75/v1/config.h b/keyboards/idobao/id75/v1/config.h index 0bb05a810c..82e7d705ee 100644 --- a/keyboards/idobao/id75/v1/config.h +++ b/keyboards/idobao/id75/v1/config.h @@ -45,7 +45,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define RGB_DI_PIN F0 #ifdef RGB_DI_PIN - // RGBLIGHT_ANIMATIONS #define RGBLIGHT_EFFECT_ALTERNATING #define RGBLIGHT_EFFECT_BREATHING #define RGBLIGHT_EFFECT_CHRISTMAS diff --git a/keyboards/idobao/id80/v2/config.h b/keyboards/idobao/id80/v2/config.h index a007cff40c..57f26aee57 100644 --- a/keyboards/idobao/id80/v2/config.h +++ b/keyboards/idobao/id80/v2/config.h @@ -71,7 +71,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define RGBLIGHT_LIMIT_VAL 180 /* The maximum brightness level */ #define RGBLIGHT_SLEEP /* If defined, the RGB lighting will be switched off when the host goes to sleep */ - // RGBLIGHT_ANIMATIONS #define RGBLIGHT_EFFECT_ALTERNATING #define RGBLIGHT_EFFECT_BREATHING #define RGBLIGHT_EFFECT_CHRISTMAS diff --git a/keyboards/idobao/id87/v1/config.h b/keyboards/idobao/id87/v1/config.h index 6c2d6fc9ce..11372855c0 100644 --- a/keyboards/idobao/id87/v1/config.h +++ b/keyboards/idobao/id87/v1/config.h @@ -50,7 +50,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define RGB_DI_PIN E2 #ifdef RGB_DI_PIN - // RGBLIGHT_ANIMATIONS #define RGBLIGHT_EFFECT_ALTERNATING #define RGBLIGHT_EFFECT_BREATHING #define RGBLIGHT_EFFECT_CHRISTMAS diff --git a/keyboards/idobao/montex/v1/config.h b/keyboards/idobao/montex/v1/config.h index fe1ea61d35..3d1a614e8a 100644 --- a/keyboards/idobao/montex/v1/config.h +++ b/keyboards/idobao/montex/v1/config.h @@ -46,7 +46,6 @@ #define RGB_DI_PIN B1 #ifdef RGB_DI_PIN - // RGBLIGHT_ANIMATIONS #define RGBLIGHT_EFFECT_ALTERNATING #define RGBLIGHT_EFFECT_BREATHING #define RGBLIGHT_EFFECT_CHRISTMAS diff --git a/keyboards/jones/v03/keymaps/default_jp/keymap.c b/keyboards/jones/v03/keymaps/default_jp/keymap.c index ae618ee0bc..dd7e878170 100644 --- a/keyboards/jones/v03/keymaps/default_jp/keymap.c +++ b/keyboards/jones/v03/keymaps/default_jp/keymap.c @@ -43,13 +43,13 @@ enum { // Declare the functions to be used with your tap dance key(s) // Function associated with all tap dances -uint8_t cur_dance(qk_tap_dance_state_t *state); +uint8_t cur_dance(tap_dance_state_t *state); // Functions associated with individual tap dances -void ql_finished(qk_tap_dance_state_t *state, void *user_data); -void ql_reset(qk_tap_dance_state_t *state, void *user_data); +void ql_finished(tap_dance_state_t *state, void *user_data); +void ql_reset(tap_dance_state_t *state, void *user_data); // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LSFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), [TD_ESC_NUM] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ql_finished, ql_reset), }; @@ -279,7 +279,7 @@ typedef struct { } tap; // Determine the current tap dance state -uint8_t cur_dance(qk_tap_dance_state_t *state) { +uint8_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (!state->pressed) { return SINGLE_TAP; @@ -310,7 +310,7 @@ static tap ql_tap_state = { }; // Functions that control what our tap dance key does -void ql_finished(qk_tap_dance_state_t *state, void *user_data) { +void ql_finished(tap_dance_state_t *state, void *user_data) { ql_tap_state.state = cur_dance(state); switch(TAP_DANCE_KEYCODE(state)) { case TD(TD_ESC_NUM): // ESC key action @@ -340,7 +340,7 @@ void ql_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void ql_reset(qk_tap_dance_state_t *state, void *user_data) { +void ql_reset(tap_dance_state_t *state, void *user_data) { switch(TAP_DANCE_KEYCODE(state)) { case TD(TD_ESC_NUM): // If the key was held down and now is released then switch off the layer diff --git a/keyboards/jones/v03_1/keymaps/default_ansi/keymap.c b/keyboards/jones/v03_1/keymaps/default_ansi/keymap.c index 962acc1810..3c11d5dc90 100644 --- a/keyboards/jones/v03_1/keymaps/default_ansi/keymap.c +++ b/keyboards/jones/v03_1/keymaps/default_ansi/keymap.c @@ -42,13 +42,13 @@ enum { // Declare the functions to be used with your tap dance key(s) // Function associated with all tap dances -uint8_t cur_dance(qk_tap_dance_state_t *state); +uint8_t cur_dance(tap_dance_state_t *state); // Functions associated with individual tap dances -void ql_finished(qk_tap_dance_state_t *state, void *user_data); -void ql_reset(qk_tap_dance_state_t *state, void *user_data); +void ql_finished(tap_dance_state_t *state, void *user_data); +void ql_reset(tap_dance_state_t *state, void *user_data); // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LSFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), [TD_ESC_NUM] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ql_finished, ql_reset), }; @@ -298,7 +298,7 @@ typedef struct { } tap; // Determine the current tap dance state -uint8_t cur_dance(qk_tap_dance_state_t *state) { +uint8_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (!state->pressed) { return SINGLE_TAP; @@ -329,7 +329,7 @@ static tap ql_tap_state = { }; // Functions that control what our tap dance key does -void ql_finished(qk_tap_dance_state_t *state, void *user_data) { +void ql_finished(tap_dance_state_t *state, void *user_data) { ql_tap_state.state = cur_dance(state); switch(TAP_DANCE_KEYCODE(state)) { case TD(TD_ESC_NUM): // ESC key action @@ -359,7 +359,7 @@ void ql_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void ql_reset(qk_tap_dance_state_t *state, void *user_data) { +void ql_reset(tap_dance_state_t *state, void *user_data) { switch(TAP_DANCE_KEYCODE(state)) { case TD(TD_ESC_NUM): // If the key was held down and now is released then switch off the layer diff --git a/keyboards/jones/v03_1/keymaps/default_jp/keymap.c b/keyboards/jones/v03_1/keymaps/default_jp/keymap.c index 6e06dfe897..9d7aa50960 100644 --- a/keyboards/jones/v03_1/keymaps/default_jp/keymap.c +++ b/keyboards/jones/v03_1/keymaps/default_jp/keymap.c @@ -43,13 +43,13 @@ enum { // Declare the functions to be used with your tap dance key(s) // Function associated with all tap dances -uint8_t cur_dance(qk_tap_dance_state_t *state); +uint8_t cur_dance(tap_dance_state_t *state); // Functions associated with individual tap dances -void ql_finished(qk_tap_dance_state_t *state, void *user_data); -void ql_reset(qk_tap_dance_state_t *state, void *user_data); +void ql_finished(tap_dance_state_t *state, void *user_data); +void ql_reset(tap_dance_state_t *state, void *user_data); // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LSFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), [TD_ESC_NUM] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ql_finished, ql_reset), }; @@ -300,7 +300,7 @@ typedef struct { } tap; // Determine the current tap dance state -uint8_t cur_dance(qk_tap_dance_state_t *state) { +uint8_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (!state->pressed) { return SINGLE_TAP; @@ -331,7 +331,7 @@ static tap ql_tap_state = { }; // Functions that control what our tap dance key does -void ql_finished(qk_tap_dance_state_t *state, void *user_data) { +void ql_finished(tap_dance_state_t *state, void *user_data) { ql_tap_state.state = cur_dance(state); switch(TAP_DANCE_KEYCODE(state)) { case TD(TD_ESC_NUM): // ESC key action @@ -361,7 +361,7 @@ void ql_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void ql_reset(qk_tap_dance_state_t *state, void *user_data) { +void ql_reset(tap_dance_state_t *state, void *user_data) { switch(TAP_DANCE_KEYCODE(state)) { case TD(TD_ESC_NUM): // If the key was held down and now is released then switch off the layer diff --git a/keyboards/kbdfans/kbd67/mkii_soldered/keymaps/adamdehaven/keymap.c b/keyboards/kbdfans/kbd67/mkii_soldered/keymaps/adamdehaven/keymap.c index 53f3b83d3a..637ea3e2c8 100644 --- a/keyboards/kbdfans/kbd67/mkii_soldered/keymaps/adamdehaven/keymap.c +++ b/keyboards/kbdfans/kbd67/mkii_soldered/keymaps/adamdehaven/keymap.c @@ -14,7 +14,7 @@ enum tapdance { TD_END }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Home, twice for PageUp [TD_HOME] = ACTION_TAP_DANCE_DOUBLE(KC_HOME, KC_PGUP), // Tap once for End, twice for PageDown diff --git a/keyboards/kbdfans/kbd6x/keymaps/othi/keymap.c b/keyboards/kbdfans/kbd6x/keymaps/othi/keymap.c index e822b39276..d748a2f736 100644 --- a/keyboards/kbdfans/kbd6x/keymaps/othi/keymap.c +++ b/keyboards/kbdfans/kbd6x/keymaps/othi/keymap.c @@ -66,7 +66,7 @@ enum { GUI_NM = 3 }; -void dance_CTL_NM_finished (qk_tap_dance_state_t *state, void *user_data) { +void dance_CTL_NM_finished (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { set_oneshot_mods(MOD_LCTL); } else { @@ -75,7 +75,7 @@ void dance_CTL_NM_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_CTL_NM_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_CTL_NM_reset (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_LCTL); } else { @@ -84,7 +84,7 @@ void dance_CTL_NM_reset (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_GUI_NM_finished (qk_tap_dance_state_t *state, void *user_data) { +void dance_GUI_NM_finished (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code (KC_LGUI); } else { @@ -93,7 +93,7 @@ void dance_GUI_NM_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_GUI_NM_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_GUI_NM_reset (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_LGUI); } else { @@ -102,7 +102,7 @@ void dance_GUI_NM_reset (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_ALT_NM_finished (qk_tap_dance_state_t *state, void *user_data) { +void dance_ALT_NM_finished (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code (KC_LALT); } else { @@ -111,7 +111,7 @@ void dance_ALT_NM_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_ALT_NM_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_ALT_NM_reset (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_LALT); } else { @@ -120,7 +120,7 @@ void dance_ALT_NM_reset (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_SFT_NM_finished (qk_tap_dance_state_t *state, void *user_data) { +void dance_SFT_NM_finished (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code (KC_LSFT); set_oneshot_mods(MOD_LSFT); @@ -130,7 +130,7 @@ void dance_SFT_NM_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_SFT_NM_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_SFT_NM_reset (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_LSFT); } else { @@ -140,7 +140,7 @@ void dance_SFT_NM_reset (qk_tap_dance_state_t *state, void *user_data) { } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [CTL_NM] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_CTL_NM_finished, dance_CTL_NM_reset), [GUI_NM] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_GUI_NM_finished, dance_GUI_NM_reset), [ALT_NM] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_ALT_NM_finished, dance_ALT_NM_reset), diff --git a/keyboards/kbdfans/kbd75/keymaps/adamdehaven/keymap.c b/keyboards/kbdfans/kbd75/keymaps/adamdehaven/keymap.c index 9bd91eade0..398f90c6d7 100644 --- a/keyboards/kbdfans/kbd75/keymaps/adamdehaven/keymap.c +++ b/keyboards/kbdfans/kbd75/keymaps/adamdehaven/keymap.c @@ -44,7 +44,7 @@ enum tapdance { TD_PGDN }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for PageUp, twice for Home [TD_PGUP] = ACTION_TAP_DANCE_DOUBLE(KC_PGUP, KC_HOME), // Tap once for PageDown, twice for End diff --git a/keyboards/kbdfans/kbd75/keymaps/noroadsleft/keymap.c b/keyboards/kbdfans/kbd75/keymaps/noroadsleft/keymap.c index 479a52454b..f1a08c2edd 100644 --- a/keyboards/kbdfans/kbd75/keymaps/noroadsleft/keymap.c +++ b/keyboards/kbdfans/kbd75/keymaps/noroadsleft/keymap.c @@ -31,7 +31,7 @@ enum tap_dances { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Escape, twice for Caps Lock [LAG] = ACTION_TAP_DANCE_DOUBLE(KC_LALT, KC_LGUI), [RAG] = ACTION_TAP_DANCE_DOUBLE(KC_RALT, KC_RGUI), diff --git a/keyboards/kbdfans/kbdpad/mk2/keymaps/iracing_replay/keymap.c b/keyboards/kbdfans/kbdpad/mk2/keymaps/iracing_replay/keymap.c index 5fb451f467..5bbd8666ae 100644 --- a/keyboards/kbdfans/kbdpad/mk2/keymaps/iracing_replay/keymap.c +++ b/keyboards/kbdfans/kbdpad/mk2/keymaps/iracing_replay/keymap.c @@ -51,7 +51,7 @@ void camera_number(uint16_t tens, uint16_t ones) { tap_code(KC_ENT); } -void cam_up(qk_tap_dance_state_t *state, void *user_data) { +void cam_up(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: tap_code(KC_C); // tap once for next cam @@ -62,7 +62,7 @@ void cam_up(qk_tap_dance_state_t *state, void *user_data) { } } -void cam_down(qk_tap_dance_state_t *state, void *user_data) { +void cam_down(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: tap_code16(LSFT(KC_C)); // tap once for prev cam @@ -74,7 +74,7 @@ void cam_down(qk_tap_dance_state_t *state, void *user_data) { } // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_CAR] = ACTION_TAP_DANCE_DOUBLE( LSFT(KC_V), // tap once for prev car LCTL(KC_V) // tap twice for my car diff --git a/keyboards/kbdfans/kbdpad/mk3/info.json b/keyboards/kbdfans/kbdpad/mk3/info.json index 2faabc311c..a22c82c681 100644 --- a/keyboards/kbdfans/kbdpad/mk3/info.json +++ b/keyboards/kbdfans/kbdpad/mk3/info.json @@ -47,7 +47,7 @@ "max_brightness": 128 }, "rgblight": { - "pin": "F5", + "pin": "F5" }, "usb": { "device_version": "3.0.0", diff --git a/keyboards/keebio/bdn9/keymaps/brandonschlack/keymap.c b/keyboards/keebio/bdn9/keymaps/brandonschlack/keymap.c index c581070895..afe150cc60 100644 --- a/keyboards/keebio/bdn9/keymaps/brandonschlack/keymap.c +++ b/keyboards/keebio/bdn9/keymaps/brandonschlack/keymap.c @@ -57,7 +57,7 @@ enum bdn9_dances { TD_DTAP_ADJT }; // Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_DTAP_ADIO] = ACTION_TAP_DANCE_TRIGGER_LAYER(DOUBLE_TAP, _AUDIO), [TD_DTAP_LGHT] = ACTION_TAP_DANCE_TRIGGER_LAYER(DOUBLE_TAP, _LIGHT), [TD_DTAP_ADJT] = ACTION_TAP_DANCE_TRIGGER_LAYER(DOUBLE_TAP, _ADJUST), diff --git a/keyboards/keebio/bdn9/keymaps/eosti/keymap.c b/keyboards/keebio/bdn9/keymaps/eosti/keymap.c index b37e2a1cdb..970cd6d6e7 100644 --- a/keyboards/keebio/bdn9/keymaps/eosti/keymap.c +++ b/keyboards/keebio/bdn9/keymaps/eosti/keymap.c @@ -48,11 +48,11 @@ static td_state_t td_state; // declare your tapdance functions: // function to determine the current tapdance state -int cur_dance (qk_tap_dance_state_t *state); +int cur_dance (tap_dance_state_t *state); // `finished` and `reset` functions for each tapdance keycode -void altlp_finished (qk_tap_dance_state_t *state, void *user_data); -void altlp_reset (qk_tap_dance_state_t *state, void *user_data); +void altlp_finished (tap_dance_state_t *state, void *user_data); +void altlp_reset (tap_dance_state_t *state, void *user_data); bool process_record_user(uint16_t keycode, keyrecord_t *record) { switch (keycode) { @@ -137,7 +137,7 @@ bool encoder_update_user(uint8_t index, bool clockwise) { // Tapdance! Hold to use as a modifier to the _MOD layout, tap to change it between _BASE and _MACRO // determine the tapdance state to return -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) { return SINGLE_TAP; } else { return SINGLE_HOLD; } @@ -146,7 +146,7 @@ int cur_dance (qk_tap_dance_state_t *state) { // handle the possible states for each tapdance keycode you define: -void altlp_finished (qk_tap_dance_state_t *state, void *user_data) { +void altlp_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -158,7 +158,7 @@ void altlp_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void altlp_reset (qk_tap_dance_state_t *state, void *user_data) { +void altlp_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: break; @@ -169,6 +169,6 @@ void altlp_reset (qk_tap_dance_state_t *state, void *user_data) { } // define `ACTION_TAP_DANCE_FN_ADVANCED()` for each tapdance keycode, passing in `finished` and `reset` functions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [LAY] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altlp_finished, altlp_reset) }; diff --git a/keyboards/keebio/bfo9000/keymaps/insertsnideremarks/keymap.c b/keyboards/keebio/bfo9000/keymaps/insertsnideremarks/keymap.c index 1795d55c62..9831a35a5c 100644 --- a/keyboards/keebio/bfo9000/keymaps/insertsnideremarks/keymap.c +++ b/keyboards/keebio/bfo9000/keymaps/insertsnideremarks/keymap.c @@ -47,20 +47,20 @@ enum { PSLPAS }; -void dance_LAYER_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_on(_ADJUST2); set_oneshot_layer(_ADJUST2, ONESHOT_START); } } -void dance_LAYER_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_off(_ADJUST2); clear_oneshot_layer_state(ONESHOT_PRESSED); } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ADJ] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_LAYER_finished, dance_LAYER_reset), // Double-tap to activate Adjust layer via oneshot layer [LBCB] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_LCBR), // Left bracket on a single-tap, left brace on a double-tap [RBCB] = ACTION_TAP_DANCE_DOUBLE(KC_RBRC, KC_RCBR), // Right bracket on a single-tap, right brace on a double-tap diff --git a/keyboards/keebio/bfo9000/keymaps/tuesdayjohn/keymap.c b/keyboards/keebio/bfo9000/keymaps/tuesdayjohn/keymap.c index 37031b936b..7a0b967329 100644 --- a/keyboards/keebio/bfo9000/keymaps/tuesdayjohn/keymap.c +++ b/keyboards/keebio/bfo9000/keymaps/tuesdayjohn/keymap.c @@ -36,20 +36,20 @@ enum { PSPA }; -void dance_LAYER_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_on(_ADJUST2); set_oneshot_layer(_ADJUST2, ONESHOT_START); } } -void dance_LAYER_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_off(_ADJUST2); clear_oneshot_layer_state(ONESHOT_PRESSED); } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ADJ] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_LAYER_finished, dance_LAYER_reset), // Double-tap to activate Adjust layer via oneshot layer [LBCB] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_LCBR), // Left bracket on a single-tap, left brace on a double-tap [RBCB] = ACTION_TAP_DANCE_DOUBLE(KC_RBRC, KC_RCBR), // Right bracket on a single-tap, right brace on a double-tap diff --git a/keyboards/keebio/iris/keymaps/adamgate/keymap.c b/keyboards/keebio/iris/keymaps/adamgate/keymap.c index 84c3b74711..e67ceef091 100644 --- a/keyboards/keebio/iris/keymaps/adamgate/keymap.c +++ b/keyboards/keebio/iris/keymaps/adamgate/keymap.c @@ -36,7 +36,7 @@ enum custom_tapdances { TD_SHFT_CAPS = 0, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SHFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), //shift if pressed 1x, caps lock if pressed 2x }; diff --git a/keyboards/keebio/iris/keymaps/boo/keymap.c b/keyboards/keebio/iris/keymaps/boo/keymap.c index 7fc9162b47..e6325ae876 100644 --- a/keyboards/keebio/iris/keymaps/boo/keymap.c +++ b/keyboards/keebio/iris/keymaps/boo/keymap.c @@ -44,7 +44,7 @@ enum keycodes { KC_KAK = SAFE_RANGE, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [_LCTLGUI] = ACTION_TAP_DANCE_DOUBLE(KC_LCTL, KC_LGUI), }; diff --git a/keyboards/keebio/iris/keymaps/davidrambo/keymap.c b/keyboards/keebio/iris/keymaps/davidrambo/keymap.c index 188e3c3345..42c6d6fcfe 100644 --- a/keyboards/keebio/iris/keymaps/davidrambo/keymap.c +++ b/keyboards/keebio/iris/keymaps/davidrambo/keymap.c @@ -126,7 +126,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Shift vs. capslock function. From bbaserdem's Planck keymap (since deprecated). -void caps_tap (qk_tap_dance_state_t *state, void *user_data) { +void caps_tap (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code (KC_LSFT); } else if (state->count == 2) { @@ -134,7 +134,7 @@ void caps_tap (qk_tap_dance_state_t *state, void *user_data) { register_code (KC_CAPS); } } -void caps_tap_end (qk_tap_dance_state_t *state, void *user_data) { +void caps_tap_end (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_LSFT); } else { @@ -142,7 +142,7 @@ void caps_tap_end (qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Shift, twice for Caps Lock [SFT_LCK] = ACTION_TAP_DANCE_FN_ADVANCED( caps_tap, NULL, caps_tap_end) }; diff --git a/keyboards/keebio/iris/keymaps/jhelvy/config.h b/keyboards/keebio/iris/keymaps/jhelvy/config.h index c019234732..7ec5b41761 100644 --- a/keyboards/keebio/iris/keymaps/jhelvy/config.h +++ b/keyboards/keebio/iris/keymaps/jhelvy/config.h @@ -20,7 +20,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // Had to swap the master to get the right-side rotary encoder supported #define MASTER_RIGHT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #undef TAPPING_TERM #define TAPPING_TERM 200 #define AUTO_SHIFT_TIMEOUT 150 diff --git a/keyboards/keebio/iris/keymaps/khord/keymap.c b/keyboards/keebio/iris/keymaps/khord/keymap.c index 10ef4ce099..07155d5d17 100644 --- a/keyboards/keebio/iris/keymaps/khord/keymap.c +++ b/keyboards/keebio/iris/keymaps/khord/keymap.c @@ -79,7 +79,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { ) }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [SFT_CAP] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS) }; diff --git a/keyboards/keebio/iris/keymaps/omgvee/keymap.c b/keyboards/keebio/iris/keymaps/omgvee/keymap.c index 29ce513fed..4276938b8d 100644 --- a/keyboards/keebio/iris/keymaps/omgvee/keymap.c +++ b/keyboards/keebio/iris/keymaps/omgvee/keymap.c @@ -40,7 +40,7 @@ enum { TD_SCL = 0 }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Shift, twice for Caps Lock [TD_SCL] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), }; diff --git a/keyboards/keebio/iris/keymaps/osiris/config.h b/keyboards/keebio/iris/keymaps/osiris/config.h index 225a858131..eac14a7246 100644 --- a/keyboards/keebio/iris/keymaps/osiris/config.h +++ b/keyboards/keebio/iris/keymaps/osiris/config.h @@ -37,6 +37,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define RGBLIGHT_VAL_STEP 8 // #undef PERMISSIVE_HOLD -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 //#define RETRO_TAPPING #define PERMISSIVE_HOLD diff --git a/keyboards/keebio/iris/keymaps/sq5rix/keymap.c b/keyboards/keebio/iris/keymaps/sq5rix/keymap.c index 92f4294a40..74e1dcd531 100644 --- a/keyboards/keebio/iris/keymaps/sq5rix/keymap.c +++ b/keyboards/keebio/iris/keymaps/sq5rix/keymap.c @@ -36,7 +36,7 @@ enum custom_keycodes { enum { TD_S }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_S] = ACTION_TAP_DANCE_DOUBLE(KC_S, KC_Z), }; diff --git a/keyboards/keebio/iris/keymaps/two_knob/keymap.c b/keyboards/keebio/iris/keymaps/two_knob/keymap.c index 221855d3fa..f6017d7266 100644 --- a/keyboards/keebio/iris/keymaps/two_knob/keymap.c +++ b/keyboards/keebio/iris/keymaps/two_knob/keymap.c @@ -53,7 +53,7 @@ enum tapdances { * * To use this in the configurator, enter the name 'TD_FIVE_ENTER' in the "Any" key. */ -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { /* Tap once for 5, twice for Enter. */ [_TD_FIVE_ENTER] = ACTION_TAP_DANCE_DOUBLE(KC_5, KC_ENT), }; diff --git a/keyboards/keebio/nyquist/keymaps/danielhklein/keymap.c b/keyboards/keebio/nyquist/keymaps/danielhklein/keymap.c index 00f0bb3ced..a65fc3b688 100644 --- a/keyboards/keebio/nyquist/keymaps/danielhklein/keymap.c +++ b/keyboards/keebio/nyquist/keymaps/danielhklein/keymap.c @@ -36,7 +36,6 @@ enum custom_keycodes { // Underglow setup #define RGBLIGHT_SLEEP -#define RGBLIGHT_ANIMATIONS const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { diff --git a/keyboards/keebio/rorschach/keymaps/insertsnideremarks/keymap.c b/keyboards/keebio/rorschach/keymaps/insertsnideremarks/keymap.c index 39b171dcdc..c2aa0c60fa 100644 --- a/keyboards/keebio/rorschach/keymaps/insertsnideremarks/keymap.c +++ b/keyboards/keebio/rorschach/keymaps/insertsnideremarks/keymap.c @@ -43,20 +43,20 @@ enum { PSLPAS }; -void dance_LAYER_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_on(_ADJUST2); set_oneshot_layer(_ADJUST2, ONESHOT_START); } } -void dance_LAYER_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_off(_ADJUST2); clear_oneshot_layer_state(ONESHOT_PRESSED); } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ADJ] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_LAYER_finished, dance_LAYER_reset), // Double-tap to activate Adjust layer via oneshot layer [LBCB] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_LCBR), // Left bracket on a single-tap, left brace on a double-tap [RBCB] = ACTION_TAP_DANCE_DOUBLE(KC_RBRC, KC_RCBR), // Right bracket on a single-tap, right brace on a double-tap diff --git a/keyboards/keebio/rorschach/keymaps/tuesdayjohn/keymap.c b/keyboards/keebio/rorschach/keymaps/tuesdayjohn/keymap.c index 38d523a34c..db5677e3b6 100644 --- a/keyboards/keebio/rorschach/keymaps/tuesdayjohn/keymap.c +++ b/keyboards/keebio/rorschach/keymaps/tuesdayjohn/keymap.c @@ -34,20 +34,20 @@ enum { PSPA }; -void dance_LAYER_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_on(_ADJUST2); set_oneshot_layer(_ADJUST2, ONESHOT_START); } } -void dance_LAYER_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_off(_ADJUST2); clear_oneshot_layer_state(ONESHOT_PRESSED); } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ADJ] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_LAYER_finished, dance_LAYER_reset), // Double-tap to activate Adjust layer via oneshot layer [LBCB] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_LCBR), // Left bracket on a single-tap, left brace on a double-tap [RBCB] = ACTION_TAP_DANCE_DOUBLE(KC_RBRC, KC_RCBR), // Right bracket on a single-tap, right brace on a double-tap diff --git a/keyboards/keebio/sinc/rev3/config.h b/keyboards/keebio/sinc/rev3/config.h index 14ce6d29f1..9b27501d3c 100644 --- a/keyboards/keebio/sinc/rev3/config.h +++ b/keyboards/keebio/sinc/rev3/config.h @@ -23,7 +23,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define SERIAL_USART_PIN_SWAP #define RP2040_BOOTLOADER_DOUBLE_TAP_RESET #define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 1000U -#define I2C_DRIVER I2CD2 +#define I2C_DRIVER I2CD1 #define I2C1_SCL_PIN GP22 #define I2C1_SDA_PIN GP23 diff --git a/keyboards/keyboardio/atreus/keymaps/kkokdae/keymap.c b/keyboards/keyboardio/atreus/keymaps/kkokdae/keymap.c index b61b937984..5ff5c87dac 100644 --- a/keyboards/keyboardio/atreus/keymaps/kkokdae/keymap.c +++ b/keyboards/keyboardio/atreus/keymaps/kkokdae/keymap.c @@ -92,7 +92,7 @@ bool get_custom_auto_shifted_key(uint16_t keycode, keyrecord_t *record) { } } -void dance_hex(qk_tap_dance_state_t *state, void *user_data) { +void dance_hex(tap_dance_state_t *state, void *user_data) { switch(state->count) { case 1: SEND_STRING("0x"); @@ -103,7 +103,7 @@ void dance_hex(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_lang(qk_tap_dance_state_t *state, void *user_data) { +void dance_lang(tap_dance_state_t *state, void *user_data) { uint32_t default_layer; switch(state->count) { case 1: @@ -121,7 +121,7 @@ void dance_lang(qk_tap_dance_state_t *state, void *user_data) { } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TdH] = ACTION_TAP_DANCE_FN(dance_hex), [TdL] = ACTION_TAP_DANCE_FN(dance_lang) }; diff --git a/keyboards/keyboardio/atreus/keymaps/replicaJunction/config.h b/keyboards/keyboardio/atreus/keymaps/replicaJunction/config.h deleted file mode 100644 index a02f9a95db..0000000000 --- a/keyboards/keyboardio/atreus/keymaps/replicaJunction/config.h +++ /dev/null @@ -1,51 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once - -// Do not allow one macro to contain the other macro -#define DYNAMIC_MACRO_NO_NESTING - -// "THE most important tap hold configuration setting" -// https://precondition.github.io/home-row-mods#ignore-mod-tap-interrupt -// https://docs.qmk.fm/#/tap_hold?id=ignore-mod-tap-interrupt -#define IGNORE_MOD_TAP_INTERRUPT - -// This one is a style choice. Play with it both on and off to see which -// one suits you better. -// https://precondition.github.io/home-row-mods#permissive-hold -// https://docs.qmk.fm/#/tap_hold?id=permissive-hold -#define PERMISSIVE_HOLD - -// If you press a dual-role key for longer than TAPPING_TERM, then -// release it without pressing another key, without this setting nothing -// would happen. With this setting, it sends the key's tap function. -// https://precondition.github.io/home-row-mods#retro-tapping -#define RETRO_TAPPING - -// Disable some unused features to save space -#undef LOCKING_SUPPORT_ENABLE -#undef LOCKING_RESYNC_ENABLE - -///// -// Flags for stuff in my userspace - -#define USER_INCLUDE_GAMING_LAYER -#define USER_INCLUDE_MACRO_LAYER - -// "Super Alt-Tab" -// https://docs.qmk.fm/#/feature_macros?id=super-alt%E2%86%AFtab -#define USER_SUPER_ALT_TAB_TIMEOUT 500 diff --git a/keyboards/keyboardio/atreus/keymaps/replicaJunction/keymap.c b/keyboards/keyboardio/atreus/keymaps/replicaJunction/keymap.c deleted file mode 100644 index 5607f8d0d9..0000000000 --- a/keyboards/keyboardio/atreus/keymaps/replicaJunction/keymap.c +++ /dev/null @@ -1,94 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include QMK_KEYBOARD_H -#include "replicaJunction.h" - -#define BSP_SYM LT(L_SYMBOLS, KC_BSPC) -#define SPC_NAV LT(L_NAVIGATION, KC_SPC) -#define EQL_FUN LT(L_FN, KC_EQL) - -#define ESC_SFT LSFT_T(KC_ESC) -#define TAB_SFT RSFT_T(KC_TAB) - -#define DF_TYPE DF(L_BASE) -#define DF_GAME DF(L_GAMING) - -const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - -[L_BASE] = LAYOUT( - KC_Q, KC_W, KC_F, KC_P, KC_B, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, - KC_A, KC_R, KC_S, KC_T, KC_G, KC_M, KC_N, KC_E, KC_I, KC_O, - KC_Z, KC_X, KC_C, KC_D, KC_V, SALTTAB,KC_BSLS,KC_K, KC_H, KC_COMM,KC_DOT, KC_SLSH, - KC_ESC, KC_LGUI,KC_TAB, ESC_SFT,BSP_SYM,CTL_DEL,ALT_ENT,SPC_NAV,TAB_SFT,KC_MINS,KC_QUOT,EQL_FUN -), - -[L_GAMING] = LAYOUT( - _______,_______,_______,_______,_______, _______,_______,_______,_______,_______, - _______,_______,_______,_______,_______, _______,_______,_______,_______,_______, - _______,_______,KC_C, KC_D, _______,_______,QK_LOCK,_______,_______,_______,_______,_______, - _______,KC_TAB, KC_LALT,KC_LSFT,KC_SPC, KC_LCTL,KC_LALT,KC_BSPC,KC_BTN1,KC_BTN2,KC_BTN3,_______ -), - -[L_NUMBERS] = LAYOUT( - _______,_______,_______,_______,_______, KC_HASH,KC_7, KC_8, KC_9, KC_SLSH, - _______,_______,_______,_______,_______, KC_PLUS,KC_4, KC_5, KC_6, KC_ASTR, - _______,_______,_______,_______,_______,_______,_______,KC_MINS,KC_1, KC_2, KC_3, KC_BSLS, - _______,_______,_______,_______,_______,_______,_______,_______,KC_0, KC_0, KC_DOT, KC_ENT -), - -[L_SYMBOLS] = LAYOUT( - KC_AT, KC_LT, KC_DLR, KC_GT, XXXXXXX, XXXXXXX,KC_LBRC,KC_UNDS,KC_RBRC,XXXXXXX, - KC_BSLS,KC_LPRN,KC_DQUO,KC_RPRN,KC_HASH, KC_PERC,KC_LCBR,KC_EQL, KC_RCBR,KC_PIPE, - KC_EXLM,KC_COLN,KC_ASTR,KC_PLUS,XXXXXXX,_______,_______,XXXXXXX,KC_AMPR,KC_CIRC,KC_TILD,KC_GRV, - _______,_______,_______,_______,ooooooo,_______,_______,ooooooo,CAPWORD,_______,_______,_______ -), - -[L_NAVIGATION] = LAYOUT( - OS_UNDO,OS_CUT, OS_PAST,OS_COPY,OS_SALL, KC_PGUP,KC_HOME,KC_UP, KC_END, KC_DEL, - KC_LGUI,KC_LALT,KC_LSFT,KC_LCTL,_______, KC_PGDN,KC_LEFT,KC_DOWN,KC_RGHT,KC_BSPC, - WIN_V, _______,_______,OS_FIND,SEARCH, _______,_______,_______,SFT_TAB,KC_TAB, KC_APP, KC_PSCR, - _______,_______,_______,NUMWORD,ooooooo,_______,_______,ooooooo,_______,_______,_______,_______ -), - -[L_FN] = LAYOUT( - _______,_______,_______,_______,_______, KC_VOLU,KC_F9, KC_F10, KC_F11, KC_F12, - _______,_______,_______,_______,_______, KC_MUTE,KC_F5, KC_F6, KC_F7, KC_F8, - _______,K_SECR1,K_SECR2,K_SECR3,K_SECR4,MS_JIGL,QK_BOOT, KC_VOLD,KC_F1, KC_F2, KC_F3, KC_F4, - DF_TYPE,DF_GAME,_______,_______,_______,KC_LCTL,KC_LALT,_______,_______,_______,_______,ooooooo -), - -[L_MACROS] = LAYOUT( - QK_MAKE,_______,DM_REC2,DM_REC1,DM_RSTP, _______,SHEBANG,_______,_______,_______, - QK_FLSH,_______,DM_PLY2,DM_PLY1,_______, PRG_NE, PRG_EQ, PRG_GEQ,PRG_LEQ,PRG_ARR, - QK_VERS,_______,_______,_______,_______,_______,_______,_______,PS_ITEM,FS_PIPE,_______,FS_ARR, - _______,_______,_______,_______,ooooooo,_______,_______,ooooooo,_______,_______,_______,_______ -) - - -// Template -// [L_FUNC] = LAYOUT( -// _______,_______,_______,_______,_______, _______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______, _______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______ -// ), - -}; - -layer_state_t layer_state_set_user(layer_state_t state) { - return update_tri_layer_state(state, L_SYMBOLS, L_NAVIGATION, L_MACROS); -} diff --git a/keyboards/keyboardio/atreus/keymaps/replicaJunction/readme.md b/keyboards/keyboardio/atreus/keymaps/replicaJunction/readme.md deleted file mode 100644 index 88f948a94f..0000000000 --- a/keyboards/keyboardio/atreus/keymaps/replicaJunction/readme.md +++ /dev/null @@ -1,6 +0,0 @@ -replicaJunction - Keyboardio Atreus -=================================== - -A 44-key layout designed for daily programming usage and occasional, light gaming. - -Most of the interesting logic in this is defined and described in [my userspace](../../../../../users/replicaJunction/readme.md), so check that out if you're interested in how things work. The CAPSWORD and NUMWORD features are especially important for a keyboard this size. diff --git a/keyboards/keyboardio/atreus/keymaps/replicaJunction/rules.mk b/keyboards/keyboardio/atreus/keymaps/replicaJunction/rules.mk deleted file mode 100644 index 7e0b3c9cac..0000000000 --- a/keyboards/keyboardio/atreus/keymaps/replicaJunction/rules.mk +++ /dev/null @@ -1,29 +0,0 @@ -# Userspace options -USER_CAPS_WORD_ENABLE = yes -USER_MOUSE_JIGGLE_ENABLE = yes -USER_NUM_WORD_ENABLE = yes -USER_SECRETS_ENABLE = yes -USER_SUPER_ALT_TAB_ENABLE = yes - -DYNAMIC_MACRO_ENABLE = yes - -# Extra features that are nice but takes space. Enable only if they're -# used in the layout. -WPM_ENABLE = no -# EXTRAKEY_ENABLE = no # For volume keys and similar -# MOUSEKEY_ENABLE = no # Them mouse keys yo -KEY_OVERRIDE_ENABLE = no -LEADER_ENABLE = no -TAP_DANCE_ENABLE = no -# RGBLIGHT_ENABLE = no # Keyboard RGB underglow -RGB_MATRIX_ENABLE = no - -# Features I definitely don't care aboud -LTO_ENABLE = yes -CONSOLE_ENABLE = no -VERBOSE = no -DEBUG_MATRIX_SCAN_RATE = no -DEBUG_MATRIX = no -MAGIC_ENABLE = no -SPACE_CADET_ENABLE = no -GRAVE_ESC_ENABLE = no diff --git a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_mac_caps.c b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_mac_caps.c index d979820923..dfb0346ff1 100644 --- a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_mac_caps.c +++ b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_mac_caps.c @@ -19,7 +19,7 @@ static td_tap_t mac_caps_language_tap_state = {.is_press_action = true, .state = TD_NONE}; -void mac_caps_language_finished(qk_tap_dance_state_t *state, void *user_data) { +void mac_caps_language_finished(tap_dance_state_t *state, void *user_data) { mac_caps_language_tap_state.state = current_dance(state); switch (mac_caps_language_tap_state.state) { case TD_SINGLE_TAP: @@ -34,7 +34,7 @@ void mac_caps_language_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void mac_caps_language_reset(qk_tap_dance_state_t *state, void *user_data) { +void mac_caps_language_reset(tap_dance_state_t *state, void *user_data) { switch (mac_caps_language_tap_state.state) { case TD_SINGLE_TAP: unregister_code(KC_SPACE); diff --git a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_mac_caps.h b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_mac_caps.h index a5f07a58a1..ef552a2c2c 100644 --- a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_mac_caps.h +++ b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_mac_caps.h @@ -19,5 +19,5 @@ #include "tap_dance_setup.h" -void mac_caps_language_finished(qk_tap_dance_state_t *state, void *user_data); -void mac_caps_language_reset(qk_tap_dance_state_t *state, void *user_data); +void mac_caps_language_finished(tap_dance_state_t *state, void *user_data); +void mac_caps_language_reset(tap_dance_state_t *state, void *user_data); diff --git a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_setup.c b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_setup.c index 6d879419bc..07257e556a 100644 --- a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_setup.c +++ b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_setup.c @@ -15,7 +15,7 @@ */ #include "tap_dance_setup.h" -td_state_t current_dance(qk_tap_dance_state_t *state) { +td_state_t current_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return TD_SINGLE_TAP; /* Key has not been interrupted, but the key is still held. Means you w ant to send a 'HOLD'. */ diff --git a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_setup.h b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_setup.h index 05160c77f5..5d2f4acd57 100644 --- a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_setup.h +++ b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_setup.h @@ -35,4 +35,4 @@ typedef struct { td_state_t state; } td_tap_t; -td_state_t current_dance(qk_tap_dance_state_t *state); +td_state_t current_dance(tap_dance_state_t *state); diff --git a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_user.c b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_user.c index 1e9542d5ee..ed8120572e 100644 --- a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_user.c +++ b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_user.c @@ -20,7 +20,7 @@ // clang-format off -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [MAC_CAPS_LANGUAGE_CHANGE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, mac_caps_language_finished, mac_caps_language_reset), [WIN_CAPS_LANGUAGE_CHANGE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, win_caps_language_finished, win_caps_language_reset) }; diff --git a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_win_caps.c b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_win_caps.c index fea72c5663..1c7c438d2e 100644 --- a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_win_caps.c +++ b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_win_caps.c @@ -19,7 +19,7 @@ static td_tap_t win_caps_language_tap_state = {.is_press_action = true, .state = TD_NONE}; -void win_caps_language_finished(qk_tap_dance_state_t *state, void *user_data) { +void win_caps_language_finished(tap_dance_state_t *state, void *user_data) { win_caps_language_tap_state.state = current_dance(state); switch (win_caps_language_tap_state.state) { case TD_SINGLE_TAP: @@ -34,7 +34,7 @@ void win_caps_language_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void win_caps_language_reset(qk_tap_dance_state_t *state, void *user_data) { +void win_caps_language_reset(tap_dance_state_t *state, void *user_data) { switch (win_caps_language_tap_state.state) { case TD_SINGLE_TAP: unregister_code(KC_SPACE); diff --git a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_win_caps.h b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_win_caps.h index 34b734ec89..2289cce326 100644 --- a/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_win_caps.h +++ b/keyboards/keychron/q1/ansi/keymaps/teimor/tap_dance_win_caps.h @@ -19,5 +19,5 @@ #include "tap_dance_setup.h" -void win_caps_language_finished(qk_tap_dance_state_t *state, void *user_data); -void win_caps_language_reset(qk_tap_dance_state_t *state, void *user_data); +void win_caps_language_finished(tap_dance_state_t *state, void *user_data); +void win_caps_language_reset(tap_dance_state_t *state, void *user_data); diff --git a/keyboards/keyhive/navi10/keymaps/default/keymap.c b/keyboards/keyhive/navi10/keymaps/default/keymap.c index 248e4d50ce..bbf51f56ff 100644 --- a/keyboards/keyhive/navi10/keymaps/default/keymap.c +++ b/keyboards/keyhive/navi10/keymaps/default/keymap.c @@ -33,11 +33,11 @@ enum { }; //function to handle all the tap dances -int cur_dance(qk_tap_dance_state_t *state); +int cur_dance(tap_dance_state_t *state); //functions for each tap dance -void tk_finished(qk_tap_dance_state_t *state, void *user_data); -void tk_reset(qk_tap_dance_state_t *state, void *user_data); +void tk_finished(tap_dance_state_t *state, void *user_data); +void tk_reset(tap_dance_state_t *state, void *user_data); #define INDICATOR_LED B5 @@ -66,7 +66,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; //determine the current tap dance state -int cur_dance (qk_tap_dance_state_t *state){ +int cur_dance (tap_dance_state_t *state){ if(state->count == 1){ //if a tap was registered if(!state->pressed){ @@ -88,7 +88,7 @@ static tap tk_tap_state = { }; //functions that control what our tap dance key does -void tk_finished(qk_tap_dance_state_t *state, void *user_data){ +void tk_finished(tap_dance_state_t *state, void *user_data){ tk_tap_state.state = cur_dance(state); switch(tk_tap_state.state){ case SINGLE_TAP: @@ -116,7 +116,7 @@ void tk_finished(qk_tap_dance_state_t *state, void *user_data){ } } -void tk_reset(qk_tap_dance_state_t *state, void *user_data){ +void tk_reset(tap_dance_state_t *state, void *user_data){ //if held and released, leave the layer if(tk_tap_state.state == SINGLE_HOLD){ layer_off(_FN0); @@ -126,6 +126,6 @@ void tk_reset(qk_tap_dance_state_t *state, void *user_data){ } //associate the tap dance key with its functionality -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TAPPY_KEY] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tk_finished, tk_reset) }; diff --git a/keyboards/keyhive/navi10/keymaps/devdev/keymap.c b/keyboards/keyhive/navi10/keymaps/devdev/keymap.c index 0fc20cbbd4..36a76c50ce 100644 --- a/keyboards/keyhive/navi10/keymaps/devdev/keymap.c +++ b/keyboards/keyhive/navi10/keymaps/devdev/keymap.c @@ -67,11 +67,11 @@ enum custom_keycodes { // git macros }; //function to handle all the tap dances -int cur_dance(qk_tap_dance_state_t *state); +int cur_dance(tap_dance_state_t *state); //functions for each tap dance -void tk_finished(qk_tap_dance_state_t *state, void *user_data); -void tk_reset(qk_tap_dance_state_t *state, void *user_data); +void tk_finished(tap_dance_state_t *state, void *user_data); +void tk_reset(tap_dance_state_t *state, void *user_data); // define the macros in here bool process_record_user(uint16_t keycode, keyrecord_t *record) { @@ -167,7 +167,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; //determine the current tap dance state -int cur_dance (qk_tap_dance_state_t *state){ +int cur_dance (tap_dance_state_t *state){ if(state->count == 1) { //if a tap was registered @@ -203,7 +203,7 @@ static tap tk_tap_state = { }; //functions that control what our tap dance key does -void tk_finished(qk_tap_dance_state_t *state, void *user_data){ +void tk_finished(tap_dance_state_t *state, void *user_data){ tk_tap_state.state = cur_dance(state); uint8_t val = rgblight_get_val(); switch(tk_tap_state.state){ @@ -246,7 +246,7 @@ void tk_finished(qk_tap_dance_state_t *state, void *user_data){ } } -void tk_reset(qk_tap_dance_state_t *state, void *user_data){ +void tk_reset(tap_dance_state_t *state, void *user_data){ //if held and released, leave the layer if(tk_tap_state.state == SINGLE_HOLD){ layer_off(_GI4); @@ -258,6 +258,6 @@ void tk_reset(qk_tap_dance_state_t *state, void *user_data){ } //associate the tap dance key with its functionality -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TAPPY_KEY] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tk_finished, tk_reset) }; diff --git a/keyboards/keyhive/navi10/keymaps/emdarcher/keymap.c b/keyboards/keyhive/navi10/keymaps/emdarcher/keymap.c index 11ac082392..4e15dc3c46 100644 --- a/keyboards/keyhive/navi10/keymaps/emdarcher/keymap.c +++ b/keyboards/keyhive/navi10/keymaps/emdarcher/keymap.c @@ -34,11 +34,11 @@ enum { }; //function to handle all the tap dances -int cur_dance(qk_tap_dance_state_t *state); +int cur_dance(tap_dance_state_t *state); //functions for each tap dance -void tk_finished(qk_tap_dance_state_t *state, void *user_data); -void tk_reset(qk_tap_dance_state_t *state, void *user_data); +void tk_finished(tap_dance_state_t *state, void *user_data); +void tk_reset(tap_dance_state_t *state, void *user_data); #define INDICATOR_LED B5 #define TX_LED D5 @@ -85,7 +85,7 @@ void matrix_init_user(void) { } //determine the current tap dance state -int cur_dance (qk_tap_dance_state_t *state){ +int cur_dance (tap_dance_state_t *state){ if(state->count == 1){ //if a tap was registered if(!state->pressed){ @@ -114,7 +114,7 @@ static tap tk_tap_state = { }; //functions that control what our tap dance key does -void tk_finished(qk_tap_dance_state_t *state, void *user_data){ +void tk_finished(tap_dance_state_t *state, void *user_data){ tk_tap_state.state = cur_dance(state); switch(tk_tap_state.state){ case SINGLE_TAP: @@ -166,7 +166,7 @@ void tk_finished(qk_tap_dance_state_t *state, void *user_data){ } } -void tk_reset(qk_tap_dance_state_t *state, void *user_data){ +void tk_reset(tap_dance_state_t *state, void *user_data){ //if held and released, leave the layer if(tk_tap_state.state == SINGLE_HOLD){ layer_off(_FN0); @@ -177,6 +177,6 @@ void tk_reset(qk_tap_dance_state_t *state, void *user_data){ //associate the tap dance key with its functionality -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TAPPY_KEY] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tk_finished, tk_reset) }; diff --git a/keyboards/keyhive/opus/keymaps/thefoxcodes/keymap.c b/keyboards/keyhive/opus/keymaps/thefoxcodes/keymap.c index 6671cb43f8..28eda8e6b6 100644 --- a/keyboards/keyhive/opus/keymaps/thefoxcodes/keymap.c +++ b/keyboards/keyhive/opus/keymaps/thefoxcodes/keymap.c @@ -89,6 +89,6 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { ), }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_PLAY_DO_NOT_DISTURB] = ACTION_TAP_DANCE_DOUBLE(KC_MPLY, KC_F6) };
\ No newline at end of file diff --git a/keyboards/keyhive/ut472/keymaps/stefanopace/keymap.c b/keyboards/keyhive/ut472/keymaps/stefanopace/keymap.c index fbaf592d22..9d1780b161 100644 --- a/keyboards/keyhive/ut472/keymaps/stefanopace/keymap.c +++ b/keyboards/keyhive/ut472/keymaps/stefanopace/keymap.c @@ -30,7 +30,7 @@ enum tapdance { TD_APP_CAPS_LOCK, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SINGLE_QUOTE_DOUBLE_QUOTES] = ACTION_TAP_DANCE_DOUBLE(KC_QUOT, KC_DQUO), [TD_APP_CAPS_LOCK] = ACTION_TAP_DANCE_DOUBLE(KC_APP, KC_CAPS), }; diff --git a/keyboards/kinesis/keymaps/farmergreg/keymap.c b/keyboards/kinesis/keymaps/farmergreg/keymap.c index 393b7c074b..554f6f8f58 100644 --- a/keyboards/kinesis/keymaps/farmergreg/keymap.c +++ b/keyboards/kinesis/keymaps/farmergreg/keymap.c @@ -45,7 +45,7 @@ enum tap_dances { TD_CAPS, // ESC on tap, CAPS on double tap }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS), }; diff --git a/keyboards/kinesis/keymaps/insertsnideremarks/keymap.c b/keyboards/kinesis/keymaps/insertsnideremarks/keymap.c index 0888f3f8cd..04fa8d39bc 100644 --- a/keyboards/kinesis/keymaps/insertsnideremarks/keymap.c +++ b/keyboards/kinesis/keymaps/insertsnideremarks/keymap.c @@ -47,20 +47,20 @@ enum { PSLPAS }; -void dance_LAYER_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_on(_ADJUST2); set_oneshot_layer(_ADJUST2, ONESHOT_START); } } -void dance_LAYER_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_off(_ADJUST2); clear_oneshot_layer_state(ONESHOT_PRESSED); } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ADJ] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_LAYER_finished, dance_LAYER_reset), // Double-tap to activate Adjust layer via oneshot layer [LBCB] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_LCBR), // Left bracket on a single-tap, left brace on a double-tap [RBCB] = ACTION_TAP_DANCE_DOUBLE(KC_RBRC, KC_RCBR), // Right bracket on a single-tap, right brace on a double-tap diff --git a/keyboards/kinesis/keymaps/tuesdayjohn/keymap.c b/keyboards/kinesis/keymaps/tuesdayjohn/keymap.c index 5fdbbcd902..6a7a6cc68e 100644 --- a/keyboards/kinesis/keymaps/tuesdayjohn/keymap.c +++ b/keyboards/kinesis/keymaps/tuesdayjohn/keymap.c @@ -36,20 +36,20 @@ enum { PSPA }; -void dance_LAYER_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_on(_ADJUST2); set_oneshot_layer(_ADJUST2, ONESHOT_START); } } -void dance_LAYER_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_LAYER_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { layer_off(_ADJUST2); clear_oneshot_layer_state(ONESHOT_PRESSED); } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ADJ] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_LAYER_finished, dance_LAYER_reset), // Double-tap to activate Adjust layer via oneshot layer [LBCB] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_LCBR), // Left bracket on a single-tap, left brace on a double-tap [RBCB] = ACTION_TAP_DANCE_DOUBLE(KC_RBRC, KC_RCBR), // Right bracket on a single-tap, right brace on a double-tap diff --git a/keyboards/kingly_keys/ave/ortho/keymaps/default/keymap.c b/keyboards/kingly_keys/ave/ortho/keymaps/default/keymap.c index 8fe6dedcbd..c8dbb6c18d 100644 --- a/keyboards/kingly_keys/ave/ortho/keymaps/default/keymap.c +++ b/keyboards/kingly_keys/ave/ortho/keymaps/default/keymap.c @@ -32,7 +32,7 @@ enum avenue_tapcodes { TD_DBQT, }; -void dance_rst_reset (qk_tap_dance_state_t *state, void *user_data) { // *Line_Note.001 +void dance_rst_reset (tap_dance_state_t *state, void *user_data) { // *Line_Note.001 if (state->count >= 2) { reset_keyboard(); reset_tap_dance(state); @@ -40,7 +40,7 @@ void dance_rst_reset (qk_tap_dance_state_t *state, void *user_data) { // *Line_N } //Tap Dance Functions: -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_RST] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, NULL, dance_rst_reset), // References "dance_rst_reset" (*Line_Note.001) [TD_DBQT] = ACTION_TAP_DANCE_DOUBLE (KC_QUOTE, KC_DQT) }; diff --git a/keyboards/kingly_keys/ave/staggered/keymaps/default/keymap.c b/keyboards/kingly_keys/ave/staggered/keymaps/default/keymap.c index e36839a584..4a56915ae5 100644 --- a/keyboards/kingly_keys/ave/staggered/keymaps/default/keymap.c +++ b/keyboards/kingly_keys/ave/staggered/keymaps/default/keymap.c @@ -32,7 +32,7 @@ enum avenue_tapcodes { TD_DBQT, }; -void dance_rst_reset (qk_tap_dance_state_t *state, void *user_data) { // *Line_Note.001 +void dance_rst_reset (tap_dance_state_t *state, void *user_data) { // *Line_Note.001 if (state->count >= 2) { reset_keyboard(); reset_tap_dance(state); @@ -40,7 +40,7 @@ void dance_rst_reset (qk_tap_dance_state_t *state, void *user_data) { // *Line_N } //Tap Dance Functions: -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_RST] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, NULL, dance_rst_reset), // References "dance_rst_reset" (*Line_Note.001) [TD_DBQT] = ACTION_TAP_DANCE_DOUBLE (KC_QUOTE, KC_DQT) }; diff --git a/keyboards/knops/mini/keymaps/mverteuil/keymap.c b/keyboards/knops/mini/keymaps/mverteuil/keymap.c index 8f28f4c617..45765a7aba 100644 --- a/keyboards/knops/mini/keymaps/mverteuil/keymap.c +++ b/keyboards/knops/mini/keymaps/mverteuil/keymap.c @@ -21,8 +21,8 @@ void led_init_animation(void); void led_set_layer(int layer); -void td_spectacles_finish(qk_tap_dance_state_t *state, void *user_data); -void td_spectacles_reset(qk_tap_dance_state_t *state, void *user_data); +void td_spectacles_finish(tap_dance_state_t *state, void *user_data); +void td_spectacles_reset(tap_dance_state_t *state, void *user_data); enum layer_led_mode { ALL_LAYERS_OFF = -1, @@ -47,7 +47,7 @@ enum mini_layers { enum { TD_SPEC = 0 }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { /* Tap once for spectacles macro, hold for layer toggle */ [TD_SPEC] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_spectacles_finish, td_spectacles_reset), }; @@ -295,7 +295,7 @@ void matrix_init_user(void) { led_init_animation(); } -void td_spectacles_finish(qk_tap_dance_state_t *state, void *user_data) { +void td_spectacles_finish(tap_dance_state_t *state, void *user_data) { if (state->pressed) { layer_on(_LAYER_SELECT); } else { @@ -303,4 +303,4 @@ void td_spectacles_finish(qk_tap_dance_state_t *state, void *user_data) { } } -void td_spectacles_reset(qk_tap_dance_state_t *state, void *user_data) { layer_off(_LAYER_SELECT); } +void td_spectacles_reset(tap_dance_state_t *state, void *user_data) { layer_off(_LAYER_SELECT); } diff --git a/keyboards/kprepublic/bm16a/bm16a.c b/keyboards/kprepublic/bm16a/bm16a.c deleted file mode 100644 index 9676b50119..0000000000 --- a/keyboards/kprepublic/bm16a/bm16a.c +++ /dev/null @@ -1,16 +0,0 @@ -/* Copyright 2019 - * - * 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/>. - */ -#include "bm16a.h" diff --git a/keyboards/kprepublic/bm16a/bm16a.h b/keyboards/kprepublic/bm16a/bm16a.h deleted file mode 100644 index cf8bab4730..0000000000 --- a/keyboards/kprepublic/bm16a/bm16a.h +++ /dev/null @@ -1,39 +0,0 @@ -/* Copyright 2019 - * - * 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/>. - */ -#pragma once - -#include "quantum.h" - -/* This a shortcut to help you visually see your layout. - * - * The first section contains all of the arguments representing the physical - * layout of the board and position of the keys. - * - * The second converts the arguments into a two-dimensional array which - * represents the switch matrix. - */ -#define LAYOUT_ortho_4x4( \ - K01, K02, K03, K04, \ - K11, K12, K13, K14, \ - K21, K22, K23, K24, \ - K31, K32, K33, K34 \ -) \ -{ \ - { K01, K02, K03, K04 }, \ - { K11, K12, K13, K14 }, \ - { K21, K22, K23, K24 }, \ - { K31, K32, K33, K34 } \ -} diff --git a/keyboards/kprepublic/bm16a/config.h b/keyboards/kprepublic/bm16a/config.h deleted file mode 100644 index e5cc440d25..0000000000 --- a/keyboards/kprepublic/bm16a/config.h +++ /dev/null @@ -1,128 +0,0 @@ -/* Copyright 2019 - * - * 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/>. - */ - -#pragma once - -#include "config_common.h" - -/* key matrix size */ -#define MATRIX_ROWS 4 -#define MATRIX_COLS 4 - -/* - * Keyboard Matrix Assignments - * - * Change this to how you wired your keyboard - * COLS: AVR pins used for columns, left to right - * ROWS: AVR pins used for rows, top to bottom - * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode) - * ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode) - * -*/ -#define MATRIX_ROW_PINS { D3, D5, D1, D2} -#define MATRIX_COL_PINS { D6, D4, D7, B4} - -/* COL2ROW, ROW2COL*/ -#define DIODE_DIRECTION COL2ROW - -/* - * Split Keyboard specific options, make sure you have 'SPLIT_KEYBOARD = yes' in your rules.mk, and define SOFT_SERIAL_PIN. - */ -//#define SOFT_SERIAL_PIN D0 // or D1, D2, D3, E6 - -#define BACKLIGHT_PIN B6 -// #define BACKLIGHT_BREATHING -#define BACKLIGHT_LEVELS 5 - -#define RGB_DI_PIN E2 -#define RGBLED_NUM 4 -#define RGBLIGHT_EFFECT_BREATHING -#define RGBLIGHT_EFFECT_RAINBOW_MOOD -#define RGBLIGHT_EFFECT_RAINBOW_SWIRL -#define RGBLIGHT_EFFECT_SNAKE -#define RGBLIGHT_EFFECT_KNIGHT -#define RGBLIGHT_EFFECT_CHRISTMAS -#define RGBLIGHT_EFFECT_STATIC_GRADIENT -#define RGBLIGHT_EFFECT_RGB_TEST -#define RGBLIGHT_EFFECT_ALTERNATING -#define RGBLIGHT_EFFECT_TWINKLE -// #ifdef RGB_DI_PIN -// #define RGBLED_NUM 16 -// #define RGBLIGHT_HUE_STEP 8 -// #define RGBLIGHT_SAT_STEP 8 -// #define RGBLIGHT_VAL_STEP 8 -// #define RGBLIGHT_LIMIT_VAL 255 /* The maximum brightness level */ -// #define RGBLIGHT_SLEEP /* If defined, the RGB lighting will be switched off when the host goes to sleep */ -// #endif - -/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */ -#define DEBOUNCE 5 - -/* define if matrix has ghost (lacks anti-ghosting diodes) */ -//#define MATRIX_HAS_GHOST - -/* number of backlight levels */ - -/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ -#define LOCKING_SUPPORT_ENABLE -/* Locking resynchronize hack */ -#define LOCKING_RESYNC_ENABLE - -/* If defined, GRAVE_ESC will always act as ESC when CTRL is held. - * This is userful for the Windows task manager shortcut (ctrl+shift+esc). - */ -// #define GRAVE_ESC_CTRL_OVERRIDE - -/* - * Force NKRO - * - * Force NKRO (nKey Rollover) to be enabled by default, regardless of the saved - * state in the bootmagic EEPROM settings. (Note that NKRO must be enabled in the - * makefile for this to work.) - * - * If forced on, NKRO can be disabled via magic key (default = LShift+RShift+N) - * until the next keyboard reset. - * - * NKRO may prevent your keystrokes from being detected in the BIOS, but it is - * fully operational during normal computer usage. - * - * For a less heavy-handed approach, enable NKRO via magic key (LShift+RShift+N) - * or via bootmagic (hold SPACE+N while plugging in the keyboard). Once set by - * bootmagic, NKRO mode will always be enabled until it is toggled again during a - * power-up. - * - */ -//#define FORCE_NKRO - -/* - * Feature disable options - * These options are also useful to firmware size reduction. - */ - -/* disable debug print */ -//#define NO_DEBUG - -/* disable print */ -//#define NO_PRINT - -/* disable action features */ -//#define NO_ACTION_LAYER -//#define NO_ACTION_TAPPING -//#define NO_ACTION_ONESHOT - -/* Bootmagic Lite key configuration */ -// #define BOOTMAGIC_LITE_ROW 0 -// #define BOOTMAGIC_LITE_COLUMN 0 diff --git a/keyboards/kprepublic/bm16a/info.json b/keyboards/kprepublic/bm16a/info.json deleted file mode 100644 index 6c616e11d1..0000000000 --- a/keyboards/kprepublic/bm16a/info.json +++ /dev/null @@ -1,33 +0,0 @@ -{ - "keyboard_name": "bm16a", - "manufacturer": "KPrepublic", - "url": "", - "maintainer": "qmk", - "usb": { - "vid": "0x4B50", - "pid": "0x016A", - "device_version": "0.0.1" - }, - "layouts": { - "LAYOUT_ortho_4x4": { - "layout": [ - {"x":0, "y":0}, - {"x":1, "y":0}, - {"x":2, "y":0}, - {"x":3, "y":0}, - {"x":0, "y":1}, - {"x":1, "y":1}, - {"x":2, "y":1}, - {"x":3, "y":1}, - {"x":0, "y":2}, - {"x":1, "y":2}, - {"x":2, "y":2}, - {"x":3, "y":2}, - {"x":0, "y":3}, - {"x":1, "y":3}, - {"x":2, "y":3}, - {"x":3, "y":3} - ] - } - } - } diff --git a/keyboards/kprepublic/bm16a/v1/info.json b/keyboards/kprepublic/bm16a/v1/info.json new file mode 100644 index 0000000000..6c700b37b8 --- /dev/null +++ b/keyboards/kprepublic/bm16a/v1/info.json @@ -0,0 +1,75 @@ +{ + "keyboard_name": "bm16a", + "manufacturer": "KPrepublic", + "url": "", + "maintainer": "qmk", + "usb": { + "vid": "0x4B50", + "pid": "0x016A", + "device_version": "0.0.1" + }, + "processor": "atmega32u4", + "bootloader": "atmel-dfu", + "features": { + "bootmagic": true, + "mousekey": true, + "extrakey": true, + "console": false, + "command": false, + "nkro": true, + "backlight": true, + "rgblight": true, + "audio": false + }, + "matrix_pins": { + "rows": ["D3", "D5", "D1", "D2"], + "cols": ["D6", "D4", "D7", "B4"] + }, + "diode_direction": "COL2ROW", + "backlight": { + "pin": "B6", + "levels": 5 + }, + "rgblight": { + "pin": "E2", + "led_count": 4, + "animations": { + "breathing": true, + "rainbow_mood": true, + "rainbow_swirl": true, + "snake": true, + "knight": true, + "christmas": true, + "static_gradient": true, + "rgb_test": true, + "alternating": true, + "twinkle": true + } + }, + "community_layouts": ["ortho_4x4"], + "layouts": { + "LAYOUT_ortho_4x4": { + "layout": [ + {"matrix": [0, 0], "x": 0, "y": 0}, + {"matrix": [0, 1], "x": 1, "y": 0}, + {"matrix": [0, 2], "x": 2, "y": 0}, + {"matrix": [0, 3], "x": 3, "y": 0}, + + {"matrix": [1, 0], "x": 0, "y": 1}, + {"matrix": [1, 1], "x": 1, "y": 1}, + {"matrix": [1, 2], "x": 2, "y": 1}, + {"matrix": [1, 3], "x": 3, "y": 1}, + + {"matrix": [2, 0], "x": 0, "y": 2}, + {"matrix": [2, 1], "x": 1, "y": 2}, + {"matrix": [2, 2], "x": 2, "y": 2}, + {"matrix": [2, 3], "x": 3, "y": 2}, + + {"matrix": [3, 0], "x": 0, "y": 3}, + {"matrix": [3, 1], "x": 1, "y": 3}, + {"matrix": [3, 2], "x": 2, "y": 3}, + {"matrix": [3, 3], "x": 3, "y": 3} + ] + } + } +} diff --git a/keyboards/kprepublic/bm16a/keymaps/default/keymap.c b/keyboards/kprepublic/bm16a/v1/keymaps/default/keymap.c index 0255603d33..0255603d33 100644 --- a/keyboards/kprepublic/bm16a/keymaps/default/keymap.c +++ b/keyboards/kprepublic/bm16a/v1/keymaps/default/keymap.c diff --git a/keyboards/kprepublic/bm16a/keymaps/default/readme.md b/keyboards/kprepublic/bm16a/v1/keymaps/default/readme.md index f356f2cca0..f356f2cca0 100644 --- a/keyboards/kprepublic/bm16a/keymaps/default/readme.md +++ b/keyboards/kprepublic/bm16a/v1/keymaps/default/readme.md diff --git a/keyboards/kprepublic/bm16a/keymaps/factory/keymap.c b/keyboards/kprepublic/bm16a/v1/keymaps/factory/keymap.c index 08f3476266..08f3476266 100644 --- a/keyboards/kprepublic/bm16a/keymaps/factory/keymap.c +++ b/keyboards/kprepublic/bm16a/v1/keymaps/factory/keymap.c diff --git a/keyboards/kprepublic/bm16a/keymaps/factory/readme.md b/keyboards/kprepublic/bm16a/v1/keymaps/factory/readme.md index 11c952366e..11c952366e 100644 --- a/keyboards/kprepublic/bm16a/keymaps/factory/readme.md +++ b/keyboards/kprepublic/bm16a/v1/keymaps/factory/readme.md diff --git a/keyboards/kprepublic/bm16a/keymaps/via/keymap.c b/keyboards/kprepublic/bm16a/v1/keymaps/via/keymap.c index 8b41b08dfe..8b41b08dfe 100644 --- a/keyboards/kprepublic/bm16a/keymaps/via/keymap.c +++ b/keyboards/kprepublic/bm16a/v1/keymaps/via/keymap.c diff --git a/keyboards/kprepublic/bm16a/keymaps/via/readme.md b/keyboards/kprepublic/bm16a/v1/keymaps/via/readme.md index b381108759..b381108759 100644 --- a/keyboards/kprepublic/bm16a/keymaps/via/readme.md +++ b/keyboards/kprepublic/bm16a/v1/keymaps/via/readme.md diff --git a/keyboards/kprepublic/bm16a/keymaps/via/rules.mk b/keyboards/kprepublic/bm16a/v1/keymaps/via/rules.mk index 36b7ba9cbc..36b7ba9cbc 100644 --- a/keyboards/kprepublic/bm16a/keymaps/via/rules.mk +++ b/keyboards/kprepublic/bm16a/v1/keymaps/via/rules.mk diff --git a/keyboards/kprepublic/bm16a/readme.md b/keyboards/kprepublic/bm16a/v1/readme.md index b1c111b74b..d24a879505 100644 --- a/keyboards/kprepublic/bm16a/readme.md +++ b/keyboards/kprepublic/bm16a/v1/readme.md @@ -10,6 +10,6 @@ A 16 key macropad, with USB C, RGB underglow and backlight. Make example for this keyboard (after setting up your build environment): - make kprepublic/bm16a:default + make kprepublic/bm16a/v1:default See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/kprepublic/bm16a/v1/rules.mk b/keyboards/kprepublic/bm16a/v1/rules.mk new file mode 100644 index 0000000000..6e7633bfe0 --- /dev/null +++ b/keyboards/kprepublic/bm16a/v1/rules.mk @@ -0,0 +1 @@ +# This file intentionally left blank diff --git a/keyboards/kprepublic/bm16a/v2/config.h b/keyboards/kprepublic/bm16a/v2/config.h new file mode 100644 index 0000000000..f4ac9e7a3b --- /dev/null +++ b/keyboards/kprepublic/bm16a/v2/config.h @@ -0,0 +1,12 @@ +// Copyright 2022 fauxpark (@fauxpark) +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#define RGB_DI_PIN B9 +#define RGB_MATRIX_LED_COUNT 16 + +#define WS2812_PWM_DRIVER PWMD4 +#define WS2812_PWM_CHANNEL 4 +#define WS2812_DMA_STREAM STM32_DMA1_STREAM7 +#define WS2812_DMA_CHANNEL 7 diff --git a/keyboards/kprepublic/bm16a/v2/halconf.h b/keyboards/kprepublic/bm16a/v2/halconf.h new file mode 100644 index 0000000000..da579a54a5 --- /dev/null +++ b/keyboards/kprepublic/bm16a/v2/halconf.h @@ -0,0 +1,8 @@ +// Copyright 2022 fauxpark (@fauxpark) +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#define HAL_USE_PWM TRUE + +#include_next <halconf.h> diff --git a/keyboards/kprepublic/bm16a/v2/info.json b/keyboards/kprepublic/bm16a/v2/info.json new file mode 100644 index 0000000000..39b7ef6758 --- /dev/null +++ b/keyboards/kprepublic/bm16a/v2/info.json @@ -0,0 +1,120 @@ +{ + "manufacturer": "kprepublic", + "keyboard_name": "BM16v2", + "maintainer": "qmk", + "bootloader": "stm32duino", + "diode_direction": "COL2ROW", + "features": { + "bootmagic": true, + "command": false, + "console": false, + "extrakey": true, + "mousekey": true, + "nkro": true, + "rgb_matrix": true + }, + "matrix_pins": { + "cols": ["B1", "A3", "B0", "B4"], + "rows": ["A8", "A9", "B5", "B3"] + }, + "processor": "STM32F103", // GD32F303CCT6 + "url": "", + "usb": { + "device_version": "0.0.2", + "pid": "0x016C", + "vid": "0x4B50" + }, + "layouts": { + "LAYOUT_ortho_4x4": { + "layout": [ + {"matrix": [0, 0], "x": 0, "y": 0}, + {"matrix": [0, 1], "x": 1, "y": 0}, + {"matrix": [0, 2], "x": 2, "y": 0}, + {"matrix": [0, 3], "x": 3, "y": 0}, + + {"matrix": [1, 0], "x": 0, "y": 1}, + {"matrix": [1, 1], "x": 1, "y": 1}, + {"matrix": [1, 2], "x": 2, "y": 1}, + {"matrix": [1, 3], "x": 3, "y": 1}, + + {"matrix": [2, 0], "x": 0, "y": 2}, + {"matrix": [2, 1], "x": 1, "y": 2}, + {"matrix": [2, 2], "x": 2, "y": 2}, + {"matrix": [2, 3], "x": 3, "y": 2}, + + {"matrix": [3, 0], "x": 0, "y": 3}, + {"matrix": [3, 1], "x": 1, "y": 3}, + {"matrix": [3, 2], "x": 2, "y": 3}, + {"matrix": [3, 3], "x": 3, "y": 3} + ] + } + }, + "community_layouts": ["ortho_4x4"], + "rgb_matrix": { + "driver": "WS2812", + "animations": { + "alphas_mods": true, + "gradient_up_down": true, + "gradient_left_right": true, + "breathing": true, + "band_sat": true, + "band_val": true, + "band_pinwheel_sat": true, + "band_pinwheel_val": true, + "band_spiral_sat": true, + "band_spiral_val": true, + "cycle_all": true, + "cycle_left_right": true, + "cycle_up_down": true, + "cycle_out_in": true, + "cycle_out_in_dual": true, + "rainbow_moving_chevron": true, + "cycle_pinwheel": true, + "cycle_spiral": true, + "dual_beacon": true, + "rainbow_beacon": true, + "rainbow_pinwheels": true, + "raindrops": true, + "jellybean_raindrops": true, + "hue_breathing": true, + "hue_pendulum": true, + "hue_wave": true, + "pixel_fractal": true, + "pixel_flow": true, + "pixel_rain": true, + "solid_reactive_simple": true, + "solid_reactive": true, + "solid_reactive_wide": true, + "solid_reactive_multiwide": true, + "solid_reactive_cross": true, + "solid_reactive_multicross": true, + "solid_reactive_nexus": true, + "solid_reactive_multinexus": true, + "splash": true, + "multisplash": true, + "solid_splash": true, + "solid_multisplash": true + }, + "layout": [ + {"matrix": [0, 0], "x": 0, "y": 0, "flags": 4}, + {"matrix": [0, 1], "x": 75, "y": 0, "flags": 4}, + {"matrix": [0, 2], "x": 149, "y": 0, "flags": 4}, + {"matrix": [0, 3], "x": 224, "y": 0, "flags": 4}, + + {"matrix": [1, 0], "x": 0, "y": 21, "flags": 4}, + {"matrix": [1, 1], "x": 75, "y": 21, "flags": 4}, + {"matrix": [1, 2], "x": 149, "y": 21, "flags": 4}, + {"matrix": [1, 3], "x": 224, "y": 21, "flags": 4}, + + {"matrix": [2, 0], "x": 0, "y": 43, "flags": 4}, + {"matrix": [2, 1], "x": 75, "y": 43, "flags": 4}, + {"matrix": [2, 2], "x": 149, "y": 43, "flags": 4}, + {"matrix": [2, 3], "x": 224, "y": 43, "flags": 4}, + + {"matrix": [3, 0], "x": 0, "y": 64, "flags": 4}, + {"matrix": [3, 1], "x": 75, "y": 64, "flags": 4}, + {"matrix": [3, 2], "x": 149, "y": 64, "flags": 4}, + {"matrix": [3, 3], "x": 224, "y": 64, "flags": 4}, + ] + } +} diff --git a/keyboards/kprepublic/bm16a/v2/keymaps/default/keymap.c b/keyboards/kprepublic/bm16a/v2/keymaps/default/keymap.c new file mode 100644 index 0000000000..0cb2b68fb9 --- /dev/null +++ b/keyboards/kprepublic/bm16a/v2/keymaps/default/keymap.c @@ -0,0 +1,19 @@ +// Copyright 2022 fauxpark (@fauxpark) +// SPDX-License-Identifier: GPL-2.0-or-later + +#include QMK_KEYBOARD_H + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + [0] = LAYOUT_ortho_4x4( + KC_P7, KC_P8, KC_P9, KC_PMNS, + KC_P4, KC_P5, KC_P6, KC_PPLS, + KC_P1, KC_P2, KC_P3, KC_PENT, + KC_P0, KC_PDOT, KC_SPC, MO(1) + ), + [1] = LAYOUT_ortho_4x4( + QK_BOOT, KC_PAST, KC_PSLS, _______, + RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, + RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, + _______, _______, _______, _______ + ) +}; diff --git a/keyboards/kprepublic/bm16a/v2/mcuconf.h b/keyboards/kprepublic/bm16a/v2/mcuconf.h new file mode 100644 index 0000000000..493b83b87c --- /dev/null +++ b/keyboards/kprepublic/bm16a/v2/mcuconf.h @@ -0,0 +1,9 @@ +// Copyright 2022 fauxpark (@fauxpark) +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include_next <mcuconf.h> + +#undef STM32_PWM_USE_TIM4 +#define STM32_PWM_USE_TIM4 TRUE diff --git a/keyboards/kprepublic/bm16a/v2/readme.md b/keyboards/kprepublic/bm16a/v2/readme.md new file mode 100644 index 0000000000..0af553f126 --- /dev/null +++ b/keyboards/kprepublic/bm16a/v2/readme.md @@ -0,0 +1,27 @@ +# BM16A V2 + + + +A 16 key macropad, with USB-C and per-key RGB. + +* Keyboard Maintainer: QMK Community +* Hardware Supported: BM16A PCB (`BM16V2-ARM`) +* Hardware Availability: [KPrepublic](https://kprepublic.com/collections/bm16/products/bm16a-16-keys-custom-mechanical-keyboard-pcb-plate-programmed-numpad-layouts-qmk-firmware-with-rgb-bottom-underglow-alps-mx) + +Make example for this keyboard (after setting up your build environment): + + make kprepublic/bm16v2:default + +Flashing example for this keyboard: + + make kprepublic/bm16a/v2:default:flash + +See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). + +## Bootloader + +Enter the bootloader in 3 ways: + +* **Bootmagic reset**: Hold down the key at (0,0) in the matrix (usually the top left key or Escape) and plug in the keyboard +* **Physical reset button**: Briefly press the button on the back of the PCB - some may have pads you must short instead +* **Keycode in layout**: Press the key mapped to `QK_BOOT` if it is available diff --git a/keyboards/kprepublic/bm16a/v2/rules.mk b/keyboards/kprepublic/bm16a/v2/rules.mk new file mode 100644 index 0000000000..c1285e300c --- /dev/null +++ b/keyboards/kprepublic/bm16a/v2/rules.mk @@ -0,0 +1 @@ +WS2812_DRIVER = pwm diff --git a/keyboards/kprepublic/bm40hsrgb/keymaps/34keys/config.h b/keyboards/kprepublic/bm40hsrgb/keymaps/34keys/config.h index 7618683d10..a6a97d5b76 100644 --- a/keyboards/kprepublic/bm40hsrgb/keymaps/34keys/config.h +++ b/keyboards/kprepublic/bm40hsrgb/keymaps/34keys/config.h @@ -12,7 +12,7 @@ #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // Mouse key speed and acceleration. #undef MOUSEKEY_DELAY diff --git a/keyboards/kprepublic/bm40hsrgb/keymaps/dan/keymap.c b/keyboards/kprepublic/bm40hsrgb/keymaps/dan/keymap.c index b8a9dc1121..54b4652fdf 100644 --- a/keyboards/kprepublic/bm40hsrgb/keymaps/dan/keymap.c +++ b/keyboards/kprepublic/bm40hsrgb/keymaps/dan/keymap.c @@ -48,7 +48,7 @@ enum { TD_PASTE_COPY }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_PAST_PSLS] = ACTION_TAP_DANCE_DOUBLE(KC_PAST, KC_PSLS), [TD_PASTE_COPY] = ACTION_TAP_DANCE_DOUBLE(LCTL(KC_V), LCTL(KC_C)) }; diff --git a/keyboards/kprepublic/bm40hsrgb/keymaps/gabustoledo/config.h b/keyboards/kprepublic/bm40hsrgb/keymaps/gabustoledo/config.h index cbadc54901..9d566d388d 100644 --- a/keyboards/kprepublic/bm40hsrgb/keymaps/gabustoledo/config.h +++ b/keyboards/kprepublic/bm40hsrgb/keymaps/gabustoledo/config.h @@ -23,7 +23,7 @@ #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // Auto Shift #define NO_AUTO_SHIFT_ALPHA diff --git a/keyboards/kprepublic/bm40hsrgb/keymaps/gabustoledo/keymap.c b/keyboards/kprepublic/bm40hsrgb/keymaps/gabustoledo/keymap.c index b911176274..a08fd535d3 100755 --- a/keyboards/kprepublic/bm40hsrgb/keymaps/gabustoledo/keymap.c +++ b/keyboards/kprepublic/bm40hsrgb/keymaps/gabustoledo/keymap.c @@ -21,7 +21,7 @@ enum { TD_MEDIA, TD_SCREEN, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_MEDIA] = ACTION_TAP_DANCE_DOUBLE( KC_MPLY , KC_MNXT ), [TD_SCREEN] = ACTION_TAP_DANCE_DOUBLE( (G(S(KC_S))) , S(C(KC_4)) ), }; diff --git a/keyboards/kprepublic/bm40hsrgb/keymaps/signynt/keymap.c b/keyboards/kprepublic/bm40hsrgb/keymaps/signynt/keymap.c index 413f12621b..5a1d366f56 100644 --- a/keyboards/kprepublic/bm40hsrgb/keymaps/signynt/keymap.c +++ b/keyboards/kprepublic/bm40hsrgb/keymaps/signynt/keymap.c @@ -177,7 +177,7 @@ enum { }; //tap dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_MEDIA] = ACTION_TAP_DANCE_DOUBLE( KC_MPLY , KC_MNXT ), [TD_SCREEN] = ACTION_TAP_DANCE_DOUBLE( (G(S(KC_S))) , S(C(KC_4)) ), }; diff --git a/keyboards/kprepublic/bm40hsrgb/keymaps/signynt_2_loud/keymap.c b/keyboards/kprepublic/bm40hsrgb/keymaps/signynt_2_loud/keymap.c index 2cdf244cdc..f53e061843 100644 --- a/keyboards/kprepublic/bm40hsrgb/keymaps/signynt_2_loud/keymap.c +++ b/keyboards/kprepublic/bm40hsrgb/keymaps/signynt_2_loud/keymap.c @@ -150,7 +150,7 @@ enum { }; //tap dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_MEDIA] = ACTION_TAP_DANCE_DOUBLE( KC_MPLY , KC_MNXT ), [TD_SCREEN] = ACTION_TAP_DANCE_DOUBLE( (G(S(KC_S))) , S(C(KC_4)) ), }; diff --git a/keyboards/kprepublic/bm40hsrgb/keymaps/signynt_2_quiet/keymap.c b/keyboards/kprepublic/bm40hsrgb/keymaps/signynt_2_quiet/keymap.c index 065f65c78a..e958071c20 100644 --- a/keyboards/kprepublic/bm40hsrgb/keymaps/signynt_2_quiet/keymap.c +++ b/keyboards/kprepublic/bm40hsrgb/keymaps/signynt_2_quiet/keymap.c @@ -114,7 +114,7 @@ enum { }; //tap dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_MEDIA] = ACTION_TAP_DANCE_DOUBLE( KC_MPLY , KC_MNXT ), [TD_SCREEN] = ACTION_TAP_DANCE_DOUBLE( (G(S(KC_S))) , S(C(KC_4)) ), }; diff --git a/keyboards/kprepublic/bm65hsrgb_iso/keymaps/p4yne/keymap.c b/keyboards/kprepublic/bm65hsrgb_iso/keymaps/p4yne/keymap.c index 8b59f9de4f..a2719798de 100644 --- a/keyboards/kprepublic/bm65hsrgb_iso/keymaps/p4yne/keymap.c +++ b/keyboards/kprepublic/bm65hsrgb_iso/keymaps/p4yne/keymap.c @@ -23,7 +23,7 @@ enum { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // tap once for home, twice for end [TD_HOME_END] = ACTION_TAP_DANCE_DOUBLE(KC_HOME, KC_END) }; diff --git a/keyboards/kprepublic/bm65hsrgb_iso/rev1/keymaps/deadolus/keymap.c b/keyboards/kprepublic/bm65hsrgb_iso/rev1/keymaps/deadolus/keymap.c index 044b864c28..d150416bed 100644 --- a/keyboards/kprepublic/bm65hsrgb_iso/rev1/keymaps/deadolus/keymap.c +++ b/keyboards/kprepublic/bm65hsrgb_iso/rev1/keymaps/deadolus/keymap.c @@ -22,7 +22,7 @@ enum { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //tap once for home, twice for end [TD_HOME_END] = ACTION_TAP_DANCE_DOUBLE(KC_HOME, KC_END) }; diff --git a/keyboards/kprepublic/bm68hsrgb/rev1/keymaps/peepeetee/config.h b/keyboards/kprepublic/bm68hsrgb/rev1/keymaps/peepeetee/config.h index e464db1e36..c1f1a06a33 100644 --- a/keyboards/kprepublic/bm68hsrgb/rev1/keymaps/peepeetee/config.h +++ b/keyboards/kprepublic/bm68hsrgb/rev1/keymaps/peepeetee/config.h @@ -44,7 +44,7 @@ // #define TAPPING_TOGGLE 2 // How many taps before triggering the toggle // #define PERMISSIVE_HOLD // Makes tap and hold keys trigger the hold if another key is pressed before releasing, even if it hasn't hit the TAPPING_TERM. See Permissive Hold for details // #define IGNORE_MOD_TAP_INTERRUPT // Makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the TAPPING_TERM for both keys. See Mod tap interrupt for details -// #define TAPPING_FORCE_HOLD // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) +// #define QUICK_TAP_TERM 0 // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) // #define LEADER_TIMEOUT 300 // How long before the leader key times out. If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the LEADER_PER_KEY_TIMING option, which resets the timeout after each key is tapped. // #define LEADER_PER_KEY_TIMING // Sets the timer for leader key chords to run on each key press rather than overall // #define LEADER_KEY_STRICT_KEY_PROCESSING // Disables keycode filtering for Mod-Tap and Layer-Tap keycodes. Eg, if you enable this, you would need to specify MT(MOD_CTL, KC_A) if you want to use KC_A. diff --git a/keyboards/kprepublic/bm80hsrgb/keymaps/peepeetee/config.h b/keyboards/kprepublic/bm80hsrgb/keymaps/peepeetee/config.h index 6062ebbbbb..be172a8cf6 100644 --- a/keyboards/kprepublic/bm80hsrgb/keymaps/peepeetee/config.h +++ b/keyboards/kprepublic/bm80hsrgb/keymaps/peepeetee/config.h @@ -29,7 +29,7 @@ // #define TAPPING_TOGGLE 2 // How many taps before triggering the toggle // #define PERMISSIVE_HOLD // Makes tap and hold keys trigger the hold if another key is pressed before releasing, even if it hasn't hit the TAPPING_TERM. See Permissive Hold for details // #define IGNORE_MOD_TAP_INTERRUPT // Makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the TAPPING_TERM for both keys. See Mod tap interrupt for details -// #define TAPPING_FORCE_HOLD // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) +// #define QUICK_TAP_TERM 0 // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) // #define LEADER_TIMEOUT 300 // How long before the leader key times out. If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the LEADER_PER_KEY_TIMING option, which resets the timeout after each key is tapped. // #define LEADER_PER_KEY_TIMING // Sets the timer for leader key chords to run on each key press rather than overall // #define LEADER_KEY_STRICT_KEY_PROCESSING // Disables keycode filtering for Mod-Tap and Layer-Tap keycodes. Eg, if you enable this, you would need to specify MT(MOD_CTL, KC_A) if you want to use KC_A. diff --git a/keyboards/kprepublic/jj40/keymaps/stevexyz/config.h b/keyboards/kprepublic/jj40/keymaps/stevexyz/config.h index c525cff819..3be7f6f0cb 100644 --- a/keyboards/kprepublic/jj40/keymaps/stevexyz/config.h +++ b/keyboards/kprepublic/jj40/keymaps/stevexyz/config.h @@ -11,7 +11,7 @@ #define IGNORE_MOD_TAP_INTERRUPT // makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the TAPPING_TERM for both keys. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // makes it possible to use a dual role key as modifier shortly after having been tapped (see Hold after tap) // Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) diff --git a/keyboards/kprepublic/jj40/keymaps/stevexyz/keymap.c b/keyboards/kprepublic/jj40/keymaps/stevexyz/keymap.c index 72136a5d96..51691e8f1f 100644 --- a/keyboards/kprepublic/jj40/keymaps/stevexyz/keymap.c +++ b/keyboards/kprepublic/jj40/keymaps/stevexyz/keymap.c @@ -57,7 +57,7 @@ enum { TD_O_GRAVE, TD_U_GRAVE, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_P_BSPC] = ACTION_TAP_DANCE_DOUBLE(KC_P, KC_BSPC), [TD_Q_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_ESC), [TD_A_TAB] = ACTION_TAP_DANCE_DOUBLE(KC_A, KC_TAB), diff --git a/keyboards/kprepublic/jj50/keymaps/archetype/keymap.c b/keyboards/kprepublic/jj50/keymaps/archetype/keymap.c index ff59ef43e5..bdeb3a0dd6 100644 --- a/keyboards/kprepublic/jj50/keymaps/archetype/keymap.c +++ b/keyboards/kprepublic/jj50/keymaps/archetype/keymap.c @@ -36,7 +36,7 @@ enum { }; -void left_brackets(qk_tap_dance_state_t *state, void *user_data) { +void left_brackets(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (!state->pressed) { register_code16(KC_LPRN); @@ -50,7 +50,7 @@ void left_brackets(qk_tap_dance_state_t *state, void *user_data) { } } -void left_brackets_reset(qk_tap_dance_state_t *state, void *user_data) { +void left_brackets_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code16(KC_LPRN); } else if (state->count == 2) { @@ -62,7 +62,7 @@ void left_brackets_reset(qk_tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); } -void right_brackets(qk_tap_dance_state_t *state, void *user_data) { +void right_brackets(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (!state->pressed) { register_code16(KC_RPRN); @@ -76,7 +76,7 @@ void right_brackets(qk_tap_dance_state_t *state, void *user_data) { } } -void right_brackets_reset(qk_tap_dance_state_t *state, void *user_data) { +void right_brackets_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code16(KC_RPRN); } else if (state->count == 2) { @@ -104,7 +104,7 @@ enum { TRIPLE_SINGLE_TAP = 8, //send three single taps }; -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return SINGLE_TAP; else return SINGLE_HOLD; @@ -128,7 +128,7 @@ static tap tap_state = { .state = 0 }; -void layer_switcher (qk_tap_dance_state_t *state, void *user_data) { +void layer_switcher (tap_dance_state_t *state, void *user_data) { tap_state.state = cur_dance(state); switch (tap_state.state) { case SINGLE_TAP: register_code(KC_ESC); break; @@ -145,7 +145,7 @@ void layer_switcher (qk_tap_dance_state_t *state, void *user_data) { } } -void layer_switcher_reset (qk_tap_dance_state_t *state, void *user_data) { +void layer_switcher_reset (tap_dance_state_t *state, void *user_data) { switch (tap_state.state) { case SINGLE_TAP: unregister_code(KC_ESC); break; case SINGLE_HOLD: unregister_code(KC_ESC); break; @@ -159,7 +159,7 @@ void layer_switcher_reset (qk_tap_dance_state_t *state, void *user_data) { tap_state.state = 0; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Single tap = Backspace | Double tap = Delete [TD_BSPC_DEL] = ACTION_TAP_DANCE_DOUBLE(KC_BSPC, KC_DEL), // Single tap = ( | Double tap = [ | Triple tap = { | Single hold = KC_LCTL diff --git a/keyboards/late9/readme.md b/keyboards/late9/readme.md index 93e5a40823..1d85e788fb 100644 --- a/keyboards/late9/readme.md +++ b/keyboards/late9/readme.md @@ -20,7 +20,7 @@ Flashing example for this keyboard: make late9/rev1:default:flash -When asked by the terminal, short with a metal wire the pins on the backside of the board highlighted as `RST` (one is the `QK_BOOT` and the other one is `GROUND`) to enter the bootloader and let the OS detects the device. +When asked by the terminal, short with a metal wire the pins on the backside of the board highlighted as `RST` (one is the `RESET` and the other one is `GROUND`) to enter the bootloader and let the OS detects the device. After installing this firmware you can use Bootmagic to enter the bootloader while plugging in your LATE-9. By default it's the button on the upper-left of the keyboard. See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/late9/rev1/keymaps/multitap/keymap.c b/keyboards/late9/rev1/keymaps/multitap/keymap.c index 9c32699c42..e378fb4921 100644 --- a/keyboards/late9/rev1/keymaps/multitap/keymap.c +++ b/keyboards/late9/rev1/keymaps/multitap/keymap.c @@ -68,7 +68,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Tap Dance cycles -void dance_1 (qk_tap_dance_state_t *state, void *user_data) { +void dance_1 (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return tap_code(KC_DOT); else return tap_code(KC_1); @@ -93,7 +93,7 @@ void dance_1 (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_2 (qk_tap_dance_state_t *state, void *user_data) { +void dance_2 (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return tap_code(KC_A); else return tap_code(KC_2); @@ -106,7 +106,7 @@ void dance_2 (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_3 (qk_tap_dance_state_t *state, void *user_data) { +void dance_3 (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return tap_code(KC_D); else return tap_code(KC_3); @@ -119,7 +119,7 @@ void dance_3 (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_4 (qk_tap_dance_state_t *state, void *user_data) { +void dance_4 (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return tap_code(KC_G); else return tap_code(KC_4); @@ -132,7 +132,7 @@ void dance_4 (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_5 (qk_tap_dance_state_t *state, void *user_data) { +void dance_5 (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return tap_code(KC_J); else return tap_code(KC_5); @@ -145,7 +145,7 @@ void dance_5 (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_6 (qk_tap_dance_state_t *state, void *user_data) { +void dance_6 (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return tap_code(KC_M); else return tap_code(KC_6); @@ -158,7 +158,7 @@ void dance_6 (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_7 (qk_tap_dance_state_t *state, void *user_data) { +void dance_7 (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return tap_code(KC_P); else return tap_code(KC_7); @@ -173,7 +173,7 @@ void dance_7 (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_8 (qk_tap_dance_state_t *state, void *user_data) { +void dance_8 (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return tap_code(KC_T); else return tap_code(KC_8); @@ -186,7 +186,7 @@ void dance_8 (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_9 (qk_tap_dance_state_t *state, void *user_data) { +void dance_9 (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return tap_code(KC_W); else return tap_code(KC_9); @@ -201,7 +201,7 @@ void dance_9 (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_0 (qk_tap_dance_state_t *state, void *user_data) { +void dance_0 (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return tap_code(KC_SPACE); else return tap_code(KC_0); @@ -210,7 +210,7 @@ void dance_0 (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_maiusc (qk_tap_dance_state_t *state, void *user_data) { +void dance_maiusc (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->interrupted || !state->pressed) return set_oneshot_mods(MOD_BIT(KC_LSFT)); else return tap_code(KC_CAPS); @@ -220,7 +220,7 @@ void dance_maiusc (qk_tap_dance_state_t *state, void *user_data) { } // Tap Dance actions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_PNCT] = ACTION_TAP_DANCE_FN (dance_1), [TD_ABC] = ACTION_TAP_DANCE_FN (dance_2), [TD_DEF] = ACTION_TAP_DANCE_FN (dance_3), diff --git a/keyboards/lets_split/keymaps/adam/keymap.c b/keyboards/lets_split/keymaps/adam/keymap.c index 6e0a33a24f..12c2f6f04a 100644 --- a/keyboards/lets_split/keymaps/adam/keymap.c +++ b/keyboards/lets_split/keymaps/adam/keymap.c @@ -48,7 +48,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; #ifdef TAP_DANCE_ENABLE -void tap_1(qk_tap_dance_state_t *state, void *user_data) { +void tap_1(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: register_code (KC_1); @@ -66,7 +66,7 @@ void tap_1(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [0] = ACTION_TAP_DANCE_DOUBLE(KC_1, KC_ESC), [1] = ACTION_TAP_DANCE_FN(tap_1) }; diff --git a/keyboards/lets_split/keymaps/cpeters1982/keymap.c b/keyboards/lets_split/keymaps/cpeters1982/keymap.c index 8428aa58c5..3574fd558f 100644 --- a/keyboards/lets_split/keymaps/cpeters1982/keymap.c +++ b/keyboards/lets_split/keymaps/cpeters1982/keymap.c @@ -32,7 +32,7 @@ enum { }; // Tap dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_GRV_TILD] = ACTION_TAP_DANCE_DOUBLE(KC_GRV, KC_TILD), }; */ diff --git a/keyboards/lets_split/keymaps/geripgeri/keymap.c b/keyboards/lets_split/keymaps/geripgeri/keymap.c index d72d7b6085..6bd524c6b9 100644 --- a/keyboards/lets_split/keymaps/geripgeri/keymap.c +++ b/keyboards/lets_split/keymaps/geripgeri/keymap.c @@ -47,10 +47,10 @@ enum { #define LOWER MO(_LOWER) #define RAISE MO(_RAISE) -int cur_dance (qk_tap_dance_state_t *state); +int cur_dance (tap_dance_state_t *state); -void u_finished (qk_tap_dance_state_t *state, void *user_data); -void o_finished (qk_tap_dance_state_t *state, void *user_data); +void u_finished (tap_dance_state_t *state, void *user_data); +void o_finished (tap_dance_state_t *state, void *user_data); uint8_t rgb_mode = RGBLIGHT_MODE_BREATHING + 1; @@ -281,7 +281,7 @@ void led_set_user(uint8_t usb_led) { rgblight_mode_noeeprom(rgb_mode); } -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return SINGLE_TAP; //key has not been interrupted, but they key is still held. Means you want to send a 'HOLD'. @@ -317,7 +317,7 @@ static tap otap_state = { .state = 0 }; -void u_finished (qk_tap_dance_state_t *state, void *user_data) { +void u_finished (tap_dance_state_t *state, void *user_data) { utap_state.state = cur_dance(state); switch(utap_state.state) { case SINGLE_TAP: SEND_STRING(SS_RALT("]")); break; @@ -326,7 +326,7 @@ void u_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void o_finished (qk_tap_dance_state_t *state, void *user_data) { +void o_finished (tap_dance_state_t *state, void *user_data) { otap_state.state = cur_dance(state); switch(otap_state.state) { case SINGLE_TAP: SEND_STRING(SS_RALT("=")); break; @@ -335,7 +335,7 @@ void o_finished (qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [U] = ACTION_TAP_DANCE_FN(u_finished), [O] = ACTION_TAP_DANCE_FN(o_finished), [NEXTPREV] = ACTION_TAP_DANCE_DOUBLE(KC_MNXT, KC_MPRV), diff --git a/keyboards/lets_split/keymaps/heartrobotninja/keymap.c b/keyboards/lets_split/keymaps/heartrobotninja/keymap.c index 7b01273bc4..dc7bc6712e 100644 --- a/keyboards/lets_split/keymaps/heartrobotninja/keymap.c +++ b/keyboards/lets_split/keymaps/heartrobotninja/keymap.c @@ -109,7 +109,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_BTK] = ACTION_TAP_DANCE_DOUBLE(KC_QUOT, KC_GRV), [TD_TDE] = ACTION_TAP_DANCE_DOUBLE(KC_SCLN, KC_TILD), [TD_LPRN] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_LPRN), diff --git a/keyboards/lets_split/keymaps/khord/keymap.c b/keyboards/lets_split/keymaps/khord/keymap.c index 1cee03fe9e..9e300d8e59 100644 --- a/keyboards/lets_split/keymaps/khord/keymap.c +++ b/keyboards/lets_split/keymaps/khord/keymap.c @@ -102,7 +102,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [SFT_CAP] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS) }; diff --git a/keyboards/lets_split/keymaps/mbsurfer/keymap.c b/keyboards/lets_split/keymaps/mbsurfer/keymap.c index 43c6bde98c..afe8f3d0e5 100644 --- a/keyboards/lets_split/keymaps/mbsurfer/keymap.c +++ b/keyboards/lets_split/keymaps/mbsurfer/keymap.c @@ -153,7 +153,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { int RGB_current_mode; int RGB_current_hue; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [SFT_CAP] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), [LFT_HOM] = ACTION_TAP_DANCE_DOUBLE(KC_LEFT, KC_HOME), [DWN_PDN] = ACTION_TAP_DANCE_DOUBLE(KC_DOWN, KC_PGDN), diff --git a/keyboards/lets_split/keymaps/tylerwince/keymap.c b/keyboards/lets_split/keymaps/tylerwince/keymap.c index cb21a6f368..3b67f80ae2 100644 --- a/keyboards/lets_split/keymaps/tylerwince/keymap.c +++ b/keyboards/lets_split/keymaps/tylerwince/keymap.c @@ -26,7 +26,7 @@ enum { TD_SEMI_COLON, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SEMI_COLON] = ACTION_TAP_DANCE_DOUBLE(KC_SCLN, KC_COLN), }; diff --git a/keyboards/lfkeyboards/lfk78/keymaps/ca178858/keymap.c b/keyboards/lfkeyboards/lfk78/keymaps/ca178858/keymap.c index 61ca4bb398..f4d1e010ee 100644 --- a/keyboards/lfkeyboards/lfk78/keymaps/ca178858/keymap.c +++ b/keyboards/lfkeyboards/lfk78/keymaps/ca178858/keymap.c @@ -105,7 +105,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { ) }; -void tap_space_spam_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_space_spam_finished(tap_dance_state_t *state, void *user_data) { if (get_mods() & (MOD_BIT(KC_LGUI))) { return; } @@ -115,12 +115,12 @@ void tap_space_spam_finished(qk_tap_dance_state_t *state, void *user_data) { tap_code(KC_SPC); } -void tap_space_spam_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_space_spam_reset(tap_dance_state_t *state, void *user_data) { spam_space = false; unregister_code(KC_SPC); } -void tap_esc_func_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_esc_func_finished(tap_dance_state_t *state, void *user_data) { if (state->pressed) { layer_on(FUNC); } else { @@ -128,11 +128,11 @@ void tap_esc_func_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void tap_esc_func_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_esc_func_reset(tap_dance_state_t *state, void *user_data) { layer_off(FUNC); } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESC_FUNC] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tap_esc_func_finished, tap_esc_func_reset), [TD_SPC_SPAM] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tap_space_spam_finished, tap_space_spam_reset), }; diff --git a/keyboards/lfkeyboards/lfk87/keymaps/ca178858/keymap.c b/keyboards/lfkeyboards/lfk87/keymaps/ca178858/keymap.c index b483bf730b..0dfba1afac 100644 --- a/keyboards/lfkeyboards/lfk87/keymaps/ca178858/keymap.c +++ b/keyboards/lfkeyboards/lfk87/keymaps/ca178858/keymap.c @@ -155,7 +155,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { ) }; -void tap_esc_func_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_esc_func_finished(tap_dance_state_t *state, void *user_data) { if (state->pressed) { layer_on(FUNC); } else { @@ -163,11 +163,11 @@ void tap_esc_func_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void tap_esc_func_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_esc_func_reset(tap_dance_state_t *state, void *user_data) { layer_off(FUNC); } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESC_FUNC] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tap_esc_func_finished, tap_esc_func_reset), }; diff --git a/keyboards/lfkeyboards/mini1800/keymaps/ca178858/keymap.c b/keyboards/lfkeyboards/mini1800/keymaps/ca178858/keymap.c index f8985bf537..75abdc258c 100644 --- a/keyboards/lfkeyboards/mini1800/keymaps/ca178858/keymap.c +++ b/keyboards/lfkeyboards/mini1800/keymaps/ca178858/keymap.c @@ -93,7 +93,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { ) }; -void tap_esc_func_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_esc_func_finished(tap_dance_state_t *state, void *user_data) { if (state->pressed) { layer_on(FUNC); } else { @@ -101,11 +101,11 @@ void tap_esc_func_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void tap_esc_func_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_esc_func_reset(tap_dance_state_t *state, void *user_data) { layer_off(FUNC); } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESC_FUNC] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tap_esc_func_finished, tap_esc_func_reset), }; diff --git a/keyboards/lily58/keymaps/bongocat_wpm_responsive/config.h b/keyboards/lily58/keymaps/bongocat_wpm_responsive/config.h index 09248850f2..e5d0aa6699 100644 --- a/keyboards/lily58/keymaps/bongocat_wpm_responsive/config.h +++ b/keyboards/lily58/keymaps/bongocat_wpm_responsive/config.h @@ -28,7 +28,7 @@ #define MASTER_LEFT // #define EE_HANDS - #define TAPPING_FORCE_HOLD + #define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #undef RGBLED_NUM diff --git a/keyboards/lily58/keymaps/chuan/config.h b/keyboards/lily58/keymaps/chuan/config.h index 7d989ba42e..d952ce457b 100644 --- a/keyboards/lily58/keymaps/chuan/config.h +++ b/keyboards/lily58/keymaps/chuan/config.h @@ -32,7 +32,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define SSD1306OLED -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 /* define tapping term */ #define TAPPING_TERM 200 diff --git a/keyboards/lily58/keymaps/cykedev/config.h b/keyboards/lily58/keymaps/cykedev/config.h index dac88dff77..d9e43606a4 100644 --- a/keyboards/lily58/keymaps/cykedev/config.h +++ b/keyboards/lily58/keymaps/cykedev/config.h @@ -17,4 +17,4 @@ #define MASTER_LEFT #define TAPPING_TERM 200 -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY +#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY diff --git a/keyboards/lily58/keymaps/cykedev/keymap.c b/keyboards/lily58/keymaps/cykedev/keymap.c index 94db33771a..88d9728469 100644 --- a/keyboards/lily58/keymaps/cykedev/keymap.c +++ b/keyboards/lily58/keymaps/cykedev/keymap.c @@ -96,9 +96,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { ) }; -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case SY_SPC: + return false; + case QK_MOD_TAP ... QK_MOD_TAP_MAX: return true; default: return false; diff --git a/keyboards/lily58/keymaps/datadavd/config.h b/keyboards/lily58/keymaps/datadavd/config.h index 83bbfff11f..19b372e569 100644 --- a/keyboards/lily58/keymaps/datadavd/config.h +++ b/keyboards/lily58/keymaps/datadavd/config.h @@ -30,7 +30,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define SSD1306OLED -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 50 #undef RGBLED_NUM diff --git a/keyboards/lily58/keymaps/default/config.h b/keyboards/lily58/keymaps/default/config.h index 79b1314456..b16e63b6d7 100644 --- a/keyboards/lily58/keymaps/default/config.h +++ b/keyboards/lily58/keymaps/default/config.h @@ -26,7 +26,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/lily58/keymaps/domnantas/config.h b/keyboards/lily58/keymaps/domnantas/config.h index f32a066c14..143a950ef2 100644 --- a/keyboards/lily58/keymaps/domnantas/config.h +++ b/keyboards/lily58/keymaps/domnantas/config.h @@ -30,5 +30,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define SSD1306OLED -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 diff --git a/keyboards/lily58/keymaps/drasbeck/config.h b/keyboards/lily58/keymaps/drasbeck/config.h index f510f7f735..01ba4faf73 100644 --- a/keyboards/lily58/keymaps/drasbeck/config.h +++ b/keyboards/lily58/keymaps/drasbeck/config.h @@ -24,7 +24,7 @@ Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) 2020 Max Drasbeck #define ENCODERS_PAD_B { F5 } #define ENCODER_RESOLUTION 4 -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #undef RGBLED_NUM diff --git a/keyboards/lily58/keymaps/gaston/config.h b/keyboards/lily58/keymaps/gaston/config.h index 621a0a9295..988e3eb6f8 100644 --- a/keyboards/lily58/keymaps/gaston/config.h +++ b/keyboards/lily58/keymaps/gaston/config.h @@ -22,5 +22,5 @@ #define MASTER_LEFT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 150 /* ms */ diff --git a/keyboards/lily58/keymaps/gshmu/config.h b/keyboards/lily58/keymaps/gshmu/config.h index 08234a4d4b..84a79412da 100644 --- a/keyboards/lily58/keymaps/gshmu/config.h +++ b/keyboards/lily58/keymaps/gshmu/config.h @@ -17,7 +17,7 @@ #pragma once #define TAPPING_TERM 200 -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define PERMISSIVE_HOLD #define DYNAMIC_TAPPING_TERM_INCREMENT 10 diff --git a/keyboards/lily58/keymaps/jhelvy/config.h b/keyboards/lily58/keymaps/jhelvy/config.h index 4d4df5b102..dbd058a8b5 100644 --- a/keyboards/lily58/keymaps/jhelvy/config.h +++ b/keyboards/lily58/keymaps/jhelvy/config.h @@ -30,7 +30,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define SSD1306OLED -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #undef TAPPING_TERM #define TAPPING_TERM 200 diff --git a/keyboards/lily58/keymaps/mikefightsbears/config.h b/keyboards/lily58/keymaps/mikefightsbears/config.h index 454f52c868..084b95d52f 100644 --- a/keyboards/lily58/keymaps/mikefightsbears/config.h +++ b/keyboards/lily58/keymaps/mikefightsbears/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/lily58/keymaps/muppetjones/config.h b/keyboards/lily58/keymaps/muppetjones/config.h index bee5ee45da..283a4ed890 100644 --- a/keyboards/lily58/keymaps/muppetjones/config.h +++ b/keyboards/lily58/keymaps/muppetjones/config.h @@ -35,7 +35,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #undef RGBLED_NUM diff --git a/keyboards/lily58/keymaps/narze/config.h b/keyboards/lily58/keymaps/narze/config.h index e10c2bb380..a6fac1a58b 100644 --- a/keyboards/lily58/keymaps/narze/config.h +++ b/keyboards/lily58/keymaps/narze/config.h @@ -34,7 +34,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define IGNORE_MOD_TAP_INTERRUPT #define PERMISSIVE_HOLD -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/lily58/keymaps/ninjonas/config.h b/keyboards/lily58/keymaps/ninjonas/config.h index d67ac41a17..9c97dc9e3f 100644 --- a/keyboards/lily58/keymaps/ninjonas/config.h +++ b/keyboards/lily58/keymaps/ninjonas/config.h @@ -26,7 +26,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define OLED_FONT_H "keyboards/lily58/lib/glcdfont.c" #define OLED_DISABLE_TIMEOUT diff --git a/keyboards/lily58/keymaps/pttbx/config.h b/keyboards/lily58/keymaps/pttbx/config.h index 79b1314456..b16e63b6d7 100644 --- a/keyboards/lily58/keymaps/pttbx/config.h +++ b/keyboards/lily58/keymaps/pttbx/config.h @@ -26,7 +26,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/lily58/keymaps/via/config.h b/keyboards/lily58/keymaps/via/config.h index a5dfe7c8d3..331521bcbf 100644 --- a/keyboards/lily58/keymaps/via/config.h +++ b/keyboards/lily58/keymaps/via/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 // Underglow diff --git a/keyboards/lily58/keymaps/yshrsmz/config.h b/keyboards/lily58/keymaps/yshrsmz/config.h index 454f52c868..084b95d52f 100644 --- a/keyboards/lily58/keymaps/yshrsmz/config.h +++ b/keyboards/lily58/keymaps/yshrsmz/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/lily58/keymaps/yuchi/config.h b/keyboards/lily58/keymaps/yuchi/config.h index 1335b805cd..8e07ec837f 100644 --- a/keyboards/lily58/keymaps/yuchi/config.h +++ b/keyboards/lily58/keymaps/yuchi/config.h @@ -30,5 +30,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. //#define OLED_DRIVER -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 diff --git a/keyboards/linworks/fave65h/readme.md b/keyboards/linworks/fave65h/readme.md index 09649fa860..7a95f65ac5 100644 --- a/keyboards/linworks/fave65h/readme.md +++ b/keyboards/linworks/fave65h/readme.md @@ -17,7 +17,7 @@ Make example for this keyboard (after setting up your build environment): ## Bootloader Enter the bootloader in 3 ways: * **Bootmagic reset**: Hold down the key ESC key and plug in the keyboard (Top Left most switch) -* **Physical reset short**: Briefly short the 2 pads labelled QK_BOOT on the back of the PCB +* **Physical reset short**: Briefly short the 2 pads labelled `RESET` on the back of the PCB * **Keycode in layout**: Press the B key on layer 1 which is mapped to `QK_BOOT` See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/linworks/fave84h/readme.md b/keyboards/linworks/fave84h/readme.md index 22ce5fd428..dab29f6766 100644 --- a/keyboards/linworks/fave84h/readme.md +++ b/keyboards/linworks/fave84h/readme.md @@ -19,5 +19,5 @@ See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_to ## Bootloader Enter the bootloader in 3 ways: * **Bootmagic reset**: Hold down the key ESC key and plug in the keyboard (Top Left most switch) -* **Physical reset short**: Briefly short the 2 pads labelled QK_BOOT on the back of the PCB +* **Physical reset short**: Briefly short the 2 pads labelled `RESET` on the back of the PCB * **Keycode in layout**: Press the B key on layer 1 which is mapped to `QK_BOOT` diff --git a/keyboards/linworks/fave87h/readme.md b/keyboards/linworks/fave87h/readme.md index bda921a61b..f06d8458c0 100644 --- a/keyboards/linworks/fave87h/readme.md +++ b/keyboards/linworks/fave87h/readme.md @@ -19,5 +19,5 @@ See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_to ## Bootloader Enter the bootloader in 3 ways: * **Bootmagic reset**: Hold down the key ESC key and plug in the keyboard (Top Left most switch) -* **Physical reset short**: Briefly short the 2 pads labelled QK_BOOT on the back of the PCB +* **Physical reset short**: Briefly short the 2 pads labelled `RESET` on the back of the PCB * **Keycode in layout**: Press the B key on layer 1 which is mapped to `QK_BOOT` diff --git a/keyboards/malevolti/lyra/keymaps/default/config.h b/keyboards/malevolti/lyra/keymaps/default/config.h index 9c4bacd36d..3e8db641e1 100644 --- a/keyboards/malevolti/lyra/keymaps/default/config.h +++ b/keyboards/malevolti/lyra/keymaps/default/config.h @@ -26,5 +26,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 diff --git a/keyboards/malevolti/lyra/keymaps/via/config.h b/keyboards/malevolti/lyra/keymaps/via/config.h index 9c4bacd36d..3e8db641e1 100644 --- a/keyboards/malevolti/lyra/keymaps/via/config.h +++ b/keyboards/malevolti/lyra/keymaps/via/config.h @@ -26,5 +26,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 diff --git a/keyboards/malevolti/superlyra/keymaps/default/config.h b/keyboards/malevolti/superlyra/keymaps/default/config.h index bbdf47463f..7f20fea8be 100644 --- a/keyboards/malevolti/superlyra/keymaps/default/config.h +++ b/keyboards/malevolti/superlyra/keymaps/default/config.h @@ -22,5 +22,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 diff --git a/keyboards/malevolti/superlyra/keymaps/via/config.h b/keyboards/malevolti/superlyra/keymaps/via/config.h index bbdf47463f..7f20fea8be 100644 --- a/keyboards/malevolti/superlyra/keymaps/via/config.h +++ b/keyboards/malevolti/superlyra/keymaps/via/config.h @@ -22,5 +22,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 diff --git a/keyboards/maple_computing/launchpad/keymaps/brandonschlack/keymap.c b/keyboards/maple_computing/launchpad/keymaps/brandonschlack/keymap.c index 6fc28dccc2..cc33fd48a1 100644 --- a/keyboards/maple_computing/launchpad/keymaps/brandonschlack/keymap.c +++ b/keyboards/maple_computing/launchpad/keymaps/brandonschlack/keymap.c @@ -41,7 +41,7 @@ enum launchpad_dances { TD_REDR_H }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SHLD_LGHT] = ACTION_TAP_DANCE_TRIGGER_LAYER(SINGLE_HOLD, _LIGHT), [TD_SHLD_ADJT] = ACTION_TAP_DANCE_TRIGGER_LAYER(SINGLE_HOLD, _ADJUST), [TD_REDR_H] = ACTION_TAP_DANCE_DOUBLE(KC_H, KC_R) diff --git a/keyboards/maple_computing/minidox/keymaps/dustypomerleau/config.h b/keyboards/maple_computing/minidox/keymaps/dustypomerleau/config.h index 0cd6c2b994..0bb532c663 100644 --- a/keyboards/maple_computing/minidox/keymaps/dustypomerleau/config.h +++ b/keyboards/maple_computing/minidox/keymaps/dustypomerleau/config.h @@ -10,9 +10,9 @@ // optional configuration: // #define CONVERT_TO_PROTON_C -// #define ONESHOT_TAP_TOGGLE 2 // not compatible with TAPPING_FORCE_HOLD +// #define ONESHOT_TAP_TOGGLE 2 // not compatible with QUICK_TAP_TERM 0 // #define PERMISSIVE_HOLD -// #define TAPPING_FORCE_HOLD // allows rapid mod use after tap event, but sacrifices double-tap to repeat +// #define QUICK_TAP_TERM 0 // allows rapid mod use after tap event, but sacrifices double-tap to repeat // #define MOUSEKEY_DELAY 0 // delay before cursor movement (high feels sluggish, low makes fine movement difficult) // #define MOUSEKEY_INTERVAL 20 // time between movement reports - low settings feel like high mouse speed diff --git a/keyboards/maple_computing/minidox/keymaps/dustypomerleau/keymap.c b/keyboards/maple_computing/minidox/keymaps/dustypomerleau/keymap.c index aec8c56b18..12823b0f2b 100644 --- a/keyboards/maple_computing/minidox/keymaps/dustypomerleau/keymap.c +++ b/keyboards/maple_computing/minidox/keymaps/dustypomerleau/keymap.c @@ -40,17 +40,17 @@ typedef enum { } td_state_t; static td_state_t td_state; -int cur_dance (qk_tap_dance_state_t *state); -void altlp_finished (qk_tap_dance_state_t *state, void *user_data); -void altlp_reset (qk_tap_dance_state_t *state, void *user_data); -void ctlrcb_finished (qk_tap_dance_state_t *state, void *user_data); -void ctlrcb_reset (qk_tap_dance_state_t *state, void *user_data); -void guirp_finished (qk_tap_dance_state_t *state, void *user_data); -void guirp_reset (qk_tap_dance_state_t *state, void *user_data); -void sftlcb_finished (qk_tap_dance_state_t *state, void *user_data); -void sftlcb_reset (qk_tap_dance_state_t *state, void *user_data); -void sftpls_finished (qk_tap_dance_state_t *state, void *user_data); -void sftpls_reset (qk_tap_dance_state_t *state, void *user_data); +int cur_dance (tap_dance_state_t *state); +void altlp_finished (tap_dance_state_t *state, void *user_data); +void altlp_reset (tap_dance_state_t *state, void *user_data); +void ctlrcb_finished (tap_dance_state_t *state, void *user_data); +void ctlrcb_reset (tap_dance_state_t *state, void *user_data); +void guirp_finished (tap_dance_state_t *state, void *user_data); +void guirp_reset (tap_dance_state_t *state, void *user_data); +void sftlcb_finished (tap_dance_state_t *state, void *user_data); +void sftlcb_reset (tap_dance_state_t *state, void *user_data); +void sftpls_finished (tap_dance_state_t *state, void *user_data); +void sftpls_reset (tap_dance_state_t *state, void *user_data); #define ALT_2 LALT_T(KC_2) #define ALT_3 LALT_T(KC_3) @@ -276,7 +276,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { } }; -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return SINGLE_TAP; else return SINGLE_HOLD; @@ -285,7 +285,7 @@ int cur_dance (qk_tap_dance_state_t *state) { else return 3; } -void altlp_finished (qk_tap_dance_state_t *state, void *user_data) { +void altlp_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -300,7 +300,7 @@ void altlp_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void altlp_reset (qk_tap_dance_state_t *state, void *user_data) { +void altlp_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: unregister_code16(KC_LPRN); @@ -313,7 +313,7 @@ void altlp_reset (qk_tap_dance_state_t *state, void *user_data) { } } -void ctlrcb_finished (qk_tap_dance_state_t *state, void *user_data) { +void ctlrcb_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -328,7 +328,7 @@ void ctlrcb_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void ctlrcb_reset (qk_tap_dance_state_t *state, void *user_data) { +void ctlrcb_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: unregister_code16(KC_RCBR); @@ -341,7 +341,7 @@ void ctlrcb_reset (qk_tap_dance_state_t *state, void *user_data) { } } -void guirp_finished (qk_tap_dance_state_t *state, void *user_data) { +void guirp_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -356,7 +356,7 @@ void guirp_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void guirp_reset (qk_tap_dance_state_t *state, void *user_data) { +void guirp_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: unregister_code16(KC_RPRN); @@ -369,7 +369,7 @@ void guirp_reset (qk_tap_dance_state_t *state, void *user_data) { } } -void sftlcb_finished (qk_tap_dance_state_t *state, void *user_data) { +void sftlcb_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -384,7 +384,7 @@ void sftlcb_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void sftlcb_reset (qk_tap_dance_state_t *state, void *user_data) { +void sftlcb_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: unregister_code16(KC_LCBR); @@ -397,7 +397,7 @@ void sftlcb_reset (qk_tap_dance_state_t *state, void *user_data) { } } -void sftpls_finished (qk_tap_dance_state_t *state, void *user_data) { +void sftpls_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -412,7 +412,7 @@ void sftpls_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void sftpls_reset (qk_tap_dance_state_t *state, void *user_data) { +void sftpls_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: unregister_code16(KC_PLUS); @@ -425,7 +425,7 @@ void sftpls_reset (qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ALT_LP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altlp_finished, altlp_reset), [CTL_RCB] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ctlrcb_finished, ctlrcb_reset), [GUI_RP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, guirp_finished, guirp_reset), diff --git a/keyboards/marksard/treadstone32/keymaps/default/keymap.c b/keyboards/marksard/treadstone32/keymaps/default/keymap.c index d0cef28353..cbc8ed42bb 100644 --- a/keyboards/marksard/treadstone32/keymaps/default/keymap.c +++ b/keyboards/marksard/treadstone32/keymaps/default/keymap.c @@ -55,7 +55,7 @@ enum custom_keycodes { // #define KC_CODO TD(TD_CODO) // #define KC_SLRO TD(TD_SLRO) -// qk_tap_dance_action_t tap_dance_actions[] = { +// tap_dance_action_t tap_dance_actions[] = { // [TD_CODO] = ACTION_TAP_DANCE_DOUBLE(KC_COMM, KC_DOT), // [TD_SLRO] = ACTION_TAP_DANCE_DOUBLE(KC_SLSH, JP_BSLS), // }; diff --git a/keyboards/marksard/treadstone32/keymaps/like_jis/keymap.c b/keyboards/marksard/treadstone32/keymaps/like_jis/keymap.c index 701d6ed688..e11726b7e2 100644 --- a/keyboards/marksard/treadstone32/keymaps/like_jis/keymap.c +++ b/keyboards/marksard/treadstone32/keymaps/like_jis/keymap.c @@ -56,7 +56,7 @@ enum custom_keycodes { // #define KC_CODO TD(TD_CODO) // #define KC_SLRO TD(TD_SLRO) -// qk_tap_dance_action_t tap_dance_actions[] = { +// tap_dance_action_t tap_dance_actions[] = { // [TD_CODO] = ACTION_TAP_DANCE_DOUBLE(KC_COMM, KC_DOT), // [TD_SLRO] = ACTION_TAP_DANCE_DOUBLE(KC_SLSH, JP_BSLS), // }; diff --git a/keyboards/massdrop/alt/keymaps/b_/config.h b/keyboards/massdrop/alt/keymaps/b_/config.h index 7dec786b79..8f06c0dd34 100644 --- a/keyboards/massdrop/alt/keymaps/b_/config.h +++ b/keyboards/massdrop/alt/keymaps/b_/config.h @@ -32,7 +32,7 @@ // #define TAPPING_TOGGLE 2 // How many taps before triggering the toggle // #define PERMISSIVE_HOLD // Makes tap and hold keys trigger the hold if another key is pressed before releasing, even if it hasn't hit the TAPPING_TERM. See Permissive Hold for details // #define IGNORE_MOD_TAP_INTERRUPT // Makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the TAPPING_TERM for both keys. See Mod tap interrupt for details -// #define TAPPING_FORCE_HOLD // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) +// #define QUICK_TAP_TERM 0 // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) // #define LEADER_TIMEOUT 300 // How long before the leader key times out. If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the LEADER_PER_KEY_TIMING option, which resets the timeout after each key is tapped. // #define LEADER_PER_KEY_TIMING // Sets the timer for leader key chords to run on each key press rather than overall // #define LEADER_KEY_STRICT_KEY_PROCESSING // Disables keycode filtering for Mod-Tap and Layer-Tap keycodes. Eg, if you enable this, you would need to specify MT(MOD_CTL, KC_A) if you want to use KC_A. diff --git a/keyboards/massdrop/alt/keymaps/jdelkins/keymap.c b/keyboards/massdrop/alt/keymaps/jdelkins/keymap.c index 1adfcb7d71..4c9a8860f4 100644 --- a/keyboards/massdrop/alt/keymaps/jdelkins/keymap.c +++ b/keyboards/massdrop/alt/keymaps/jdelkins/keymap.c @@ -42,10 +42,10 @@ enum alt_keycodes { int ctl_state = 0; -void ctl_finished(qk_tap_dance_state_t *state, void *user_data) { +void ctl_finished(tap_dance_state_t *state, void *user_data) { ctl_state = cur_dance(state); switch(ctl_state) { - case SINGLE_TAP: qk_leader_start(); break; + case SINGLE_TAP: leader_start(); break; case SINGLE_HOLD: register_code(KC_LCTL); break; case DOUBLE_TAP: tap_code(KC_RCTL); break; case DOUBLE_HOLD: register_code(KC_RCTL); break; @@ -54,7 +54,7 @@ void ctl_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void ctl_reset(qk_tap_dance_state_t *state, void *user_data) { +void ctl_reset(tap_dance_state_t *state, void *user_data) { switch(ctl_state) { case SINGLE_HOLD: unregister_code(KC_LCTL); break; case DOUBLE_HOLD: @@ -63,7 +63,7 @@ void ctl_reset(qk_tap_dance_state_t *state, void *user_data) { ctl_state = 0; } -void g_finished(qk_tap_dance_state_t *state, void *user_data) { +void g_finished(tap_dance_state_t *state, void *user_data) { switch (cur_dance(state)) { case SINGLE_TAP: tap_code16(C(KC_END)); @@ -80,7 +80,7 @@ enum { TD_G, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LDCTL] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ctl_finished, ctl_reset), [TD_GUI] = ACTION_TAP_DANCE_DOUBLE(KC_LGUI, KC_RGUI), [TD_G] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, g_finished, NULL), diff --git a/keyboards/massdrop/alt/keymaps/pregame/config.h b/keyboards/massdrop/alt/keymaps/pregame/config.h index 90892cc802..83f0d13bd5 100644 --- a/keyboards/massdrop/alt/keymaps/pregame/config.h +++ b/keyboards/massdrop/alt/keymaps/pregame/config.h @@ -45,7 +45,7 @@ // #define TAPPING_TOGGLE 2 // How many taps before triggering the toggle // #define PERMISSIVE_HOLD // Makes tap and hold keys trigger the hold if another key is pressed before releasing, even if it hasn't hit the TAPPING_TERM. See Permissive Hold for details // #define IGNORE_MOD_TAP_INTERRUPT // Makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the TAPPING_TERM for both keys. See Mod tap interrupt for details -// #define TAPPING_FORCE_HOLD // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) +// #define QUICK_TAP_TERM 0 // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) // #define LEADER_TIMEOUT 300 // How long before the leader key times out. If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the LEADER_PER_KEY_TIMING option, which resets the timeout after each key is tapped. // #define LEADER_PER_KEY_TIMING // Sets the timer for leader key chords to run on each key press rather than overall // #define LEADER_KEY_STRICT_KEY_PROCESSING // Disables keycode filtering for Mod-Tap and Layer-Tap keycodes. Eg, if you enable this, you would need to specify MT(MOD_CTL, KC_A) if you want to use KC_A. diff --git a/keyboards/massdrop/ctrl/keymaps/endgame/config.h b/keyboards/massdrop/ctrl/keymaps/endgame/config.h index 1a7c77b90e..8584c07a5d 100644 --- a/keyboards/massdrop/ctrl/keymaps/endgame/config.h +++ b/keyboards/massdrop/ctrl/keymaps/endgame/config.h @@ -29,7 +29,7 @@ #define TAPPING_TOGGLE 2 // How many taps before triggering the toggle // #define PERMISSIVE_HOLD // Makes tap and hold keys trigger the hold if another key is pressed before releasing, even if it hasn't hit the TAPPING_TERM. See Permissive Hold for details // #define IGNORE_MOD_TAP_INTERRUPT // Makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the TAPPING_TERM for both keys. See Mod tap interrupt for details -// #define TAPPING_FORCE_HOLD // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) +// #define QUICK_TAP_TERM 0 // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) // #define LEADER_TIMEOUT 300 // How long before the leader key times out. If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the LEADER_PER_KEY_TIMING option, which resets the timeout after each key is tapped. // #define LEADER_PER_KEY_TIMING // Sets the timer for leader key chords to run on each key press rather than overall // #define LEADER_KEY_STRICT_KEY_PROCESSING // Disables keycode filtering for Mod-Tap and Layer-Tap keycodes. Eg, if you enable this, you would need to specify MT(MOD_CTL, KC_A) if you want to use KC_A. diff --git a/keyboards/massdrop/ctrl/keymaps/endgame/keymap.c b/keyboards/massdrop/ctrl/keymaps/endgame/keymap.c index aaea8199f1..87b14ff93f 100644 --- a/keyboards/massdrop/ctrl/keymaps/endgame/keymap.c +++ b/keyboards/massdrop/ctrl/keymaps/endgame/keymap.c @@ -25,7 +25,7 @@ static const char * sendstring_commands[] = { }; //Associate our tap dance key with its functionality -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LGUI_ML] = ACTION_TAP_DANCE_LAYER_TOGGLE(KC_LGUI, _ML), [TD_APP_YL] = ACTION_TAP_DANCE_LAYER_TOGGLE(KC_APP, _YL), [TD_CTRL_TERM] = ACTION_TAP_DANCE_DOUBLE(KC_LCTL, LCA(KC_T)), diff --git a/keyboards/massdrop/ctrl/keymaps/matthewrobo/config.h b/keyboards/massdrop/ctrl/keymaps/matthewrobo/config.h index deb40efb7d..b975b7895b 100644 --- a/keyboards/massdrop/ctrl/keymaps/matthewrobo/config.h +++ b/keyboards/massdrop/ctrl/keymaps/matthewrobo/config.h @@ -47,7 +47,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define TAPPING_TOGGLE 2 // How many taps before triggering the toggle // #define PERMISSIVE_HOLD // Makes tap and hold keys trigger the hold if another key is pressed before releasing, even if it hasn't hit the TAPPING_TERM. See Permissive Hold for details // #define IGNORE_MOD_TAP_INTERRUPT // Makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the TAPPING_TERM for both keys. See Mod tap interrupt for details -// #define TAPPING_FORCE_HOLD // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) +// #define QUICK_TAP_TERM 0 // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) // #define LEADER_TIMEOUT 300 // How long before the leader key times out. If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the LEADER_PER_KEY_TIMING option, which resets the timeout after each key is tapped. // #define LEADER_PER_KEY_TIMING // Sets the timer for leader key chords to run on each key press rather than overall // #define LEADER_KEY_STRICT_KEY_PROCESSING // Disables keycode filtering for Mod-Tap and Layer-Tap keycodes. Eg, if you enable this, you would need to specify MT(MOD_CTL, KC_A) if you want to use KC_A. diff --git a/keyboards/massdrop/ctrl/keymaps/xanimos/config.h b/keyboards/massdrop/ctrl/keymaps/xanimos/config.h index 767fbaffca..87db7fe8ea 100644 --- a/keyboards/massdrop/ctrl/keymaps/xanimos/config.h +++ b/keyboards/massdrop/ctrl/keymaps/xanimos/config.h @@ -45,7 +45,7 @@ #define TAPPING_TOGGLE 2 // How many taps before triggering the toggle // #define PERMISSIVE_HOLD // Makes tap and hold keys trigger the hold if another key is pressed before releasing, even if it hasn't hit the TAPPING_TERM. See Permissive Hold for details // #define IGNORE_MOD_TAP_INTERRUPT // Makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the TAPPING_TERM for both keys. See Mod tap interrupt for details -// #define TAPPING_FORCE_HOLD // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) +// #define QUICK_TAP_TERM 0 // Makes it possible to use a dual role key as modifier shortly after having been tapped. See Hold after tap. Breaks any Tap Toggle functionality (TT or the One Shot Tap Toggle) // #define LEADER_TIMEOUT 300 // How long before the leader key times out. If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the LEADER_PER_KEY_TIMING option, which resets the timeout after each key is tapped. // #define LEADER_PER_KEY_TIMING // Sets the timer for leader key chords to run on each key press rather than overall // #define LEADER_KEY_STRICT_KEY_PROCESSING // Disables keycode filtering for Mod-Tap and Layer-Tap keycodes. Eg, if you enable this, you would need to specify MT(MOD_CTL, KC_A) if you want to use KC_A. diff --git a/keyboards/massdrop/ctrl/keymaps/xanimos/keymap.c b/keyboards/massdrop/ctrl/keymaps/xanimos/keymap.c index 3dbb48f16c..ac41b17a96 100644 --- a/keyboards/massdrop/ctrl/keymaps/xanimos/keymap.c +++ b/keyboards/massdrop/ctrl/keymaps/xanimos/keymap.c @@ -355,7 +355,7 @@ bool rgb_matrix_indicators_user(void) { -td_state_t cur_dance(qk_tap_dance_state_t *state) { +td_state_t cur_dance(tap_dance_state_t *state) { if (state->pressed && !state->interrupted) { if (state->count == 1) { return TD_SINGLE_HOLD; } return TD_DOUBLE_HOLD; @@ -368,7 +368,7 @@ static td_tap_t fn_tap_state = { .state = TD_NONE }; -void fn_tap_finished(qk_tap_dance_state_t *state, void *user_data) { +void fn_tap_finished(tap_dance_state_t *state, void *user_data) { fn_tap_state.state = cur_dance(state); switch (fn_tap_state.state) { case TD_SINGLE_HOLD: @@ -387,7 +387,7 @@ void fn_tap_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void fn_tap_reset(qk_tap_dance_state_t *state, void *user_data) { +void fn_tap_reset(tap_dance_state_t *state, void *user_data) { switch (fn_tap_state.state) { case TD_UNKNOWN: unregister_code(KC_APP); @@ -406,6 +406,6 @@ void fn_tap_reset(qk_tap_dance_state_t *state, void *user_data) { fn_tap_state.state = TD_NONE; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_FN_SWITCH] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, fn_tap_finished, fn_tap_reset) }; diff --git a/keyboards/massdrop/ctrl/keymaps/xanimos/keymap.h b/keyboards/massdrop/ctrl/keymaps/xanimos/keymap.h index 4f5238e702..2dae7131e4 100644 --- a/keyboards/massdrop/ctrl/keymaps/xanimos/keymap.h +++ b/keyboards/massdrop/ctrl/keymaps/xanimos/keymap.h @@ -86,11 +86,11 @@ typedef struct { // Declare your tapdance functions: // Function to determine the current tapdance state -td_state_t cur_dance(qk_tap_dance_state_t *state); +td_state_t cur_dance(tap_dance_state_t *state); // `finished` and `reset` functions for each tapdance keycode -void fn_tap_finished(qk_tap_dance_state_t *state, void *user_data); -void fn_tap_reset(qk_tap_dance_state_t *state, void *user_data); +void fn_tap_finished(tap_dance_state_t *state, void *user_data); +void fn_tap_reset(tap_dance_state_t *state, void *user_data); enum ctrl_keycodes { MD_BOOT = SAFE_RANGE, // Restart into bootloader after hold timeout diff --git a/keyboards/matrix/noah/keymaps/blockader/keymap.c b/keyboards/matrix/noah/keymaps/blockader/keymap.c index b6d9a9acc3..cec0905677 100644 --- a/keyboards/matrix/noah/keymaps/blockader/keymap.c +++ b/keyboards/matrix/noah/keymaps/blockader/keymap.c @@ -32,7 +32,7 @@ enum{ DANCE_PGUP_TOP, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [DANCE_PGDN_BOTTOM] = ACTION_TAP_DANCE_DOUBLE(KC_PGDN, LGUI(KC_DOWN)), [DANCE_PGUP_TOP] = ACTION_TAP_DANCE_DOUBLE(KC_PGUP, LGUI(KC_UP)), }; diff --git a/keyboards/mechanickeys/miniashen40/readme.md b/keyboards/mechanickeys/miniashen40/readme.md index c61398ba1a..67753d37bd 100644 --- a/keyboards/mechanickeys/miniashen40/readme.md +++ b/keyboards/mechanickeys/miniashen40/readme.md @@ -32,7 +32,7 @@ Enter the bootloader in 3 ways: * **Bootmagic reset**: Hold down the key at (0,0) in the matrix (usually the top left key or Escape) and plug in the keyboard * **Physical**: 1. Press and hold `BOOT` switch - 2. Tap `QK_BOOT` switch + 2. Tap `RESET` switch 3. Release `BOOT` switch * **Keycode in layout**: Press the key mapped to `QK_BOOT` if it is available diff --git a/keyboards/mechkeys/mechmini/v2/keymaps/lbibass_625_space/keymap.c b/keyboards/mechkeys/mechmini/v2/keymaps/lbibass_625_space/keymap.c index e39e6d00b2..566a2f9bee 100755 --- a/keyboards/mechkeys/mechmini/v2/keymaps/lbibass_625_space/keymap.c +++ b/keyboards/mechkeys/mechmini/v2/keymaps/lbibass_625_space/keymap.c @@ -11,7 +11,7 @@ enum TD_DOTCOM = 0 }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Esc, twice for Caps Lock [TD_DOTCOM] = ACTION_TAP_DANCE_DOUBLE(KC_COMMA, KC_DOT) // Other declarations would go here, separated by commas, if you have them diff --git a/keyboards/mechkeys/mechmini/v2/keymaps/wsturgiss/keymap.c b/keyboards/mechkeys/mechmini/v2/keymaps/wsturgiss/keymap.c index c55bc30ada..2338bb7d04 100644 --- a/keyboards/mechkeys/mechmini/v2/keymaps/wsturgiss/keymap.c +++ b/keyboards/mechkeys/mechmini/v2/keymaps/wsturgiss/keymap.c @@ -13,7 +13,7 @@ enum { }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for ;, twice for ' -not using this currently [TD_SEMI_QUOT] = ACTION_TAP_DANCE_DOUBLE(KC_SCLN, KC_QUOT), //Tap once for , twice for - diff --git a/keyboards/mechwild/bde/lefty/keymaps/fancy/keymap.c b/keyboards/mechwild/bde/lefty/keymaps/fancy/keymap.c index 3240dbdfb2..b70ac7a8ed 100644 --- a/keyboards/mechwild/bde/lefty/keymaps/fancy/keymap.c +++ b/keyboards/mechwild/bde/lefty/keymaps/fancy/keymap.c @@ -44,9 +44,9 @@ enum { left_enter, }; -uint8_t cur_dance(qk_tap_dance_state_t *state); -void left_enter_finished(qk_tap_dance_state_t *state, void *user_data); -void left_enter_reset(qk_tap_dance_state_t *state, void *user_data); +uint8_t cur_dance(tap_dance_state_t *state); +void left_enter_finished(tap_dance_state_t *state, void *user_data); +void left_enter_reset(tap_dance_state_t *state, void *user_data); @@ -79,7 +79,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -uint8_t cur_dance(qk_tap_dance_state_t *state) { +uint8_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return SINGLE_TAP; // Key has not been interrupted, but the key is still held. Means you want to send a 'HOLD'. @@ -95,7 +95,7 @@ static tap left_enter_tap_state = { .state = 0 }; -void left_enter_finished(qk_tap_dance_state_t *state, void *user_data) { +void left_enter_finished(tap_dance_state_t *state, void *user_data) { left_enter_tap_state.state = cur_dance(state); switch (left_enter_tap_state.state) { //case SINGLE_TAP: register_code(KC_ENT); break; @@ -104,7 +104,7 @@ void left_enter_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void left_enter_reset(qk_tap_dance_state_t *state, void *user_data) { +void left_enter_reset(tap_dance_state_t *state, void *user_data) { switch (left_enter_tap_state.state) { //case SINGLE_TAP: unregister_code(KC_ENT); break; case SINGLE_HOLD: unregister_code(KC_LSFT); break; @@ -113,7 +113,7 @@ void left_enter_reset(qk_tap_dance_state_t *state, void *user_data) { left_enter_tap_state.state = 0; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [left_enter] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, left_enter_finished, left_enter_reset) }; diff --git a/keyboards/mechwild/mercutio/keymaps/fearless_spiff/keymap.c b/keyboards/mechwild/mercutio/keymaps/fearless_spiff/keymap.c index f150c04803..76438f9dc3 100644 --- a/keyboards/mechwild/mercutio/keymaps/fearless_spiff/keymap.c +++ b/keyboards/mechwild/mercutio/keymaps/fearless_spiff/keymap.c @@ -58,7 +58,7 @@ enum { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Tab, twice for Esc [TD_TAB_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_TAB, KC_ESC), }; diff --git a/keyboards/mechwild/mercutio/keymaps/fearless_spiff_en/keymap.c b/keyboards/mechwild/mercutio/keymaps/fearless_spiff_en/keymap.c index b39bc8b123..c79c00a707 100644 --- a/keyboards/mechwild/mercutio/keymaps/fearless_spiff_en/keymap.c +++ b/keyboards/mechwild/mercutio/keymaps/fearless_spiff_en/keymap.c @@ -57,7 +57,7 @@ enum { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Tab, twice for Esc [TD_TAB_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_TAB, KC_ESC), }; diff --git a/keyboards/minimacro5/keymaps/devdev/keymap.c b/keyboards/minimacro5/keymaps/devdev/keymap.c index 3c203fcc37..cb183a91b7 100644 --- a/keyboards/minimacro5/keymaps/devdev/keymap.c +++ b/keyboards/minimacro5/keymaps/devdev/keymap.c @@ -114,7 +114,7 @@ void keyboard_post_init_user(void) { } // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Escape, twice for Caps Lock [TD_TO_DISCORD] = ACTION_TAP_DANCE_LAYER_MOVE(KC_MUTE, _DISCORD), [TD_TO_PHOTOSHOP] = ACTION_TAP_DANCE_LAYER_MOVE(KC_E, _PHOTOSHOP), diff --git a/keyboards/moonlander/config.h b/keyboards/moonlander/config.h index 7db3a184fa..9aff554ace 100644 --- a/keyboards/moonlander/config.h +++ b/keyboards/moonlander/config.h @@ -76,7 +76,7 @@ #define DRIVER_1_LED_TOTAL 36 #define DRIVER_2_LED_TOTAL 36 #define RGB_MATRIX_LED_COUNT (DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL) -#define RGB_MATRIX_CENTER { 125, 26 } +#define RGB_MATRIX_CENTER { 120, 36 } #define RGB_MATRIX_MAXIMUM_BRIGHTNESS 175 #define RGB_MATRIX_FRAMEBUFFER_EFFECTS #define RGB_MATRIX_KEYPRESSES diff --git a/keyboards/moonlander/moonlander.c b/keyboards/moonlander/moonlander.c index 2d6b1f037b..83b5997b53 100644 --- a/keyboards/moonlander/moonlander.c +++ b/keyboards/moonlander/moonlander.c @@ -264,50 +264,54 @@ const is31_led PROGMEM g_is31_leds[RGB_MATRIX_LED_COUNT] = { }; led_config_t g_led_config = { { - { 0, 5, 10, 15, 20, 25, 29 }, - { 1, 6, 11, 16, 21, 26, 30 }, - { 2, 7, 12, 17, 22, 27, 31 }, - { 3, 8, 13, 18, 23, 28, NO_LED }, - { 4, 9, 14, 19, 24, NO_LED, NO_LED }, - { 32, 33, 34, 35, NO_LED, NO_LED, NO_LED }, - { 65, 61, 56, 51, 46, 41, 36 }, - { 66, 62, 57, 52, 47, 42, 37 }, - { 67, 63, 58, 53, 48, 43, 38 }, - { NO_LED, 64, 59, 54, 49, 44, 39 }, - { NO_LED, NO_LED, 60, 55, 50, 45, 40 }, - { NO_LED, NO_LED, NO_LED, 71, 70, 69, 68 }, + { 0, 5, 10, 15, 20, 25, 29 }, + { 1, 6, 11, 16, 21, 26, 30 }, + { 2, 7, 12, 17, 22, 27, 31 }, + { 3, 8, 13, 18, 23, 28, NO_LED }, + { 4, 9, 14, 19, 24, NO_LED, NO_LED }, + { 32, 33, 34, 35, NO_LED, NO_LED, NO_LED }, + { 65, 61, 56, 51, 46, 41, 36 }, + { 66, 62, 57, 52, 47, 42, 37 }, + { 67, 63, 58, 53, 48, 43, 38 }, + { NO_LED, 64, 59, 54, 49, 44, 39 }, + { NO_LED, NO_LED, 60, 55, 50, 45, 40 }, + { NO_LED, NO_LED, NO_LED, 71, 70, 69, 68 } }, { - { 0, 0 }, { 0, 12 }, { 0, 25 }, { 0, 38 }, { 0, 51 }, - { 17, 0 }, { 17, 12 }, { 17, 25 }, { 17, 38 }, { 17, 51 }, - { 34, 0 }, { 34, 12 }, { 34, 25 }, { 34, 38 }, { 34, 51 }, - { 51, 0 }, { 51, 12 }, { 51, 25 }, { 51, 38 }, { 51, 51 }, - { 68, 0 }, { 68, 12 }, { 68, 25 }, { 68, 38 }, { 68, 51 }, - { 86, 0 }, { 86, 12 }, { 86, 25 }, { 86, 38 }, - { 105, 0 }, { 105, 12 }, { 105, 25 }, - { 90, 55 }, { 105, 68 }, { 116, 86 }, { 116, 59 }, - - { 250, 0 }, { 250, 12 }, { 250, 25 }, { 250, 38 }, { 250, 51 }, - { 233, 0 }, { 233, 12 }, { 233, 25 }, { 233, 38 }, { 233, 51 }, - { 216, 0 }, { 216, 12 }, { 216, 25 }, { 216, 38 }, { 216, 51 }, - { 198, 0 }, { 198, 12 }, { 198, 25 }, { 198, 38 }, { 198, 51 }, - { 181, 0 }, { 181, 12 }, { 181, 25 }, { 181, 38 }, { 181, 51 }, - { 163, 0 }, { 163, 12 }, { 163, 25 }, { 163, 38 }, - { 146, 0 }, { 146, 12 }, { 146, 25 }, - { 161, 55 }, { 161, 68 }, { 146, 86 }, { 131, 59 } - + { 0, 4}, { 0, 20}, { 0, 36}, { 0, 52}, { 0, 68}, + { 16, 3}, { 16, 19}, { 16, 35}, { 16, 51}, { 16, 67}, + { 32, 1}, { 32, 17}, { 32, 33}, { 32, 49}, { 32, 65}, + { 48, 0}, { 48, 16}, { 48, 32}, { 48, 48}, { 48, 64}, + { 64, 1}, { 64, 17}, { 64, 33}, { 64, 49}, { 64, 65}, + { 80, 3}, { 80, 19}, { 80, 35}, { 80, 51}, + { 96, 4}, { 96, 20}, { 96, 36}, + { 88, 69}, {100, 80}, {112, 91}, {108, 69}, + + {240, 4}, {240, 20}, {240, 36}, {240, 52}, {240, 68}, + {224, 3}, {224, 19}, {224, 35}, {224, 51}, {224, 67}, + {208, 1}, {208, 17}, {208, 33}, {208, 49}, {208, 65}, + {192, 0}, {192, 16}, {192, 32}, {192, 48}, {192, 64}, + {176, 1}, {176, 17}, {176, 33}, {176, 49}, {176, 65}, + {160, 3}, {160, 19}, {160, 35}, {160, 51}, + {144, 4}, {144, 20}, {144, 36}, + {152, 69}, {140, 80}, {128, 91}, {132, 69} }, { - 1, 1, 1, 1, 1, 4, - 4, 4, 4, 1, 4, 4, - 4, 4, 1, 4, 4, 4, - 4, 1, 4, 4, 4, 4, - 1, 4, 4, 4, 4, 4, - 4, 4, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 4, - 4, 4, 4, 1, 4, 4, - 4, 4, 1, 4, 4, 4, - 4, 1, 4, 4, 4, 4, - 1, 4, 4, 4, 4, 4, - 4, 4, 1, 1, 1, 1 + 1, 1, 1, 1, 1, + 4, 4, 4, 4, 1, + 4, 4, 4, 4, 1, + 4, 4, 4, 4, 1, + 4, 4, 4, 4, 1, + 4, 4, 4, 4, + 1, 1, 1, + 1, 1, 1, 1, + + 1, 1, 1, 1, 1, + 4, 4, 4, 4, 1, + 4, 4, 4, 4, 1, + 4, 4, 4, 4, 1, + 4, 4, 4, 4, 1, + 4, 4, 4, 4, + 1, 1, 1, + 1, 1, 1, 1 } }; // clang-format on diff --git a/keyboards/moonlander/moonlander.h b/keyboards/moonlander/moonlander.h index 19618a9e2a..96e0b0ff14 100644 --- a/keyboards/moonlander/moonlander.h +++ b/keyboards/moonlander/moonlander.h @@ -59,6 +59,34 @@ extern bool mcp23018_leds[]; { KC_NO, KC_NO, ka2, ka3, ka4, ka5, ka6 }, \ { KC_NO, KC_NO, KC_NO, kb3, kb4, kb5, kb6 } \ } + +#define LED_LAYOUT_moonlander( \ + l00, l01, l02, l03, l04, l05, l06, l60, l61, l62, l63, l64, l65, l66, \ + l10, l11, l12, l13, l14, l15, l16, l70, l71, l72, l73, l74, l75, l76, \ + l20, l21, l22, l23, l24, l25, l26, l80, l81, l82, l83, l84, l85, l86, \ + l30, l31, l32, l33, l34, l35, l91, l92, l93, l94, l95, l96, \ + l40, l41, l42, l43, l44, l53, lb3, la2, la3, la4, la5, la6, \ + l50, l51, l52, lb4, lb5, lb6 \ +) \ +{ \ + l00, l10, l20, l30, l40, \ + l01, l11, l21, l31, l41, \ + l02, l12, l22, l32, l42, \ + l03, l13, l23, l33, l43, \ + l04, l14, l24, l34, l44, \ + l05, l15, l25, l35, \ + l06, l16, l26, \ + l50, l51, l52, l53, \ +\ + l66, l76, l86, l96, la6, \ + l65, l75, l85, l95, la5, \ + l64, l74, l84, l94, la4, \ + l63, l73, l83, l93, la3, \ + l62, l72, l82, l92, la2, \ + l61, l71, l81, l91, \ + l60, l70, l80, \ + lb6, lb5, lb4, lb3 \ +} // clang-format on enum planck_ez_keycodes { diff --git a/keyboards/mt/mt980/keymaps/walker/keymap.c b/keyboards/mt/mt980/keymaps/walker/keymap.c index 87e0998687..4e284ec913 100644 --- a/keyboards/mt/mt980/keymaps/walker/keymap.c +++ b/keyboards/mt/mt980/keymaps/walker/keymap.c @@ -20,9 +20,9 @@ enum { ALT_L1 = 0 }; -int cur_dance (qk_tap_dance_state_t *state); -void alt_finished (qk_tap_dance_state_t *state, void *user_data); -void alt_reset (qk_tap_dance_state_t *state, void *user_data); +int cur_dance (tap_dance_state_t *state); +void alt_finished (tap_dance_state_t *state, void *user_data); +void alt_reset (tap_dance_state_t *state, void *user_data); const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { @@ -44,7 +44,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->pressed) return SINGLE_HOLD; else return SINGLE_TAP; @@ -65,7 +65,7 @@ static tap alttap_state = { .state = 0 }; -void alt_finished (qk_tap_dance_state_t *state, void *user_data) { +void alt_finished (tap_dance_state_t *state, void *user_data) { alttap_state.state = cur_dance(state); switch (alttap_state.state) { case SINGLE_TAP: set_oneshot_layer(1, ONESHOT_START); clear_oneshot_layer_state(ONESHOT_PRESSED); break; @@ -75,7 +75,7 @@ void alt_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void alt_reset (qk_tap_dance_state_t *state, void *user_data) { +void alt_reset (tap_dance_state_t *state, void *user_data) { switch (alttap_state.state) { case SINGLE_TAP: break; case SINGLE_HOLD: unregister_code(KC_LALT); break; @@ -85,7 +85,7 @@ void alt_reset (qk_tap_dance_state_t *state, void *user_data) { alttap_state.state = 0; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ALT_L1] = ACTION_TAP_DANCE_FN_ADVANCED(NULL,alt_finished, alt_reset) }; diff --git a/keyboards/nasu/keymaps/mariocs/keymap.c b/keyboards/nasu/keymaps/mariocs/keymap.c index d68ff76dbf..d8cae4295d 100644 --- a/keyboards/nasu/keymaps/mariocs/keymap.c +++ b/keyboards/nasu/keymaps/mariocs/keymap.c @@ -25,7 +25,7 @@ layer_state_t layer_state_set_user(layer_state_t state) { return state; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LGUI] = ACTION_TAP_DANCE_LAYER_TOGGLE(KC_LGUI, 1), }; diff --git a/keyboards/neopad/readme.md b/keyboards/neopad/readme.md index 6d2bd8a288..9e83e9bb6d 100644 --- a/keyboards/neopad/readme.md +++ b/keyboards/neopad/readme.md @@ -19,7 +19,7 @@ Flashing example for this keyboard: make neopad/rev1:default:flash -When asked by the terminal, press the dedicated `QK_BOOT` button (the one above the 2 LEDs) to enter the bootloader and let the OS detects the device. +When asked by the terminal, press the dedicated `RESET` button (the one above the 2 LEDs) to enter the bootloader and let the OS detects the device. See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/numatreus/keymaps/like_jis/keymap.c b/keyboards/numatreus/keymaps/like_jis/keymap.c index fbcbea84c2..bfb258c37e 100644 --- a/keyboards/numatreus/keymaps/like_jis/keymap.c +++ b/keyboards/numatreus/keymaps/like_jis/keymap.c @@ -56,7 +56,7 @@ enum tapdances{ #define KC_CODO TD(TD_CODO) // #define KC_MNUB TD(TD_MNUB) -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_CODO] = ACTION_TAP_DANCE_DOUBLE(KC_COMM, KC_DOT), // [TD_MNUB] = ACTION_TAP_DANCE_DOUBLE(KC_MINS, LSFT(JP_BSLS)), }; diff --git a/keyboards/obosob/steal_this_keyboard/keymaps/default/config.h b/keyboards/obosob/steal_this_keyboard/keymaps/default/config.h index 14ec0792b1..3e3ba7a401 100644 --- a/keyboards/obosob/steal_this_keyboard/keymaps/default/config.h +++ b/keyboards/obosob/steal_this_keyboard/keymaps/default/config.h @@ -36,4 +36,4 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define TAPPING_TERM 200 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 diff --git a/keyboards/palette1202/keymaps/default/config.h b/keyboards/palette1202/keymaps/default/config.h index a5bb9bbfc8..3ec3b391d4 100644 --- a/keyboards/palette1202/keymaps/default/config.h +++ b/keyboards/palette1202/keymaps/default/config.h @@ -16,5 +16,5 @@ #pragma once -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 diff --git a/keyboards/pearlboards/atlas/readme.md b/keyboards/pearlboards/atlas/readme.md index 5161dd2a55..3631df8a29 100644 --- a/keyboards/pearlboards/atlas/readme.md +++ b/keyboards/pearlboards/atlas/readme.md @@ -18,5 +18,5 @@ See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_to Enter the bootloader in 2 ways: -* **Physical reset button**: Briefly press the button on the back of the PCB labeled "QK_BOOT" +* **Physical reset button**: Briefly press the button on the back of the PCB labeled `RESET` * **Keycode in layout**: Press the key mapped to `QK_BOOT` in conjunction with the key mapped to `MO(1))` diff --git a/keyboards/pearlboards/pandora/readme.md b/keyboards/pearlboards/pandora/readme.md index 2ac1d8acbc..c90311507d 100644 --- a/keyboards/pearlboards/pandora/readme.md +++ b/keyboards/pearlboards/pandora/readme.md @@ -15,3 +15,10 @@ Make example for this keyboard (after setting up your build environment): make pearlboards/pandora:default See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). + +## Bootloader + +Enter the bootloader in 2 ways: + +* **Physical reset button**: Briefly press the button on the back of the PCB labeled `RESET` +* **Keycode in layout**: Press the key mapped to `QK_BOOT` in conjunction with the key mapped to `MO(1))` diff --git a/keyboards/pearlboards/pearl/readme.md b/keyboards/pearlboards/pearl/readme.md index e12d59c8b0..8a8d2b9a3b 100644 --- a/keyboards/pearlboards/pearl/readme.md +++ b/keyboards/pearlboards/pearl/readme.md @@ -18,5 +18,5 @@ See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_to Enter the bootloader in 2 ways: -* **Physical reset button**: Briefly press the button on the front left of the PCB labeled "QK_BOOT" +* **Physical reset button**: Briefly press the button on the front left of the PCB labeled `RESET` * **Keycode in layout**: Press the key mapped to `QK_BOOT` in conjunction with the key mapped to `MO(1))` diff --git a/keyboards/pearlboards/zeus/readme.md b/keyboards/pearlboards/zeus/readme.md index 2db71d3c64..b8217e81c1 100644 --- a/keyboards/pearlboards/zeus/readme.md +++ b/keyboards/pearlboards/zeus/readme.md @@ -18,5 +18,5 @@ See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_to Enter the bootloader in 2 ways: -* **Physical reset button**: Briefly press the button on the back of the PCB labeled "QK_BOOT" +* **Physical reset button**: Briefly press the button on the back of the PCB labeled `RESET` * **Keycode in layout**: Press the key mapped to `QK_BOOT` in conjunction with the key mapped to `MO(1))` diff --git a/keyboards/pearlboards/zeuspad/readme.md b/keyboards/pearlboards/zeuspad/readme.md index 690af89b79..b64be5261a 100644 --- a/keyboards/pearlboards/zeuspad/readme.md +++ b/keyboards/pearlboards/zeuspad/readme.md @@ -18,5 +18,5 @@ See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_to Enter the bootloader in 2 ways: -* **Physical reset button**: Briefly press the button on the front of the PCB labeled "QK_BOOT" +* **Physical reset button**: Briefly press the button on the front of the PCB labeled `RESET` * **Keycode in layout**: Press the key mapped to `QK_BOOT` in conjunction with the key mapped to `MO(1))` diff --git a/keyboards/pierce/keymaps/durken1/config.h b/keyboards/pierce/keymaps/durken1/config.h index 7c9970c5a9..7049a692ed 100644 --- a/keyboards/pierce/keymaps/durken1/config.h +++ b/keyboards/pierce/keymaps/durken1/config.h @@ -23,7 +23,7 @@ #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define PERMISSIVE_HOLD diff --git a/keyboards/pinky/3/keymaps/default/config.h b/keyboards/pinky/3/keymaps/default/config.h index 63e8168b47..3671c13a38 100644 --- a/keyboards/pinky/3/keymaps/default/config.h +++ b/keyboards/pinky/3/keymaps/default/config.h @@ -24,6 +24,6 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define RETRO_TAPPPING diff --git a/keyboards/pinky/3/keymaps/ninjonas/config.h b/keyboards/pinky/3/keymaps/ninjonas/config.h index 63e8168b47..3671c13a38 100644 --- a/keyboards/pinky/3/keymaps/ninjonas/config.h +++ b/keyboards/pinky/3/keymaps/ninjonas/config.h @@ -24,6 +24,6 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define RETRO_TAPPPING diff --git a/keyboards/pinky/3/keymaps/via/config.h b/keyboards/pinky/3/keymaps/via/config.h index 63e8168b47..3671c13a38 100644 --- a/keyboards/pinky/3/keymaps/via/config.h +++ b/keyboards/pinky/3/keymaps/via/config.h @@ -24,6 +24,6 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define RETRO_TAPPPING diff --git a/keyboards/pinky/4/keymaps/default/config.h b/keyboards/pinky/4/keymaps/default/config.h index 63e8168b47..3671c13a38 100644 --- a/keyboards/pinky/4/keymaps/default/config.h +++ b/keyboards/pinky/4/keymaps/default/config.h @@ -24,6 +24,6 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define RETRO_TAPPPING diff --git a/keyboards/pinky/4/keymaps/via/config.h b/keyboards/pinky/4/keymaps/via/config.h index 63e8168b47..3671c13a38 100644 --- a/keyboards/pinky/4/keymaps/via/config.h +++ b/keyboards/pinky/4/keymaps/via/config.h @@ -24,6 +24,6 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define RETRO_TAPPPING diff --git a/keyboards/planck/keymaps/adamtabrams/config.h b/keyboards/planck/keymaps/adamtabrams/config.h index 0c275f20c5..d47e552434 100644 --- a/keyboards/planck/keymaps/adamtabrams/config.h +++ b/keyboards/planck/keymaps/adamtabrams/config.h @@ -33,7 +33,7 @@ // Tap-Hold Configs #define TAPPING_TERM 180 #define PERMISSIVE_HOLD -#define IGNORE_MOD_TAP_INTERRUPT -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY -#define TAPPING_FORCE_HOLD -#define TAPPING_FORCE_HOLD_PER_KEY +#define HOLD_ON_OTHER_KEY_PRESS +#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY +#define QUICK_TAP_TERM 0 +#define QUICK_TAP_TERM_PER_KEY diff --git a/keyboards/planck/keymaps/adamtabrams/keymap.c b/keyboards/planck/keymaps/adamtabrams/keymap.c index 3d4aa46963..ce1acd437b 100644 --- a/keyboards/planck/keymaps/adamtabrams/keymap.c +++ b/keyboards/planck/keymaps/adamtabrams/keymap.c @@ -229,7 +229,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case SHFTESC: case NUMSPAC: @@ -249,13 +249,13 @@ bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { case CTL__J: case CTL__T: case CTL__N: - return true; + return 0; default: - return false; + return QUICK_TAP_TERM; } } -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case ALT__A: case ALTSCLN: @@ -272,7 +272,7 @@ bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { case CTL__J: case CTL__T: case CTL__N: - return true; + return false; default: return false; } diff --git a/keyboards/planck/keymaps/altgr/common/keycode_functions.h b/keyboards/planck/keymaps/altgr/common/keycode_functions.h index e0ae15089c..1aed08b37a 100644 --- a/keyboards/planck/keymaps/altgr/common/keycode_functions.h +++ b/keyboards/planck/keymaps/altgr/common/keycode_functions.h @@ -109,7 +109,7 @@ void double_shift(uint16_t keycode, uint8_t layer) } // tap dance LT (LAYER, KEY) emulation with <KEY><DOWN> -> <KEY><SHIFT> and auto-repeat extensions! -void tap_shift(qk_tap_dance_state_t *state, uint16_t keycode, uint8_t layer) +void tap_shift(tap_dance_state_t *state, uint16_t keycode, uint8_t layer) { // double tap plus down if (state->count > 2) { @@ -152,23 +152,23 @@ void tap_reset(uint16_t keycode, uint8_t layer) } // augment pseudo LT (_RSHIFT, KC_ENT) handling below for rapid <ENTER><SHIFT> sequences -void enter(qk_tap_dance_state_t *state, void *user_data) +void enter(tap_dance_state_t *state, void *user_data) { tap_shift(state, KC_ENT, _RSHIFT); } -void enter_reset(qk_tap_dance_state_t *state, void *user_data) +void enter_reset(tap_dance_state_t *state, void *user_data) { tap_reset(KC_ENT, _RSHIFT); } // augment pseudo LT (_LSHIFT, KC_SPC) handling below for rapid <SPACE><SHIFT> sequences -void space(qk_tap_dance_state_t *state, void *user_data) +void space(tap_dance_state_t *state, void *user_data) { tap_shift(state, KC_SPC, _LSHIFT); } -void space_reset(qk_tap_dance_state_t *state, void *user_data) +void space_reset(tap_dance_state_t *state, void *user_data) { tap_reset(KC_SPC, _LSHIFT); } @@ -191,7 +191,7 @@ void double_max(uint8_t count, uint8_t shift, uint16_t keycode) } } -void colon(qk_tap_dance_state_t *state, void *user_data) +void colon(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -205,7 +205,7 @@ void colon(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void eql(qk_tap_dance_state_t *state, void *user_data) +void eql(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key(KC_SPC); @@ -219,7 +219,7 @@ void eql(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void greater(qk_tap_dance_state_t *state, void *user_data) +void greater(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -233,7 +233,7 @@ void greater(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void lesser(qk_tap_dance_state_t *state, void *user_data) +void lesser(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -247,7 +247,7 @@ void lesser(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void tilde(qk_tap_dance_state_t *state, void *user_data) +void tilde(tap_dance_state_t *state, void *user_data) { // double tap plus down: repeating keycode if (state->count > 2) { @@ -264,7 +264,7 @@ void tilde(qk_tap_dance_state_t *state, void *user_data) } } -void tilde_reset(qk_tap_dance_state_t *state, void *user_data) +void tilde_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_GRV); unregister_code(KC_LSFT); @@ -293,7 +293,7 @@ void symbol_pair(uint8_t shift, uint16_t left, uint16_t right) #define CLOSE 1 // tap dance symbol pairs -void tap_pair(qk_tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_t right, uint16_t modifier, uint8_t close) +void tap_pair(tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_t right, uint16_t modifier, uint8_t close) { // triple tap: left right with cursor between symbol pair a la vim :-) if (state->count > 2) { @@ -324,69 +324,69 @@ void tap_pair(qk_tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_ } } -void doublequote(qk_tap_dance_state_t *state, void *user_data) +void doublequote(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_QUOT, KC_QUOT, 0, 0); } -void grave(qk_tap_dance_state_t *state, void *user_data) +void grave(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_GRV, KC_GRV, 0, 0); } -void lbrace(qk_tap_dance_state_t *state, void *user_data) +void lbrace(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_LBRC, KC_RBRC, 0, 0); } -void lcurly(qk_tap_dance_state_t *state, void *user_data) +void lcurly(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_LBRC, KC_RBRC, 0, 0); } -void lparen(qk_tap_dance_state_t *state, void *user_data) +void lparen(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_9, KC_0, KC_LCTL, 0); } -void lparen_reset(qk_tap_dance_state_t *state, void *user_data) +void lparen_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); } -void quote(qk_tap_dance_state_t *state, void *user_data) +void quote(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_QUOT, KC_QUOT, 0, 0); } -void rangle(qk_tap_dance_state_t *state, void *user_data) +void rangle(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_COMM, KC_DOT, 0, CLOSE); } -void rbrace(qk_tap_dance_state_t *state, void *user_data) +void rbrace(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_LBRC, KC_RBRC, 0, CLOSE); } -void rcurly(qk_tap_dance_state_t *state, void *user_data) +void rcurly(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_LBRC, KC_RBRC, 0, CLOSE); } -void rparen(qk_tap_dance_state_t *state, void *user_data) +void rparen(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_9, KC_0, 0, CLOSE); } -void rparen_reset(qk_tap_dance_state_t *state, void *user_data) +void rparen_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); } // ............................................................ Tap Dance Insert -void comma(qk_tap_dance_state_t *state, void *user_data) +void comma(tap_dance_state_t *state, void *user_data) { tap_key(KC_COMM); if (state->count > 1) { @@ -395,7 +395,7 @@ void comma(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void dot(qk_tap_dance_state_t *state, void *user_data) +void dot(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { shift_key(KC_COLN); @@ -407,7 +407,7 @@ void dot(qk_tap_dance_state_t *state, void *user_data) } // compile time macro string, see functions/hardware planck script -void private(qk_tap_dance_state_t *state, void *user_data) +void private(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { #ifdef PRIVATE_STRING @@ -418,7 +418,7 @@ void private(qk_tap_dance_state_t *state, void *user_data) } // config.h defined string -void send(qk_tap_dance_state_t *state, void *user_data) +void send(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { SEND_STRING(PUBLIC_STRING); @@ -428,7 +428,7 @@ void send(qk_tap_dance_state_t *state, void *user_data) // .......................................................... Tap Dance One Shot -void caps(qk_tap_dance_state_t *state, void *user_data) +void caps(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_key(KC_CAPS); @@ -439,14 +439,14 @@ void caps(qk_tap_dance_state_t *state, void *user_data) } } -void caps_reset(qk_tap_dance_state_t *state, void *user_data) +void caps_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LSFT); } // ................................................................... Tap Dance -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [_CAPS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, caps, caps_reset) ,[_COLN] = ACTION_TAP_DANCE_FN (colon) ,[_COMM] = ACTION_TAP_DANCE_FN (comma) diff --git a/keyboards/planck/keymaps/ariccb/keymap.c b/keyboards/planck/keymaps/ariccb/keymap.c index c507a6fe5e..4237955bb5 100644 --- a/keyboards/planck/keymaps/ariccb/keymap.c +++ b/keyboards/planck/keymaps/ariccb/keymap.c @@ -98,11 +98,11 @@ enum { // Declare the functions to be used with your tap dance key(s) // Function associated with all tap dances -td_state_t cur_dance(qk_tap_dance_state_t *state); +td_state_t cur_dance(tap_dance_state_t *state); // Functions associated with individual tap dances -void usl_finished(qk_tap_dance_state_t *state, void *user_data); -void usl_reset(qk_tap_dance_state_t *state, void *user_data); +void usl_finished(tap_dance_state_t *state, void *user_data); +void usl_reset(tap_dance_state_t *state, void *user_data); /* ----------------------------------------------------------------------------------------------------------------------------- */ @@ -304,7 +304,7 @@ layer_state_t layer_state_set_user(layer_state_t state) { return state; } -// void dance_media (qk_tap_dance_state_t *state, void *user_data) +// void dance_media (tap_dance_state_t *state, void *user_data) // if (state->count == 1) { // tap_code(KC_MPLY); // } else if (state->count == 2) { @@ -316,12 +316,12 @@ layer_state_t layer_state_set_user(layer_state_t state) { // } // } -// qk_tap_dance_action_t tap_dance_actions[] = { +// tap_dance_action_t tap_dance_actions[] = { // [0] = ACTION_TAP_DANCE_FN (dance_media), // }; // Determine the current tap dance state -td_state_t cur_dance(qk_tap_dance_state_t *state) { +td_state_t cur_dance(tap_dance_state_t *state) { if (state->interrupted) return TD_SINGLE_HOLD; if (state->count == 1) { if (!state->pressed) return TD_SINGLE_TAP; @@ -337,7 +337,7 @@ static td_tap_t usl_tap_state = { }; // Functions that control what our tap dance key does -void usl_finished(qk_tap_dance_state_t *state, void *user_data) { +void usl_finished(tap_dance_state_t *state, void *user_data) { usl_tap_state.state = cur_dance(state); switch (usl_tap_state.state) { case TD_SINGLE_TAP: @@ -368,7 +368,7 @@ void usl_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void usl_reset(qk_tap_dance_state_t *state, void *user_data) { +void usl_reset(tap_dance_state_t *state, void *user_data) { // If the key was held down and now is released then switch off the layer if (usl_tap_state.state == TD_SINGLE_HOLD) { layer_off(_LOWER); @@ -378,7 +378,7 @@ void usl_reset(qk_tap_dance_state_t *state, void *user_data) { } // Associate our tap dance key with its functionality -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [UNDS_LOWER] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, usl_finished, usl_reset) }; diff --git a/keyboards/planck/keymaps/circuit/keymap.c b/keyboards/planck/keymaps/circuit/keymap.c index d259914d8a..4b3db082a7 100644 --- a/keyboards/planck/keymaps/circuit/keymap.c +++ b/keyboards/planck/keymaps/circuit/keymap.c @@ -36,7 +36,7 @@ enum planck_keycodes { // Tap Dance Definitions #ifdef TAP_DANCE_ENABLE -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [0] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS) }; #endif diff --git a/keyboards/planck/keymaps/copface/keymap.c b/keyboards/planck/keymaps/copface/keymap.c index da23715949..8435ef405d 100644 --- a/keyboards/planck/keymaps/copface/keymap.c +++ b/keyboards/planck/keymaps/copface/keymap.c @@ -53,7 +53,7 @@ enum tapdancers { }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [T_BR] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_RBRC), [T_PA] = ACTION_TAP_DANCE_DOUBLE(KC_LPRN, KC_RPRN), [T_CU] = ACTION_TAP_DANCE_DOUBLE(KC_LCBR, KC_RCBR), diff --git a/keyboards/planck/keymaps/corvec/tapdance.c b/keyboards/planck/keymaps/corvec/tapdance.c index a597fe29fa..35eef2d838 100644 --- a/keyboards/planck/keymaps/corvec/tapdance.c +++ b/keyboards/planck/keymaps/corvec/tapdance.c @@ -30,7 +30,7 @@ typedef struct { int state; } tap; -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) { return SINGLE_TAP; @@ -57,7 +57,7 @@ static tap quote_state = { .state = 0 }; -void quote_finished(qk_tap_dance_state_t *state, void *user_data) { +void quote_finished(tap_dance_state_t *state, void *user_data) { quote_state.state = cur_dance(state); switch(quote_state.state) { case SINGLE_TAP: register_code(KC_QUOT); break; @@ -66,7 +66,7 @@ void quote_finished(qk_tap_dance_state_t *state, void *user_data) { case DOUBLE_SINGLE_TAP: register_code(KC_QUOT); unregister_code(KC_QUOT); register_code(KC_QUOT); break; } } -void quote_reset(qk_tap_dance_state_t *state, void *user_data) { +void quote_reset(tap_dance_state_t *state, void *user_data) { switch(quote_state.state) { case SINGLE_TAP: unregister_code(KC_QUOT); break; case SINGLE_HOLD: layer_off(_LEANDOWN); break; @@ -85,7 +85,7 @@ static tap ralt_state = { .state = 0 }; -void ralt_finished(qk_tap_dance_state_t *state, void *user_data) { +void ralt_finished(tap_dance_state_t *state, void *user_data) { ralt_state.state = cur_dance(state); switch(ralt_state.state) { case SINGLE_TAP: register_code(KC_LBRC); break; @@ -95,7 +95,7 @@ void ralt_finished(qk_tap_dance_state_t *state, void *user_data) { case DOUBLE_SINGLE_TAP: register_code(KC_RALT); break; } } -void ralt_reset(qk_tap_dance_state_t *state, void *user_data) { +void ralt_reset(tap_dance_state_t *state, void *user_data) { switch(ralt_state.state) { case SINGLE_TAP: unregister_code(KC_LBRC); break; case SINGLE_HOLD: unregister_code(KC_RALT); break; @@ -114,7 +114,7 @@ static tap rgui_state = { .state = 0 }; -void rgui_finished(qk_tap_dance_state_t *state, void *user_data) { +void rgui_finished(tap_dance_state_t *state, void *user_data) { rgui_state.state = cur_dance(state); switch(rgui_state.state) { case SINGLE_TAP: register_code(KC_RBRC); break; @@ -124,7 +124,7 @@ void rgui_finished(qk_tap_dance_state_t *state, void *user_data) { case DOUBLE_SINGLE_TAP: register_code(KC_RGUI); break; } } -void rgui_reset(qk_tap_dance_state_t *state, void *user_data) { +void rgui_reset(tap_dance_state_t *state, void *user_data) { switch(rgui_state.state) { case SINGLE_TAP: unregister_code(KC_RBRC); break; case SINGLE_HOLD: unregister_code(KC_RGUI); break; @@ -146,7 +146,7 @@ enum { TD_RBRC_RGUI_RCBR }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Alt, twice for Shift [TD_ALT_SHIFT] = ACTION_TAP_DANCE_DOUBLE(KC_RALT, KC_RSFT), [TD_QUOT_LEAN_MINS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, quote_finished, quote_reset), diff --git a/keyboards/planck/keymaps/davidrambo/keymap.c b/keyboards/planck/keymaps/davidrambo/keymap.c index bd0603a760..2770bb60e3 100644 --- a/keyboards/planck/keymaps/davidrambo/keymap.c +++ b/keyboards/planck/keymaps/davidrambo/keymap.c @@ -91,7 +91,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Shift vs capslock function. From bbaserdem's Planck keymap. -void caps_tap (qk_tap_dance_state_t *state, void *user_data) { +void caps_tap (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code (KC_LSFT); } else if (state->count == 2) { @@ -99,7 +99,7 @@ void caps_tap (qk_tap_dance_state_t *state, void *user_data) { register_code (KC_CAPS); } } -void caps_tap_end (qk_tap_dance_state_t *state, void *user_data) { +void caps_tap_end (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_LSFT); } else { @@ -108,7 +108,7 @@ void caps_tap_end (qk_tap_dance_state_t *state, void *user_data) { } //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Shift, twice for Caps Lock [SFT_LCK] = ACTION_TAP_DANCE_FN_ADVANCED( caps_tap, NULL, caps_tap_end ) }; diff --git a/keyboards/planck/keymaps/dc/keymap.c b/keyboards/planck/keymaps/dc/keymap.c index 83b6f9eaad..6a4da9546f 100644 --- a/keyboards/planck/keymaps/dc/keymap.c +++ b/keyboards/planck/keymaps/dc/keymap.c @@ -26,7 +26,7 @@ enum tap_dance_codes { CT_DEL_ESC }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [0] = ACTION_TAP_DANCE_DOUBLE(KC_SCLN, KC_LPRN), [1] = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_LCBR), [2] = ACTION_TAP_DANCE_DOUBLE(KC_J, KC_LBRC), diff --git a/keyboards/planck/keymaps/dodger/keymap.c b/keyboards/planck/keymaps/dodger/keymap.c index 1ef2645395..76493e714d 100644 --- a/keyboards/planck/keymaps/dodger/keymap.c +++ b/keyboards/planck/keymaps/dodger/keymap.c @@ -44,7 +44,7 @@ enum { TD_ESC_CAPS }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SPC_ENT] = ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT), [TD_ESC_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS) }; diff --git a/keyboards/planck/keymaps/dr_notsokind/keymap.c b/keyboards/planck/keymaps/dr_notsokind/keymap.c index 901c7cc23e..0338e1806e 100644 --- a/keyboards/planck/keymaps/dr_notsokind/keymap.c +++ b/keyboards/planck/keymaps/dr_notsokind/keymap.c @@ -50,7 +50,7 @@ enum planck_keycodes { // Tap Dance Definitions #ifdef TAP_DANCE_ENABLE -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [0] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS) }; #endif diff --git a/keyboards/planck/keymaps/dvorak2space/keymap.c b/keyboards/planck/keymaps/dvorak2space/keymap.c index 08d56dd97a..928f71ab1c 100644 --- a/keyboards/planck/keymaps/dvorak2space/keymap.c +++ b/keyboards/planck/keymaps/dvorak2space/keymap.c @@ -179,7 +179,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { //X_KEY doesn' }; //tapdance state evaluation -int cur_dance(qk_tap_dance_state_t *state) { +int cur_dance(tap_dance_state_t *state) { int press = 0; switch(state->count) { case 1: @@ -196,11 +196,11 @@ int cur_dance(qk_tap_dance_state_t *state) { return press; } -void back_tap(qk_tap_dance_state_t *state, void *user_data) { tap_code(KC_BACKSPACE); } +void back_tap(tap_dance_state_t *state, void *user_data) { tap_code(KC_BACKSPACE); } -void back_finished(qk_tap_dance_state_t *state, void *user_data) { if(!(state->interrupted || !state->pressed)) tap_code16(LCTL(KC_BACKSPACE)); } +void back_finished(tap_dance_state_t *state, void *user_data) { if(!(state->interrupted || !state->pressed)) tap_code16(LCTL(KC_BACKSPACE)); } -void slash_finished(qk_tap_dance_state_t *state, void *user_data) { +void slash_finished(tap_dance_state_t *state, void *user_data) { int td_state = cur_dance(state); switch(td_state) { case SINGLE_TAP: @@ -213,7 +213,7 @@ void slash_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dash_finished(qk_tap_dance_state_t *state, void *user_data) { +void dash_finished(tap_dance_state_t *state, void *user_data) { int td_state = cur_dance(state); switch(td_state) { case SINGLE_TAP: @@ -233,7 +233,7 @@ void dash_finished(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [LPN] = ACTION_TAP_DANCE_DOUBLE(KC_LPRN, KC_LBRC), [RPN] = ACTION_TAP_DANCE_DOUBLE(KC_RPRN, KC_RBRC), [FB] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, slash_finished, NULL), diff --git a/keyboards/planck/keymaps/hiea/common/keycode_functions.h b/keyboards/planck/keymaps/hiea/common/keycode_functions.h index e0ae15089c..1aed08b37a 100644 --- a/keyboards/planck/keymaps/hiea/common/keycode_functions.h +++ b/keyboards/planck/keymaps/hiea/common/keycode_functions.h @@ -109,7 +109,7 @@ void double_shift(uint16_t keycode, uint8_t layer) } // tap dance LT (LAYER, KEY) emulation with <KEY><DOWN> -> <KEY><SHIFT> and auto-repeat extensions! -void tap_shift(qk_tap_dance_state_t *state, uint16_t keycode, uint8_t layer) +void tap_shift(tap_dance_state_t *state, uint16_t keycode, uint8_t layer) { // double tap plus down if (state->count > 2) { @@ -152,23 +152,23 @@ void tap_reset(uint16_t keycode, uint8_t layer) } // augment pseudo LT (_RSHIFT, KC_ENT) handling below for rapid <ENTER><SHIFT> sequences -void enter(qk_tap_dance_state_t *state, void *user_data) +void enter(tap_dance_state_t *state, void *user_data) { tap_shift(state, KC_ENT, _RSHIFT); } -void enter_reset(qk_tap_dance_state_t *state, void *user_data) +void enter_reset(tap_dance_state_t *state, void *user_data) { tap_reset(KC_ENT, _RSHIFT); } // augment pseudo LT (_LSHIFT, KC_SPC) handling below for rapid <SPACE><SHIFT> sequences -void space(qk_tap_dance_state_t *state, void *user_data) +void space(tap_dance_state_t *state, void *user_data) { tap_shift(state, KC_SPC, _LSHIFT); } -void space_reset(qk_tap_dance_state_t *state, void *user_data) +void space_reset(tap_dance_state_t *state, void *user_data) { tap_reset(KC_SPC, _LSHIFT); } @@ -191,7 +191,7 @@ void double_max(uint8_t count, uint8_t shift, uint16_t keycode) } } -void colon(qk_tap_dance_state_t *state, void *user_data) +void colon(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -205,7 +205,7 @@ void colon(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void eql(qk_tap_dance_state_t *state, void *user_data) +void eql(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key(KC_SPC); @@ -219,7 +219,7 @@ void eql(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void greater(qk_tap_dance_state_t *state, void *user_data) +void greater(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -233,7 +233,7 @@ void greater(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void lesser(qk_tap_dance_state_t *state, void *user_data) +void lesser(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -247,7 +247,7 @@ void lesser(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void tilde(qk_tap_dance_state_t *state, void *user_data) +void tilde(tap_dance_state_t *state, void *user_data) { // double tap plus down: repeating keycode if (state->count > 2) { @@ -264,7 +264,7 @@ void tilde(qk_tap_dance_state_t *state, void *user_data) } } -void tilde_reset(qk_tap_dance_state_t *state, void *user_data) +void tilde_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_GRV); unregister_code(KC_LSFT); @@ -293,7 +293,7 @@ void symbol_pair(uint8_t shift, uint16_t left, uint16_t right) #define CLOSE 1 // tap dance symbol pairs -void tap_pair(qk_tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_t right, uint16_t modifier, uint8_t close) +void tap_pair(tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_t right, uint16_t modifier, uint8_t close) { // triple tap: left right with cursor between symbol pair a la vim :-) if (state->count > 2) { @@ -324,69 +324,69 @@ void tap_pair(qk_tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_ } } -void doublequote(qk_tap_dance_state_t *state, void *user_data) +void doublequote(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_QUOT, KC_QUOT, 0, 0); } -void grave(qk_tap_dance_state_t *state, void *user_data) +void grave(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_GRV, KC_GRV, 0, 0); } -void lbrace(qk_tap_dance_state_t *state, void *user_data) +void lbrace(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_LBRC, KC_RBRC, 0, 0); } -void lcurly(qk_tap_dance_state_t *state, void *user_data) +void lcurly(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_LBRC, KC_RBRC, 0, 0); } -void lparen(qk_tap_dance_state_t *state, void *user_data) +void lparen(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_9, KC_0, KC_LCTL, 0); } -void lparen_reset(qk_tap_dance_state_t *state, void *user_data) +void lparen_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); } -void quote(qk_tap_dance_state_t *state, void *user_data) +void quote(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_QUOT, KC_QUOT, 0, 0); } -void rangle(qk_tap_dance_state_t *state, void *user_data) +void rangle(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_COMM, KC_DOT, 0, CLOSE); } -void rbrace(qk_tap_dance_state_t *state, void *user_data) +void rbrace(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_LBRC, KC_RBRC, 0, CLOSE); } -void rcurly(qk_tap_dance_state_t *state, void *user_data) +void rcurly(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_LBRC, KC_RBRC, 0, CLOSE); } -void rparen(qk_tap_dance_state_t *state, void *user_data) +void rparen(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_9, KC_0, 0, CLOSE); } -void rparen_reset(qk_tap_dance_state_t *state, void *user_data) +void rparen_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); } // ............................................................ Tap Dance Insert -void comma(qk_tap_dance_state_t *state, void *user_data) +void comma(tap_dance_state_t *state, void *user_data) { tap_key(KC_COMM); if (state->count > 1) { @@ -395,7 +395,7 @@ void comma(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void dot(qk_tap_dance_state_t *state, void *user_data) +void dot(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { shift_key(KC_COLN); @@ -407,7 +407,7 @@ void dot(qk_tap_dance_state_t *state, void *user_data) } // compile time macro string, see functions/hardware planck script -void private(qk_tap_dance_state_t *state, void *user_data) +void private(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { #ifdef PRIVATE_STRING @@ -418,7 +418,7 @@ void private(qk_tap_dance_state_t *state, void *user_data) } // config.h defined string -void send(qk_tap_dance_state_t *state, void *user_data) +void send(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { SEND_STRING(PUBLIC_STRING); @@ -428,7 +428,7 @@ void send(qk_tap_dance_state_t *state, void *user_data) // .......................................................... Tap Dance One Shot -void caps(qk_tap_dance_state_t *state, void *user_data) +void caps(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_key(KC_CAPS); @@ -439,14 +439,14 @@ void caps(qk_tap_dance_state_t *state, void *user_data) } } -void caps_reset(qk_tap_dance_state_t *state, void *user_data) +void caps_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LSFT); } // ................................................................... Tap Dance -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [_CAPS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, caps, caps_reset) ,[_COLN] = ACTION_TAP_DANCE_FN (colon) ,[_COMM] = ACTION_TAP_DANCE_FN (comma) diff --git a/keyboards/planck/keymaps/hieax/common/keycode_functions.h b/keyboards/planck/keymaps/hieax/common/keycode_functions.h index a26b562fff..ecf3636ae8 100644 --- a/keyboards/planck/keymaps/hieax/common/keycode_functions.h +++ b/keyboards/planck/keymaps/hieax/common/keycode_functions.h @@ -115,7 +115,7 @@ void double_shift(uint16_t keycode, uint8_t layer) } // tap dance LT (LAYER, KEY) emulation with <KEY><DOWN> -> <KEY><SHIFT> and auto-repeat extensions! -void tap_shift(qk_tap_dance_state_t *state, uint16_t keycode, uint8_t layer) +void tap_shift(tap_dance_state_t *state, uint16_t keycode, uint8_t layer) { // double tap plus down if (state->count > 2) { @@ -158,23 +158,23 @@ void tap_reset(uint16_t keycode, uint8_t layer) } // augment pseudo LT (_RSHIFT, KC_ENT) handling below for rapid <ENTER><SHIFT> sequences -void enter(qk_tap_dance_state_t *state, void *user_data) +void enter(tap_dance_state_t *state, void *user_data) { tap_shift(state, KC_ENT, _RSHIFT); } -void enter_reset(qk_tap_dance_state_t *state, void *user_data) +void enter_reset(tap_dance_state_t *state, void *user_data) { tap_reset(KC_ENT, _RSHIFT); } // augment pseudo LT (_LSHIFT, KC_SPC) handling below for rapid <SPACE><SHIFT> sequences -void space(qk_tap_dance_state_t *state, void *user_data) +void space(tap_dance_state_t *state, void *user_data) { tap_shift(state, KC_SPC, _LSHIFT); } -void space_reset(qk_tap_dance_state_t *state, void *user_data) +void space_reset(tap_dance_state_t *state, void *user_data) { tap_reset(KC_SPC, _LSHIFT); } @@ -197,7 +197,7 @@ void double_max(uint8_t count, uint8_t shift, uint16_t keycode) } } -void colon(qk_tap_dance_state_t *state, void *user_data) +void colon(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -211,7 +211,7 @@ void colon(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void eql(qk_tap_dance_state_t *state, void *user_data) +void eql(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key(KC_SPC); @@ -225,7 +225,7 @@ void eql(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void greater(qk_tap_dance_state_t *state, void *user_data) +void greater(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -239,7 +239,7 @@ void greater(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void lesser(qk_tap_dance_state_t *state, void *user_data) +void lesser(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -253,7 +253,7 @@ void lesser(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void tilde(qk_tap_dance_state_t *state, void *user_data) +void tilde(tap_dance_state_t *state, void *user_data) { // double tap plus down: repeating keycode if (state->count > 2) { @@ -270,7 +270,7 @@ void tilde(qk_tap_dance_state_t *state, void *user_data) } } -void tilde_reset(qk_tap_dance_state_t *state, void *user_data) +void tilde_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_GRV); unregister_code(KC_LSFT); @@ -299,7 +299,7 @@ void symbol_pair(uint8_t shift, uint16_t left, uint16_t right) #define CLOSE 1 // tap dance symbol pairs -void tap_pair(qk_tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_t right, uint16_t modifier, uint8_t close) +void tap_pair(tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_t right, uint16_t modifier, uint8_t close) { // triple tap: left right with cursor between symbol pair a la vim :-) if (state->count > 2) { @@ -330,69 +330,69 @@ void tap_pair(qk_tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_ } } -void doublequote(qk_tap_dance_state_t *state, void *user_data) +void doublequote(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_QUOT, KC_QUOT, 0, 0); } -void grave(qk_tap_dance_state_t *state, void *user_data) +void grave(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_GRV, KC_GRV, 0, 0); } -void lbrace(qk_tap_dance_state_t *state, void *user_data) +void lbrace(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_LBRC, KC_RBRC, 0, 0); } -void lcurly(qk_tap_dance_state_t *state, void *user_data) +void lcurly(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_LBRC, KC_RBRC, 0, 0); } -void lparen(qk_tap_dance_state_t *state, void *user_data) +void lparen(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_9, KC_0, KC_LCTL, 0); } -void lparen_reset(qk_tap_dance_state_t *state, void *user_data) +void lparen_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); } -void quote(qk_tap_dance_state_t *state, void *user_data) +void quote(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_QUOT, KC_QUOT, 0, 0); } -void rangle(qk_tap_dance_state_t *state, void *user_data) +void rangle(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_COMM, KC_DOT, 0, CLOSE); } -void rbrace(qk_tap_dance_state_t *state, void *user_data) +void rbrace(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_LBRC, KC_RBRC, 0, CLOSE); } -void rcurly(qk_tap_dance_state_t *state, void *user_data) +void rcurly(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_LBRC, KC_RBRC, 0, CLOSE); } -void rparen(qk_tap_dance_state_t *state, void *user_data) +void rparen(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_9, KC_0, 0, CLOSE); } -void rparen_reset(qk_tap_dance_state_t *state, void *user_data) +void rparen_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); } // ............................................................ Tap Dance Insert -void comma(qk_tap_dance_state_t *state, void *user_data) +void comma(tap_dance_state_t *state, void *user_data) { tap_key(KC_COMM); if (state->count > 1) { @@ -401,7 +401,7 @@ void comma(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void dot(qk_tap_dance_state_t *state, void *user_data) +void dot(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { shift_key(KC_COLN); @@ -413,7 +413,7 @@ void dot(qk_tap_dance_state_t *state, void *user_data) } // compile time macro string, see functions/hardware planck script -void private(qk_tap_dance_state_t *state, void *user_data) +void private(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { #ifdef PRIVATE_STRING @@ -424,7 +424,7 @@ void private(qk_tap_dance_state_t *state, void *user_data) } // config.h defined string -void send(qk_tap_dance_state_t *state, void *user_data) +void send(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { SEND_STRING(PUBLIC_STRING); @@ -434,7 +434,7 @@ void send(qk_tap_dance_state_t *state, void *user_data) // .......................................................... Tap Dance One Shot -void caps(qk_tap_dance_state_t *state, void *user_data) +void caps(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_key(KC_CAPS); @@ -445,14 +445,14 @@ void caps(qk_tap_dance_state_t *state, void *user_data) } } -void caps_reset(qk_tap_dance_state_t *state, void *user_data) +void caps_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LSFT); } // ................................................................... Tap Dance -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [_CAPS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, caps, caps_reset) ,[_COLN] = ACTION_TAP_DANCE_FN (colon) ,[_COMM] = ACTION_TAP_DANCE_FN (comma) diff --git a/keyboards/planck/keymaps/jdelkins/keymap.c b/keyboards/planck/keymaps/jdelkins/keymap.c index 521ade05b9..9d306abc78 100644 --- a/keyboards/planck/keymaps/jdelkins/keymap.c +++ b/keyboards/planck/keymaps/jdelkins/keymap.c @@ -40,10 +40,10 @@ enum { int ctl_state = 0; -void ctl_finished(qk_tap_dance_state_t *state, void *user_data) { +void ctl_finished(tap_dance_state_t *state, void *user_data) { ctl_state = cur_dance(state); switch (ctl_state) { - case SINGLE_TAP: qk_leader_start(); break; + case SINGLE_TAP: leader_start(); break; case SINGLE_HOLD: register_code(KC_LCTL); break; case DOUBLE_TAP: tap_code(KC_RCTL); break; case DOUBLE_HOLD: register_code(KC_RCTL); break; @@ -52,7 +52,7 @@ void ctl_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void ctl_reset(qk_tap_dance_state_t *state, void *user_data) { +void ctl_reset(tap_dance_state_t *state, void *user_data) { switch (ctl_state) { case SINGLE_HOLD: unregister_code(KC_LCTL); break; case DOUBLE_HOLD: @@ -61,7 +61,7 @@ void ctl_reset(qk_tap_dance_state_t *state, void *user_data) { ctl_state = 0; } -void g_finished(qk_tap_dance_state_t *state, void *user_data) { +void g_finished(tap_dance_state_t *state, void *user_data) { switch (cur_dance(state)) { case SINGLE_TAP: tap_code16(C(KC_END)); @@ -74,7 +74,7 @@ void g_finished(qk_tap_dance_state_t *state, void *user_data) { int kp_state = 0; -void kp_finished(qk_tap_dance_state_t *state, void *user_data) { +void kp_finished(tap_dance_state_t *state, void *user_data) { kp_state = hold_cur_dance(state); switch (kp_state) { case SINGLE_HOLD: layer_on(_KP); break; @@ -82,7 +82,7 @@ void kp_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void kp_reset(qk_tap_dance_state_t *state, void *user_data) { +void kp_reset(tap_dance_state_t *state, void *user_data) { switch (kp_state) { case SINGLE_HOLD: layer_off(_KP); break; case DOUBLE_HOLD: layer_off(_RPT); break; @@ -96,7 +96,7 @@ enum { TD_KP }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LDCTL] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ctl_finished, ctl_reset), [TD_G] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, g_finished, NULL), [TD_KP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, kp_finished, kp_reset), diff --git a/keyboards/planck/keymaps/jweickm/config.h b/keyboards/planck/keymaps/jweickm/config.h index 3b34ddf832..bd34fca202 100644 --- a/keyboards/planck/keymaps/jweickm/config.h +++ b/keyboards/planck/keymaps/jweickm/config.h @@ -58,7 +58,7 @@ #define TAPPING_TERM_PER_KEY //#define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD_PER_KEY +#define QUICK_TAP_TERM_PER_KEY // settings for LEADER key #define LEADER_PER_KEY_TIMING diff --git a/keyboards/planck/keymaps/jweickm/keymap.c b/keyboards/planck/keymaps/jweickm/keymap.c index b2c317f039..eb3391c171 100644 --- a/keyboards/planck/keymaps/jweickm/keymap.c +++ b/keyboards/planck/keymaps/jweickm/keymap.c @@ -290,7 +290,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // define the tap dance functions -void dance_prn(qk_tap_dance_state_t *state, void *user_data) { +void dance_prn(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(KC_LPRN); } else { @@ -299,7 +299,7 @@ void dance_prn(qk_tap_dance_state_t *state, void *user_data) { tap_code(KC_LEFT); } } -void dance_brc(qk_tap_dance_state_t *state, void *user_data) { +void dance_brc(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code(KC_LBRC); } else { @@ -308,7 +308,7 @@ void dance_brc(qk_tap_dance_state_t *state, void *user_data) { tap_code(KC_LEFT); } } -void dance_cbr(qk_tap_dance_state_t *state, void *user_data) { +void dance_cbr(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(KC_LCBR); } else { @@ -317,7 +317,7 @@ void dance_cbr(qk_tap_dance_state_t *state, void *user_data) { tap_code(KC_LEFT); } } -void dance_prn_de(qk_tap_dance_state_t *state, void *user_data) { +void dance_prn_de(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(KC_ASTR); } else { @@ -326,7 +326,7 @@ void dance_prn_de(qk_tap_dance_state_t *state, void *user_data) { tap_code(KC_LEFT); } } -void dance_brc_de(qk_tap_dance_state_t *state, void *user_data) { +void dance_brc_de(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(RALT(KC_8)); } else { @@ -335,7 +335,7 @@ void dance_brc_de(qk_tap_dance_state_t *state, void *user_data) { tap_code(KC_LEFT); } } -void dance_cbr_de(qk_tap_dance_state_t *state, void *user_data) { +void dance_cbr_de(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(RALT(KC_7)); } else { @@ -344,7 +344,7 @@ void dance_cbr_de(qk_tap_dance_state_t *state, void *user_data) { tap_code(KC_LEFT); } } -void vim_gg(qk_tap_dance_state_t *state, void *user_data) { +void vim_gg(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(LCTL(KC_END)); } else { @@ -352,7 +352,7 @@ void vim_gg(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // declare tap dance actions here [TD_PRN] = ACTION_TAP_DANCE_FN(dance_prn), [TD_BRC] = ACTION_TAP_DANCE_FN(dance_brc), [TD_CBR] = ACTION_TAP_DANCE_FN(dance_cbr), [TD_PRN_DE] = ACTION_TAP_DANCE_FN(dance_prn_de), [TD_BRC_DE] = ACTION_TAP_DANCE_FN(dance_brc_de), [TD_CBR_DE] = ACTION_TAP_DANCE_FN(dance_cbr_de), [TD_VIM_GG] = ACTION_TAP_DANCE_FN(vim_gg)}; @@ -1039,30 +1039,30 @@ bool music_mask_user(uint16_t keycode) { } } -bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case LSFT_T(KC_S): - return true; + return 0; case RSFT_T(KC_E): - return true; + return 0; case LSFT_T(KC_D): - return true; + return 0; case RSFT_T(KC_K): - return true; + return 0; case LSFT_T(KC_F): - return true; + return 0; case RSFT_T(KC_U): - return true; + return 0; case LT(_RAISE, KC_ENT): - return true; + return 0; case LT(_RAISE_DE, KC_ENT): - return true; + return 0; case LT(_LOWER, KC_BSPC): - return true; + return 0; case LT(_LOWER_DE, KC_BSPC): - return true; + return 0; default: - return false; + return QUICK_TAP_TERM; } } diff --git a/keyboards/planck/keymaps/mjuma/keymap.c b/keyboards/planck/keymaps/mjuma/keymap.c index d449b28e51..c5faeb4385 100644 --- a/keyboards/planck/keymaps/mjuma/keymap.c +++ b/keyboards/planck/keymaps/mjuma/keymap.c @@ -36,7 +36,7 @@ enum taps { TD_SHIFT_CAPS = 0 }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SHIFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS) }; diff --git a/keyboards/planck/keymaps/muppetjones/config.h b/keyboards/planck/keymaps/muppetjones/config.h index 1046d21499..1a05bfc837 100644 --- a/keyboards/planck/keymaps/muppetjones/config.h +++ b/keyboards/planck/keymaps/muppetjones/config.h @@ -53,4 +53,4 @@ #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 diff --git a/keyboards/planck/keymaps/roguepullrequest/keymap.c b/keyboards/planck/keymaps/roguepullrequest/keymap.c index 53171593b2..61221601e6 100644 --- a/keyboards/planck/keymaps/roguepullrequest/keymap.c +++ b/keyboards/planck/keymaps/roguepullrequest/keymap.c @@ -31,12 +31,12 @@ enum { SLASH }; -int cur_dance (qk_tap_dance_state_t *state); +int cur_dance (tap_dance_state_t *state); -void x_finished (qk_tap_dance_state_t *state, void *user_data); -void x_reset (qk_tap_dance_state_t *state, void *user_data); -void lshift_finished (qk_tap_dance_state_t *state, void *user_data); -void lshift_reset(qk_tap_dance_state_t *state, void *user_data); +void x_finished (tap_dance_state_t *state, void *user_data); +void x_reset (tap_dance_state_t *state, void *user_data); +void lshift_finished (tap_dance_state_t *state, void *user_data); +void lshift_reset(tap_dance_state_t *state, void *user_data); bool is_alt_tab_active = false; @@ -142,7 +142,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { // Super crazy tap dancing stuff - see quad dance in feature_tap_dance.md -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return SINGLE_TAP; // key not interrupted, but still held sends 'HOLD' @@ -166,7 +166,7 @@ static tap xtap_state = { }; // registering keypresses -void x_finished (qk_tap_dance_state_t *state, void *user_data) { +void x_finished (tap_dance_state_t *state, void *user_data) { xtap_state.state = cur_dance(state); switch (xtap_state.state) { case SINGLE_TAP: register_code16(KC_AT); break; @@ -176,7 +176,7 @@ void x_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void lshift_finished (qk_tap_dance_state_t *state, void *user_data) { +void lshift_finished (tap_dance_state_t *state, void *user_data) { xtap_state.state = cur_dance(state); switch (xtap_state.state) { case SINGLE_TAP: register_code16(KC_LSFT); register_code16(KC_9); break; @@ -185,7 +185,7 @@ void lshift_finished (qk_tap_dance_state_t *state, void *user_data) { case TRIPLE_TAP: register_code16(KC_LSFT); register_code16(KC_LBRC); break; } } -void s_finished (qk_tap_dance_state_t *state, void *user_data) { +void s_finished (tap_dance_state_t *state, void *user_data) { xtap_state.state = cur_dance(state); switch (xtap_state.state) { case SINGLE_TAP: register_code16(KC_S); break; @@ -194,7 +194,7 @@ void s_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void rshift_finished (qk_tap_dance_state_t *state, void *user_data) { +void rshift_finished (tap_dance_state_t *state, void *user_data) { xtap_state.state = cur_dance(state); switch (xtap_state.state) { case SINGLE_TAP: register_code16(KC_LSFT); register_code16(KC_0); break; @@ -206,7 +206,7 @@ void rshift_finished (qk_tap_dance_state_t *state, void *user_data) { // forgetting keypresses -void x_reset (qk_tap_dance_state_t *state, void *user_data) { +void x_reset (tap_dance_state_t *state, void *user_data) { switch (xtap_state.state) { case SINGLE_TAP: unregister_code16(KC_AT); break; case SINGLE_HOLD: clear_oneshot_layer_state(ONESHOT_PRESSED); break; @@ -215,7 +215,7 @@ void x_reset (qk_tap_dance_state_t *state, void *user_data) { } xtap_state.state = 0; } -void lshift_reset (qk_tap_dance_state_t *state, void *user_data) { +void lshift_reset (tap_dance_state_t *state, void *user_data) { switch (xtap_state.state) { case SINGLE_TAP: unregister_code16(KC_9); unregister_code16(KC_LSFT); break; case SINGLE_HOLD: unregister_code16(KC_LSFT); break; @@ -225,7 +225,7 @@ void lshift_reset (qk_tap_dance_state_t *state, void *user_data) { xtap_state.state = 0; } -void rshift_reset (qk_tap_dance_state_t *state, void *user_data) { +void rshift_reset (tap_dance_state_t *state, void *user_data) { switch (xtap_state.state) { case SINGLE_TAP: unregister_code16(KC_0); unregister_code16(KC_LSFT); break; case SINGLE_HOLD: unregister_code16(KC_RSFT); break; @@ -234,7 +234,7 @@ void rshift_reset (qk_tap_dance_state_t *state, void *user_data) { } xtap_state.state = 0; } -void s_reset (qk_tap_dance_state_t *state, void *user_data) { +void s_reset (tap_dance_state_t *state, void *user_data) { switch (xtap_state.state) { case SINGLE_TAP: unregister_code16(KC_S); break; case DOUBLE_TAP: unregister_code16(KC_MINUS); break; @@ -242,7 +242,7 @@ void s_reset (qk_tap_dance_state_t *state, void *user_data) { } xtap_state.state = 0; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [X_AT_FUN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished, x_reset), [LSHIFT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, lshift_finished, lshift_reset), [RSHIFT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, rshift_finished, rshift_reset), diff --git a/keyboards/planck/keymaps/rootiest/config.h b/keyboards/planck/keymaps/rootiest/config.h index 4de638ce29..1cca7e5ba9 100644 --- a/keyboards/planck/keymaps/rootiest/config.h +++ b/keyboards/planck/keymaps/rootiest/config.h @@ -117,8 +117,8 @@ * MACRO per-key options */ #define RETRO_TAPPING_PER_KEY // Control Retro-Tap individually by key -#define TAPPING_FORCE_HOLD_PER_KEY // Control Force-Hold individually by key -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY // Control Mod-Tap-Interrupt individually by key +#define QUICK_TAP_TERM_PER_KEY // Control Quick-Tap individually by key +#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY // Control Hold-on-Other-Key-Press individually by key #define PERMISSIVE_HOLD_PER_KEY // Control Permissive-Hold individually by key #define MK_KINETIC_SPEED // Use kinetic acceleration for mouse-keys diff --git a/keyboards/planck/keymaps/rootiest/keymap.c b/keyboards/planck/keymaps/rootiest/keymap.c index 097f313cca..20034c97e1 100644 --- a/keyboards/planck/keymaps/rootiest/keymap.c +++ b/keyboards/planck/keymaps/rootiest/keymap.c @@ -243,15 +243,15 @@ bool did_leader_succeed; LEADER_EXTERNS(); // Tap-Dance stuffs, initializing functions that are coded further below -td_state_t cur_dance(qk_tap_dance_state_t* state); -void sml_finished(qk_tap_dance_state_t* state, void* user_data); -void sml_reset(qk_tap_dance_state_t* state, void* user_data); -void scap_finished(qk_tap_dance_state_t* state, void* user_data); -void scap_reset(qk_tap_dance_state_t* state, void* user_data); -void slctl_finished(qk_tap_dance_state_t* state, void* user_data); -void slctl_reset(qk_tap_dance_state_t* state, void* user_data); -void slalt_finished(qk_tap_dance_state_t* state, void* user_data); -void slalt_reset(qk_tap_dance_state_t* state, void* user_data); +td_state_t cur_dance(tap_dance_state_t* state); +void sml_finished(tap_dance_state_t* state, void* user_data); +void sml_reset(tap_dance_state_t* state, void* user_data); +void scap_finished(tap_dance_state_t* state, void* user_data); +void scap_reset(tap_dance_state_t* state, void* user_data); +void slctl_finished(tap_dance_state_t* state, void* user_data); +void slctl_reset(tap_dance_state_t* state, void* user_data); +void slalt_finished(tap_dance_state_t* state, void* user_data); +void slalt_reset(tap_dance_state_t* state, void* user_data); bool lctl_sticky = false; bool lalt_sticky = false; @@ -1325,7 +1325,7 @@ void rgb_wakeup_sequence(void) { } // Spits out some unicode special characters in response to a tap-dance -void send_degree_symbol(qk_tap_dance_state_t* state, void* user_data) { +void send_degree_symbol(tap_dance_state_t* state, void* user_data) { switch (state->count) { case 4: // ℃ @@ -1369,18 +1369,20 @@ bool get_retro_tapping(uint16_t keycode, keyrecord_t* record) { return false; } } -// Handles per-key configuration of Mod-Tap-Interrupt -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t* record) { +// Handles per-key configuration of Hold-on-Other-Key-Press +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t* record) { switch (keycode) { + case QK_MOD_TAP ... QK_MOD_TAP_MAX: + return true; default: return false; } } -// Handles per-key configuration of Tapping Force-Hold -bool get_tapping_force_hold(uint16_t keycode, keyrecord_t* record) { +// Handles per-key configuration of Quick-Tap +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t* record) { switch (keycode) { default: - return false; + return QUICK_TAP_TERM; } } // Handles per-key configuration of Permissive-Hold @@ -1395,13 +1397,13 @@ bool get_permissive_hold(uint16_t keycode, keyrecord_t* record) { * by playing sound at different stages of the leader chord */ // Called when you tap the Leader key -void leader_start(void) { +void leader_start_user(void) { #ifdef AUDIO_ENABLE PLAY_SONG(leader_started); #endif } // Called when either the leader sequence is completed, or the leader timeout is hit -void leader_end(void) { +void leader_end_user(void) { if (did_leader_succeed) { #ifdef AUDIO_ENABLE PLAY_SONG(leader_succeed); @@ -1414,7 +1416,7 @@ void leader_end(void) { } // Monitors and labels the current state of any tap-dances -td_state_t cur_dance(qk_tap_dance_state_t* state) { +td_state_t cur_dance(tap_dance_state_t* state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return TD_SINGLE_TAP; // Key has not been interrupted, but the key is still held. Means you want to send a 'HOLD'. @@ -1444,7 +1446,7 @@ static td_tap_t slctl_state = {.is_press_action = true, .state = TD_NONE}; static td_tap_t slalt_state = {.is_press_action = true, .state = TD_NONE}; // Left-Shift->Sticky-Caps tap-dance finished -void scap_finished(qk_tap_dance_state_t* state, void* user_data) { +void scap_finished(tap_dance_state_t* state, void* user_data) { scap_state.state = cur_dance(state); switch (scap_state.state) { case TD_SINGLE_HOLD: @@ -1469,13 +1471,13 @@ void scap_finished(qk_tap_dance_state_t* state, void* user_data) { } // Left-Shift->Sticky-Caps tap-dance reset -void scap_reset(qk_tap_dance_state_t* state, void* user_data) { +void scap_reset(tap_dance_state_t* state, void* user_data) { unregister_code(KC_LSFT); scap_state.state = TD_NONE; } // Sticky-Left-Control tap-dance finished -void slctl_finished(qk_tap_dance_state_t* state, void* user_data) { +void slctl_finished(tap_dance_state_t* state, void* user_data) { slctl_state.state = cur_dance(state); switch (slctl_state.state) { case TD_SINGLE_HOLD: @@ -1505,7 +1507,7 @@ void slctl_finished(qk_tap_dance_state_t* state, void* user_data) { } // Sticky-Left-Control tap-dance reset -void slctl_reset(qk_tap_dance_state_t* state, void* user_data) { +void slctl_reset(tap_dance_state_t* state, void* user_data) { if (!lctl_sticky) { unregister_code(KC_LCTL); slctl_state.state = TD_NONE; @@ -1515,7 +1517,7 @@ void slctl_reset(qk_tap_dance_state_t* state, void* user_data) { } // Sticky-Left-Alt tap-dance finished -void slalt_finished(qk_tap_dance_state_t* state, void* user_data) { +void slalt_finished(tap_dance_state_t* state, void* user_data) { slalt_state.state = cur_dance(state); switch (slalt_state.state) { case TD_SINGLE_HOLD: @@ -1545,7 +1547,7 @@ void slalt_finished(qk_tap_dance_state_t* state, void* user_data) { } // Sticky-Left-Alt tap-dance reset -void slalt_reset(qk_tap_dance_state_t* state, void* user_data) { +void slalt_reset(tap_dance_state_t* state, void* user_data) { if (!lalt_sticky) { unregister_code(KC_LALT); slalt_state.state = TD_NONE; @@ -1555,7 +1557,7 @@ void slalt_reset(qk_tap_dance_state_t* state, void* user_data) { } // Smiley key tap-dance finished -void sml_finished(qk_tap_dance_state_t* state, void* user_data) { +void sml_finished(tap_dance_state_t* state, void* user_data) { sml_state.state = cur_dance(state); switch (sml_state.state) { default: @@ -1651,10 +1653,10 @@ void sml_finished(qk_tap_dance_state_t* state, void* user_data) { break; } } -void sml_reset(qk_tap_dance_state_t* state, void* user_data) { sml_state.state = TD_NONE; } +void sml_reset(tap_dance_state_t* state, void* user_data) { sml_state.state = TD_NONE; } // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for °, twice for ℉, thrice for ℃ [TD_DEG_DEGF] = ACTION_TAP_DANCE_FN(send_degree_symbol), // [TD_LSHFT_CAPS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, scap_finished, scap_reset), // diff --git a/keyboards/planck/keymaps/sdothum/common/keycode_functions.h b/keyboards/planck/keymaps/sdothum/common/keycode_functions.h index 08c5deca51..86d2645b4c 100644 --- a/keyboards/planck/keymaps/sdothum/common/keycode_functions.h +++ b/keyboards/planck/keymaps/sdothum/common/keycode_functions.h @@ -109,7 +109,7 @@ void double_shift(uint16_t keycode, uint8_t layer) } // tap dance LT (LAYER, KEY) emulation with <KEY><DOWN> -> <KEY><SHIFT> and auto-repeat extensions! -void tap_shift(qk_tap_dance_state_t *state, uint16_t keycode, uint8_t layer) +void tap_shift(tap_dance_state_t *state, uint16_t keycode, uint8_t layer) { // double tap plus down if (state->count > 2) { @@ -152,23 +152,23 @@ void tap_reset(uint16_t keycode, uint8_t layer) } // augment pseudo LT (_RSHIFT, KC_ENT) handling below for rapid <ENTER><SHIFT> sequences -void enter(qk_tap_dance_state_t *state, void *user_data) +void enter(tap_dance_state_t *state, void *user_data) { tap_shift(state, KC_ENT, _RSHIFT); } -void enter_reset(qk_tap_dance_state_t *state, void *user_data) +void enter_reset(tap_dance_state_t *state, void *user_data) { tap_reset(KC_ENT, _RSHIFT); } // augment pseudo LT (_LSHIFT, KC_SPC) handling below for rapid <SPACE><SHIFT> sequences -void space(qk_tap_dance_state_t *state, void *user_data) +void space(tap_dance_state_t *state, void *user_data) { tap_shift(state, KC_SPC, _LSHIFT); } -void space_reset(qk_tap_dance_state_t *state, void *user_data) +void space_reset(tap_dance_state_t *state, void *user_data) { tap_reset(KC_SPC, _LSHIFT); } @@ -191,7 +191,7 @@ void double_max(uint8_t count, uint8_t shift, uint16_t keycode) } } -void colon(qk_tap_dance_state_t *state, void *user_data) +void colon(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -205,7 +205,7 @@ void colon(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void eql(qk_tap_dance_state_t *state, void *user_data) +void eql(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key(KC_SPC); @@ -219,7 +219,7 @@ void eql(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void greater(qk_tap_dance_state_t *state, void *user_data) +void greater(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -233,7 +233,7 @@ void greater(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void lesser(qk_tap_dance_state_t *state, void *user_data) +void lesser(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_key (KC_SPC); @@ -247,7 +247,7 @@ void lesser(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void tilde(qk_tap_dance_state_t *state, void *user_data) +void tilde(tap_dance_state_t *state, void *user_data) { // double tap plus down: repeating keycode if (state->count > 2) { @@ -264,7 +264,7 @@ void tilde(qk_tap_dance_state_t *state, void *user_data) } } -void tilde_reset(qk_tap_dance_state_t *state, void *user_data) +void tilde_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_GRV); unregister_code(KC_LSFT); @@ -293,7 +293,7 @@ void symbol_pair(uint8_t shift, uint16_t left, uint16_t right) #define CLOSE 1 // tap dance symbol pairs -void tap_pair(qk_tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_t right, uint16_t modifier, uint8_t close) +void tap_pair(tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_t right, uint16_t modifier, uint8_t close) { // triple tap: left right with cursor between symbol pair a la vim :-) if (state->count > 2) { @@ -324,69 +324,69 @@ void tap_pair(qk_tap_dance_state_t *state, uint8_t shift, uint16_t left, uint16_ } } -void doublequote(qk_tap_dance_state_t *state, void *user_data) +void doublequote(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_QUOT, KC_QUOT, 0, 0); } -void grave(qk_tap_dance_state_t *state, void *user_data) +void grave(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_GRV, KC_GRV, 0, 0); } -void lbrace(qk_tap_dance_state_t *state, void *user_data) +void lbrace(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_LBRC, KC_RBRC, 0, 0); } -void lcurly(qk_tap_dance_state_t *state, void *user_data) +void lcurly(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_LBRC, KC_RBRC, 0, 0); } -void lparen(qk_tap_dance_state_t *state, void *user_data) +void lparen(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_9, KC_0, KC_LCTL, 0); } -void lparen_reset(qk_tap_dance_state_t *state, void *user_data) +void lparen_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); } -void quote(qk_tap_dance_state_t *state, void *user_data) +void quote(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_QUOT, KC_QUOT, 0, 0); } -void rangle(qk_tap_dance_state_t *state, void *user_data) +void rangle(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_COMM, KC_DOT, 0, CLOSE); } -void rbrace(qk_tap_dance_state_t *state, void *user_data) +void rbrace(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_NEVER, KC_LBRC, KC_RBRC, 0, CLOSE); } -void rcurly(qk_tap_dance_state_t *state, void *user_data) +void rcurly(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_LBRC, KC_RBRC, 0, CLOSE); } -void rparen(qk_tap_dance_state_t *state, void *user_data) +void rparen(tap_dance_state_t *state, void *user_data) { tap_pair(state, S_ALWAYS, KC_9, KC_0, 0, CLOSE); } -void rparen_reset(qk_tap_dance_state_t *state, void *user_data) +void rparen_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); } // ............................................................ Tap Dance Insert -void comma(qk_tap_dance_state_t *state, void *user_data) +void comma(tap_dance_state_t *state, void *user_data) { tap_key(KC_COMM); if (state->count > 1) { @@ -395,7 +395,7 @@ void comma(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void dot(qk_tap_dance_state_t *state, void *user_data) +void dot(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { shift_key(KC_COLN); @@ -407,7 +407,7 @@ void dot(qk_tap_dance_state_t *state, void *user_data) } // compile time macro string, see functions/hardware planck script -void private(qk_tap_dance_state_t *state, void *user_data) +void private(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { #ifdef PRIVATE_STRING @@ -418,7 +418,7 @@ void private(qk_tap_dance_state_t *state, void *user_data) } // config.h defined string -void send(qk_tap_dance_state_t *state, void *user_data) +void send(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { SEND_STRING(PUBLIC_STRING); @@ -428,7 +428,7 @@ void send(qk_tap_dance_state_t *state, void *user_data) // .......................................................... Tap Dance One Shot -void caps(qk_tap_dance_state_t *state, void *user_data) +void caps(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_key(KC_CAPS); @@ -439,14 +439,14 @@ void caps(qk_tap_dance_state_t *state, void *user_data) } } -void caps_reset(qk_tap_dance_state_t *state, void *user_data) +void caps_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LSFT); } // ................................................................... Tap Dance -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [_CAPS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, caps, caps_reset) ,[_COLN] = ACTION_TAP_DANCE_FN (colon) ,[_COMM] = ACTION_TAP_DANCE_FN (comma) diff --git a/keyboards/planck/keymaps/snowkuma/keymap.c b/keyboards/planck/keymaps/snowkuma/keymap.c index ecf6b0725a..0df04d87fc 100644 --- a/keyboards/planck/keymaps/snowkuma/keymap.c +++ b/keyboards/planck/keymaps/snowkuma/keymap.c @@ -63,13 +63,13 @@ enum { }; // Tap Dance Definitions -void safe_reset(qk_tap_dance_state_t *state, void *user_data) { +void safe_reset(tap_dance_state_t *state, void *user_data) { if (state->count >=3) { // Reset the keyboard if you tap the key more than three times reset_keyboard(); reset_tap_dance(state); } -}; void tilde_home(qk_tap_dance_state_t *state, void *user_data) { +}; void tilde_home(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { register_code(KC_LSFT); register_code(KC_GRV); @@ -86,7 +86,7 @@ void safe_reset(qk_tap_dance_state_t *state, void *user_data) { } } -void tilde_reset(qk_tap_dance_state_t *state, void *user_data) +void tilde_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code(KC_SLSH); @@ -97,7 +97,7 @@ void tilde_reset(qk_tap_dance_state_t *state, void *user_data) } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_RESET] = ACTION_TAP_DANCE_FN (safe_reset), [TD_TILD] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, tilde_home, tilde_reset) }; diff --git a/keyboards/planck/keymaps/tylerwince/config.h b/keyboards/planck/keymaps/tylerwince/config.h index 24adad94f3..52c1494a1d 100644 --- a/keyboards/planck/keymaps/tylerwince/config.h +++ b/keyboards/planck/keymaps/tylerwince/config.h @@ -12,7 +12,7 @@ Set any config.h overrides for your specific keymap here. See config.h options at https://docs.qmk.fm/#/config_options?id=the-configh-file */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define IGNORE_MOD_TAP_INTERRUPT #define EECONFIG_RGB_MATRIX (uint32_t *)16 diff --git a/keyboards/planck/keymaps/tylerwince/keymap.c b/keyboards/planck/keymaps/tylerwince/keymap.c index ae9211f5a5..5477dab6a1 100644 --- a/keyboards/planck/keymaps/tylerwince/keymap.c +++ b/keyboards/planck/keymaps/tylerwince/keymap.c @@ -19,7 +19,7 @@ enum { TD_SEMI_COLON, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SEMI_COLON] = ACTION_TAP_DANCE_DOUBLE(KC_SCLN, KC_COLN), }; diff --git a/keyboards/planck/keymaps/unagi/keymap.c b/keyboards/planck/keymaps/unagi/keymap.c index 0424c5b520..6227a73e4f 100644 --- a/keyboards/planck/keymaps/unagi/keymap.c +++ b/keyboards/planck/keymaps/unagi/keymap.c @@ -178,7 +178,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [SFT_CAP] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS) }; diff --git a/keyboards/planck/keymaps/yhaliaw/keymap.c b/keyboards/planck/keymaps/yhaliaw/keymap.c index 54bf431f22..62d856e9f2 100644 --- a/keyboards/planck/keymaps/yhaliaw/keymap.c +++ b/keyboards/planck/keymaps/yhaliaw/keymap.c @@ -187,7 +187,7 @@ void matrix_scan_user(void) { } } -void leader_end(void) { +void leader_end_user(void) { // Plays sound on if leader sequence found. if (leader_found) { #ifdef AUDIO_ENABLE diff --git a/keyboards/planck/keymaps/zach/zach_common_functions.c b/keyboards/planck/keymaps/zach/zach_common_functions.c index 7a594b567f..b6e8d9be47 100644 --- a/keyboards/planck/keymaps/zach/zach_common_functions.c +++ b/keyboards/planck/keymaps/zach/zach_common_functions.c @@ -68,7 +68,7 @@ float unilin[][2] = SONG(UNICODE_LINUX); #ifdef TAP_DANCE_ENABLE #define TAPPING_TERM 200 -void dance_raise_press(qk_tap_dance_state_t *state, void *user_data){// Called on each tap +void dance_raise_press(tap_dance_state_t *state, void *user_data){// Called on each tap switch(state->count){ // Only turn the layer on once case 1: layer_off(_UNICODES); @@ -77,7 +77,7 @@ void dance_raise_press(qk_tap_dance_state_t *state, void *user_data){// Called o break; } }; -void dance_raise_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release +void dance_raise_lift(tap_dance_state_t *state, void *user_data){ // Called on release switch(state->count){ case 1: // Normal action. Turn off layers layer_off(_RAISE); @@ -87,7 +87,7 @@ void dance_raise_lift(qk_tap_dance_state_t *state, void *user_data){ // Called o } }; ///////////////////////////////////////////////////////////////////// -void dance_lower_press(qk_tap_dance_state_t *state, void *user_data){// Called on tap +void dance_lower_press(tap_dance_state_t *state, void *user_data){// Called on tap switch(state->count){ case 1: // Turn on lower layer_off(_UNICODES); @@ -96,7 +96,7 @@ void dance_lower_press(qk_tap_dance_state_t *state, void *user_data){// Called o break; } }; -void dance_lower_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release +void dance_lower_lift(tap_dance_state_t *state, void *user_data){ // Called on release switch(state->count){ case 1: // Normal action. Turn off layers layer_off(_LOWER); @@ -114,12 +114,12 @@ void dance_lower_lift(qk_tap_dance_state_t *state, void *user_data){ // Called o } }; ///////////////////////////////////////////////////////////////////// -void dance_super_press(qk_tap_dance_state_t *state, void *user_data){ // Called on down +void dance_super_press(tap_dance_state_t *state, void *user_data){ // Called on down if(state->count == 1){ register_code(KC_LGUI); } } -void dance_super_done(qk_tap_dance_state_t *state, void *user_data){ // Called on timeout +void dance_super_done(tap_dance_state_t *state, void *user_data){ // Called on timeout switch(state->count){ case 2: register_code(KC_LGUI); @@ -128,11 +128,11 @@ void dance_super_done(qk_tap_dance_state_t *state, void *user_data){ // Calle break; } } -void dance_super_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on up +void dance_super_lift(tap_dance_state_t *state, void *user_data){ // Called on up unregister_code(KC_LGUI); } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [RAI] = ACTION_TAP_DANCE_FN_ADVANCED(dance_raise_press, NULL, dance_raise_lift), [LOW] = ACTION_TAP_DANCE_FN_ADVANCED(dance_lower_press, NULL, dance_lower_lift), [SUP] = ACTION_TAP_DANCE_FN_ADVANCED(dance_super_press, dance_super_done, dance_super_lift) diff --git a/keyboards/polycarbdiet/s20/readme.md b/keyboards/polycarbdiet/s20/readme.md index e40f999a1c..eee783a4ff 100644 --- a/keyboards/polycarbdiet/s20/readme.md +++ b/keyboards/polycarbdiet/s20/readme.md @@ -17,7 +17,7 @@ Flashing example for this keyboard: make polycarbdiet/s20:default:flash **Reset Method:** -- Press the `QK_BOOT` button on the under side of the PCB +- Press the `RESET` button on the under side of the PCB **Bootloader Method:** - Hold down the key located at `K00`, commonly programmed as `ESC`, while plugging in the keyboard. diff --git a/keyboards/preonic/keymaps/choromanski/keymap.c b/keyboards/preonic/keymaps/choromanski/keymap.c index dd4a151980..ce7be97a57 100644 --- a/keyboards/preonic/keymaps/choromanski/keymap.c +++ b/keyboards/preonic/keymaps/choromanski/keymap.c @@ -21,7 +21,7 @@ enum { }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for 1, twice for Grave [G1] = ACTION_TAP_DANCE_DOUBLE(KC_1, KC_GRV), //Tap once for [, twice for ] diff --git a/keyboards/preonic/keymaps/davidrambo/keymap.c b/keyboards/preonic/keymaps/davidrambo/keymap.c index 823bcb6862..aca8a7c1e3 100755 --- a/keyboards/preonic/keymaps/davidrambo/keymap.c +++ b/keyboards/preonic/keymaps/davidrambo/keymap.c @@ -156,7 +156,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Shift vs capslock function. From bbaserdem's Planck keymap. -void caps_tap (qk_tap_dance_state_t *state, void *user_data) { +void caps_tap (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code (KC_LSFT); } else if (state->count == 2) { @@ -164,7 +164,7 @@ void caps_tap (qk_tap_dance_state_t *state, void *user_data) { register_code (KC_CAPS); } } -void caps_tap_end (qk_tap_dance_state_t *state, void *user_data) { +void caps_tap_end (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_LSFT); } else { @@ -173,7 +173,7 @@ void caps_tap_end (qk_tap_dance_state_t *state, void *user_data) { } //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Shift, twice for Caps Lock [SFT_LCK] = ACTION_TAP_DANCE_FN_ADVANCED( caps_tap, NULL, caps_tap_end ) }; diff --git a/keyboards/preonic/keymaps/egstad/keymap.c b/keyboards/preonic/keymaps/egstad/keymap.c index 0ea9c339b1..4b1fad7323 100644 --- a/keyboards/preonic/keymaps/egstad/keymap.c +++ b/keyboards/preonic/keymaps/egstad/keymap.c @@ -219,7 +219,7 @@ layer_state_t layer_state_set_user(layer_state_t state) { /* Tap Dance Definitions ========================================================================== */ -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Left Brace, twice for Right Brace [TD_BRC] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_RBRC), //Tap once for Minus, twice for Equal diff --git a/keyboards/preonic/keymaps/era1112/keymap.c b/keyboards/preonic/keymaps/era1112/keymap.c index 43c8ab9572..74ba6772d5 100644 --- a/keyboards/preonic/keymaps/era1112/keymap.c +++ b/keyboards/preonic/keymaps/era1112/keymap.c @@ -66,7 +66,7 @@ typedef struct { td_state_t state; } td_tap_t; -td_state_t cur_dance(qk_tap_dance_state_t* state); +td_state_t cur_dance(tap_dance_state_t* state); /* Return an integer that corresponds to what kind of tap dance should be executed. * @@ -95,7 +95,7 @@ td_state_t cur_dance(qk_tap_dance_state_t* state); * For the third point, there does exist the 'TD_DOUBLE_SINGLE_TAP', however this is not fully tested * */ -td_state_t cur_dance(qk_tap_dance_state_t* state) { +td_state_t cur_dance(tap_dance_state_t* state) { if (state->count == 1) { if (state->interrupted || !state->pressed) { return TD_1_TAP; @@ -117,15 +117,15 @@ td_state_t cur_dance(qk_tap_dance_state_t* state) { //----------- 2tap capslock --------------// //----------------------------------------// -void twoCapsLock_finished(qk_tap_dance_state_t* state, void* user_data); -void twoCapsLock_reset(qk_tap_dance_state_t* state, void* user_data); +void twoCapsLock_finished(tap_dance_state_t* state, void* user_data); +void twoCapsLock_reset(tap_dance_state_t* state, void* user_data); static td_tap_t twoCapsLock_tap_state = { .is_press_action = true, .state = TD_NONE }; -void twoCapsLock_finished(qk_tap_dance_state_t* state, void* user_data) { +void twoCapsLock_finished(tap_dance_state_t* state, void* user_data) { twoCapsLock_tap_state.state = cur_dance(state); switch (twoCapsLock_tap_state.state) { case TD_NONE: register_code(KC_LSFT); break; @@ -142,7 +142,7 @@ void twoCapsLock_finished(qk_tap_dance_state_t* state, void* user_data) { } } -void twoCapsLock_reset(qk_tap_dance_state_t* state, void* user_data) { +void twoCapsLock_reset(tap_dance_state_t* state, void* user_data) { switch (twoCapsLock_tap_state.state) { case TD_UNKNOWN: unregister_code(KC_LSFT); break; case TD_NONE: unregister_code(KC_LSFT); break; @@ -202,7 +202,7 @@ enum custom_keycodes { static bool blinky = false; // Track blinky behavior on/off for keycode -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_2_CAPSLOCK] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, twoCapsLock_finished, twoCapsLock_reset) }; diff --git a/keyboards/preonic/keymaps/mverteuil/keymap.c b/keyboards/preonic/keymaps/mverteuil/keymap.c index c54eff71d5..332e2877b2 100644 --- a/keyboards/preonic/keymaps/mverteuil/keymap.c +++ b/keyboards/preonic/keymaps/mverteuil/keymap.c @@ -75,17 +75,17 @@ typedef struct { t_tap_state right_brackets; } t_tap; -t_tap_state get_tapdance_state(qk_tap_dance_state_t *state); +t_tap_state get_tapdance_state(tap_dance_state_t *state); -void td_numpad_funcrow_finished(qk_tap_dance_state_t *state, void *user_data); -void td_numpad_funcrow_reset(qk_tap_dance_state_t *state, void *user_data); -void td_brackets_left_finished(qk_tap_dance_state_t *state, void *user_data); -void td_brackets_left_reset(qk_tap_dance_state_t *state, void *user_data); -void td_brackets_right_finished(qk_tap_dance_state_t *state, void *user_data); -void td_brackets_right_reset(qk_tap_dance_state_t *state, void *user_data); +void td_numpad_funcrow_finished(tap_dance_state_t *state, void *user_data); +void td_numpad_funcrow_reset(tap_dance_state_t *state, void *user_data); +void td_brackets_left_finished(tap_dance_state_t *state, void *user_data); +void td_brackets_left_reset(tap_dance_state_t *state, void *user_data); +void td_brackets_right_finished(tap_dance_state_t *state, void *user_data); +void td_brackets_right_reset(tap_dance_state_t *state, void *user_data); /* Tap Dance Definitions */ -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { /* Tap once for left parenthesis, twice for left bracket, thrice for left brace */ [TD_BRACKETS_LEFT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_brackets_left_finished, td_brackets_left_reset), /* Tap once for right parenthesis, twice for right bracket, thrice for right brace */ @@ -290,7 +290,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { }; /* Global TapDance State */ -static t_tap qk_tap_state = { +static t_tap tap_state = { .left_brackets = 0, .numpad_funcrow = 0, .right_brackets = 0, @@ -300,7 +300,7 @@ float s_functionrow_on[][2] = LAYER_FUNCROW_ON_SONG; float s_functionrow_off[][2] = LAYER_FUNCROW_OFF_SONG; float s_numpad_toggle[][2] = LAYER_NMPAD_SONG; -t_tap_state get_tapdance_state(qk_tap_dance_state_t *state) { +t_tap_state get_tapdance_state(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) { return SINGLE_TAP; @@ -323,9 +323,9 @@ t_tap_state get_tapdance_state(qk_tap_dance_state_t *state) { return TAP_DANCE_NO_MATCH; } -void td_numpad_funcrow_finished(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_state.numpad_funcrow = get_tapdance_state(state); - switch (qk_tap_state.numpad_funcrow) { +void td_numpad_funcrow_finished(tap_dance_state_t *state, void *user_data) { + tap_state.numpad_funcrow = get_tapdance_state(state); + switch (tap_state.numpad_funcrow) { case SINGLE_TAP ... SINGLE_HOLD: layer_on(_NUMPAD); PLAY_SONG(s_numpad_toggle); @@ -347,8 +347,8 @@ void td_numpad_funcrow_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void td_numpad_funcrow_reset(qk_tap_dance_state_t *state, void *user_data) { - switch (qk_tap_state.numpad_funcrow) { +void td_numpad_funcrow_reset(tap_dance_state_t *state, void *user_data) { + switch (tap_state.numpad_funcrow) { case SINGLE_HOLD: layer_off(_NUMPAD); break; @@ -360,9 +360,9 @@ void td_numpad_funcrow_reset(qk_tap_dance_state_t *state, void *user_data) { } } -void td_brackets_left_finished(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_state.left_brackets = get_tapdance_state(state); - switch (qk_tap_state.left_brackets) { +void td_brackets_left_finished(tap_dance_state_t *state, void *user_data) { + tap_state.left_brackets = get_tapdance_state(state); + switch (tap_state.left_brackets) { case SINGLE_TAP: register_code16(KC_LEFT_PAREN); break; @@ -377,8 +377,8 @@ void td_brackets_left_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void td_brackets_left_reset(qk_tap_dance_state_t *state, void *user_data) { - switch (qk_tap_state.left_brackets) { +void td_brackets_left_reset(tap_dance_state_t *state, void *user_data) { + switch (tap_state.left_brackets) { case SINGLE_TAP: unregister_code16(KC_LEFT_PAREN); break; @@ -391,12 +391,12 @@ void td_brackets_left_reset(qk_tap_dance_state_t *state, void *user_data) { default: break; } - qk_tap_state.left_brackets = 0; + tap_state.left_brackets = 0; } -void td_brackets_right_finished(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_state.right_brackets = get_tapdance_state(state); - switch (qk_tap_state.right_brackets) { +void td_brackets_right_finished(tap_dance_state_t *state, void *user_data) { + tap_state.right_brackets = get_tapdance_state(state); + switch (tap_state.right_brackets) { case SINGLE_TAP: register_code16(KC_RIGHT_PAREN); break; @@ -411,8 +411,8 @@ void td_brackets_right_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void td_brackets_right_reset(qk_tap_dance_state_t *state, void *user_data) { - switch (qk_tap_state.right_brackets) { +void td_brackets_right_reset(tap_dance_state_t *state, void *user_data) { + switch (tap_state.right_brackets) { case SINGLE_TAP: unregister_code16(KC_RIGHT_PAREN); break; @@ -425,7 +425,7 @@ void td_brackets_right_reset(qk_tap_dance_state_t *state, void *user_data) { default: break; } - qk_tap_state.right_brackets = 0; + tap_state.right_brackets = 0; } bool muse_mode = false; diff --git a/keyboards/preonic/keymaps/mverteuil_2x2u/keymap.c b/keyboards/preonic/keymaps/mverteuil_2x2u/keymap.c index a269519339..c6cad0fe5f 100644 --- a/keyboards/preonic/keymaps/mverteuil_2x2u/keymap.c +++ b/keyboards/preonic/keymaps/mverteuil_2x2u/keymap.c @@ -78,15 +78,15 @@ typedef struct { t_tap_state right_brackets; } t_tap; -t_tap_state get_tapdance_state(qk_tap_dance_state_t *state); +t_tap_state get_tapdance_state(tap_dance_state_t *state); -void td_brackets_left_finished(qk_tap_dance_state_t *state, void *user_data); -void td_brackets_left_reset(qk_tap_dance_state_t *state, void *user_data); -void td_brackets_right_finished(qk_tap_dance_state_t *state, void *user_data); -void td_brackets_right_reset(qk_tap_dance_state_t *state, void *user_data); +void td_brackets_left_finished(tap_dance_state_t *state, void *user_data); +void td_brackets_left_reset(tap_dance_state_t *state, void *user_data); +void td_brackets_right_finished(tap_dance_state_t *state, void *user_data); +void td_brackets_right_reset(tap_dance_state_t *state, void *user_data); /* Tap Dance Definitions */ -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { /* Tap once for left parenthesis, twice for left bracket, thrice for left brace */ [TD_BRACKETS_LEFT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_brackets_left_finished, td_brackets_left_reset), /* Tap once for right parenthesis, twice for right bracket, thrice for right brace */ @@ -266,14 +266,14 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { }; /* Global TapDance State */ -static t_tap qk_tap_state = { +static t_tap tap_state = { .left_brackets = 0, .right_brackets = 0, }; float s_numpad_toggle[][2] = LAYER_NMPAD_SONG; -t_tap_state get_tapdance_state(qk_tap_dance_state_t *state) { +t_tap_state get_tapdance_state(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) { return SINGLE_TAP; @@ -296,9 +296,9 @@ t_tap_state get_tapdance_state(qk_tap_dance_state_t *state) { return TAP_DANCE_NO_MATCH; } -void td_brackets_left_finished(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_state.left_brackets = get_tapdance_state(state); - switch (qk_tap_state.left_brackets) { +void td_brackets_left_finished(tap_dance_state_t *state, void *user_data) { + tap_state.left_brackets = get_tapdance_state(state); + switch (tap_state.left_brackets) { case SINGLE_TAP: register_code16(KC_LEFT_PAREN); break; @@ -313,8 +313,8 @@ void td_brackets_left_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void td_brackets_left_reset(qk_tap_dance_state_t *state, void *user_data) { - switch (qk_tap_state.left_brackets) { +void td_brackets_left_reset(tap_dance_state_t *state, void *user_data) { + switch (tap_state.left_brackets) { case SINGLE_TAP: unregister_code16(KC_LEFT_PAREN); break; @@ -327,12 +327,12 @@ void td_brackets_left_reset(qk_tap_dance_state_t *state, void *user_data) { default: break; } - qk_tap_state.left_brackets = 0; + tap_state.left_brackets = 0; } -void td_brackets_right_finished(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_state.right_brackets = get_tapdance_state(state); - switch (qk_tap_state.right_brackets) { +void td_brackets_right_finished(tap_dance_state_t *state, void *user_data) { + tap_state.right_brackets = get_tapdance_state(state); + switch (tap_state.right_brackets) { case SINGLE_TAP: register_code16(KC_RIGHT_PAREN); break; @@ -347,8 +347,8 @@ void td_brackets_right_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void td_brackets_right_reset(qk_tap_dance_state_t *state, void *user_data) { - switch (qk_tap_state.right_brackets) { +void td_brackets_right_reset(tap_dance_state_t *state, void *user_data) { + switch (tap_state.right_brackets) { case SINGLE_TAP: unregister_code16(KC_RIGHT_PAREN); break; @@ -361,7 +361,7 @@ void td_brackets_right_reset(qk_tap_dance_state_t *state, void *user_data) { default: break; } - qk_tap_state.right_brackets = 0; + tap_state.right_brackets = 0; } bool muse_mode = false; diff --git a/keyboards/preonic/keymaps/pcurt854/keymap.c b/keyboards/preonic/keymaps/pcurt854/keymap.c index c039320b34..15e31df0a6 100644 --- a/keyboards/preonic/keymaps/pcurt854/keymap.c +++ b/keyboards/preonic/keymaps/pcurt854/keymap.c @@ -469,13 +469,13 @@ void matrix_scan_user(void) { } } -void leader_start(void) { +void leader_start_user(void) { #ifdef AUDIO_ENABLE PLAY_SONG(leader_start_song); #endif } -void leader_end(void) { +void leader_end_user(void) { if (did_leader_succeed) { #ifdef AUDIO_ENABLE PLAY_SONG(leader_succeed_song); diff --git a/keyboards/preonic/keymaps/yhaliaw/keymap.c b/keyboards/preonic/keymaps/yhaliaw/keymap.c index 139bd16a29..b64aa7d745 100644 --- a/keyboards/preonic/keymaps/yhaliaw/keymap.c +++ b/keyboards/preonic/keymaps/yhaliaw/keymap.c @@ -197,7 +197,7 @@ void matrix_scan_user(void) { } } -void leader_end(void) { +void leader_end_user(void) { // Plays sound on if leader sequence found. if (leader_found) { #ifdef AUDIO_ENABLE diff --git a/keyboards/preonic/keymaps/zach/zach_common_functions.c b/keyboards/preonic/keymaps/zach/zach_common_functions.c index 7a594b567f..b6e8d9be47 100644 --- a/keyboards/preonic/keymaps/zach/zach_common_functions.c +++ b/keyboards/preonic/keymaps/zach/zach_common_functions.c @@ -68,7 +68,7 @@ float unilin[][2] = SONG(UNICODE_LINUX); #ifdef TAP_DANCE_ENABLE #define TAPPING_TERM 200 -void dance_raise_press(qk_tap_dance_state_t *state, void *user_data){// Called on each tap +void dance_raise_press(tap_dance_state_t *state, void *user_data){// Called on each tap switch(state->count){ // Only turn the layer on once case 1: layer_off(_UNICODES); @@ -77,7 +77,7 @@ void dance_raise_press(qk_tap_dance_state_t *state, void *user_data){// Called o break; } }; -void dance_raise_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release +void dance_raise_lift(tap_dance_state_t *state, void *user_data){ // Called on release switch(state->count){ case 1: // Normal action. Turn off layers layer_off(_RAISE); @@ -87,7 +87,7 @@ void dance_raise_lift(qk_tap_dance_state_t *state, void *user_data){ // Called o } }; ///////////////////////////////////////////////////////////////////// -void dance_lower_press(qk_tap_dance_state_t *state, void *user_data){// Called on tap +void dance_lower_press(tap_dance_state_t *state, void *user_data){// Called on tap switch(state->count){ case 1: // Turn on lower layer_off(_UNICODES); @@ -96,7 +96,7 @@ void dance_lower_press(qk_tap_dance_state_t *state, void *user_data){// Called o break; } }; -void dance_lower_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on release +void dance_lower_lift(tap_dance_state_t *state, void *user_data){ // Called on release switch(state->count){ case 1: // Normal action. Turn off layers layer_off(_LOWER); @@ -114,12 +114,12 @@ void dance_lower_lift(qk_tap_dance_state_t *state, void *user_data){ // Called o } }; ///////////////////////////////////////////////////////////////////// -void dance_super_press(qk_tap_dance_state_t *state, void *user_data){ // Called on down +void dance_super_press(tap_dance_state_t *state, void *user_data){ // Called on down if(state->count == 1){ register_code(KC_LGUI); } } -void dance_super_done(qk_tap_dance_state_t *state, void *user_data){ // Called on timeout +void dance_super_done(tap_dance_state_t *state, void *user_data){ // Called on timeout switch(state->count){ case 2: register_code(KC_LGUI); @@ -128,11 +128,11 @@ void dance_super_done(qk_tap_dance_state_t *state, void *user_data){ // Calle break; } } -void dance_super_lift(qk_tap_dance_state_t *state, void *user_data){ // Called on up +void dance_super_lift(tap_dance_state_t *state, void *user_data){ // Called on up unregister_code(KC_LGUI); } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [RAI] = ACTION_TAP_DANCE_FN_ADVANCED(dance_raise_press, NULL, dance_raise_lift), [LOW] = ACTION_TAP_DANCE_FN_ADVANCED(dance_lower_press, NULL, dance_lower_lift), [SUP] = ACTION_TAP_DANCE_FN_ADVANCED(dance_super_press, dance_super_done, dance_super_lift) diff --git a/keyboards/primekb/prime_e/keymaps/brandonschlack/keymap.c b/keyboards/primekb/prime_e/keymaps/brandonschlack/keymap.c index b7fb4dae47..349b767b33 100644 --- a/keyboards/primekb/prime_e/keymaps/brandonschlack/keymap.c +++ b/keyboards/primekb/prime_e/keymaps/brandonschlack/keymap.c @@ -23,7 +23,7 @@ enum { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for LBracket, twice for RBracket [TD_LR_BRC] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_RBRC), // Tap once for Single Quote, twice for Double Quote diff --git a/keyboards/primekb/prime_o/keymaps/reasonsandreasons/keymap.c b/keyboards/primekb/prime_o/keymaps/reasonsandreasons/keymap.c index f5a4d06204..20f34ce60b 100644 --- a/keyboards/primekb/prime_o/keymaps/reasonsandreasons/keymap.c +++ b/keyboards/primekb/prime_o/keymaps/reasonsandreasons/keymap.c @@ -28,7 +28,7 @@ enum { TD_SPC_ENT = 0 }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SPC_ENT] = ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT) }; diff --git a/keyboards/projectcain/relic/keymaps/default/config.h b/keyboards/projectcain/relic/keymaps/default/config.h index 7756a8db2f..ebe839c4c4 100644 --- a/keyboards/projectcain/relic/keymaps/default/config.h +++ b/keyboards/projectcain/relic/keymaps/default/config.h @@ -19,5 +19,5 @@ #define ENCODER_RESOLUTION 2 #define COMBO_COUNT 6 #define COMBO_TERM 50 -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define DISABLE_LEADER diff --git a/keyboards/projectcain/vault35/keymaps/default/config.h b/keyboards/projectcain/vault35/keymaps/default/config.h index 3022aa84c4..885d5ad9cb 100644 --- a/keyboards/projectcain/vault35/keymaps/default/config.h +++ b/keyboards/projectcain/vault35/keymaps/default/config.h @@ -18,4 +18,4 @@ #define COMBO_COUNT 2 #define COMBO_TERM 50 -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 diff --git a/keyboards/projectcain/vault45/keymaps/default/config.h b/keyboards/projectcain/vault45/keymaps/default/config.h index 2ca1e8f123..4a98bb89d4 100644 --- a/keyboards/projectcain/vault45/keymaps/default/config.h +++ b/keyboards/projectcain/vault45/keymaps/default/config.h @@ -18,4 +18,4 @@ #define COMBO_COUNT 2 #define COMBO_TERM 50 -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 diff --git a/keyboards/ramonimbao/mona/v1_1/readme.md b/keyboards/ramonimbao/mona/v1_1/readme.md index 17ae6012bd..b28fedd76c 100644 --- a/keyboards/ramonimbao/mona/v1_1/readme.md +++ b/keyboards/ramonimbao/mona/v1_1/readme.md @@ -7,7 +7,7 @@ A gummy-worm o-ring mount 60% marble keyboard. Now with ALPS/MX, Caps Lock LED, * Keyboard Maintainer: [Ramon Imbao](https://github.com/ramonimbao) * Hardware Supported: ATmega32u4 -To get to the bootloader, with the USB cable plugged in, press the `QK_BOOT` button on the back of the PCB. +To get to the bootloader, with the USB cable plugged in, press the `RESET` button on the back of the PCB. Make example for this keyboard (after setting up your build environment): diff --git a/keyboards/ramonimbao/mona/v32a/readme.md b/keyboards/ramonimbao/mona/v32a/readme.md index f9a730691f..61a3deefaa 100644 --- a/keyboards/ramonimbao/mona/v32a/readme.md +++ b/keyboards/ramonimbao/mona/v32a/readme.md @@ -7,7 +7,7 @@ A gummy-worm o-ring mount 60% marble keyboard. Now with ALPS/MX, Caps Lock LED, * Keyboard Maintainer: [Ramon Imbao](https://github.com/ramonimbao) * Hardware Supported: ATmega32A -To get to the bootloader, with the USB cable plugged in, press the `QK_BOOT` button on the back of the PCB. +To get to the bootloader, with the USB cable plugged in, press the `RESET` button on the back of the PCB. Make example for this keyboard (after setting up your build environment): diff --git a/keyboards/recompile_keys/nomu30/keymaps/center_sprit/keymap.c b/keyboards/recompile_keys/nomu30/keymaps/center_sprit/keymap.c index 4d90914332..832a682c42 100644 --- a/keyboards/recompile_keys/nomu30/keymaps/center_sprit/keymap.c +++ b/keyboards/recompile_keys/nomu30/keymaps/center_sprit/keymap.c @@ -54,7 +54,7 @@ enum tapdances{ // Tap dance #define KC_CODO TD(TD_CODO) -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_CODO] = ACTION_TAP_DANCE_DOUBLE(KC_COMM, KC_DOT), }; diff --git a/keyboards/recompile_keys/nomu30/keymaps/like_jis/keymap.c b/keyboards/recompile_keys/nomu30/keymaps/like_jis/keymap.c index c7c3c57723..4f17e7c1a1 100644 --- a/keyboards/recompile_keys/nomu30/keymaps/like_jis/keymap.c +++ b/keyboards/recompile_keys/nomu30/keymaps/like_jis/keymap.c @@ -53,7 +53,7 @@ enum custom_keycodes { // #define KC_CODO TD(TD_CODO) // #define KC_SLRO TD(TD_SLRO) -// qk_tap_dance_action_t tap_dance_actions[] = { +// tap_dance_action_t tap_dance_actions[] = { // [TD_CODO] = ACTION_TAP_DANCE_DOUBLE(KC_COMM, KC_DOT), // [TD_SLRO] = ACTION_TAP_DANCE_DOUBLE(KC_SLSH, JP_BSLS), // }; diff --git a/keyboards/redox/keymaps/finex/keymap.c b/keyboards/redox/keymaps/finex/keymap.c index 6470addb27..9057dee074 100644 --- a/keyboards/redox/keymaps/finex/keymap.c +++ b/keyboards/redox/keymaps/finex/keymap.c @@ -47,7 +47,7 @@ enum tap_dance{ }; // Semicolon to Colon -void dance_scln_finished (qk_tap_dance_state_t *state, void *user_data) { +void dance_scln_finished (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code (KC_SCLN); } else { @@ -55,7 +55,7 @@ void dance_scln_finished (qk_tap_dance_state_t *state, void *user_data) { register_code (KC_SCLN); } } -void dance_scln_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_scln_reset (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_SCLN); } else { @@ -65,7 +65,7 @@ void dance_scln_reset (qk_tap_dance_state_t *state, void *user_data) { } // Square braket to curly bracket (left) -void dance_lbrc_finished (qk_tap_dance_state_t *state, void *user_data) { +void dance_lbrc_finished (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code (KC_LBRC); } else { @@ -73,7 +73,7 @@ void dance_lbrc_finished (qk_tap_dance_state_t *state, void *user_data) { register_code (KC_LBRC); } } -void dance_lbrc_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_lbrc_reset (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_LBRC); } else { @@ -83,7 +83,7 @@ void dance_lbrc_reset (qk_tap_dance_state_t *state, void *user_data) { } // Square braket to curly bracket (right) -void dance_rbrc_finished (qk_tap_dance_state_t *state, void *user_data) { +void dance_rbrc_finished (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code (KC_RBRC); } else { @@ -91,7 +91,7 @@ void dance_rbrc_finished (qk_tap_dance_state_t *state, void *user_data) { register_code (KC_RBRC); } } -void dance_rbrc_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_rbrc_reset (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_RBRC); } else { @@ -102,7 +102,7 @@ void dance_rbrc_reset (qk_tap_dance_state_t *state, void *user_data) { //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SCLN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_scln_finished, dance_scln_reset), [TD_LBRC] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_lbrc_finished, dance_lbrc_reset), [TD_RBRC] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_rbrc_finished, dance_rbrc_reset) diff --git a/keyboards/reviung/reviung41/keymaps/ciutadellla/keymap.c b/keyboards/reviung/reviung41/keymaps/ciutadellla/keymap.c index e3ae65a45f..7bfa16e8f4 100644 --- a/keyboards/reviung/reviung41/keymaps/ciutadellla/keymap.c +++ b/keyboards/reviung/reviung41/keymaps/ciutadellla/keymap.c @@ -163,7 +163,7 @@ #define TD_CTRL_LANG TD(_TD_CTRL_LANG) #define TD_SCLN_NTILDE TD(_TD_SCLN_NTILDE) //TP with costum keycodes has to be a funtion - void td_scln_ntilde(qk_tap_dance_state_t *state, void *user_data) { + void td_scln_ntilde(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code(KC_SCLN); unregister_code(KC_SCLN); @@ -174,7 +174,7 @@ } // Tap Dance Definitions - qk_tap_dance_action_t tap_dance_actions[] = { + tap_dance_action_t tap_dance_actions[] = { [_TD_TAB_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_TAB, KC_ESC), [_TD_BSPC_WDEL] = ACTION_TAP_DANCE_DOUBLE(KC_BSPC, LALT(KC_BSPC)), [_TD_SFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), diff --git a/keyboards/rgbkb/mun/keymaps/xulkal2/config.h b/keyboards/rgbkb/mun/keymaps/xulkal2/config.h index 7e3fc2d908..c945db1417 100644 --- a/keyboards/rgbkb/mun/keymaps/xulkal2/config.h +++ b/keyboards/rgbkb/mun/keymaps/xulkal2/config.h @@ -10,7 +10,7 @@ #pragma once // Xulkal custom stuff -#undef TAPPING_FORCE_HOLD +#undef QUICK_TAP_TERM #undef TAPPING_TERM #define TAPPING_TERM 175 diff --git a/keyboards/rgbkb/zen/rev1/keymaps/starcalleramethyst/keymap.c b/keyboards/rgbkb/zen/rev1/keymaps/starcalleramethyst/keymap.c index 1b4227708a..47e8e3fa24 100644 --- a/keyboards/rgbkb/zen/rev1/keymaps/starcalleramethyst/keymap.c +++ b/keyboards/rgbkb/zen/rev1/keymaps/starcalleramethyst/keymap.c @@ -105,7 +105,7 @@ enum { }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Esc, twice for Caps Lock [TD_SPC_DOT] = ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_PDOT) // Other declarations would go here, separated by commas, if you have them diff --git a/keyboards/ryanskidmore/rskeys100/readme.md b/keyboards/ryanskidmore/rskeys100/readme.md index 3100e74f2d..4be465dbde 100644 --- a/keyboards/ryanskidmore/rskeys100/readme.md +++ b/keyboards/ryanskidmore/rskeys100/readme.md @@ -19,4 +19,4 @@ See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_to ## Bootloader -To enter the bootloader, press the `QK_BOOT` button on your daughterboard PCB while it's plugged in.
\ No newline at end of file +To enter the bootloader, press the `RESET` button on your daughterboard PCB while it's plugged in.
\ No newline at end of file diff --git a/keyboards/ryloo_studio/m0110/readme.md b/keyboards/ryloo_studio/m0110/readme.md index 8729ef6319..78a59f0e62 100755 --- a/keyboards/ryloo_studio/m0110/readme.md +++ b/keyboards/ryloo_studio/m0110/readme.md @@ -16,9 +16,9 @@ Flashing example for this keyboard: Putting the Keyboard in Bootloader Mode: -The shipped PCB did not come with a reset button. To put the PCB in bootloader mode: locate the 2 `QK_BOOT` pins in the back of the PCB and short them with a conductive wire or tweezer. +The shipped PCB did not come with a reset button. To put the PCB in bootloader mode: locate the 2 `RESET` pins in the back of the PCB and short them with a conductive wire or tweezer. - + See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/salicylic_acid3/7skb/keymaps/default/config.h b/keyboards/salicylic_acid3/7skb/keymaps/default/config.h index 4b3496d856..c2844a6775 100644 --- a/keyboards/salicylic_acid3/7skb/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/7skb/keymaps/default/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/7skb/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/7skb/keymaps/salicylic/config.h index cc4a3d4426..09bf50b6ab 100644 --- a/keyboards/salicylic_acid3/7skb/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/7skb/keymaps/salicylic/config.h @@ -18,6 +18,6 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 //#define MASTER_RIGHT diff --git a/keyboards/salicylic_acid3/7skb/keymaps/salicylic/keymap.c b/keyboards/salicylic_acid3/7skb/keymaps/salicylic/keymap.c index 690476e1ef..58f6fb408a 100644 --- a/keyboards/salicylic_acid3/7skb/keymaps/salicylic/keymap.c +++ b/keyboards/salicylic_acid3/7skb/keymaps/salicylic/keymap.c @@ -31,7 +31,7 @@ enum tapdances{ TD_ESQW, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESFL] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _FLOCK), [TD_ESQW] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _QWERTY), }; diff --git a/keyboards/salicylic_acid3/7splus/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/7splus/keymaps/salicylic/config.h index 81ee8ef785..8a42af5127 100644 --- a/keyboards/salicylic_acid3/7splus/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/7splus/keymaps/salicylic/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/7splus/keymaps/salicylic/keymap.c b/keyboards/salicylic_acid3/7splus/keymaps/salicylic/keymap.c index 23728e8000..22d9a683b1 100644 --- a/keyboards/salicylic_acid3/7splus/keymaps/salicylic/keymap.c +++ b/keyboards/salicylic_acid3/7splus/keymaps/salicylic/keymap.c @@ -38,7 +38,7 @@ enum tapdances{ TD_ESAR, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESMS] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _MOUSE), [TD_ESAR] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _QWERTY), }; diff --git a/keyboards/salicylic_acid3/7splus/keymaps/via/config.h b/keyboards/salicylic_acid3/7splus/keymaps/via/config.h index 8a89da2eae..83e6f1b184 100644 --- a/keyboards/salicylic_acid3/7splus/keymaps/via/config.h +++ b/keyboards/salicylic_acid3/7splus/keymaps/via/config.h @@ -18,6 +18,6 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #define DYNAMIC_KEYMAP_LAYER_COUNT 3 diff --git a/keyboards/salicylic_acid3/ajisai74/keymaps/default/config.h b/keyboards/salicylic_acid3/ajisai74/keymaps/default/config.h index 81ee8ef785..8a42af5127 100644 --- a/keyboards/salicylic_acid3/ajisai74/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/ajisai74/keymaps/default/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/ajisai74/keymaps/jis/config.h b/keyboards/salicylic_acid3/ajisai74/keymaps/jis/config.h index 81ee8ef785..8a42af5127 100644 --- a/keyboards/salicylic_acid3/ajisai74/keymaps/jis/config.h +++ b/keyboards/salicylic_acid3/ajisai74/keymaps/jis/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/ajisai74/keymaps/jis/keymap.c b/keyboards/salicylic_acid3/ajisai74/keymaps/jis/keymap.c index aaeffc6d22..5fa8be4024 100644 --- a/keyboards/salicylic_acid3/ajisai74/keymaps/jis/keymap.c +++ b/keyboards/salicylic_acid3/ajisai74/keymaps/jis/keymap.c @@ -30,7 +30,7 @@ enum tapdances{ TD_ENT = 0, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ENT] = ACTION_TAP_DANCE_DOUBLE(KC_ENT, KC_ENT), }; diff --git a/keyboards/salicylic_acid3/ajisai74/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/ajisai74/keymaps/salicylic/config.h index 81ee8ef785..8a42af5127 100644 --- a/keyboards/salicylic_acid3/ajisai74/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/ajisai74/keymaps/salicylic/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/ajisai74/keymaps/salicylic/keymap.c b/keyboards/salicylic_acid3/ajisai74/keymaps/salicylic/keymap.c index 5cb816448d..b0ceb7cf37 100644 --- a/keyboards/salicylic_acid3/ajisai74/keymaps/salicylic/keymap.c +++ b/keyboards/salicylic_acid3/ajisai74/keymaps/salicylic/keymap.c @@ -31,7 +31,7 @@ enum tapdances{ TD_ENT = 0, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ENT] = ACTION_TAP_DANCE_DOUBLE(KC_ENT, KC_ENT), }; diff --git a/keyboards/salicylic_acid3/ajisai74/keymaps/via/config.h b/keyboards/salicylic_acid3/ajisai74/keymaps/via/config.h index 81ee8ef785..8a42af5127 100644 --- a/keyboards/salicylic_acid3/ajisai74/keymaps/via/config.h +++ b/keyboards/salicylic_acid3/ajisai74/keymaps/via/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/ergoarrows/keymaps/default/config.h b/keyboards/salicylic_acid3/ergoarrows/keymaps/default/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/salicylic_acid3/ergoarrows/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/ergoarrows/keymaps/default/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/ergoarrows/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/ergoarrows/keymaps/salicylic/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/salicylic_acid3/ergoarrows/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/ergoarrows/keymaps/salicylic/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/ergoarrows/keymaps/via/config.h b/keyboards/salicylic_acid3/ergoarrows/keymaps/via/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/salicylic_acid3/ergoarrows/keymaps/via/config.h +++ b/keyboards/salicylic_acid3/ergoarrows/keymaps/via/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/getta25/keymaps/default/config.h b/keyboards/salicylic_acid3/getta25/keymaps/default/config.h index 8c4e1f5129..a79d62d614 100644 --- a/keyboards/salicylic_acid3/getta25/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/getta25/keymaps/default/config.h @@ -18,7 +18,7 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/getta25/keymaps/oled/config.h b/keyboards/salicylic_acid3/getta25/keymaps/oled/config.h index be988915c2..23f8b5343f 100644 --- a/keyboards/salicylic_acid3/getta25/keymaps/oled/config.h +++ b/keyboards/salicylic_acid3/getta25/keymaps/oled/config.h @@ -18,7 +18,7 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #define OLED_FONT_H "keyboards/getta25/keymaps/oled/glcdfont.c" diff --git a/keyboards/salicylic_acid3/jisplit89/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/jisplit89/keymaps/salicylic/config.h index 81ee8ef785..8a42af5127 100644 --- a/keyboards/salicylic_acid3/jisplit89/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/jisplit89/keymaps/salicylic/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/jisplit89/keymaps/salicylic/keymap.c b/keyboards/salicylic_acid3/jisplit89/keymaps/salicylic/keymap.c index 3f73bd8ebb..093ae4650a 100644 --- a/keyboards/salicylic_acid3/jisplit89/keymaps/salicylic/keymap.c +++ b/keyboards/salicylic_acid3/jisplit89/keymaps/salicylic/keymap.c @@ -38,7 +38,7 @@ enum tapdances{ TD_ESAR, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESMS] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _MOUSE), [TD_ESAR] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _QWERTY), }; diff --git a/keyboards/salicylic_acid3/nafuda/keymaps/default/config.h b/keyboards/salicylic_acid3/nafuda/keymaps/default/config.h index e35fe2ccd7..1633dcc847 100644 --- a/keyboards/salicylic_acid3/nafuda/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/nafuda/keymaps/default/config.h @@ -18,6 +18,6 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked48/keymaps/default/config.h b/keyboards/salicylic_acid3/naked48/keymaps/default/config.h index 4f3a44d6bb..c3d26106ca 100644 --- a/keyboards/salicylic_acid3/naked48/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/naked48/keymaps/default/config.h @@ -22,5 +22,5 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked48/keymaps/default_with_nafuda/config.h b/keyboards/salicylic_acid3/naked48/keymaps/default_with_nafuda/config.h index 4d52c01805..12d5784374 100644 --- a/keyboards/salicylic_acid3/naked48/keymaps/default_with_nafuda/config.h +++ b/keyboards/salicylic_acid3/naked48/keymaps/default_with_nafuda/config.h @@ -22,7 +22,7 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #ifdef RGBLED_NUM diff --git a/keyboards/salicylic_acid3/naked48/keymaps/default_with_setta21/config.h b/keyboards/salicylic_acid3/naked48/keymaps/default_with_setta21/config.h index 7cb5d61e2b..392f2f97e8 100644 --- a/keyboards/salicylic_acid3/naked48/keymaps/default_with_setta21/config.h +++ b/keyboards/salicylic_acid3/naked48/keymaps/default_with_setta21/config.h @@ -22,7 +22,7 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #ifdef RGBLED_NUM diff --git a/keyboards/salicylic_acid3/naked48/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/naked48/keymaps/salicylic/config.h index e7016c4b78..b8a6b843ce 100644 --- a/keyboards/salicylic_acid3/naked48/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/naked48/keymaps/salicylic/config.h @@ -18,7 +18,7 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #ifdef RGBLED_NUM diff --git a/keyboards/salicylic_acid3/naked48/keymaps/salicylic_with_nafuda/config.h b/keyboards/salicylic_acid3/naked48/keymaps/salicylic_with_nafuda/config.h index 4d52c01805..12d5784374 100644 --- a/keyboards/salicylic_acid3/naked48/keymaps/salicylic_with_nafuda/config.h +++ b/keyboards/salicylic_acid3/naked48/keymaps/salicylic_with_nafuda/config.h @@ -22,7 +22,7 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #ifdef RGBLED_NUM diff --git a/keyboards/salicylic_acid3/naked48/keymaps/salicylic_with_setta21/config.h b/keyboards/salicylic_acid3/naked48/keymaps/salicylic_with_setta21/config.h index 7cb5d61e2b..392f2f97e8 100644 --- a/keyboards/salicylic_acid3/naked48/keymaps/salicylic_with_setta21/config.h +++ b/keyboards/salicylic_acid3/naked48/keymaps/salicylic_with_setta21/config.h @@ -22,7 +22,7 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #ifdef RGBLED_NUM diff --git a/keyboards/salicylic_acid3/naked48/keymaps/scheiklp/config.h b/keyboards/salicylic_acid3/naked48/keymaps/scheiklp/config.h index 8c11ad6078..1742af4c5c 100644 --- a/keyboards/salicylic_acid3/naked48/keymaps/scheiklp/config.h +++ b/keyboards/salicylic_acid3/naked48/keymaps/scheiklp/config.h @@ -5,5 +5,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked48/keymaps/via/config.h b/keyboards/salicylic_acid3/naked48/keymaps/via/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/salicylic_acid3/naked48/keymaps/via/config.h +++ b/keyboards/salicylic_acid3/naked48/keymaps/via/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked48/keymaps/via_rgb_matrix/config.h b/keyboards/salicylic_acid3/naked48/keymaps/via_rgb_matrix/config.h index 6106dc4e3d..21494a0dfd 100644 --- a/keyboards/salicylic_acid3/naked48/keymaps/via_rgb_matrix/config.h +++ b/keyboards/salicylic_acid3/naked48/keymaps/via_rgb_matrix/config.h @@ -18,7 +18,7 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #ifdef RGBLED_NUM diff --git a/keyboards/salicylic_acid3/naked60/keymaps/333fred/config.h b/keyboards/salicylic_acid3/naked60/keymaps/333fred/config.h index d19e77f044..5cb4da0133 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/333fred/config.h +++ b/keyboards/salicylic_acid3/naked60/keymaps/333fred/config.h @@ -20,5 +20,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 diff --git a/keyboards/salicylic_acid3/naked60/keymaps/default/config.h b/keyboards/salicylic_acid3/naked60/keymaps/default/config.h index 4b3496d856..c2844a6775 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/naked60/keymaps/default/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked60/keymaps/default_with_nafuda/config.h b/keyboards/salicylic_acid3/naked60/keymaps/default_with_nafuda/config.h index 603c9ab026..ed08dc121c 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/default_with_nafuda/config.h +++ b/keyboards/salicylic_acid3/naked60/keymaps/default_with_nafuda/config.h @@ -22,5 +22,5 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked60/keymaps/default_with_setta21/config.h b/keyboards/salicylic_acid3/naked60/keymaps/default_with_setta21/config.h index 603c9ab026..ed08dc121c 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/default_with_setta21/config.h +++ b/keyboards/salicylic_acid3/naked60/keymaps/default_with_setta21/config.h @@ -22,5 +22,5 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked60/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/naked60/keymaps/salicylic/config.h index 4b3496d856..c2844a6775 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/naked60/keymaps/salicylic/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked60/keymaps/salicylic/keymap.c b/keyboards/salicylic_acid3/naked60/keymaps/salicylic/keymap.c index a845ebe57e..85030c1402 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/salicylic/keymap.c +++ b/keyboards/salicylic_acid3/naked60/keymaps/salicylic/keymap.c @@ -22,7 +22,7 @@ enum tapdances{ TD_ESQW, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESFL] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _FLOCK), [TD_ESQW] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _QWERTY), }; diff --git a/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_nafuda/config.h b/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_nafuda/config.h index 603c9ab026..ed08dc121c 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_nafuda/config.h +++ b/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_nafuda/config.h @@ -22,5 +22,5 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_nafuda/keymap.c b/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_nafuda/keymap.c index ff3a787576..ad3a1cff2b 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_nafuda/keymap.c +++ b/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_nafuda/keymap.c @@ -33,7 +33,7 @@ enum tapdances{ TD_ESQW, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESFL] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _FLOCK), [TD_ESQW] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _QWERTY), }; diff --git a/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_setta21/config.h b/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_setta21/config.h index 603c9ab026..ed08dc121c 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_setta21/config.h +++ b/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_setta21/config.h @@ -22,5 +22,5 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_setta21/keymap.c b/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_setta21/keymap.c index c7d783fe8b..b80ef8ab4d 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_setta21/keymap.c +++ b/keyboards/salicylic_acid3/naked60/keymaps/salicylic_with_setta21/keymap.c @@ -31,7 +31,7 @@ enum tapdances{ TD_ESQW, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESFL] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _FLOCK), [TD_ESQW] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _QWERTY), }; diff --git a/keyboards/salicylic_acid3/naked60/keymaps/via/config.h b/keyboards/salicylic_acid3/naked60/keymaps/via/config.h index 32ec5281b2..f90e802882 100644 --- a/keyboards/salicylic_acid3/naked60/keymaps/via/config.h +++ b/keyboards/salicylic_acid3/naked60/keymaps/via/config.h @@ -18,6 +18,6 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #define DYNAMIC_KEYMAP_LAYER_COUNT 3 diff --git a/keyboards/salicylic_acid3/naked64/keymaps/default/config.h b/keyboards/salicylic_acid3/naked64/keymaps/default/config.h index 8c4e1f5129..a79d62d614 100644 --- a/keyboards/salicylic_acid3/naked64/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/naked64/keymaps/default/config.h @@ -18,7 +18,7 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked64/keymaps/default_with_setta21/config.h b/keyboards/salicylic_acid3/naked64/keymaps/default_with_setta21/config.h index cba07919ff..73a3019540 100644 --- a/keyboards/salicylic_acid3/naked64/keymaps/default_with_setta21/config.h +++ b/keyboards/salicylic_acid3/naked64/keymaps/default_with_setta21/config.h @@ -22,7 +22,7 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #define RGBLED_NUM 12 // Number of LEDs diff --git a/keyboards/salicylic_acid3/naked64/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/naked64/keymaps/salicylic/config.h index 4b3496d856..c2844a6775 100644 --- a/keyboards/salicylic_acid3/naked64/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/naked64/keymaps/salicylic/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked64/keymaps/salicylic/keymap.c b/keyboards/salicylic_acid3/naked64/keymaps/salicylic/keymap.c index 5ccb02ee8a..c34f07e2d9 100644 --- a/keyboards/salicylic_acid3/naked64/keymaps/salicylic/keymap.c +++ b/keyboards/salicylic_acid3/naked64/keymaps/salicylic/keymap.c @@ -32,7 +32,7 @@ enum tapdances{ TD_ESQW, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESFL] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _FLOCK), [TD_ESQW] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _QWERTY), }; diff --git a/keyboards/salicylic_acid3/naked64/keymaps/salicylic_with_setta21/config.h b/keyboards/salicylic_acid3/naked64/keymaps/salicylic_with_setta21/config.h index 603c9ab026..ed08dc121c 100644 --- a/keyboards/salicylic_acid3/naked64/keymaps/salicylic_with_setta21/config.h +++ b/keyboards/salicylic_acid3/naked64/keymaps/salicylic_with_setta21/config.h @@ -22,5 +22,5 @@ // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/naked64/keymaps/salicylic_with_setta21/keymap.c b/keyboards/salicylic_acid3/naked64/keymaps/salicylic_with_setta21/keymap.c index 1272a2fe2d..68250c44c2 100644 --- a/keyboards/salicylic_acid3/naked64/keymaps/salicylic_with_setta21/keymap.c +++ b/keyboards/salicylic_acid3/naked64/keymaps/salicylic_with_setta21/keymap.c @@ -37,7 +37,7 @@ enum tapdances{ TD_ESQW, }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESFL] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _FLOCK), [TD_ESQW] = ACTION_TAP_DANCE_LAYER_MOVE(KC_ESC, _QWERTY), }; diff --git a/keyboards/salicylic_acid3/nknl7en/keymaps/default/config.h b/keyboards/salicylic_acid3/nknl7en/keymaps/default/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/salicylic_acid3/nknl7en/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/nknl7en/keymaps/default/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/nknl7en/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/nknl7en/keymaps/salicylic/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/salicylic_acid3/nknl7en/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/nknl7en/keymaps/salicylic/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/nknl7en/keymaps/via/config.h b/keyboards/salicylic_acid3/nknl7en/keymaps/via/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/salicylic_acid3/nknl7en/keymaps/via/config.h +++ b/keyboards/salicylic_acid3/nknl7en/keymaps/via/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/nknl7jp/keymaps/default/config.h b/keyboards/salicylic_acid3/nknl7jp/keymaps/default/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/salicylic_acid3/nknl7jp/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/nknl7jp/keymaps/default/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/nknl7jp/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/nknl7jp/keymaps/salicylic/config.h index 6f3b77b0de..d06aae947a 100644 --- a/keyboards/salicylic_acid3/nknl7jp/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/nknl7jp/keymaps/salicylic/config.h @@ -18,6 +18,6 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #define UNICODE_SELECTED_MODES UNICODE_MODE_WINCOMPOSE diff --git a/keyboards/salicylic_acid3/nknl7jp/keymaps/via/config.h b/keyboards/salicylic_acid3/nknl7jp/keymaps/via/config.h index fd96baa819..0e221d844d 100644 --- a/keyboards/salicylic_acid3/nknl7jp/keymaps/via/config.h +++ b/keyboards/salicylic_acid3/nknl7jp/keymaps/via/config.h @@ -18,5 +18,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/setta21/keymaps/default/config.h b/keyboards/salicylic_acid3/setta21/keymaps/default/config.h index e35fe2ccd7..1633dcc847 100644 --- a/keyboards/salicylic_acid3/setta21/keymaps/default/config.h +++ b/keyboards/salicylic_acid3/setta21/keymaps/default/config.h @@ -18,6 +18,6 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/salicylic_acid3/setta21/keymaps/salicylic/config.h b/keyboards/salicylic_acid3/setta21/keymaps/salicylic/config.h index 26607eca89..540c819c2b 100644 --- a/keyboards/salicylic_acid3/setta21/keymaps/salicylic/config.h +++ b/keyboards/salicylic_acid3/setta21/keymaps/salicylic/config.h @@ -18,7 +18,7 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 #define RGB_MATRIX_LED_COUNT RGBLED_NUM diff --git a/keyboards/sirius/unigo66/custom_matrix.cpp b/keyboards/sirius/unigo66/custom_matrix.cpp index 72e120400f..15b30c8177 100644 --- a/keyboards/sirius/unigo66/custom_matrix.cpp +++ b/keyboards/sirius/unigo66/custom_matrix.cpp @@ -220,7 +220,8 @@ extern "C" kbd2.SetReport(0, 0, 2, 0, 1, &usb_led); kbd3.SetReport(0, 0, 2, 0, 1, &usb_led); kbd4.SetReport(0, 0, 2, 0, 1, &usb_led); - led_set_kb(usb_led); + led_set_user(usb_led); + led_update_kb((led_t){.raw = usb_led}); } }; diff --git a/keyboards/sofle/keymaps/devdev/config.h b/keyboards/sofle/keymaps/devdev/config.h index c3694d1292..6564238bba 100644 --- a/keyboards/sofle/keymaps/devdev/config.h +++ b/keyboards/sofle/keymaps/devdev/config.h @@ -32,7 +32,7 @@ #define CUSTOM_LAYER_READ //if you remove this it causes issues - needs better guarding -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #ifdef TAPPING_TERM #undef TAPPING_TERM #define TAPPING_TERM 200 diff --git a/keyboards/sofle/keymaps/flare576/keymap.c b/keyboards/sofle/keymaps/flare576/keymap.c index 997fab9f3d..57784d633b 100644 --- a/keyboards/sofle/keymaps/flare576/keymap.c +++ b/keyboards/sofle/keymaps/flare576/keymap.c @@ -19,7 +19,7 @@ #include "enums.h" #include "graphics.h" -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_PLAY] = ACTION_TAP_DANCE_DOUBLE(KC_MPLY, KC_MNXT), [TD_HOME] = ACTION_TAP_DANCE_DOUBLE(KC_HOME, KC_END), }; diff --git a/keyboards/sofle/keymaps/rgb_default/config.h b/keyboards/sofle/keymaps/rgb_default/config.h index c3694d1292..6564238bba 100644 --- a/keyboards/sofle/keymaps/rgb_default/config.h +++ b/keyboards/sofle/keymaps/rgb_default/config.h @@ -32,7 +32,7 @@ #define CUSTOM_LAYER_READ //if you remove this it causes issues - needs better guarding -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #ifdef TAPPING_TERM #undef TAPPING_TERM #define TAPPING_TERM 200 diff --git a/keyboards/spaceman/2_milk/keymaps/copypasta_macfancy/keymap.c b/keyboards/spaceman/2_milk/keymaps/copypasta_macfancy/keymap.c index 6f21c630bf..93c0f0eee3 100644 --- a/keyboards/spaceman/2_milk/keymaps/copypasta_macfancy/keymap.c +++ b/keyboards/spaceman/2_milk/keymaps/copypasta_macfancy/keymap.c @@ -8,7 +8,7 @@ enum tapdance_keycodes { TD_KEY_2 }; -void dance_key_one(qk_tap_dance_state_t *state, void *user_data) { +void dance_key_one(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { /* Copy for Mac. */ /* Windows & Linux use Ctrl+C: tap_code16(C(KC_C)) */ @@ -26,7 +26,7 @@ void dance_key_one(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_key_two(qk_tap_dance_state_t *state, void *user_data) { +void dance_key_two(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { /* Paste for Mac. */ /* Windows & Linux use Ctrl+V: tap_code16(C(KC_V)) */ @@ -45,7 +45,7 @@ void dance_key_two(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_KEY_1] = ACTION_TAP_DANCE_FN(dance_key_one), [TD_KEY_2] = ACTION_TAP_DANCE_FN(dance_key_two) }; diff --git a/keyboards/spaceman/2_milk/keymaps/emoji/keymap.c b/keyboards/spaceman/2_milk/keymaps/emoji/keymap.c index 9deb2ddaf0..8859573ce5 100644 --- a/keyboards/spaceman/2_milk/keymaps/emoji/keymap.c +++ b/keyboards/spaceman/2_milk/keymaps/emoji/keymap.c @@ -5,7 +5,7 @@ enum tapdance_keycodes { TD_KEY_2, }; -void dance_key_one (qk_tap_dance_state_t *state, void *user_data) { +void dance_key_one (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { send_unicode_string("¯\\_(ツ)_/¯"); tap_code(KC_ENTER); @@ -16,7 +16,7 @@ void dance_key_one (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_key_two (qk_tap_dance_state_t *state, void *user_data) { +void dance_key_two (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { send_unicode_string("ಠ_ಠ"); tap_code(KC_ENTER); @@ -40,7 +40,7 @@ void dance_key_two (qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_KEY_1] = ACTION_TAP_DANCE_FN(dance_key_one), [TD_KEY_2] = ACTION_TAP_DANCE_FN(dance_key_two), }; diff --git a/keyboards/spacetime/keymaps/kyleterry/keymap.c b/keyboards/spacetime/keymaps/kyleterry/keymap.c index d4d31dc1fd..fd91fafbd2 100644 --- a/keyboards/spacetime/keymaps/kyleterry/keymap.c +++ b/keyboards/spacetime/keymaps/kyleterry/keymap.c @@ -114,7 +114,7 @@ void led_set_user(uint8_t usb_led) { } -void td_common(qk_tap_dance_state_t *state, void *user_data) { +void td_common(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: /* this case handles ctrl+o which is my tmux prefix @@ -132,7 +132,7 @@ void td_common(qk_tap_dance_state_t *state, void *user_data) { } } -void td_media(qk_tap_dance_state_t *state, void *user_data) { +void td_media(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: tap_code16(KC_MPLY); @@ -145,7 +145,7 @@ void td_media(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_C] = ACTION_TAP_DANCE_FN(td_common), [TD_MD] = ACTION_TAP_DANCE_FN(td_media), }; diff --git a/keyboards/sparrow62/keymaps/74th/config.h b/keyboards/sparrow62/keymaps/74th/config.h index 15eb08ed7a..e1fae611ce 100644 --- a/keyboards/sparrow62/keymaps/74th/config.h +++ b/keyboards/sparrow62/keymaps/74th/config.h @@ -19,5 +19,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/sparrow62/keymaps/default/config.h b/keyboards/sparrow62/keymaps/default/config.h index 15eb08ed7a..e1fae611ce 100644 --- a/keyboards/sparrow62/keymaps/default/config.h +++ b/keyboards/sparrow62/keymaps/default/config.h @@ -19,5 +19,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/sparrow62/keymaps/via/config.h b/keyboards/sparrow62/keymaps/via/config.h index 15eb08ed7a..e1fae611ce 100644 --- a/keyboards/sparrow62/keymaps/via/config.h +++ b/keyboards/sparrow62/keymaps/via/config.h @@ -19,5 +19,5 @@ /* Select hand configuration */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 180 diff --git a/keyboards/splitkb/kyria/keymaps/artflag/keymap.c b/keyboards/splitkb/kyria/keymaps/artflag/keymap.c index a49eaafb89..311a1c75e2 100644 --- a/keyboards/splitkb/kyria/keymaps/artflag/keymap.c +++ b/keyboards/splitkb/kyria/keymaps/artflag/keymap.c @@ -9,7 +9,7 @@ enum { CT_CLN, // Reverses colon and semicolon and triggers semicolon on tap dance. }; -void dance_cln_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_cln_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code16(KC_COLN); } else { @@ -17,7 +17,7 @@ void dance_cln_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_cln_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_cln_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code16(KC_COLN); } else { @@ -26,7 +26,7 @@ void dance_cln_reset(qk_tap_dance_state_t *state, void *user_data) { } // All tap dance functions would go here. -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_cln_finished, dance_cln_reset), }; diff --git a/keyboards/splitkb/kyria/keymaps/jhelvy/config.h b/keyboards/splitkb/kyria/keymaps/jhelvy/config.h index 86f3d5b5c3..518c9378e4 100644 --- a/keyboards/splitkb/kyria/keymaps/jhelvy/config.h +++ b/keyboards/splitkb/kyria/keymaps/jhelvy/config.h @@ -22,7 +22,7 @@ #define ENCODER_RESOLUTION 2 -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 200 #define AUTO_SHIFT_TIMEOUT 150 diff --git a/keyboards/splitkb/kyria/keymaps/lms_ace01/keymap.c b/keyboards/splitkb/kyria/keymaps/lms_ace01/keymap.c index b2ba6b71eb..89f0b06edd 100644 --- a/keyboards/splitkb/kyria/keymaps/lms_ace01/keymap.c +++ b/keyboards/splitkb/kyria/keymaps/lms_ace01/keymap.c @@ -130,11 +130,11 @@ static td_tap_t td_tap_state = { .state = TD_NONE }; -td_state_t td_current (qk_tap_dance_state_t *state); -void td_kc_ly_finished(qk_tap_dance_state_t *state, void *user_data); -void td_kc_ly_reset (qk_tap_dance_state_t *state, void *user_data); +td_state_t td_current (tap_dance_state_t *state); +void td_kc_ly_finished(tap_dance_state_t *state, void *user_data); +void td_kc_ly_reset (tap_dance_state_t *state, void *user_data); -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TAB] = ACTION_TAP_DANCE_DOUBLE(KC_TAB, KC_CAPS), [ESC] = ACTION_TAP_DANCE_FN_ADVANCED_USER(NULL, td_kc_ly_finished, td_kc_ly_reset, \ &((td_user_data_t) { KC_ESC, { _NAVIGATION, _QWERTY_ES, _QWERTY_ES }})), @@ -505,7 +505,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { * TAP DANCE FUNCTIONS */ #ifdef TAP_DANCE_ENABLE -td_state_t td_current(qk_tap_dance_state_t *state) { +td_state_t td_current(tap_dance_state_t *state) { switch (state->count) { case 1: return ((!state->pressed) ? TD_SINGLE_TAP : TD_SINGLE_HOLD); @@ -516,7 +516,7 @@ td_state_t td_current(qk_tap_dance_state_t *state) { } } -void td_kc_ly_finished(qk_tap_dance_state_t *state, void *user_data) { +void td_kc_ly_finished(tap_dance_state_t *state, void *user_data) { td_tap_state.state = td_current(state); uint16_t keycode = ((td_user_data_t *)user_data)->keycode; uint8_t *layer_arr = ((td_user_data_t *)user_data)->layer; @@ -576,7 +576,7 @@ void td_kc_ly_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void td_kc_ly_reset(qk_tap_dance_state_t *state, void *user_data) { +void td_kc_ly_reset(tap_dance_state_t *state, void *user_data) { uint8_t *layer_arr = ((td_user_data_t *)user_data)->layer; if (td_tap_state.state == TD_SINGLE_HOLD) { diff --git a/keyboards/splitkb/kyria/keymaps/muppetjones/config.h b/keyboards/splitkb/kyria/keymaps/muppetjones/config.h index 92d495be4a..b6351869fe 100644 --- a/keyboards/splitkb/kyria/keymaps/muppetjones/config.h +++ b/keyboards/splitkb/kyria/keymaps/muppetjones/config.h @@ -43,7 +43,7 @@ #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // Reduce firmware size // https://thomasbaart.nl/2018/12/01/reducing-firmware-size-in-qmk/ diff --git a/keyboards/splitkb/kyria/keymaps/ohlin/config.h b/keyboards/splitkb/kyria/keymaps/ohlin/config.h index 238206a49e..4451ff731c 100644 --- a/keyboards/splitkb/kyria/keymaps/ohlin/config.h +++ b/keyboards/splitkb/kyria/keymaps/ohlin/config.h @@ -26,4 +26,4 @@ // Prevent normal rollover on alphas from accidentally triggering mods. #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD
\ No newline at end of file +#define QUICK_TAP_TERM 0 diff --git a/keyboards/splitkb/kyria/keymaps/pierrec83/config.h b/keyboards/splitkb/kyria/keymaps/pierrec83/config.h index 816dd16312..b4f3f32255 100644 --- a/keyboards/splitkb/kyria/keymaps/pierrec83/config.h +++ b/keyboards/splitkb/kyria/keymaps/pierrec83/config.h @@ -44,7 +44,7 @@ #define TAPPING_TERM 200 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // Allows to use either side as the master. Look at the documentation for info: // https://docs.qmk.fm/#/config_options?id=setting-handedness #define EE_HANDS diff --git a/keyboards/splitkb/kyria/keymaps/winternebs/config.h b/keyboards/splitkb/kyria/keymaps/winternebs/config.h index 1df48a1f49..f0632e90ae 100755 --- a/keyboards/splitkb/kyria/keymaps/winternebs/config.h +++ b/keyboards/splitkb/kyria/keymaps/winternebs/config.h @@ -27,5 +27,5 @@ #define NO_ACTION_MACRO #define NO_ACTION_FUNCTION #define NO_ACTION_ONESHOT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define IGNORE_MOD_TAP_INTERRUPT diff --git a/keyboards/splitkb/kyria/keymaps/zigotica/config.h b/keyboards/splitkb/kyria/keymaps/zigotica/config.h index b59e04474b..8c4e8dfece 100644 --- a/keyboards/splitkb/kyria/keymaps/zigotica/config.h +++ b/keyboards/splitkb/kyria/keymaps/zigotica/config.h @@ -24,7 +24,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define TAPPING_TERM 350 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define LEADER_PER_KEY_TIMING #define LEADER_TIMEOUT 300 diff --git a/keyboards/the_uni/info.json b/keyboards/stenokeyboards/the_uni/info.json index b7cb80957e..b7cb80957e 100644 --- a/keyboards/the_uni/info.json +++ b/keyboards/stenokeyboards/the_uni/info.json diff --git a/keyboards/the_uni/keymaps/default/keymap.c b/keyboards/stenokeyboards/the_uni/keymaps/default/keymap.c index 492c7a3c94..492c7a3c94 100644 --- a/keyboards/the_uni/keymaps/default/keymap.c +++ b/keyboards/stenokeyboards/the_uni/keymaps/default/keymap.c diff --git a/keyboards/the_uni/keymaps/qwerty/keymap.c b/keyboards/stenokeyboards/the_uni/keymaps/qwerty/keymap.c index b2f03a3613..b2f03a3613 100644 --- a/keyboards/the_uni/keymaps/qwerty/keymap.c +++ b/keyboards/stenokeyboards/the_uni/keymaps/qwerty/keymap.c diff --git a/keyboards/the_uni/pro_micro/config.h b/keyboards/stenokeyboards/the_uni/pro_micro/config.h index dc0493face..dc0493face 100644 --- a/keyboards/the_uni/pro_micro/config.h +++ b/keyboards/stenokeyboards/the_uni/pro_micro/config.h diff --git a/keyboards/the_uni/pro_micro/info.json b/keyboards/stenokeyboards/the_uni/pro_micro/info.json index 90ac25f360..90ac25f360 100644 --- a/keyboards/the_uni/pro_micro/info.json +++ b/keyboards/stenokeyboards/the_uni/pro_micro/info.json diff --git a/keyboards/the_uni/pro_micro/pro_micro.c b/keyboards/stenokeyboards/the_uni/pro_micro/pro_micro.c index 3d5b3b23bb..3d5b3b23bb 100644 --- a/keyboards/the_uni/pro_micro/pro_micro.c +++ b/keyboards/stenokeyboards/the_uni/pro_micro/pro_micro.c diff --git a/keyboards/the_uni/pro_micro/pro_micro.h b/keyboards/stenokeyboards/the_uni/pro_micro/pro_micro.h index 9371c3a241..9371c3a241 100644 --- a/keyboards/the_uni/pro_micro/pro_micro.h +++ b/keyboards/stenokeyboards/the_uni/pro_micro/pro_micro.h diff --git a/keyboards/the_uni/pro_micro/readme.md b/keyboards/stenokeyboards/the_uni/pro_micro/readme.md index 397cf7a198..1fc689e6ee 100644 --- a/keyboards/the_uni/pro_micro/readme.md +++ b/keyboards/stenokeyboards/the_uni/pro_micro/readme.md @@ -17,6 +17,6 @@ Enter the bootloader by: Make examples for this keyboard (after setting up your build environment): - make the_uni/pro_micro:default + make stenokeyboards/the_uni/pro_micro:default See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/the_uni/pro_micro/rules.mk b/keyboards/stenokeyboards/the_uni/pro_micro/rules.mk index ba22869d5e..ba22869d5e 100644 --- a/keyboards/the_uni/pro_micro/rules.mk +++ b/keyboards/stenokeyboards/the_uni/pro_micro/rules.mk diff --git a/keyboards/the_uni/readme.md b/keyboards/stenokeyboards/the_uni/readme.md index 88cb81b111..9197266497 100644 --- a/keyboards/the_uni/readme.md +++ b/keyboards/stenokeyboards/the_uni/readme.md @@ -25,12 +25,12 @@ Enter the bootloader by: Make examples for this keyboard (after setting up your build environment): # version 1 and 2 - make the_uni/pro_micro:default + make stenokeyboards/the_uni/pro_micro:default # version 3 - make the_uni/usb_c:default + make stenokeyboards/the_uni/usb_c:default # version 4 - qmk compile -kb the_uni/rp_2040 -km default + qmk compile -kb stenokeyboards/the_uni/rp_2040 -km default See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/the_uni/rp_2040/config.h b/keyboards/stenokeyboards/the_uni/rp_2040/config.h index b14a6ea2d2..b14a6ea2d2 100644 --- a/keyboards/the_uni/rp_2040/config.h +++ b/keyboards/stenokeyboards/the_uni/rp_2040/config.h diff --git a/keyboards/the_uni/rp_2040/info.json b/keyboards/stenokeyboards/the_uni/rp_2040/info.json index cebd90c01e..cebd90c01e 100644 --- a/keyboards/the_uni/rp_2040/info.json +++ b/keyboards/stenokeyboards/the_uni/rp_2040/info.json diff --git a/keyboards/the_uni/rp_2040/readme.md b/keyboards/stenokeyboards/the_uni/rp_2040/readme.md index 5867a213d9..2dcdf3d540 100644 --- a/keyboards/the_uni/rp_2040/readme.md +++ b/keyboards/stenokeyboards/the_uni/rp_2040/readme.md @@ -20,6 +20,6 @@ Enter the bootloader by: Make examples for this keyboard (after setting up your build environment): - qmk compile -kb the_uni/rp_2040 -km default + qmk compile -kb stenokeyboards/the_uni/rp_2040 -km default See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/the_uni/rp_2040/rp_2040.c b/keyboards/stenokeyboards/the_uni/rp_2040/rp_2040.c index b032a22f42..b032a22f42 100644 --- a/keyboards/the_uni/rp_2040/rp_2040.c +++ b/keyboards/stenokeyboards/the_uni/rp_2040/rp_2040.c diff --git a/keyboards/the_uni/rp_2040/rp_2040.h b/keyboards/stenokeyboards/the_uni/rp_2040/rp_2040.h index 9371c3a241..9371c3a241 100644 --- a/keyboards/the_uni/rp_2040/rp_2040.h +++ b/keyboards/stenokeyboards/the_uni/rp_2040/rp_2040.h diff --git a/keyboards/the_uni/rp_2040/rules.mk b/keyboards/stenokeyboards/the_uni/rp_2040/rules.mk index da6a3dc6a8..da6a3dc6a8 100644 --- a/keyboards/the_uni/rp_2040/rules.mk +++ b/keyboards/stenokeyboards/the_uni/rp_2040/rules.mk diff --git a/keyboards/the_uni/usb_c/config.h b/keyboards/stenokeyboards/the_uni/usb_c/config.h index 02b6ad5a1f..02b6ad5a1f 100644 --- a/keyboards/the_uni/usb_c/config.h +++ b/keyboards/stenokeyboards/the_uni/usb_c/config.h diff --git a/keyboards/the_uni/usb_c/info.json b/keyboards/stenokeyboards/the_uni/usb_c/info.json index b377cdff00..b377cdff00 100644 --- a/keyboards/the_uni/usb_c/info.json +++ b/keyboards/stenokeyboards/the_uni/usb_c/info.json diff --git a/keyboards/the_uni/usb_c/readme.md b/keyboards/stenokeyboards/the_uni/usb_c/readme.md index 23895db39f..f7a630cf86 100644 --- a/keyboards/the_uni/usb_c/readme.md +++ b/keyboards/stenokeyboards/the_uni/usb_c/readme.md @@ -10,11 +10,11 @@ Enter the bootloader by: -* **Physical reset button**: On the Uni v3, briefly press the button on the back of the PCB. -* **Reset Pads**: Uni v1 and v2 have pins/pads you must short instead (RST to GND). +- **Physical reset button**: On the Uni v3, briefly press the button on the back of the PCB. +- **Reset Pads**: Uni v1 and v2 have pins/pads you must short instead (RST to GND). Make examples for this keyboard (after setting up your build environment): - make the_uni/usb_c:default + make stenokeyboards/the_uni/usb_c:default See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/the_uni/usb_c/rules.mk b/keyboards/stenokeyboards/the_uni/usb_c/rules.mk index 5b78a2ede1..5b78a2ede1 100644 --- a/keyboards/the_uni/usb_c/rules.mk +++ b/keyboards/stenokeyboards/the_uni/usb_c/rules.mk diff --git a/keyboards/the_uni/usb_c/usb_c.c b/keyboards/stenokeyboards/the_uni/usb_c/usb_c.c index e690d0a886..e690d0a886 100644 --- a/keyboards/the_uni/usb_c/usb_c.c +++ b/keyboards/stenokeyboards/the_uni/usb_c/usb_c.c diff --git a/keyboards/the_uni/usb_c/usb_c.h b/keyboards/stenokeyboards/the_uni/usb_c/usb_c.h index 9371c3a241..9371c3a241 100644 --- a/keyboards/the_uni/usb_c/usb_c.h +++ b/keyboards/stenokeyboards/the_uni/usb_c/usb_c.h diff --git a/keyboards/studiokestra/bourgeau/readme.md b/keyboards/studiokestra/bourgeau/readme.md index b0a0bb2a89..16f87618e0 100644 --- a/keyboards/studiokestra/bourgeau/readme.md +++ b/keyboards/studiokestra/bourgeau/readme.md @@ -11,7 +11,7 @@ Compact 75% universal hotswap PCB with USB-C that supports a fixed 6.25U bottom There are 3 ways to put the board in bootloader mode: - Hold the top-left key (typically `Esc`) while plugging in the USB cable, OR -- While the PCB is plugged into the PC, press the physical `QK_BOOT` button on the back of the board, OR +- While the PCB is plugged into the PC, press the physical `RESET` button on the back of the board, OR - With the default layout, toggle Layer 1 and press the `ESC` key. ## Compiling Firmware diff --git a/keyboards/studiokestra/cascade/readme.md b/keyboards/studiokestra/cascade/readme.md index e217b3edea..db55844ed1 100644 --- a/keyboards/studiokestra/cascade/readme.md +++ b/keyboards/studiokestra/cascade/readme.md @@ -11,7 +11,7 @@ There are 3 ways to put the board in bootloader mode: - Hold the top-left key (typically `Esc`) while plugging in the USB cable, OR -- While the PCB is plugged into the PC, press the physical `QK_BOOT` button on the back of the board, OR +- While the PCB is plugged into the PC, press the physical `RESET` button on the back of the board, OR - With the default layout, toggle Layer 1 and press the `ESC` key. ## Compiling Firmware diff --git a/keyboards/studiokestra/galatea/readme.md b/keyboards/studiokestra/galatea/readme.md index 08a6eae011..1268c596bf 100644 --- a/keyboards/studiokestra/galatea/readme.md +++ b/keyboards/studiokestra/galatea/readme.md @@ -13,7 +13,7 @@ TKL H87/88c compatible PCB with support for the most common layouts. There are 3 ways to put the board in bootloader mode: - Hold the top-left key (typically `Esc`) while plugging in the USB cable, OR -- While the PCB is plugged into the PC, press the physical `QK_BOOT` button on the back of the board, OR +- While the PCB is plugged into the PC, press the physical `RESET` button on the back of the board, OR - With the default layout, toggle Layer 1 and press the `R` key. ## Compiling Firmware diff --git a/keyboards/studiokestra/nue/readme.md b/keyboards/studiokestra/nue/readme.md index f29f27be22..42e72902e4 100644 --- a/keyboards/studiokestra/nue/readme.md +++ b/keyboards/studiokestra/nue/readme.md @@ -11,7 +11,7 @@ There are 3 ways to put the board in bootloader mode: - Hold the top-left key (typically `Esc`) while plugging in the USB cable, OR -- While the PCB is plugged into the PC, press the physical `QK_BOOT` button on the back of the board, OR +- While the PCB is plugged into the PC, press the physical `RESET` button on the back of the board, OR - With the default layout, toggle Layer 1 and press the `R` key. ## Compiling Firmware diff --git a/keyboards/tada68/keymaps/abishalom/keymap.c b/keyboards/tada68/keymaps/abishalom/keymap.c index f21fd93313..9dba7374bf 100644 --- a/keyboards/tada68/keymaps/abishalom/keymap.c +++ b/keyboards/tada68/keymaps/abishalom/keymap.c @@ -15,7 +15,7 @@ enum { }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_WIN_LOCK] = ACTION_TAP_DANCE_DOUBLE(MAGIC_NO_GUI, MAGIC_UNNO_GUI) }; diff --git a/keyboards/tada68/keymaps/sm0g/keymap.c b/keyboards/tada68/keymaps/sm0g/keymap.c index f7d1c6ba69..2c1e104732 100644 --- a/keyboards/tada68/keymaps/sm0g/keymap.c +++ b/keyboards/tada68/keymaps/sm0g/keymap.c @@ -84,7 +84,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Tapdance definitions. Tap Dance F Keys. -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_F1] = ACTION_TAP_DANCE_DOUBLE(KC_1, KC_F1), [TD_F2] = ACTION_TAP_DANCE_DOUBLE(KC_2, KC_F2), [TD_F3] = ACTION_TAP_DANCE_DOUBLE(KC_3, KC_F3), diff --git a/keyboards/tada68/keymaps/trashcat/keymap.c b/keyboards/tada68/keymaps/trashcat/keymap.c index 6f5f85aa53..9ec31e0d5a 100644 --- a/keyboards/tada68/keymaps/trashcat/keymap.c +++ b/keyboards/tada68/keymaps/trashcat/keymap.c @@ -92,7 +92,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Tapdance definitions. Tap Dance F Keys. -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_F1] = ACTION_TAP_DANCE_DOUBLE(KC_1, KC_F1), [TD_F2] = ACTION_TAP_DANCE_DOUBLE(KC_2, KC_F2), [TD_F3] = ACTION_TAP_DANCE_DOUBLE(KC_3, KC_F3), diff --git a/keyboards/the_royal/liminal/keymaps/default/keymap.c b/keyboards/the_royal/liminal/keymaps/default/keymap.c index 5ff6c4aa3c..5dedb8b0ad 100644 --- a/keyboards/the_royal/liminal/keymaps/default/keymap.c +++ b/keyboards/the_royal/liminal/keymaps/default/keymap.c @@ -14,7 +14,7 @@ enum { TD_DBQT }; -void dance_rst_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_rst_reset (tap_dance_state_t *state, void *user_data) { if (state->count >= 2) { reset_keyboard(); reset_tap_dance(state); @@ -22,7 +22,7 @@ void dance_rst_reset (qk_tap_dance_state_t *state, void *user_data) { } //All tap dance functions would go here. Only showing this one. -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_RST] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, NULL, dance_rst_reset), [TD_DBQT] = ACTION_TAP_DANCE_DOUBLE (KC_QUOTE, KC_DQT) }; diff --git a/keyboards/the_royal/liminal/keymaps/default_iso/keymap.c b/keyboards/the_royal/liminal/keymaps/default_iso/keymap.c index d5fe730d80..43b2fa2256 100644 --- a/keyboards/the_royal/liminal/keymaps/default_iso/keymap.c +++ b/keyboards/the_royal/liminal/keymaps/default_iso/keymap.c @@ -14,7 +14,7 @@ enum { TD_DBQT }; -void dance_rst_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_rst_reset (tap_dance_state_t *state, void *user_data) { if (state->count >= 2) { reset_keyboard(); reset_tap_dance(state); @@ -22,7 +22,7 @@ void dance_rst_reset (qk_tap_dance_state_t *state, void *user_data) { } //All tap dance functions would go here. Only showing this one. -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_RST] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, NULL, dance_rst_reset), [TD_DBQT] = ACTION_TAP_DANCE_DOUBLE (KC_QUOTE, KC_DQT) }; diff --git a/keyboards/the_royal/schwann/keymaps/default/keymap.c b/keyboards/the_royal/schwann/keymaps/default/keymap.c index 1535e3dc1f..532dfe4123 100644 --- a/keyboards/the_royal/schwann/keymaps/default/keymap.c +++ b/keyboards/the_royal/schwann/keymaps/default/keymap.c @@ -18,7 +18,7 @@ enum { TD_RST }; -void dance_rst_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_rst_reset (tap_dance_state_t *state, void *user_data) { if (state->count >= 2) { reset_keyboard(); reset_tap_dance(state); @@ -26,7 +26,7 @@ void dance_rst_reset (qk_tap_dance_state_t *state, void *user_data) { } //All tap dance functions would go here. Only showing this one. -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_RST] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, NULL, dance_rst_reset) }; diff --git a/keyboards/thevankeyboards/minivan/keymaps/belak/keymap.c b/keyboards/thevankeyboards/minivan/keymaps/belak/keymap.c index 0ed709747a..67d11f5e4c 100644 --- a/keyboards/thevankeyboards/minivan/keymaps/belak/keymap.c +++ b/keyboards/thevankeyboards/minivan/keymaps/belak/keymap.c @@ -31,10 +31,10 @@ enum belak_td { BE_TD_ALT, }; -void mod_tap_fn(qk_tap_dance_state_t *state, void *user_data); -void mod_reset_fn(qk_tap_dance_state_t *state, void *user_data); +void mod_tap_fn(tap_dance_state_t *state, void *user_data); +void mod_reset_fn(tap_dance_state_t *state, void *user_data); -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [BE_TD_GUI] = ACTION_TAP_DANCE_MOD_TAP(KC_LGUI), [BE_TD_CTL] = ACTION_TAP_DANCE_MOD_TAP(KC_LCTL), [BE_TD_ALT] = ACTION_TAP_DANCE_MOD_TAP(KC_LALT), @@ -68,7 +68,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Tap dance functions -void mod_tap_fn(qk_tap_dance_state_t *state, void *user_data) { +void mod_tap_fn(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: uint8_t *mod = (uint8_t *)user_data; @@ -87,7 +87,7 @@ void mod_tap_fn(qk_tap_dance_state_t *state, void *user_data) { } } -void mod_reset_fn(qk_tap_dance_state_t *state, void *user_data) { +void mod_reset_fn(tap_dance_state_t *state, void *user_data) { uint8_t *mod = (uint8_t *)user_data; layer_off(_L1); layer_off(_L2); diff --git a/keyboards/thevankeyboards/minivan/keymaps/like_jis/keymap.c b/keyboards/thevankeyboards/minivan/keymaps/like_jis/keymap.c index 3b146b8e37..67f7c0717c 100644 --- a/keyboards/thevankeyboards/minivan/keymaps/like_jis/keymap.c +++ b/keyboards/thevankeyboards/minivan/keymaps/like_jis/keymap.c @@ -45,7 +45,7 @@ enum tapdances{ #define KC_SCCL TD(TD_SCCL) -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SCCL] = ACTION_TAP_DANCE_DOUBLE(KC_SCLN, KC_QUOT), }; diff --git a/keyboards/torn/keymaps/kinesish/config.h b/keyboards/torn/keymaps/kinesish/config.h index 734512e6cd..5c4de67989 100644 --- a/keyboards/torn/keymaps/kinesish/config.h +++ b/keyboards/torn/keymaps/kinesish/config.h @@ -17,5 +17,5 @@ #pragma once #define TAPPING_TERM 200 -#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY +#define HOLD_ON_OTHER_KEY_PRESS_PER_KEY #define PERMISSIVE_HOLD_PER_KEY diff --git a/keyboards/torn/keymaps/kinesish/keymap.c b/keyboards/torn/keymaps/kinesish/keymap.c index 13f3304068..9ddbac3601 100644 --- a/keyboards/torn/keymaps/kinesish/keymap.c +++ b/keyboards/torn/keymaps/kinesish/keymap.c @@ -133,18 +133,18 @@ layer_state_t layer_state_set_user(layer_state_t state) { } /* - * Enable `IGNORE_MOD_TAP_INTERRUPT` for all modifiers except `Shift`. - * For more info see `IGNORE_MOD_TAP_INTERRUPT_PER_KEY` in `docs/tap_hold.md`. + * Enable `HOLD_ON_OTHER_KEY_PRESS` only for `Shift`. + * For more info see `HOLD_ON_OTHER_KEY_PRESS_PER_KEY` in `docs/tap_hold.md`. */ -bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { +bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case S_EQL: - return false; + return true; case S_MINS: - return false; - default: return true; + default: + return false; } } diff --git a/keyboards/tunks/ergo33/keymaps/prpro/keymap.c b/keyboards/tunks/ergo33/keymaps/prpro/keymap.c index db49eeb7f8..8751f65126 100644 --- a/keyboards/tunks/ergo33/keymaps/prpro/keymap.c +++ b/keyboards/tunks/ergo33/keymaps/prpro/keymap.c @@ -43,7 +43,7 @@ enum { }; /* Tap Dance definitions */ -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_1] = ACTION_TAP_DANCE_DOUBLE(LCTL(KC_1), LCTL(LSFT(KC_1))), [TD_2] = ACTION_TAP_DANCE_DOUBLE(LCTL(KC_2), LCTL(LSFT(KC_2))), [TD_3] = ACTION_TAP_DANCE_DOUBLE(LCTL(KC_3), LCTL(LSFT(KC_3))), diff --git a/keyboards/ungodly/launch_pad/keymaps/warzone/keymap.c b/keyboards/ungodly/launch_pad/keymaps/warzone/keymap.c index ea7b50c129..e3292dd30c 100644 --- a/keyboards/ungodly/launch_pad/keymaps/warzone/keymap.c +++ b/keyboards/ungodly/launch_pad/keymaps/warzone/keymap.c @@ -32,7 +32,7 @@ enum { }; // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Escape, twice for Number 4 (armor plates in warzone) [TD_ESC_TAB] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_TAB), [TD_3_L0] = ACTION_TAP_DANCE_LAYER_TOGGLE(KC_3, 1), diff --git a/keyboards/unikeyboard/diverge3/keymaps/default/keymap.c b/keyboards/unikeyboard/diverge3/keymaps/default/keymap.c index acf262696b..dc5c261f59 100644 --- a/keyboards/unikeyboard/diverge3/keymaps/default/keymap.c +++ b/keyboards/unikeyboard/diverge3/keymaps/default/keymap.c @@ -34,7 +34,7 @@ typedef struct { int state; } tap; -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP if (state->interrupted || state->pressed==0) return SINGLE_TAP; @@ -58,7 +58,7 @@ static tap se_tap_state = { .state = 0 }; -void se_finished (qk_tap_dance_state_t *state, void *user_data) { +void se_finished (tap_dance_state_t *state, void *user_data) { se_tap_state.state = cur_dance(state); switch (se_tap_state.state) { case SINGLE_TAP: register_code(KC_SPC); break; @@ -70,7 +70,7 @@ void se_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void se_reset (qk_tap_dance_state_t *state, void *user_data) { +void se_reset (tap_dance_state_t *state, void *user_data) { switch (se_tap_state.state) { case SINGLE_TAP: unregister_code(KC_SPC); break; case SINGLE_HOLD: unregister_code(KC_ENT); break; @@ -79,7 +79,7 @@ void se_reset (qk_tap_dance_state_t *state, void *user_data) { se_tap_state.state = 0; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [SE_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, se_finished, se_reset) }; diff --git a/keyboards/unikeyboard/divergetm2/keymaps/xtonhasvim/config.h b/keyboards/unikeyboard/divergetm2/keymaps/xtonhasvim/config.h index 4ba4a57165..4585f2230b 100644 --- a/keyboards/unikeyboard/divergetm2/keymaps/xtonhasvim/config.h +++ b/keyboards/unikeyboard/divergetm2/keymaps/xtonhasvim/config.h @@ -3,7 +3,7 @@ // help for fast typist+dual function keys? #define PERMISSIVE_HOLD // Let me type `ls -l` more quickly. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // where is the cord plugged in? #define MASTER_RIGHT diff --git a/keyboards/wolf/m60_b/config.h b/keyboards/wolf/m60_b/config.h new file mode 100644 index 0000000000..2115f265b4 --- /dev/null +++ b/keyboards/wolf/m60_b/config.h @@ -0,0 +1,86 @@ +/* +Copyright 2020 <contact@vwolf.be> + +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/>. +*/ +#pragma once +#include "config_common.h" + +/* Define RGB */ +#ifdef RGB_MATRIX_ENABLE + +#define RGB_MATRIX_LED_COUNT 62 +#define RGB_DI_PIN D1 + +#define RGB_DISABLE_WHEN_USB_SUSPENDED +#define RGB_MATRIX_KEYPRESSES +#define RGB_MATRIX_FRAMEBUFFER_EFFECTS +#define RGB_MATRIX_MAXIMUM_BRIGHTNESS 120 + +#define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_CYCLE_ALL + +#define ENABLE_RGB_MATRIX_ALPHAS_MODS +#define ENABLE_RGB_MATRIX_GRADIENT_UP_DOWN +#define ENABLE_RGB_MATRIX_GRADIENT_LEFT_RIGHT +#define ENABLE_RGB_MATRIX_BREATHING +#define ENABLE_RGB_MATRIX_BAND_SAT +#define ENABLE_RGB_MATRIX_BAND_VAL +#define ENABLE_RGB_MATRIX_BAND_PINWHEEL_SAT +#define ENABLE_RGB_MATRIX_BAND_PINWHEEL_VAL +#define ENABLE_RGB_MATRIX_BAND_SPIRAL_SAT +#define ENABLE_RGB_MATRIX_BAND_SPIRAL_VAL +#define ENABLE_RGB_MATRIX_CYCLE_ALL +#define ENABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT +#define ENABLE_RGB_MATRIX_CYCLE_UP_DOWN +#define ENABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON +#define ENABLE_RGB_MATRIX_CYCLE_OUT_IN +#define ENABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL +#define ENABLE_RGB_MATRIX_CYCLE_PINWHEEL +#define ENABLE_RGB_MATRIX_CYCLE_SPIRAL +#define ENABLE_RGB_MATRIX_DUAL_BEACON +#define ENABLE_RGB_MATRIX_RAINBOW_BEACON +#define ENABLE_RGB_MATRIX_RAINBOW_PINWHEELS +#define ENABLE_RGB_MATRIX_RAINDROPS +#define ENABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS +#define ENABLE_RGB_MATRIX_HUE_BREATHING +#define ENABLE_RGB_MATRIX_HUE_PENDULUM +#define ENABLE_RGB_MATRIX_HUE_WAVE +#define ENABLE_RGB_MATRIX_PIXEL_RAIN +// The PIXEL_FRACTAL effect does not work properly when the matrix layout is +// different from the physical layout; it also has problems when underglow +// LEDs are present, or when multiple LEDs are associated with the same key. +#undef ENABLE_RGB_MATRIX_PIXEL_FRACTAL + +// Framebuffer effects; can be enabled only if RGB_MATRIX_FRAMEBUFFER_EFFECTS +// is defined. Both of these effects currently don't work properly when the +// key matrix does not match the physical layout, so they are disabled. +#undef ENABLE_RGB_MATRIX_TYPING_HEATMAP +#undef ENABLE_RGB_MATRIX_DIGITAL_RAIN + +// Reactive effects; can be enabled only if at least one of +// RGB_MATRIX_KEYPRESSES or RGB_MATRIX_KEYRELEASES is defined. +#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE +#define ENABLE_RGB_MATRIX_SOLID_REACTIVE +#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE +#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE +#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS +#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS +#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS +#define ENABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS +#define ENABLE_RGB_MATRIX_SPLASH +#define ENABLE_RGB_MATRIX_MULTISPLASH +#define ENABLE_RGB_MATRIX_SOLID_SPLASH +#define ENABLE_RGB_MATRIX_SOLID_MULTISPLASH + +#endif diff --git a/keyboards/wolf/m60_b/info.json b/keyboards/wolf/m60_b/info.json new file mode 100644 index 0000000000..be2237354a --- /dev/null +++ b/keyboards/wolf/m60_b/info.json @@ -0,0 +1,161 @@ +{ + "manufacturer": "Rama Works", + "keyboard_name": "M60-B", + "maintainer": "ToastyStoemp", + "bootloader": "atmel-dfu", + "diode_direction": "COL2ROW", + "features": { + "bootmagic": true, + "command": false, + "console": false, + "extrakey": true, + "mousekey": true, + "nkro": true, + "rgb_matrix": true, + "rgblight": false + }, + "matrix_pins": { + "cols": ["B7", "F0", "F1", "F4", "F5", "F6", "F7", "C7", "C6", "B6", "B5", "B4", "D7", "D6"], + "rows": ["D5", "D3", "D2", "B0", "B2"] + }, + "processor": "atmega32u4", + "rgb_matrix": { + "driver": "WS2812", + "layout": [ + { "flags": 4, "matrix": [2, 0], "x": 7, "y": 32 }, + { "flags": 4, "matrix": [1, 0], "x": 4, "y": 16 }, + { "flags": 4, "matrix": [1, 1], "x": 26, "y": 16 }, + { "flags": 4, "matrix": [1, 2], "x": 44, "y": 16 }, + { "flags": 4, "matrix": [1, 3], "x": 61, "y": 16 }, + { "flags": 4, "matrix": [1, 4], "x": 78, "y": 16 }, + { "flags": 4, "matrix": [1, 5], "x": 96, "y": 16 }, + { "flags": 4, "matrix": [1, 6], "x": 113, "y": 16 }, + { "flags": 4, "matrix": [1, 7], "x": 131, "y": 16 }, + { "flags": 4, "matrix": [1, 8], "x": 148, "y": 16 }, + { "flags": 4, "matrix": [1, 9], "x": 166, "y": 16 }, + { "flags": 4, "matrix": [1, 10], "x": 183, "y": 16 }, + { "flags": 4, "matrix": [1, 11], "x": 200, "y": 16 }, + { "flags": 4, "matrix": [1, 12], "x": 218, "y": 16 }, + { "flags": 4, "matrix": [1, 13], "x": 240, "y": 16 }, + { "flags": 4, "matrix": [2, 13], "x": 233, "y": 32 }, + { "flags": 4, "matrix": [2, 11], "x": 205, "y": 32 }, + { "flags": 4, "matrix": [2, 10], "x": 187, "y": 32 }, + { "flags": 4, "matrix": [2, 9], "x": 170, "y": 32 }, + { "flags": 4, "matrix": [2, 8], "x": 153, "y": 32 }, + { "flags": 4, "matrix": [2, 7], "x": 135, "y": 32 }, + { "flags": 4, "matrix": [2, 6], "x": 118, "y": 32 }, + { "flags": 4, "matrix": [2, 5], "x": 100, "y": 32 }, + { "flags": 4, "matrix": [2, 4], "x": 83, "y": 32 }, + { "flags": 4, "matrix": [2, 3], "x": 65, "y": 32 }, + { "flags": 4, "matrix": [2, 2], "x": 48, "y": 32 }, + { "flags": 4, "matrix": [2, 1], "x": 31, "y": 32 }, + { "flags": 4, "matrix": [3, 1], "x": 39, "y": 48 }, + { "flags": 4, "matrix": [3, 2], "x": 57, "y": 48 }, + { "flags": 4, "matrix": [3, 3], "x": 74, "y": 48 }, + { "flags": 4, "matrix": [3, 4], "x": 92, "y": 48 }, + { "flags": 4, "matrix": [3, 5], "x": 109, "y": 48 }, + { "flags": 4, "matrix": [3, 6], "x": 126, "y": 48 }, + { "flags": 4, "matrix": [3, 7], "x": 144, "y": 48 }, + { "flags": 4, "matrix": [3, 8], "x": 161, "y": 48 }, + { "flags": 4, "matrix": [3, 9], "x": 179, "y": 48 }, + { "flags": 4, "matrix": [3, 10], "x": 196, "y": 48 }, + { "flags": 4, "matrix": [3, 12], "x": 220, "y": 48 }, + { "flags": 4, "matrix": [3, 13], "x": 244, "y": 48 }, + { "flags": 4, "matrix": [4, 12], "x": 218, "y": 64 }, + { "flags": 4, "matrix": [4, 10], "x": 196, "y": 64 }, + { "flags": 4, "matrix": [3, 9], "x": 174, "y": 60 }, + { "flags": 4, "matrix": [4, 6], "x": 122, "y": 64 }, + { "flags": 4, "matrix": [3, 3], "x": 70, "y": 60 }, + { "flags": 4, "matrix": [4, 2], "x": 48, "y": 64 }, + { "flags": 4, "matrix": [4, 1], "x": 26, "y": 64 }, + { "flags": 4, "matrix": [3, 0], "x": 11, "y": 48 }, + { "flags": 4, "matrix": [0, 0], "x": 0, "y": 0 }, + { "flags": 4, "matrix": [0, 1], "x": 17, "y": 0 }, + { "flags": 4, "matrix": [0, 2], "x": 35, "y": 0 }, + { "flags": 4, "matrix": [0, 3], "x": 52, "y": 0 }, + { "flags": 4, "matrix": [0, 4], "x": 70, "y": 0 }, + { "flags": 4, "matrix": [0, 5], "x": 87, "y": 0 }, + { "flags": 4, "matrix": [0, 6], "x": 105, "y": 0 }, + { "flags": 4, "matrix": [0, 7], "x": 122, "y": 0 }, + { "flags": 4, "matrix": [0, 8], "x": 139, "y": 0 }, + { "flags": 4, "matrix": [0, 9], "x": 157, "y": 0 }, + { "flags": 4, "matrix": [0, 10], "x": 174, "y": 0 }, + { "flags": 4, "matrix": [0, 11], "x": 192, "y": 0 }, + { "flags": 4, "matrix": [0, 12], "x": 209, "y": 0 }, + { "flags": 4, "matrix": [2, 12], "x": 227, "y": 0 }, + { "flags": 4, "matrix": [0, 13], "x": 244, "y": 0 } + ] + }, + "url": "", + "usb": { + "device_version": "1.0.0", + "pid": "0x0059", + "vid": "0x5453" + }, + "layouts": { + "LAYOUT_60_hhkb": { + "layout": [ + { "matrix": [0, 0], "x": 0, "y": 0 }, + { "matrix": [0, 1], "x": 1, "y": 0 }, + { "matrix": [0, 2], "x": 2, "y": 0 }, + { "matrix": [0, 3], "x": 3, "y": 0 }, + { "matrix": [0, 4], "x": 4, "y": 0 }, + { "matrix": [0, 5], "x": 5, "y": 0 }, + { "matrix": [0, 6], "x": 6, "y": 0 }, + { "matrix": [0, 7], "x": 7, "y": 0 }, + { "matrix": [0, 8], "x": 8, "y": 0 }, + { "matrix": [0, 9], "x": 9, "y": 0 }, + { "matrix": [0, 10], "x": 10, "y": 0 }, + { "matrix": [0, 11], "x": 11, "y": 0 }, + { "matrix": [0, 12], "x": 12, "y": 0 }, + { "matrix": [2, 12], "x": 13, "y": 0 }, + { "matrix": [0, 13], "x": 14, "y": 0 }, + { "matrix": [1, 0], "w": 1.5, "x": 0, "y": 1 }, + { "matrix": [1, 1], "x": 1.5, "y": 1 }, + { "matrix": [1, 2], "x": 2.5, "y": 1 }, + { "matrix": [1, 3], "x": 3.5, "y": 1 }, + { "matrix": [1, 4], "x": 4.5, "y": 1 }, + { "matrix": [1, 5], "x": 5.5, "y": 1 }, + { "matrix": [1, 6], "x": 6.5, "y": 1 }, + { "matrix": [1, 7], "x": 7.5, "y": 1 }, + { "matrix": [1, 8], "x": 8.5, "y": 1 }, + { "matrix": [1, 9], "x": 9.5, "y": 1 }, + { "matrix": [1, 10], "x": 10.5, "y": 1 }, + { "matrix": [1, 11], "x": 11.5, "y": 1 }, + { "matrix": [1, 12], "x": 12.5, "y": 1 }, + { "matrix": [1, 13], "w": 1.5, "x": 13.5, "y": 1 }, + { "matrix": [2, 0], "w": 1.75, "x": 0, "y": 2 }, + { "matrix": [2, 1], "x": 1.75, "y": 2 }, + { "matrix": [2, 2], "x": 2.75, "y": 2 }, + { "matrix": [2, 3], "x": 3.75, "y": 2 }, + { "matrix": [2, 4], "x": 4.75, "y": 2 }, + { "matrix": [2, 5], "x": 5.75, "y": 2 }, + { "matrix": [2, 6], "x": 6.75, "y": 2 }, + { "matrix": [2, 7], "x": 7.75, "y": 2 }, + { "matrix": [2, 8], "x": 8.75, "y": 2 }, + { "matrix": [2, 9], "x": 9.75, "y": 2 }, + { "matrix": [2, 10], "x": 10.75, "y": 2 }, + { "matrix": [2, 11], "x": 11.75, "y": 2 }, + { "matrix": [2, 13], "w": 2.25, "x": 12.75, "y": 2 }, + { "matrix": [3, 0], "w": 2.25, "x": 0, "y": 3 }, + { "matrix": [3, 1], "x": 2.25, "y": 3 }, + { "matrix": [3, 2], "x": 3.25, "y": 3 }, + { "matrix": [3, 3], "x": 4.25, "y": 3 }, + { "matrix": [3, 4], "x": 5.25, "y": 3 }, + { "matrix": [3, 5], "x": 6.25, "y": 3 }, + { "matrix": [3, 6], "x": 7.25, "y": 3 }, + { "matrix": [3, 7], "x": 8.25, "y": 3 }, + { "matrix": [3, 8], "x": 9.25, "y": 3 }, + { "matrix": [3, 9], "x": 10.25, "y": 3 }, + { "matrix": [3, 10], "x": 11.25, "y": 3 }, + { "matrix": [3, 12], "w": 1.75, "x": 12.25, "y": 3 }, + { "matrix": [3, 13], "x": 14, "y": 3 }, + { "matrix": [4, 1], "x": 1.5, "y": 4 }, + { "matrix": [4, 2], "w": 1.5, "x": 2.5, "y": 4 }, + { "matrix": [4, 6], "w": 7, "x": 4, "y": 4 }, + { "matrix": [4, 10], "w": 1.5, "x": 11, "y": 4 }, + { "matrix": [4, 12], "x": 12.5, "y": 4 } + ] + } + } +}
\ No newline at end of file diff --git a/keyboards/wolf/m60_b/keymaps/default/keymap.c b/keyboards/wolf/m60_b/keymaps/default/keymap.c new file mode 100644 index 0000000000..152ab88b50 --- /dev/null +++ b/keyboards/wolf/m60_b/keymaps/default/keymap.c @@ -0,0 +1,39 @@ +/* +Copyright 2020 <contact@vwolf.be> +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/>. +*/ + +#include QMK_KEYBOARD_H + +enum layers { + _LAYER0, + _LAYER1 +}; + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + + [_LAYER0] = LAYOUT_60_hhkb( + QK_GESC, 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_BSPC, KC_DEL, + KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, + KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, + KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, MO(1), + KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RGUI + ), + + [_LAYER1] = LAYOUT_60_hhkb( + KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_TRNS, KC_TRNS, + KC_TRNS, RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, KC_TRNS, KC_PSCR, KC_SCRL, KC_TRNS, KC_TRNS, + KC_TRNS, RGB_SPI, RGB_SPD, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, QK_BOOT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS + ) +};
\ No newline at end of file diff --git a/keyboards/wolf/m60_b/keymaps/via/keymap.c b/keyboards/wolf/m60_b/keymaps/via/keymap.c new file mode 100644 index 0000000000..152ab88b50 --- /dev/null +++ b/keyboards/wolf/m60_b/keymaps/via/keymap.c @@ -0,0 +1,39 @@ +/* +Copyright 2020 <contact@vwolf.be> +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/>. +*/ + +#include QMK_KEYBOARD_H + +enum layers { + _LAYER0, + _LAYER1 +}; + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { + + [_LAYER0] = LAYOUT_60_hhkb( + QK_GESC, 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_BSPC, KC_DEL, + KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS, + KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, + KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, MO(1), + KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RGUI + ), + + [_LAYER1] = LAYOUT_60_hhkb( + KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_TRNS, KC_TRNS, + KC_TRNS, RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, KC_TRNS, KC_PSCR, KC_SCRL, KC_TRNS, KC_TRNS, + KC_TRNS, RGB_SPI, RGB_SPD, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, QK_BOOT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS + ) +};
\ No newline at end of file diff --git a/keyboards/wolf/m60_b/keymaps/via/rules.mk b/keyboards/wolf/m60_b/keymaps/via/rules.mk new file mode 100644 index 0000000000..7f1f849dce --- /dev/null +++ b/keyboards/wolf/m60_b/keymaps/via/rules.mk @@ -0,0 +1,2 @@ +LTO_ENABLE = yes +VIA_ENABLE = yes
\ No newline at end of file diff --git a/keyboards/wolf/m60_b/readme.md b/keyboards/wolf/m60_b/readme.md new file mode 100644 index 0000000000..81163f6230 --- /dev/null +++ b/keyboards/wolf/m60_b/readme.md @@ -0,0 +1,25 @@ +# M60-B + +The following is the QMK Firmware for the M60-B Hotswap PCB. + +The PCB features: +* QMK & VIA compatibility +* Hotswap +* RGB Leds + +--- + +* Keyboard Maintainer: [ToastyStoemp](https://github.com/ToastyStoemp) + +Make example for this keyboard (after setting up your build environment): + + make wolf/m60_b:default + +Flashing example for this keyboard: + + make wolf/m60_b:default:flash +See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). + +## Bootloader Enter the bootloader in 3 ways: +* **Bootmagic reset**: Hold down the key ESC key and plug in the keyboard (Top Left most switch) +* **Physical reset button**: Briefly press the button on the back of the PCB diff --git a/keyboards/wolf/m60_b/rules.mk b/keyboards/wolf/m60_b/rules.mk new file mode 100644 index 0000000000..3437a35bdf --- /dev/null +++ b/keyboards/wolf/m60_b/rules.mk @@ -0,0 +1,2 @@ +# Processor frequency +F_CPU = 8000000 diff --git a/keyboards/woodkeys/bigseries/1key/keymaps/dudeofawesome/keymap.c b/keyboards/woodkeys/bigseries/1key/keymaps/dudeofawesome/keymap.c index 4c3739bbeb..2c754c3a68 100755 --- a/keyboards/woodkeys/bigseries/1key/keymaps/dudeofawesome/keymap.c +++ b/keyboards/woodkeys/bigseries/1key/keymaps/dudeofawesome/keymap.c @@ -25,7 +25,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { LAYOUT(TD(TD_PLAY)), }; -void tap_dance (qk_tap_dance_state_t *state, void *user_data) { +void tap_dance (tap_dance_state_t *state, void *user_data) { switch (state->count) { case 0 ... 1: register_code(KC_MEDIA_PLAY_PAUSE); @@ -45,6 +45,6 @@ void tap_dance (qk_tap_dance_state_t *state, void *user_data) { } //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_PLAY] = ACTION_TAP_DANCE_FN(tap_dance), }; diff --git a/keyboards/woodkeys/bigseries/1key/keymaps/leddance/keymap.c b/keyboards/woodkeys/bigseries/1key/keymaps/leddance/keymap.c index c77e579028..0bbd8beab5 100755 --- a/keyboards/woodkeys/bigseries/1key/keymaps/leddance/keymap.c +++ b/keyboards/woodkeys/bigseries/1key/keymaps/leddance/keymap.c @@ -34,7 +34,7 @@ enum { TD_TOGGLE = 0 }; -void dance_toggle (qk_tap_dance_state_t *state, void *user_data) { +void dance_toggle (tap_dance_state_t *state, void *user_data) { if (state->count >= 2) { println("Double tapped, switching layers"); if (layer_state_is(LED)) { @@ -59,7 +59,7 @@ void dance_toggle (qk_tap_dance_state_t *state, void *user_data) { } //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_TOGGLE] = ACTION_TAP_DANCE_FN(dance_toggle) // Other declarations would go here, separated by commas, if you have them }; diff --git a/keyboards/work_louder/work_board/keymaps/default/keymap.c b/keyboards/work_louder/work_board/keymaps/default/keymap.c index 14fb5014c7..56c4a2ce1d 100644 --- a/keyboards/work_louder/work_board/keymaps/default/keymap.c +++ b/keyboards/work_louder/work_board/keymaps/default/keymap.c @@ -61,7 +61,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -void dance_enc_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_enc_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code(KC_MPLY); } else if (state->count == 2) { @@ -71,7 +71,7 @@ void dance_enc_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_enc_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_enc_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code(KC_MPLY); } else if (state->count == 2) { @@ -82,7 +82,7 @@ void dance_enc_reset(qk_tap_dance_state_t *state, void *user_data) { } // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ENC_TAP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_enc_finished, dance_enc_reset), }; diff --git a/keyboards/work_louder/work_board/keymaps/via/keymap.c b/keyboards/work_louder/work_board/keymaps/via/keymap.c index 9ae3b36262..18689543da 100644 --- a/keyboards/work_louder/work_board/keymaps/via/keymap.c +++ b/keyboards/work_louder/work_board/keymaps/via/keymap.c @@ -59,7 +59,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; -void dance_enc_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_enc_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code(KC_MPLY); } else if (state->count == 2) { @@ -69,7 +69,7 @@ void dance_enc_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_enc_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_enc_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code(KC_MPLY); } else if (state->count == 2) { @@ -80,7 +80,7 @@ void dance_enc_reset(qk_tap_dance_state_t *state, void *user_data) { } // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ENC_TAP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_enc_finished, dance_enc_reset), }; diff --git a/keyboards/wsk/gothic50/keymaps/default/keymap.c b/keyboards/wsk/gothic50/keymaps/default/keymap.c index bf6c9c89aa..71ad616eb6 100644 --- a/keyboards/wsk/gothic50/keymaps/default/keymap.c +++ b/keyboards/wsk/gothic50/keymaps/default/keymap.c @@ -51,7 +51,7 @@ layer_state_t layer_state_set_user(layer_state_t state) } // Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // double tap for caps [TD_SCAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS) }; diff --git a/keyboards/wsk/gothic70/keymaps/default/keymap.c b/keyboards/wsk/gothic70/keymaps/default/keymap.c index 66ed2da1b7..589b30c4ef 100644 --- a/keyboards/wsk/gothic70/keymaps/default/keymap.c +++ b/keyboards/wsk/gothic70/keymaps/default/keymap.c @@ -63,7 +63,7 @@ layer_state_t layer_state_set_user(layer_state_t state) // Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for [TD_SCAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), }; diff --git a/keyboards/xelus/xs60/config.h b/keyboards/xelus/xs60/hotswap/config.h index a61cd22e53..5604b8139b 100644 --- a/keyboards/xelus/xs60/config.h +++ b/keyboards/xelus/xs60/hotswap/config.h @@ -1,4 +1,4 @@ -/* Copyright 2021 Harrison Chan (Xelus) +/* Copyright 2022 Harrison Chan (Xelus) * * 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 @@ -16,17 +16,6 @@ #pragma once -/* key matrix size */ -#define MATRIX_ROWS 5 -#define MATRIX_COLS 14 - -/* key matrix pins */ -#define MATRIX_ROW_PINS { B4, B3, A15, A14, A7 } -#define MATRIX_COL_PINS { B0, B1, A8, A9, B5, A6, C14, C15, A0, A5, A4, A3, A2, A1 } - -/* COL2ROW or ROW2COL */ -#define DIODE_DIRECTION COL2ROW - /* Set 0 if debouncing isn't needed */ #define DEBOUNCE 5 @@ -50,3 +39,13 @@ // More EEPROM for layers #define DYNAMIC_KEYMAP_EEPROM_MAX_ADDR 8191 + +// RGBLIGHT +#define RGB_DI_PIN A10 +#define RGBLED_NUM 8 // actually only has 1 +#define RGBLIGHT_LAYERS +#define WS2812_EXTERNAL_PULLUP +#define RGBLIGHT_LAYERS_OVERRIDE_RGB_OFF + +// Bitbang WS2812 +#define NOP_FUDGE 0.4 diff --git a/keyboards/xelus/xs60/halconf.h b/keyboards/xelus/xs60/hotswap/halconf.h index 73481c72a6..b494afca7f 100644 --- a/keyboards/xelus/xs60/halconf.h +++ b/keyboards/xelus/xs60/hotswap/halconf.h @@ -1,4 +1,4 @@ -/* Copyright 2021 Harrison Chan (Xelus) +/* Copyright 2022 Harrison Chan (Xelus) * * 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 diff --git a/keyboards/xelus/xs60/xs60.c b/keyboards/xelus/xs60/hotswap/hotswap.c index 95247c934a..cb84eeca18 100644 --- a/keyboards/xelus/xs60/xs60.c +++ b/keyboards/xelus/xs60/hotswap/hotswap.c @@ -1,4 +1,4 @@ -/* Copyright 2021 Harrison Chan (Xelus) +/* Copyright 2022 Harrison Chan (Xelus) * * 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 @@ -14,7 +14,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. */ -#include "xs60.h" +#include "hotswap.h" // tested and working void matrix_io_delay(void) { __asm__ volatile("nop\nnop\nnop\n"); } diff --git a/keyboards/xelus/xs60/hotswap/hotswap.h b/keyboards/xelus/xs60/hotswap/hotswap.h new file mode 100644 index 0000000000..b2d4431554 --- /dev/null +++ b/keyboards/xelus/xs60/hotswap/hotswap.h @@ -0,0 +1,34 @@ +/* Copyright 2022 Harrison Chan (Xelus) + * + * 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/>. + */ +#pragma once + +#include "quantum.h" + +#define XXX KC_NO + +#define LAYOUT_60_ansi_tsangan_split_rshift( \ + K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \ + K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \ + K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2D, \ + K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3C, K3D, \ + K40, K41, K42, K45, K4A, K4B, K4D \ +) { \ + { K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D }, \ + { K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D }, \ + { K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, XXX, K2D }, \ + { K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, XXX, K3C, K3D }, \ + { K40, K41, K42, XXX, XXX, K45, XXX, XXX, XXX, XXX, K4A, K4B, XXX, K4D } \ +} diff --git a/keyboards/xelus/xs60/hotswap/info.json b/keyboards/xelus/xs60/hotswap/info.json new file mode 100644 index 0000000000..e16b675902 --- /dev/null +++ b/keyboards/xelus/xs60/hotswap/info.json @@ -0,0 +1,83 @@ +{ + "keyboard_name": "XS60 Hotswap", + "manufacturer": "Xelus", + "url": "", + "maintainer": "Xelus22", + "usb": { + "vid": "0x5845", + "pid": "0x5861", + "device_version": "0.0.1" + }, + "diode_direction": "COL2ROW", + "matrix_pins": { + "cols": ["B0", "B1", "A8", "A9", "B5", "A6", "C14", "C15", "A0", "A5","A4","A3","A2","A1"], + "rows": ["B4", "B3", "A15", "A14", "A7"] + }, + "layouts": { + "LAYOUT_60_ansi_tsangan_split_rshift": { + "layout": [ + {"label":"Esc", "x":0, "y":0}, + {"label":"1", "x":1, "y":0}, + {"label":"2", "x":2, "y":0}, + {"label":"3", "x":3, "y":0}, + {"label":"4", "x":4, "y":0}, + {"label":"5", "x":5, "y":0}, + {"label":"6", "x":6, "y":0}, + {"label":"7", "x":7, "y":0}, + {"label":"8", "x":8, "y":0}, + {"label":"9", "x":9, "y":0}, + {"label":"0", "x":10, "y":0}, + {"label":"-", "x":11, "y":0}, + {"label":"=", "x":12, "y":0}, + {"label":"Backspace", "x":13, "y":0, "w":2}, + {"label":"Tab", "x":0, "y":1, "w":1.5}, + {"label":"Q", "x":1.5, "y":1}, + {"label":"W", "x":2.5, "y":1}, + {"label":"E", "x":3.5, "y":1}, + {"label":"R", "x":4.5, "y":1}, + {"label":"T", "x":5.5, "y":1}, + {"label":"Y", "x":6.5, "y":1}, + {"label":"U", "x":7.5, "y":1}, + {"label":"I", "x":8.5, "y":1}, + {"label":"O", "x":9.5, "y":1}, + {"label":"P", "x":10.5, "y":1}, + {"label":"[", "x":11.5, "y":1}, + {"label":"]", "x":12.5, "y":1}, + {"label":"Backspace", "x":13.5, "y":1, "w":1.5}, + {"label":"Caps Lock", "x":0, "y":2, "w":1.75}, + {"label":"A", "x":1.75, "y":2}, + {"label":"S", "x":2.75, "y":2}, + {"label":"D", "x":3.75, "y":2}, + {"label":"F", "x":4.75, "y":2}, + {"label":"G", "x":5.75, "y":2}, + {"label":"H", "x":6.75, "y":2}, + {"label":"J", "x":7.75, "y":2}, + {"label":"K", "x":8.75, "y":2}, + {"label":"L", "x":9.75, "y":2}, + {"label":";", "x":10.75, "y":2}, + {"label":"'", "x":11.75, "y":2}, + {"label":"Enter", "x":12.75, "y":2, "w":2.25}, + {"label":"Shift", "x":0, "y":3, "w":2.25}, + {"label":"Z", "x":2.25, "y":3}, + {"label":"X", "x":3.25, "y":3}, + {"label":"C", "x":4.25, "y":3}, + {"label":"V", "x":5.25, "y":3}, + {"label":"B", "x":6.25, "y":3}, + {"label":"N", "x":7.25, "y":3}, + {"label":"M", "x":8.25, "y":3}, + {"label":",", "x":9.25, "y":3}, + {"label":".", "x":10.25, "y":3}, + {"label":"/", "x":11.25, "y":3}, + {"label":"Shift", "x":12.25, "y":3, "w":1.75}, + {"label":"Fn", "x":14, "y":3}, + {"label":"Ctrl", "x":0, "y":4, "w":1.5}, + {"label":"GUI", "x":1.5, "y":4}, + {"label":"Alt", "x":2.5, "y":4, "w":1.5}, + {"label":"Space", "x":4, "y":4, "w":7}, + {"label":"Alt", "x":11, "y":4, "w":1.5}, + {"label":"GUI", "x":12.5, "y":4}, + {"label":"Ctrl", "x":13.5, "y":4, "w":1.5} + ] + } + } +} diff --git a/keyboards/xelus/xs60/hotswap/keymaps/default/keymap.c b/keyboards/xelus/xs60/hotswap/keymaps/default/keymap.c new file mode 100644 index 0000000000..87aa2adc03 --- /dev/null +++ b/keyboards/xelus/xs60/hotswap/keymaps/default/keymap.c @@ -0,0 +1,81 @@ +/* Copyright 2022 Harrison Chan (Xelus) + * + * 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/>. + */ + +// Default layout for XS60 +#include QMK_KEYBOARD_H + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { +// Default layer: Pressing caps-lock momentarily switches to Layer 1. +// This is the default layer. Pressing an empty keycode on another layer will take you here. + [0] = LAYOUT_60_ansi_tsangan_split_rshift( + KC_ESC, 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_BSLS, + KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSPC, + KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, + KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_UP, MO(1), + KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RGUI, KC_RCTL + ), + + [1] = LAYOUT_60_ansi_tsangan_split_rshift( + KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_PSCR, + KC_CAPS, KC_TRNS, KC_UP , KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE, + KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_RSFT, KC_PGUP, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PGDN, KC_END + ) +}; + +#ifdef RGBLIGHT_LAYERS +const rgblight_segment_t PROGMEM my_capslock_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_ORANGE} +); + +const rgblight_segment_t PROGMEM my_layer1_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_CYAN} +); + +const rgblight_segment_t PROGMEM my_layer2_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_PURPLE} +); + +const rgblight_segment_t PROGMEM my_layer3_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_GREEN} +); + +// Now define the array of layers. Later layers take precedence +const rgblight_segment_t* const PROGMEM my_rgb_layers[] = RGBLIGHT_LAYERS_LIST( + my_capslock_layer, + my_layer1_layer, // Overrides caps lock layer + my_layer2_layer, // Overrides other layers + my_layer3_layer // Overrides other layers +); + +void keyboard_post_init_user(void) { + // Enable the LED layers + rgblight_layers = my_rgb_layers; +} + +bool led_update_user(led_t led_state) { + rgblight_set_layer_state(0, led_state.caps_lock); + return true; +} + +layer_state_t layer_state_set_user(layer_state_t state) { + rgblight_set_layer_state(1, layer_state_cmp(state, 1)); + rgblight_set_layer_state(2, layer_state_cmp(state, 2)); + rgblight_set_layer_state(3, layer_state_cmp(state, 3)); + return state; +} +#endif diff --git a/keyboards/xelus/xs60/keymaps/via/config.h b/keyboards/xelus/xs60/hotswap/keymaps/via/config.h index 8c0ed0c6e3..965c516a63 100644 --- a/keyboards/xelus/xs60/keymaps/via/config.h +++ b/keyboards/xelus/xs60/hotswap/keymaps/via/config.h @@ -1,4 +1,4 @@ -/* Copyright 2021 Harrison Chan (Xelus) +/* Copyright 2022 Harrison Chan (Xelus) * * 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 diff --git a/keyboards/xelus/xs60/hotswap/keymaps/via/keymap.c b/keyboards/xelus/xs60/hotswap/keymaps/via/keymap.c new file mode 100644 index 0000000000..b749a01580 --- /dev/null +++ b/keyboards/xelus/xs60/hotswap/keymaps/via/keymap.c @@ -0,0 +1,128 @@ +/* Copyright 2022 Harrison Chan (Xelus) + * + * 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/>. + */ + +#include QMK_KEYBOARD_H + +const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { +// Default layer: Pressing caps-lock momentarily switches to Layer 1. +// This is the default layer. Pressing an empty keycode on another layer will take you here. + [0] = LAYOUT_60_ansi_tsangan_split_rshift( + KC_ESC, 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_BSLS, + KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSPC, + KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, + KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, MO(1), + KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RGUI, KC_RCTL + ), + + [1] = LAYOUT_60_ansi_tsangan_split_rshift( + KC_ESC, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_PSCR, + KC_CAPS, KC_TRNS, KC_UP , KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_VOLD, KC_VOLU, KC_MUTE, + KC_TRNS, KC_LEFT, KC_DOWN, KC_RGHT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_RSFT, KC_PGUP, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PGDN, KC_END + ), + + [2] = LAYOUT_60_ansi_tsangan_split_rshift( + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS + ), + + [3] = LAYOUT_60_ansi_tsangan_split_rshift( + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS + ), + + [4] = LAYOUT_60_ansi_tsangan_split_rshift( + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS + ), + + [5] = LAYOUT_60_ansi_tsangan_split_rshift( + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS + ), + + [6] = LAYOUT_60_ansi_tsangan_split_rshift( + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS + ), + + [7] = LAYOUT_60_ansi_tsangan_split_rshift( + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, + KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS + ) +}; + +#ifdef RGBLIGHT_LAYERS +const rgblight_segment_t PROGMEM my_capslock_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_ORANGE} +); + +const rgblight_segment_t PROGMEM my_layer1_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_CYAN} +); + +const rgblight_segment_t PROGMEM my_layer2_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_PURPLE} +); + +const rgblight_segment_t PROGMEM my_layer3_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_GREEN} +); + +// Now define the array of layers. Later layers take precedence +const rgblight_segment_t* const PROGMEM my_rgb_layers[] = RGBLIGHT_LAYERS_LIST( + my_capslock_layer, + my_layer1_layer, // Overrides caps lock layer + my_layer2_layer, // Overrides other layers + my_layer3_layer // Overrides other layers +); + +void keyboard_post_init_user(void) { + // Enable the LED layers + rgblight_layers = my_rgb_layers; +} + +bool led_update_user(led_t led_state) { + rgblight_set_layer_state(0, led_state.caps_lock); + return true; +} + +layer_state_t layer_state_set_user(layer_state_t state) { + rgblight_set_layer_state(1, layer_state_cmp(state, 1)); + rgblight_set_layer_state(2, layer_state_cmp(state, 2)); + rgblight_set_layer_state(3, layer_state_cmp(state, 3)); + return state; +} +#endif diff --git a/keyboards/xelus/xs60/hotswap/keymaps/via/rules.mk b/keyboards/xelus/xs60/hotswap/keymaps/via/rules.mk new file mode 100644 index 0000000000..1e5b99807c --- /dev/null +++ b/keyboards/xelus/xs60/hotswap/keymaps/via/rules.mk @@ -0,0 +1 @@ +VIA_ENABLE = yes diff --git a/keyboards/xelus/xs60/mcuconf.h b/keyboards/xelus/xs60/hotswap/mcuconf.h index a1d2f9480e..95f3845f57 100644 --- a/keyboards/xelus/xs60/mcuconf.h +++ b/keyboards/xelus/xs60/hotswap/mcuconf.h @@ -1,4 +1,4 @@ -/* Copyright 2021 Harrison Chan (Xelus) +/* Copyright 2022 Harrison Chan (Xelus) * * 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 diff --git a/keyboards/xelus/xs60/hotswap/readme.md b/keyboards/xelus/xs60/hotswap/readme.md new file mode 100644 index 0000000000..a8c7801c84 --- /dev/null +++ b/keyboards/xelus/xs60/hotswap/readme.md @@ -0,0 +1,16 @@ +# XS60HS + +XS60HS - ANSI, tsangan bottom row. + +* Keyboard Maintainer: [Xelus22](https://github.com/Xelus22) +* Hardware Supported: Group buys + +Make example for this keyboard (after setting up your build environment): + + make xelus/xs60/hotswap:default + +Reset your keyboard in 3 ways: +* Bootmagic reset: hold down the top left key (usually ESC) and plugin the keyboard +* Physical reset button: on the back of the PCB, there should be a small golden button you can press + +See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs). diff --git a/keyboards/kprepublic/bm16a/rules.mk b/keyboards/xelus/xs60/hotswap/rules.mk index 325564a154..a013327f56 100644 --- a/keyboards/kprepublic/bm16a/rules.mk +++ b/keyboards/xelus/xs60/hotswap/rules.mk @@ -1,8 +1,8 @@ # MCU name -MCU = atmega32u4 +MCU = STM32L422 # Bootloader selection -BOOTLOADER = atmel-dfu +BOOTLOADER = stm32-dfu # Build Options # change yes to no to disable @@ -10,11 +10,18 @@ BOOTLOADER = atmel-dfu BOOTMAGIC_ENABLE = yes # Enable Bootmagic Lite MOUSEKEY_ENABLE = yes # Mouse keys EXTRAKEY_ENABLE = yes # Audio control and System control -CONSOLE_ENABLE = no # Console for debug +CONSOLE_ENABLE = yes # Console for debug COMMAND_ENABLE = no # Commands for debug and configuration NKRO_ENABLE = yes # Enable N-Key Rollover -BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality -RGBLIGHT_ENABLE = yes # Enable keyboard RGB underglow +BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality AUDIO_ENABLE = no # Audio output -LAYOUTS = ortho_4x4 +EEPROM_DRIVER = i2c + +RGBLIGHT_ENABLE = yes +WS2812_DRIVER = bitbang + +LTO_ENABLE = yes +OPT = 2 + +# LAYOUTS = LAYOUT_60_ansi_tsangan_split_rshift diff --git a/keyboards/xelus/xs60/soldered/config.h b/keyboards/xelus/xs60/soldered/config.h new file mode 100644 index 0000000000..bb97900a03 --- /dev/null +++ b/keyboards/xelus/xs60/soldered/config.h @@ -0,0 +1,50 @@ +/* Copyright 2022 Harrison Chan (Xelus) + * + * 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/>. + */ + +#pragma once + +/* Set 0 if debouncing isn't needed */ +#define DEBOUNCE 5 + +/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ +#define LOCKING_SUPPORT_ENABLE + +/* Locking resynchronize hack */ +#define LOCKING_RESYNC_ENABLE + +// I2C setup +#define I2C1_SCL_PAL_MODE 4 +#define I2C1_SDA_PAL_MODE 4 +#define I2C1_TIMINGR_PRESC 0U +#define I2C1_TIMINGR_SCLDEL 7U +#define I2C1_TIMINGR_SDADEL 0U +#define I2C1_TIMINGR_SCLH 45U +#define I2C1_TIMINGR_SCLL 149U + +// I2C EEPROM +#define EEPROM_I2C_24LC64 + +// More EEPROM for layers + +// RGBLIGHT +#define RGB_DI_PIN A10 +#define RGBLED_NUM 8 // actually only has 1 +#define RGBLIGHT_LAYERS +#define WS2812_EXTERNAL_PULLUP +#define RGBLIGHT_LAYERS_OVERRIDE_RGB_OFF + +// Bitbang WS2812 +#define NOP_FUDGE 0.4 diff --git a/keyboards/xelus/xs60/soldered/halconf.h b/keyboards/xelus/xs60/soldered/halconf.h new file mode 100644 index 0000000000..b494afca7f --- /dev/null +++ b/keyboards/xelus/xs60/soldered/halconf.h @@ -0,0 +1,22 @@ +/* Copyright 2022 Harrison Chan (Xelus) + * + * 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/>. + */ + +#pragma once + +#define HAL_USE_I2C TRUE + +#include_next <halconf.h> + diff --git a/keyboards/xelus/xs60/info.json b/keyboards/xelus/xs60/soldered/info.json index 089d728b01..c44aaca642 100644 --- a/keyboards/xelus/xs60/info.json +++ b/keyboards/xelus/xs60/soldered/info.json @@ -1,5 +1,5 @@ { - "keyboard_name": "XS60", + "keyboard_name": "XS60 Soldered", "manufacturer": "Xelus", "url": "", "maintainer": "Xelus22", @@ -8,6 +8,11 @@ "pid": "0x5860", "device_version": "0.0.1" }, + "diode_direction": "COL2ROW", + "matrix_pins": { + "cols": ["B0", "B1", "A8", "A9", "B5", "A6", "C14", "C15", "A0", "A5", "A4", "A3", "A2", "A1"], + "rows": ["B4", "B3", "A15", "A14", "A7"] + }, "layouts": { "LAYOUT_60_ansi_split_bs_rshift": { "layout": [ diff --git a/keyboards/xelus/xs60/keymaps/default/keymap.c b/keyboards/xelus/xs60/soldered/keymaps/default/keymap.c index 6970b02543..63d910eff4 100644 --- a/keyboards/xelus/xs60/keymaps/default/keymap.c +++ b/keyboards/xelus/xs60/soldered/keymaps/default/keymap.c @@ -1,4 +1,4 @@ -/* Copyright 2021 Harrison Chan (Xelus) +/* Copyright 2022 Harrison Chan (Xelus) * * 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 @@ -36,3 +36,47 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_HOME, KC_PGDN, KC_END ) }; + + +#ifdef RGBLIGHT_LAYERS +const rgblight_segment_t PROGMEM my_capslock_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_ORANGE} +); + +const rgblight_segment_t PROGMEM my_layer1_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_CYAN} +); + +const rgblight_segment_t PROGMEM my_layer2_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_PURPLE} +); + +const rgblight_segment_t PROGMEM my_layer3_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_GREEN} +); + +// Now define the array of layers. Later layers take precedence +const rgblight_segment_t* const PROGMEM my_rgb_layers[] = RGBLIGHT_LAYERS_LIST( + my_capslock_layer, + my_layer1_layer, // Overrides caps lock layer + my_layer2_layer, // Overrides other layers + my_layer3_layer // Overrides other layers +); + +void keyboard_post_init_user(void) { + // Enable the LED layers + rgblight_layers = my_rgb_layers; +} + +bool led_update_user(led_t led_state) { + rgblight_set_layer_state(0, led_state.caps_lock); + return true; +} + +layer_state_t layer_state_set_user(layer_state_t state) { + rgblight_set_layer_state(1, layer_state_cmp(state, 1)); + rgblight_set_layer_state(2, layer_state_cmp(state, 2)); + rgblight_set_layer_state(3, layer_state_cmp(state, 3)); + return state; +} +#endif diff --git a/keyboards/xelus/xs60/soldered/keymaps/via/config.h b/keyboards/xelus/xs60/soldered/keymaps/via/config.h new file mode 100644 index 0000000000..965c516a63 --- /dev/null +++ b/keyboards/xelus/xs60/soldered/keymaps/via/config.h @@ -0,0 +1,19 @@ +/* Copyright 2022 Harrison Chan (Xelus) + * + * 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/>. + */ +#pragma once + +// More layers +#define DYNAMIC_KEYMAP_LAYER_COUNT 8 diff --git a/keyboards/xelus/xs60/keymaps/via/keymap.c b/keyboards/xelus/xs60/soldered/keymaps/via/keymap.c index 76901c41c7..a6ae08741a 100644 --- a/keyboards/xelus/xs60/keymaps/via/keymap.c +++ b/keyboards/xelus/xs60/soldered/keymaps/via/keymap.c @@ -1,4 +1,4 @@ -/* Copyright 2021 Harrison Chan (Xelus) +/* Copyright 2022 Harrison Chan (Xelus) * * 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 @@ -83,3 +83,47 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS ) }; + + +#ifdef RGBLIGHT_LAYERS +const rgblight_segment_t PROGMEM my_capslock_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_ORANGE} +); + +const rgblight_segment_t PROGMEM my_layer1_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_CYAN} +); + +const rgblight_segment_t PROGMEM my_layer2_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_PURPLE} +); + +const rgblight_segment_t PROGMEM my_layer3_layer[] = RGBLIGHT_LAYER_SEGMENTS( + {0, 1, HSV_GREEN} +); + +// Now define the array of layers. Later layers take precedence +const rgblight_segment_t* const PROGMEM my_rgb_layers[] = RGBLIGHT_LAYERS_LIST( + my_capslock_layer, + my_layer1_layer, // Overrides caps lock layer + my_layer2_layer, // Overrides other layers + my_layer3_layer // Overrides other layers +); + +void keyboard_post_init_user(void) { + // Enable the LED layers + rgblight_layers = my_rgb_layers; +} + +bool led_update_user(led_t led_state) { + rgblight_set_layer_state(0, led_state.caps_lock); + return true; +} + +layer_state_t layer_state_set_user(layer_state_t state) { + rgblight_set_layer_state(1, layer_state_cmp(state, 1)); + rgblight_set_layer_state(2, layer_state_cmp(state, 2)); + rgblight_set_layer_state(3, layer_state_cmp(state, 3)); + return state; +} +#endif diff --git a/keyboards/xelus/xs60/soldered/keymaps/via/rules.mk b/keyboards/xelus/xs60/soldered/keymaps/via/rules.mk new file mode 100644 index 0000000000..1e5b99807c --- /dev/null +++ b/keyboards/xelus/xs60/soldered/keymaps/via/rules.mk @@ -0,0 +1 @@ +VIA_ENABLE = yes diff --git a/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/config.h b/keyboards/xelus/xs60/soldered/mcuconf.h index a6abd50bbe..95f3845f57 100644 --- a/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/config.h +++ b/keyboards/xelus/xs60/soldered/mcuconf.h @@ -1,4 +1,4 @@ -/* Copyright 2021 Stefan Kerkmann +/* Copyright 2022 Harrison Chan (Xelus) * * 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 @@ -16,7 +16,8 @@ #pragma once -#include "test_common.h" +#include_next <mcuconf.h> + +#undef STM32_I2C_USE_I2C1 +#define STM32_I2C_USE_I2C1 TRUE -#define IGNORE_MOD_TAP_INTERRUPT -#define PERMISSIVE_HOLD
\ No newline at end of file diff --git a/keyboards/xelus/xs60/readme.md b/keyboards/xelus/xs60/soldered/readme.md index f169f7f169..24a0b96280 100644 --- a/keyboards/xelus/xs60/readme.md +++ b/keyboards/xelus/xs60/soldered/readme.md @@ -1,4 +1,4 @@ -# XS60 +# XS60 Soldered XS60 ANSI, normal + tsangan bottom row. @@ -7,10 +7,9 @@ XS60 ANSI, normal + tsangan bottom row. Make example for this keyboard (after setting up your build environment): - make xelus/xs60:default + make xelus/xs60/soldered:default Reset your keyboard in 3 ways: -* Software reset on Fn + Backspace * Bootmagic reset: hold down the top left key (usually ESC) and plugin the keyboard * Physical reset button: on the back of the PCB, there should be a small golden button you can press diff --git a/keyboards/xelus/xs60/rules.mk b/keyboards/xelus/xs60/soldered/rules.mk index 65c7d981ef..17919eff22 100644 --- a/keyboards/xelus/xs60/rules.mk +++ b/keyboards/xelus/xs60/soldered/rules.mk @@ -18,6 +18,9 @@ AUDIO_ENABLE = no # Audio output EEPROM_DRIVER = i2c +RGBLIGHT_ENABLE = yes +WS2812_DRIVER = bitbang + LTO_ENABLE = yes OPT = 2 diff --git a/keyboards/xelus/xs60/soldered/soldered.c b/keyboards/xelus/xs60/soldered/soldered.c new file mode 100644 index 0000000000..bedf318221 --- /dev/null +++ b/keyboards/xelus/xs60/soldered/soldered.c @@ -0,0 +1,20 @@ +/* Copyright 2022 Harrison Chan (Xelus) + * + * 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/>. + */ + +#include "soldered.h" + +// tested and working +void matrix_io_delay(void) { __asm__ volatile("nop\nnop\nnop\n"); } diff --git a/keyboards/xelus/xs60/xs60.h b/keyboards/xelus/xs60/soldered/soldered.h index 41ecb4efaf..bcfd1437de 100644 --- a/keyboards/xelus/xs60/xs60.h +++ b/keyboards/xelus/xs60/soldered/soldered.h @@ -1,4 +1,4 @@ -/* Copyright 2021 Harrison Chan (Xelus) +/* Copyright 2022 Harrison Chan (Xelus) * * 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 diff --git a/keyboards/xiudi/xd002/keymaps/tap_dance/keymap.c b/keyboards/xiudi/xd002/keymaps/tap_dance/keymap.c index 0f384ce99f..9d337bc8d9 100644 --- a/keyboards/xiudi/xd002/keymaps/tap_dance/keymap.c +++ b/keyboards/xiudi/xd002/keymaps/tap_dance/keymap.c @@ -8,7 +8,7 @@ enum { TD_BC = 0 }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_BC] = ACTION_TAP_DANCE_DOUBLE(KC_B, KC_C) }; diff --git a/keyboards/xiudi/xd60/keymaps/Jos/keymap.c b/keyboards/xiudi/xd60/keymaps/Jos/keymap.c index b41b77edd7..9b4b2d9c37 100644 --- a/keyboards/xiudi/xd60/keymaps/Jos/keymap.c +++ b/keyboards/xiudi/xd60/keymaps/Jos/keymap.c @@ -83,7 +83,7 @@ typedef struct { bool sticky; } td_ta_state_t; -static void ang_tap_dance_ta_finished (qk_tap_dance_state_t *state, void *user_data) { +static void ang_tap_dance_ta_finished (tap_dance_state_t *state, void *user_data) { td_ta_state_t *td_ta = (td_ta_state_t *) user_data; // if (td_ta->sticky) { @@ -105,7 +105,7 @@ static void ang_tap_dance_ta_finished (qk_tap_dance_state_t *state, void *user_d } // Added this one to make it more reactive on keyup -static void ang_tap_dance_ta_each (qk_tap_dance_state_t *state, void *user_data) { +static void ang_tap_dance_ta_each (tap_dance_state_t *state, void *user_data) { td_ta_state_t *td_ta = (td_ta_state_t *) user_data; if (!td_ta->layer_toggle) { // Braces added for clarity @@ -114,7 +114,7 @@ static void ang_tap_dance_ta_each (qk_tap_dance_state_t *state, void *user_data) } -static void ang_tap_dance_ta_reset (qk_tap_dance_state_t *state, void *user_data) { +static void ang_tap_dance_ta_reset (tap_dance_state_t *state, void *user_data) { td_ta_state_t *td_ta = (td_ta_state_t *) user_data; if (!td_ta->layer_toggle) { // Braces added for clarity @@ -125,7 +125,7 @@ static void ang_tap_dance_ta_reset (qk_tap_dance_state_t *state, void *user_data } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [0] = { .fn = { ang_tap_dance_ta_each, ang_tap_dance_ta_finished, ang_tap_dance_ta_reset }, .user_data = (void *)&((td_ta_state_t) { false, false }) diff --git a/keyboards/xiudi/xd75/keymaps/davidrambo/keymap.c b/keyboards/xiudi/xd75/keymaps/davidrambo/keymap.c index 3b40c12567..7787a59ff8 100644 --- a/keyboards/xiudi/xd75/keymaps/davidrambo/keymap.c +++ b/keyboards/xiudi/xd75/keymaps/davidrambo/keymap.c @@ -160,7 +160,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { }; // Shift vs capslock function. From bbaserdem's Planck keymap. -void caps_tap (qk_tap_dance_state_t *state, void *user_data) { +void caps_tap (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code (KC_LSFT); } else if (state->count == 2) { @@ -168,7 +168,7 @@ void caps_tap (qk_tap_dance_state_t *state, void *user_data) { register_code (KC_CAPS); } } -void caps_tap_end (qk_tap_dance_state_t *state, void *user_data) { +void caps_tap_end (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code (KC_LSFT); } else { @@ -177,7 +177,7 @@ void caps_tap_end (qk_tap_dance_state_t *state, void *user_data) { } //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Shift, twice for Caps Lock [SFT_LCK] = ACTION_TAP_DANCE_FN_ADVANCED( caps_tap, NULL, caps_tap_end ) }; diff --git a/keyboards/xiudi/xd75/keymaps/dyn_macro_tap_dance/keymap.c b/keyboards/xiudi/xd75/keymaps/dyn_macro_tap_dance/keymap.c index 353494f914..1cabfd8ef8 100644 --- a/keyboards/xiudi/xd75/keymaps/dyn_macro_tap_dance/keymap.c +++ b/keyboards/xiudi/xd75/keymaps/dyn_macro_tap_dance/keymap.c @@ -34,7 +34,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; }; -void macro_tog_key( qk_tap_dance_state_t *state, void *user_data ) { +void macro_tog_key( tap_dance_state_t *state, void *user_data ) { if ( state->count > 3 ) return; @@ -60,7 +60,7 @@ enum { MCROTOG_ = 0 }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [MCROTOG_] = ACTION_TAP_DANCE_FN( macro_tog_key ) }; diff --git a/keyboards/xiudi/xd75/keymaps/germanized/keymap.c b/keyboards/xiudi/xd75/keymaps/germanized/keymap.c index a525c5a585..cbb8da838e 100644 --- a/keyboards/xiudi/xd75/keymaps/germanized/keymap.c +++ b/keyboards/xiudi/xd75/keymaps/germanized/keymap.c @@ -19,7 +19,7 @@ enum { }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Esc, twice Ctrl+Alt+Del [TD_ESC_RUPT] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, LALT(LCTL(KC_DEL))), [TD_TAB] = ACTION_TAP_DANCE_DOUBLE(KC_LCTL, LGUI(KC_TAB)) diff --git a/keyboards/xiudi/xd75/keymaps/hybrid/keymap.c b/keyboards/xiudi/xd75/keymaps/hybrid/keymap.c index fbb0ecdc8a..60fa737dc8 100644 --- a/keyboards/xiudi/xd75/keymaps/hybrid/keymap.c +++ b/keyboards/xiudi/xd75/keymaps/hybrid/keymap.c @@ -39,7 +39,7 @@ enum { -void dance_a_accent (qk_tap_dance_state_t *state, void *user_data) { +void dance_a_accent (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_0); } @@ -47,7 +47,7 @@ void dance_a_accent (qk_tap_dance_state_t *state, void *user_data) { tap_code (KC_Q); } } -void dance_e_accent (qk_tap_dance_state_t *state, void *user_data) { +void dance_e_accent (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_2); } @@ -58,7 +58,7 @@ void dance_e_accent (qk_tap_dance_state_t *state, void *user_data) { tap_code (KC_E); } } -void dance_i_accent (qk_tap_dance_state_t *state, void *user_data) { +void dance_i_accent (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_NUM_LOCK); register_code (KC_LALT); @@ -74,7 +74,7 @@ void dance_i_accent (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_o_accent (qk_tap_dance_state_t *state, void *user_data) { +void dance_o_accent (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_NUM_LOCK); register_code (KC_LALT); @@ -89,7 +89,7 @@ void dance_o_accent (qk_tap_dance_state_t *state, void *user_data) { tap_code (KC_O); } } -void dance_u_accent (qk_tap_dance_state_t *state, void *user_data) { +void dance_u_accent (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_NUM_LOCK); register_code (KC_LALT); @@ -105,7 +105,7 @@ void dance_u_accent (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_slash (qk_tap_dance_state_t *state, void *user_data) { +void dance_slash (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_NUM_LOCK); register_code (KC_LALT); @@ -119,7 +119,7 @@ void dance_slash (qk_tap_dance_state_t *state, void *user_data) { tap_code (KC_PSLS); } } -void dance_under (qk_tap_dance_state_t *state, void *user_data) { +void dance_under (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_NUM_LOCK); register_code (KC_LALT); @@ -133,7 +133,7 @@ void dance_under (qk_tap_dance_state_t *state, void *user_data) { tap_code (KC_6); } } -void dance_open_accol (qk_tap_dance_state_t *state, void *user_data) { +void dance_open_accol (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_NUM_LOCK); register_code (KC_LALT); @@ -157,7 +157,7 @@ void dance_open_accol (qk_tap_dance_state_t *state, void *user_data) { tap_code (KC_5); } } -void dance_close_accol (qk_tap_dance_state_t *state, void *user_data) { +void dance_close_accol (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_NUM_LOCK); register_code (KC_LALT); @@ -182,7 +182,7 @@ void dance_close_accol (qk_tap_dance_state_t *state, void *user_data) { tap_code (KC_MINS); } } -void dance_question (qk_tap_dance_state_t *state, void *user_data) { +void dance_question (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_NUM_LOCK); register_code (KC_LALT); @@ -206,7 +206,7 @@ void dance_question (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_cedille (qk_tap_dance_state_t *state, void *user_data) { +void dance_cedille (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_9); } @@ -214,7 +214,7 @@ void dance_cedille (qk_tap_dance_state_t *state, void *user_data) { tap_code (KC_C); } } -void dance_dot (qk_tap_dance_state_t *state, void *user_data) { +void dance_dot (tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code (KC_NUM_LOCK); register_code (KC_LALT); @@ -234,7 +234,7 @@ void dance_dot (qk_tap_dance_state_t *state, void *user_data) { tap_code (KC_NUM_LOCK); } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_A] = ACTION_TAP_DANCE_FN(dance_a_accent), [TD_E] = ACTION_TAP_DANCE_FN(dance_e_accent), [TD_I] = ACTION_TAP_DANCE_FN(dance_i_accent), diff --git a/keyboards/xiudi/xd75/keymaps/odyssey/keymap.c b/keyboards/xiudi/xd75/keymaps/odyssey/keymap.c index e1cda81cd5..ae27ba0292 100644 --- a/keyboards/xiudi/xd75/keymaps/odyssey/keymap.c +++ b/keyboards/xiudi/xd75/keymaps/odyssey/keymap.c @@ -13,9 +13,9 @@ typedef enum { } td_state_t; static td_state_t td_state = NONE_NONE; -int cur_dance (qk_tap_dance_state_t *state); -void altlp_finished (qk_tap_dance_state_t *state, void *user_data); -void altlp_reset (qk_tap_dance_state_t *state, void *user_data); +int cur_dance (tap_dance_state_t *state); +void altlp_finished (tap_dance_state_t *state, void *user_data); +void altlp_reset (tap_dance_state_t *state, void *user_data); // Four differend underglow states for 2 language layouts x 2 states of colemak layer enum layer_states { @@ -65,7 +65,7 @@ void update_led_state_c(void) { } } -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted && state->pressed) { return SINGLE_HOLD; } else if (!state->pressed) { return SINGLE_TAP; } @@ -76,7 +76,7 @@ int cur_dance (qk_tap_dance_state_t *state) { } // Tapdance code stolen long time ago from one of the forum answers i found related to my problem, sadly can't provide link for the credits -void lesc_finished (qk_tap_dance_state_t *state, void *user_data) { +void lesc_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -94,7 +94,7 @@ void lesc_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void lesc_reset (qk_tap_dance_state_t *state, void *user_data) { +void lesc_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: unregister_code16(KC_ESC); @@ -115,7 +115,7 @@ void lesc_reset (qk_tap_dance_state_t *state, void *user_data) { update_led_state_c(); } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [LESC] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, lesc_finished, lesc_reset) }; diff --git a/keyboards/xiudi/xd75/keymaps/replicajunction/config.h b/keyboards/xiudi/xd75/keymaps/replicajunction/config.h deleted file mode 100644 index a02f9a95db..0000000000 --- a/keyboards/xiudi/xd75/keymaps/replicajunction/config.h +++ /dev/null @@ -1,51 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once - -// Do not allow one macro to contain the other macro -#define DYNAMIC_MACRO_NO_NESTING - -// "THE most important tap hold configuration setting" -// https://precondition.github.io/home-row-mods#ignore-mod-tap-interrupt -// https://docs.qmk.fm/#/tap_hold?id=ignore-mod-tap-interrupt -#define IGNORE_MOD_TAP_INTERRUPT - -// This one is a style choice. Play with it both on and off to see which -// one suits you better. -// https://precondition.github.io/home-row-mods#permissive-hold -// https://docs.qmk.fm/#/tap_hold?id=permissive-hold -#define PERMISSIVE_HOLD - -// If you press a dual-role key for longer than TAPPING_TERM, then -// release it without pressing another key, without this setting nothing -// would happen. With this setting, it sends the key's tap function. -// https://precondition.github.io/home-row-mods#retro-tapping -#define RETRO_TAPPING - -// Disable some unused features to save space -#undef LOCKING_SUPPORT_ENABLE -#undef LOCKING_RESYNC_ENABLE - -///// -// Flags for stuff in my userspace - -#define USER_INCLUDE_GAMING_LAYER -#define USER_INCLUDE_MACRO_LAYER - -// "Super Alt-Tab" -// https://docs.qmk.fm/#/feature_macros?id=super-alt%E2%86%AFtab -#define USER_SUPER_ALT_TAB_TIMEOUT 500 diff --git a/keyboards/xiudi/xd75/keymaps/replicajunction/keymap.c b/keyboards/xiudi/xd75/keymaps/replicajunction/keymap.c deleted file mode 100644 index 06e048e9f9..0000000000 --- a/keyboards/xiudi/xd75/keymaps/replicajunction/keymap.c +++ /dev/null @@ -1,138 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include QMK_KEYBOARD_H -#include "replicaJunction.h" - -// enum additional_keyboard_layers { -// L_RGB = _LAYER_SAFE_RANGE -// }; - -#define BSP_SYM LT(L_SYMBOLS, KC_BSPC) -#define SPC_NAV LT(L_NAVIGATION, KC_SPC) -#define ESC_NUM LT(L_NUMBERS, KC_ESC) -#define MO_FN MO(L_FN) -#define MO_MAC MO(L_MACROS) - -#define DF_TYPE DF(L_BASE) -#define DF_GAME DF(L_GAMING) - -#define ESC_SFT LSFT_T(KC_ESC) -#define TAB_SFT RSFT_T(KC_TAB) - - -const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - [L_BASE] = LAYOUT_ortho_5x15( - KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_MINS, KC_GRV, KC_EQL, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, - KC_EQL, KC_Q, KC_W, KC_F, KC_P, KC_B, KC_LBRC, KC_BSLS, KC_RBRC, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSLS, - KC_MINS, KC_A, KC_R, KC_S, KC_T, KC_G, SALTTAB, KC_UP, KC_END, KC_M, KC_N, KC_E, KC_I, KC_O, KC_QUOT, - NUMWORD, KC_Z, KC_X, KC_C, KC_D, KC_V, KC_LEFT, KC_DOWN, KC_RGHT, KC_K, KC_H, KC_COMM, KC_DOT, KC_SLSH, CAPWORD, - KC_LCTL, KC_LGUI, KC_LALT, MO_FN, ESC_SFT, BSP_SYM, CTL_DEL, KC_ENT, ALT_ENT, SPC_NAV, TAB_SFT, MO_FN, KC_RALT, KC_RGUI, KC_RCTL - ), - - - [L_GAMING] = LAYOUT_ortho_5x15( - KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_MINS, KC_GRV, KC_EQL, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, - KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_LBRC, KC_BSLS, KC_RBRC, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_QUOT, - KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_HOME, KC_DEL, KC_PGUP, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_ENT, - KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_END, KC_UP, KC_PGDN, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, - KC_LCTL, KC_LCTL, KC_LALT, KC_LSFT, KC_SPC, KC_LALT, KC_LEFT, KC_DOWN, KC_RGHT, KC_BSPC, KC_SPC, MO_FN, KC_RALT, KC_RGUI, KC_RCTL - ), - - - // [L_QWERTY] = LAYOUT_ortho_5x15( - // KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_MINS, KC_GRV, KC_EQL, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, - // KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_LBRC, KC_BSLS, KC_RBRC, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_QUOT, - // KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_HOME, KC_DEL, KC_PGUP, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_ENT, - // KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_END, KC_UP, KC_PGDN, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, - // KC_LCTL, KC_LGUI, KC_LALT, MO(_FN), KC_SPC, KC_SPC, KC_LEFT, KC_DOWN, KC_RGHT, KC_SPC, KC_SPC, MO(_FN), KC_RALT, KC_RGUI, KC_RCTL - // ), - - - // [L_CURSOR] = LAYOUT_ortho_5x15( - // _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, - // _______, _______, _______, _______, _______, _______, _______, _______, _______, OS_SALL, OS_COPY, OS_PAST, OS_CUT, OS_UNDO, _______, - // _______, KC_LGUI, KC_LALT, KC_LSFT, KC_LCTL, _______, _______, _______, SEARCH, SALTTAB, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT, _______, - // _______, KC_RGUI, KC_RALT, KC_RSFT, KC_RCTL, _______, _______, _______, _______, OS_FIND, KC_HOME, KC_PGDN, KC_PGUP, KC_END, _______, - // _______, _______, _______, _______, _______, ooooooo, _______, _______, _______, SPC_NAV, _______, _______, _______, _______, _______ - // ), - - - [L_NUMBERS] = LAYOUT_ortho_5x15( - _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_NUM, _______, _______, _______, _______, _______, - _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_HASH, KC_P7, KC_P8, KC_P9, KC_PSLS, SFT_TAB, - _______, KC_LGUI, KC_LALT, KC_LSFT, KC_LCTL, _______, _______, _______, _______, KC_PPLS, KC_P4, KC_P5, KC_P6, KC_PAST, KC_TAB, - _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_PMNS, KC_P1, KC_P2, KC_P3, KC_BSLS, KC_EQL, - _______, _______, _______, _______, ooooooo, _______, _______, _______, _______, _______, KC_P0, KC_P0, KC_PDOT, KC_PENT, _______ - ), - - - [L_SYMBOLS] = LAYOUT_ortho_5x15( - _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, - _______, KC_AT, KC_LT, KC_DLR, KC_GT, XXXXXXX, _______, _______, _______, XXXXXXX, KC_LBRC, KC_UNDS, KC_RBRC, XXXXXXX, _______, - _______, KC_BSLS, KC_LPRN, KC_DQUO, KC_RPRN, KC_HASH, _______, _______, _______, KC_PERC, KC_LCBR, KC_EQL, KC_RCBR, KC_PIPE, _______, - _______, KC_EXLM, KC_COLN, KC_ASTR, KC_PLUS, XXXXXXX, _______, _______, _______, XXXXXXX, KC_AMPR, KC_CIRC, KC_TILD, KC_GRV, _______, - _______, _______, _______, _______, _______, ooooooo, _______, _______, _______, ooooooo, _______, _______, _______, _______, _______ - ), - - - [L_NAVIGATION] = LAYOUT_ortho_5x15( - _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, - _______, OS_UNDO, OS_CUT, OS_PAST, OS_COPY, OS_SALL, _______, _______, _______, KC_PGUP, KC_HOME, KC_UP, KC_END, KC_DEL, _______, - _______, KC_LGUI, KC_LALT, KC_LSFT, KC_LCTL, _______, _______, _______, _______, KC_PGDN, KC_LEFT, KC_DOWN, KC_RGHT, KC_BSPC, _______, - _______, WIN_V, _______, _______, OS_FIND, SEARCH, _______, _______, _______, _______, SFT_TAB, KC_TAB, KC_APP, KC_PSCR, _______, - _______, _______, _______, _______, _______, ooooooo, _______, _______, _______, ooooooo, _______, _______, _______, _______, _______ - ), - - - [L_FN] = LAYOUT_ortho_5x15( - DF_TYPE, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, _______, MS_JIGL, _______, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, - DF_GAME, RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, _______, _______, _______, _______, KC_VOLU, _______, _______, _______, _______, KC_F12, - _______, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, _______, KC_CAPS, QK_BOOT, _______, KC_MUTE, _______, _______, _______, _______, _______, - _______, RGB_M_P, RGB_M_B, _______, _______, _______, _______, _______, _______, KC_VOLD, K_SECR1, K_SECR2, K_SECR3, K_SECR4, _______, - _______, _______, _______, ooooooo, _______, _______, _______, _______, _______, _______, _______, ooooooo, _______, _______, _______ - ), - - - [L_MACROS] = LAYOUT_ortho_5x15( - _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, - _______, QK_MAKE, _______, DM_REC2, DM_REC1, _______, _______, _______, _______, _______, SHEBANG, _______, _______, _______, _______, - _______, QK_FLSH, _______, DM_PLY2, DM_PLY1, DM_RSTP, _______, _______, _______, PRG_NE, PRG_EQ, PRG_GEQ, PRG_LEQ, PRG_ARR, _______, - _______, QK_VERS, _______, _______, _______, _______, _______, _______, _______, _______, PS_ITEM, FS_PIPE, _______, FS_ARR, _______, - _______, _______, _______, _______, ooooooo, _______, _______, _______, _______, ooooooo, _______, _______, _______, _______, _______ - ) - - // [_FN] = LAYOUT_ortho_5x15( /* FUNCTION */ - // _______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_NUM, KC_SLSH, KC_ASTR, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, - // KC_MSEL, KC_CALC, KC_MYCM, KC_MAIL, RGB_HUD, RGB_HUI, KC_P7, KC_P8, KC_P9, KC_MINS, _______, _______, KC_PSCR, KC_SCRL, KC_F12, - // KC_MPRV, KC_MPLY, KC_MNXT, KC_MSTP, RGB_SAD, RGB_SAI, KC_P4, KC_P5, KC_P6, KC_PLUS, _______, QK_BOOT, _______, _______, _______, - // KC_VOLD, KC_MUTE, KC_VOLU, KC_APP, RGB_VAD, RGB_VAI, KC_P1, KC_P2, KC_P3, KC_PENT, _______, _______, _______, _______, _______, - // _______, _______, RGB_TOG, ooooooo, RGB_RMOD,RGB_MOD, KC_P0, _______, KC_PDOT, KC_PENT, KC_PENT, ooooooo, _______, _______, _______ - // ) - - // // Template - // [_LAYER] = LAYOUT_ortho_5x15( - // _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, - // _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, - // _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, - // _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, - // _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ - // ), -}; - -layer_state_t layer_state_set_user(layer_state_t state) { - return update_tri_layer_state(state, L_SYMBOLS, L_NAVIGATION, L_MACROS); -} diff --git a/keyboards/xiudi/xd75/keymaps/replicajunction/readme.md b/keyboards/xiudi/xd75/keymaps/replicajunction/readme.md deleted file mode 100644 index 980a2f7272..0000000000 --- a/keyboards/xiudi/xd75/keymaps/replicajunction/readme.md +++ /dev/null @@ -1,5 +0,0 @@ -# replicaJunction - XD75 layout - -As a longtime ortho user, I prefer the "pseudo-split" keymap, where the center 3 columns are used for other purposes. This leaves 6 columns on each side to used like a split Preonic. - -Most of the goodies in this layout are defined in [my userspace folder](../../../../users/replicaJunction/readme.md). Better explanations of the interesting features are provided there. diff --git a/keyboards/xiudi/xd75/keymaps/replicajunction/rules.mk b/keyboards/xiudi/xd75/keymaps/replicajunction/rules.mk deleted file mode 100644 index 7e0b3c9cac..0000000000 --- a/keyboards/xiudi/xd75/keymaps/replicajunction/rules.mk +++ /dev/null @@ -1,29 +0,0 @@ -# Userspace options -USER_CAPS_WORD_ENABLE = yes -USER_MOUSE_JIGGLE_ENABLE = yes -USER_NUM_WORD_ENABLE = yes -USER_SECRETS_ENABLE = yes -USER_SUPER_ALT_TAB_ENABLE = yes - -DYNAMIC_MACRO_ENABLE = yes - -# Extra features that are nice but takes space. Enable only if they're -# used in the layout. -WPM_ENABLE = no -# EXTRAKEY_ENABLE = no # For volume keys and similar -# MOUSEKEY_ENABLE = no # Them mouse keys yo -KEY_OVERRIDE_ENABLE = no -LEADER_ENABLE = no -TAP_DANCE_ENABLE = no -# RGBLIGHT_ENABLE = no # Keyboard RGB underglow -RGB_MATRIX_ENABLE = no - -# Features I definitely don't care aboud -LTO_ENABLE = yes -CONSOLE_ENABLE = no -VERBOSE = no -DEBUG_MATRIX_SCAN_RATE = no -DEBUG_MATRIX = no -MAGIC_ENABLE = no -SPACE_CADET_ENABLE = no -GRAVE_ESC_ENABLE = no diff --git a/keyboards/xiudi/xd75/keymaps/tdl-jturner/keymap.c b/keyboards/xiudi/xd75/keymaps/tdl-jturner/keymap.c index 2cc3f5b7a3..626f77f67f 100644 --- a/keyboards/xiudi/xd75/keymaps/tdl-jturner/keymap.c +++ b/keyboards/xiudi/xd75/keymaps/tdl-jturner/keymap.c @@ -48,7 +48,7 @@ enum { }; //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Esc, twice for Caps Lock [TD_LOCK_SLEEP] = ACTION_TAP_DANCE_DOUBLE(LGUI(KC_L), KC_SLEP), [TD_ABK] = ACTION_TAP_DANCE_DOUBLE(KC_LABK,KC_RABK), diff --git a/keyboards/yatara/drink_me/keymaps/queen/keymap.c b/keyboards/yatara/drink_me/keymaps/queen/keymap.c index 2d99b38663..806dae3fcd 100644 --- a/keyboards/yatara/drink_me/keymaps/queen/keymap.c +++ b/keyboards/yatara/drink_me/keymaps/queen/keymap.c @@ -9,7 +9,7 @@ enum td_keys { }; -void td_spade_lnx (qk_tap_dance_state_t *state, void *user_data) { +void td_spade_lnx (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_unicode(0x2660); // â™ } else { @@ -19,7 +19,7 @@ void td_spade_lnx (qk_tap_dance_state_t *state, void *user_data) { } -void td_diamond_osx (qk_tap_dance_state_t *state, void *user_data) { +void td_diamond_osx (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_unicode(0x2666); // ♦ } else { @@ -29,7 +29,7 @@ void td_diamond_osx (qk_tap_dance_state_t *state, void *user_data) { } -void td_club_win (qk_tap_dance_state_t *state, void *user_data) { +void td_club_win (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_unicode(0x2663); // ♣ } else { @@ -39,7 +39,7 @@ void td_club_win (qk_tap_dance_state_t *state, void *user_data) { } -void td_heart_winc (qk_tap_dance_state_t *state, void *user_data) { +void td_heart_winc (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_unicode(0x2665); // ♥ } else { @@ -49,7 +49,7 @@ void td_heart_winc (qk_tap_dance_state_t *state, void *user_data) { } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_K0] = ACTION_TAP_DANCE_FN(td_spade_lnx), [TD_K1] = ACTION_TAP_DANCE_FN(td_diamond_osx), [TD_K2] = ACTION_TAP_DANCE_FN(td_club_win), diff --git a/keyboards/ydkb/just60/readme.md b/keyboards/ydkb/just60/readme.md index 76eee5dced..1fe05bd3ea 100644 --- a/keyboards/ydkb/just60/readme.md +++ b/keyboards/ydkb/just60/readme.md @@ -2,7 +2,7 @@ Just60 keyboard produced by Yang. The keyboard comes with a custom Mass Storage Device bootloader and a TMK based firmware from ydkb.io. -To use a QMK based firmware, you might want to install a QMK bootloader. The PCB exposes 6 pins for ISP(In-System Programming), and they are located just under the ATMega32U4 chip. From left to right, the pins are `VCC`, `SCLK`, `MOSI`, `MISO`, `QK_BOOT`, `GND`. The `GND` is the square one. You could program the flash with any AVR programmer, or a Raspberry Pi with `avrdude`. +To use a QMK based firmware, you might want to install a QMK bootloader. The PCB exposes 6 pins for ISP(In-System Programming), and they are located just under the ATMega32U4 chip. From left to right, the pins are `VCC`, `SCLK`, `MOSI`, `MISO`, `RESET`, `GND`. The `GND` is the square one. You could program the flash with any AVR programmer, or a Raspberry Pi with `avrdude`. Backlight LEDs and Bluetooth are not working yet. diff --git a/keyboards/ymdk/ymd96/keymaps/hgoel89/keymap.c b/keyboards/ymdk/ymd96/keymaps/hgoel89/keymap.c index 16d8f08137..31e9ac5b48 100644 --- a/keyboards/ymdk/ymd96/keymaps/hgoel89/keymap.c +++ b/keyboards/ymdk/ymd96/keymaps/hgoel89/keymap.c @@ -20,7 +20,7 @@ enum { TD_H_E = 0 }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_H_E] = ACTION_TAP_DANCE_DOUBLE(KC_HOME, KC_END) }; #define ______ KC_TRNS diff --git a/keyboards/yosino58/keymaps/default/config.h b/keyboards/yosino58/keymaps/default/config.h index 89778175c7..763b31aa10 100644 --- a/keyboards/yosino58/keymaps/default/config.h +++ b/keyboards/yosino58/keymaps/default/config.h @@ -26,7 +26,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // #define MASTER_RIGHT // #define EE_HANDS -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/yosino58/keymaps/sakura/config.h b/keyboards/yosino58/keymaps/sakura/config.h index 001160d60e..a463ee1808 100644 --- a/keyboards/yosino58/keymaps/sakura/config.h +++ b/keyboards/yosino58/keymaps/sakura/config.h @@ -28,7 +28,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define OLED_DISPLAY_128X64 -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 100 #undef RGBLED_NUM diff --git a/keyboards/yushakobo/navpad/10/config.h b/keyboards/yushakobo/navpad/10/config.h index 6d631ac32d..d9325aee19 100644 --- a/keyboards/yushakobo/navpad/10/config.h +++ b/keyboards/yushakobo/navpad/10/config.h @@ -72,6 +72,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. //#define BOOTMAGIC_LITE_COLUMN 0 -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 132 #define TAPPING_LAYER_TERM 90 diff --git a/keyboards/yushakobo/navpad/10_helix_r/config.h b/keyboards/yushakobo/navpad/10_helix_r/config.h index 646cb59b63..3a5ba847b5 100644 --- a/keyboards/yushakobo/navpad/10_helix_r/config.h +++ b/keyboards/yushakobo/navpad/10_helix_r/config.h @@ -107,6 +107,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. //#define BOOTMAGIC_LITE_COLUMN 0 -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #define TAPPING_TERM 132 #define TAPPING_LAYER_TERM 90 diff --git a/keyboards/z34/keymaps/zigotica/config.h b/keyboards/z34/keymaps/zigotica/config.h index 1b223cb71d..6f86fe803f 100644 --- a/keyboards/z34/keymaps/zigotica/config.h +++ b/keyboards/z34/keymaps/zigotica/config.h @@ -24,5 +24,5 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #define TAPPING_TERM 350 #define PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 diff --git a/keyboards/zfrontier/big_switch/keymaps/longtap/keymap.c b/keyboards/zfrontier/big_switch/keymaps/longtap/keymap.c index a475421a3a..486adcf369 100644 --- a/keyboards/zfrontier/big_switch/keymaps/longtap/keymap.c +++ b/keyboards/zfrontier/big_switch/keymaps/longtap/keymap.c @@ -93,7 +93,7 @@ void zf_send_random_string(void) { tap_code(KC_ENT); } -void dance_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_finished(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: register_code(KC_ENTER); @@ -107,12 +107,12 @@ void dance_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code(KC_ENTER); } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ENTER] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_finished, dance_reset) }; diff --git a/layouts/community/ergodox/belak/keymap.c b/layouts/community/ergodox/belak/keymap.c index 95255be683..ea72091145 100644 --- a/layouts/community/ergodox/belak/keymap.c +++ b/layouts/community/ergodox/belak/keymap.c @@ -45,11 +45,11 @@ enum belak_td { TD_LAYER_TOGGLE = 0, }; -void belak_td_each(qk_tap_dance_state_t *state, void *user_data); -void belak_td_finished(qk_tap_dance_state_t *state, void *user_data); -void belak_td_reset(qk_tap_dance_state_t *state, void *user_data); +void belak_td_each(tap_dance_state_t *state, void *user_data); +void belak_td_finished(tap_dance_state_t *state, void *user_data); +void belak_td_reset(tap_dance_state_t *state, void *user_data); -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LAYER_TOGGLE] = ACTION_TAP_DANCE_FN_ADVANCED(belak_td_each, belak_td_finished, belak_td_reset), }; @@ -332,7 +332,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -void belak_td_each(qk_tap_dance_state_t *state, void *user_data) { +void belak_td_each(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: td_led_override = 1; @@ -345,7 +345,7 @@ void belak_td_each(qk_tap_dance_state_t *state, void *user_data) { } } -void belak_td_finished(qk_tap_dance_state_t *state, void *user_data) { +void belak_td_finished(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: layer_on(SYMB); @@ -357,6 +357,6 @@ void belak_td_finished(qk_tap_dance_state_t *state, void *user_data) { td_led_override = 0; } -void belak_td_reset(qk_tap_dance_state_t *state, void *user_data) { +void belak_td_reset(tap_dance_state_t *state, void *user_data) { td_led_override = 0; } diff --git a/layouts/community/ergodox/haegin/keymap.c b/layouts/community/ergodox/haegin/keymap.c index 7c1883e57a..3704fe557c 100644 --- a/layouts/community/ergodox/haegin/keymap.c +++ b/layouts/community/ergodox/haegin/keymap.c @@ -167,7 +167,7 @@ static fib_tap fib_bspc = { .state = BSPC_LETTER }; -void cur_backspace (qk_tap_dance_state_t *state) { +void cur_backspace (tap_dance_state_t *state) { int next_fib = fib_bspc.a + fib_bspc.b; fib_bspc.a = fib_bspc.b; fib_bspc.b = next_fib; @@ -177,7 +177,7 @@ void cur_backspace (qk_tap_dance_state_t *state) { } } -void dance_backspace (qk_tap_dance_state_t *state, void *user_data) { +void dance_backspace (tap_dance_state_t *state, void *user_data) { // If we're at the fifth tap, switch to deleting by words, and reset the fib // counter if (state->count == 4) { @@ -197,7 +197,7 @@ void dance_backspace (qk_tap_dance_state_t *state, void *user_data) { } }; -void dance_backspace_ended (qk_tap_dance_state_t *state, void *user_data) { +void dance_backspace_ended (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { if (state->pressed) { fib_bspc.state = HOLD_CTRL; @@ -208,7 +208,7 @@ void dance_backspace_ended (qk_tap_dance_state_t *state, void *user_data) { } }; -void dance_backspace_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_backspace_reset (tap_dance_state_t *state, void *user_data) { switch (fib_bspc.state) { case HOLD_CTRL: unregister_code(KC_LCTL); break; case BSPC_WORD: unregister_code(KC_BSPC); unregister_code(KC_LALT); break; @@ -219,7 +219,7 @@ void dance_backspace_reset (qk_tap_dance_state_t *state, void *user_data) { fib_bspc.state = BSPC_LETTER; }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_BSPC] = ACTION_TAP_DANCE_FN_ADVANCED (dance_backspace, dance_backspace_ended, dance_backspace_reset) }; diff --git a/layouts/community/ergodox/meagerfindings/keymap.c b/layouts/community/ergodox/meagerfindings/keymap.c index 3035572a77..800fd091b3 100644 --- a/layouts/community/ergodox/meagerfindings/keymap.c +++ b/layouts/community/ergodox/meagerfindings/keymap.c @@ -51,7 +51,7 @@ enum custom_keycodes { static uint16_t key_timer; //key timer for macros //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Copy, twice for Paste, three times for Cut. [TD_COPY_CUT] = ACTION_TAP_DANCE_DOUBLE(LGUI(KC_C),LGUI(KC_X)), //Tap once for Snagit, twice for Cmd + Shift + Opt + 4 (OS X cropping screenshot that is copied to the clipboard only.) diff --git a/layouts/community/ergodox/replicaJunction/config.h b/layouts/community/ergodox/replicaJunction/config.h deleted file mode 100644 index a02f9a95db..0000000000 --- a/layouts/community/ergodox/replicaJunction/config.h +++ /dev/null @@ -1,51 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once - -// Do not allow one macro to contain the other macro -#define DYNAMIC_MACRO_NO_NESTING - -// "THE most important tap hold configuration setting" -// https://precondition.github.io/home-row-mods#ignore-mod-tap-interrupt -// https://docs.qmk.fm/#/tap_hold?id=ignore-mod-tap-interrupt -#define IGNORE_MOD_TAP_INTERRUPT - -// This one is a style choice. Play with it both on and off to see which -// one suits you better. -// https://precondition.github.io/home-row-mods#permissive-hold -// https://docs.qmk.fm/#/tap_hold?id=permissive-hold -#define PERMISSIVE_HOLD - -// If you press a dual-role key for longer than TAPPING_TERM, then -// release it without pressing another key, without this setting nothing -// would happen. With this setting, it sends the key's tap function. -// https://precondition.github.io/home-row-mods#retro-tapping -#define RETRO_TAPPING - -// Disable some unused features to save space -#undef LOCKING_SUPPORT_ENABLE -#undef LOCKING_RESYNC_ENABLE - -///// -// Flags for stuff in my userspace - -#define USER_INCLUDE_GAMING_LAYER -#define USER_INCLUDE_MACRO_LAYER - -// "Super Alt-Tab" -// https://docs.qmk.fm/#/feature_macros?id=super-alt%E2%86%AFtab -#define USER_SUPER_ALT_TAB_TIMEOUT 500 diff --git a/layouts/community/ergodox/replicaJunction/keymap.c b/layouts/community/ergodox/replicaJunction/keymap.c deleted file mode 100644 index 4e0559a3e2..0000000000 --- a/layouts/community/ergodox/replicaJunction/keymap.c +++ /dev/null @@ -1,378 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include QMK_KEYBOARD_H -#include "replicaJunction.h" - -// Most layers are defined in my userspace, but this keyboard has -// an extra one. -enum additional_keyboard_layers { - L_SYSLEDS = _LAYER_SAFE_RANGE -}; - -#define BSP_SYM LT(L_SYMBOLS, KC_BSPC) -#define SPC_NAV LT(L_NAVIGATION, KC_SPC) - -#define MO_FN MO(L_FN) -#define MO_MAC MO(L_MACROS) -#define MO_SLED MO(L_SYSLEDS) - -#define TG_GAME TG(L_GAMING) - -#define ESC_SFT LSFT_T(KC_ESC) -#define TAB_SFT RSFT_T(KC_TAB) - - -const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - - -[L_BASE] = LAYOUT_ergodox( - KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_MINS, - KC_EQL, KC_Q, KC_W, KC_F, KC_P, KC_B, NUMWORD, - KC_MINS, KC_A, KC_R, KC_S, KC_T, KC_G, - KC_LSFT, KC_Z, KC_X, KC_C, KC_D, KC_V, KC_RBRC, - KC_LCTL, KC_LGUI ,KC_LALT, MO_FN, ESC_SFT, - KC_HOME, KC_END, - KC_PGUP, - BSP_SYM, CTL_DEL, KC_PGDN, - - TG_GAME, KC_6, KC_7, KC_8, KC_9, KC_0, KC_EQL, - CAPWORD, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSLS, - KC_M, KC_N, KC_E, KC_I, KC_O, KC_QUOT, - QK_LOCK, KC_K, KC_H, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, - TAB_SFT, MO_FN, KC_RALT, KC_RGUI, MO_SLED, - KC_LEFT, KC_RGHT, - KC_UP, - KC_DOWN, ALT_ENT, SPC_NAV -), - - -[L_GAMING] = LAYOUT_ergodox( - KC_GRV, _______,_______,_______,_______,_______,_______, - KC_TAB, _______,_______,_______,_______,_______,_______, - KC_ESC, KC_A, KC_R, KC_S, KC_T, _______, - KC_LSFT,_______,_______,KC_C, KC_D, _______,_______, - _______,_______,KC_TAB, KC_LALT,KC_LCTL, - QK_LOCK,_______, - _______, - KC_SPC, KC_LSFT,_______, - - ooooooo,_______,_______,_______,_______,_______,_______, - _______,_______,_______,_______,_______,_______,_______, - _______,KC_N, KC_E, KC_I, KC_O, _______, - _______,_______,_______,_______,_______,_______,_______, - MO_FN, KC_LEFT,KC_DOWN,KC_UP, KC_RGHT, - KC_BTN3,_______, - KC_BTN2, - KC_BTN1,KC_ENT, KC_BSPC -), - - -[L_NUMBERS] = LAYOUT_ergodox( - _______,_______,_______,_______,_______,_______,_______, - _______,_______,_______,_______,_______,_______,_______, - _______,KC_LGUI,KC_LALT,KC_LSFT,KC_LCTL,_______, - _______,_______,_______,_______,_______,_______,_______, - _______,_______,_______,_______,_______, - _______,_______, - _______, - _______,_______,_______, - - _______,KC_NUM, _______,_______,_______,_______,_______, - KC_NUM, KC_HASH,KC_P7, KC_P8, KC_P9, KC_PSLS,SFT_TAB, - KC_PPLS,KC_P4, KC_P5, KC_P6, KC_PAST,KC_TAB, - _______,KC_PMNS,KC_P1, KC_P2, KC_P3, KC_BSLS,KC_EQL, - KC_P0, KC_P0, KC_PDOT,KC_PENT,_______, - _______,_______, - _______, - _______,_______,_______ -), - - -[L_SYMBOLS] = LAYOUT_ergodox( - _______,KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, _______, - _______,KC_AT, KC_LT, KC_DLR, KC_GT, XXXXXXX,_______, - _______,KC_BSLS,KC_LPRN,KC_DQUO,KC_RPRN,KC_HASH, - _______,KC_EXLM,KC_COLN,KC_ASTR,KC_PLUS,XXXXXXX,_______, - _______,_______,_______,_______,_______, - _______,_______, - _______, - ooooooo,_______,_______, - - _______,KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, - _______,XXXXXXX,KC_LBRC,KC_UNDS,KC_RBRC,XXXXXXX,KC_F12, - KC_PERC,KC_LCBR,KC_EQL, KC_RCBR,KC_PIPE,_______, - _______,XXXXXXX,KC_AMPR,KC_CIRC,KC_TILD,KC_GRV, _______, - _______,_______,_______,_______,_______, - _______,_______, - _______, - _______,_______,ooooooo -), - - -[L_NAVIGATION] = LAYOUT_ergodox( - _______,KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, _______, - _______,OS_UNDO,OS_CUT, OS_PAST,OS_COPY,OS_SALL,_______, - _______,KC_LGUI,KC_LSFT,KC_LALT,KC_LCTL,_______, - _______,WIN_V, _______,_______,OS_FIND,SEARCH, _______, - _______,_______,_______,_______,_______, - _______,_______, - _______, - _______,_______,_______, - - _______,KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, - _______,KC_PGUP,KC_HOME,KC_UP, KC_END, KC_DEL, KC_F12, - KC_PGDN,KC_LEFT,KC_DOWN,KC_RGHT,KC_BSPC,_______, - _______,_______,SFT_TAB,KC_TAB, KC_APP, KC_PSCR,_______, - _______,_______,_______,_______,_______, - _______,_______, - _______, - _______,_______,ooooooo -), - - -[L_FN] = LAYOUT_ergodox( - _______,_______,_______,_______,_______,_______,_______, - _______,QK_VERS,_______,DM_REC2,DM_REC1,DM_RSTP,_______, - _______,QK_MAKE,_______,DM_PLY2,DM_PLY1,_______, - _______,QK_FLSH,K_SECR1,K_SECR2,K_SECR3,K_SECR4,_______, - _______,_______,_______,ooooooo,_______, - _______,_______, - _______, - KC_LCTL,_______,_______, - - _______,_______,_______,_______,_______,_______,_______, - _______,KC_VOLU,KC_F9, KC_F10, KC_F11, KC_F12, _______, - KC_MUTE,KC_F5, KC_F6, KC_F7, KC_F8, _______, - _______,KC_VOLD,KC_F1, KC_F2, KC_F3, KC_F4, _______, - _______,ooooooo,_______,_______,_______, - _______,QK_BOOT, - _______, - _______,_______,KC_LALT -), - - -[L_MACROS] = LAYOUT_ergodox( - _______,_______,_______,_______,_______,_______,_______, - _______,_______,_______,DM_REC2,DM_REC1,_______,_______, - _______,_______,_______,DM_PLY2,DM_PLY1,DM_RSTP, - _______,_______,_______,_______,_______,_______,_______, - _______,_______,_______,_______,_______, - _______,_______, - _______, - ooooooo,_______,_______, - - _______,_______,_______,_______,_______,_______,_______, - _______,_______,SHEBANG,_______,_______,_______,_______, - PRG_NE, PRG_EQ, PRG_GEQ,PRG_LEQ,PRG_ARR,_______, - _______,_______,PS_ITEM,FS_PIPE,_______,FS_ARR, _______, - _______,_______,_______,_______,_______, - _______,_______, - _______, - _______,_______,ooooooo -), - - - -[L_SYSLEDS] = LAYOUT_ergodox( - _______,_______,_______,_______,_______,_______,_______, - _______,_______,_______,_______,_______,_______,_______, - _______,_______,_______,_______,_______,_______, - _______,_______,_______,_______,_______,_______,_______, - _______,_______,_______,_______,_______, - _______,_______, - _______, - _______,_______,_______, - - KC_NUM, _______,_______,_______,_______,_______,_______, - KC_CAPS,_______,_______,_______,_______,_______,_______, - _______,_______,_______,_______,_______,_______, - KC_SCRL,_______,_______,_______,_______,_______,_______, - _______,_______,_______,_______,ooooooo, - _______,_______, - _______, - _______,_______,_______ -) - -// Template -// [_NUMBERS] = LAYOUT_ergodox( -// _______,_______,_______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______, -// _______,_______, -// _______, -// _______,_______,_______, - -// _______,_______,_______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______,_______,_______, -// _______,_______,_______,_______,_______, -// _______,_______, -// _______, -// _______,_______,_______ -// ), - -}; - -void keyboard_post_init_user_kb(void) { - ergodox_right_led_1_on(); -} - - -//////////////////////////////////////////////////////////// -// System LED code -//////////////////////////////////////////////////////////// - -// We need to track both the layer state and the system LED state in -// order to update the LEDs appropriately when either one changes. -// These are both represented as a bitmask. -// -// There is a global 'layer_state' variable but it is set after the call -// to layer_state_set_user(), so it doesn't work properly for our -// purposes. -static uint32_t current_layer_state = 0; -static uint8_t sys_led_state = 0; - -// Whether the given layer (one of the constant defined at the top) is active. -#define LAYER_ON(state, layer) (state & (1<<layer)) - -// Brightness of LEDs (0-255) -// Default value is 255. Use a lesser value for dimmer LEDs. -static const uint8_t max_led_value = 255; - -void led_1_on(void) { - ergodox_right_led_1_on(); - ergodox_right_led_1_set(max_led_value); -} - -void led_2_on(void) { - ergodox_right_led_2_on(); - ergodox_right_led_2_set(max_led_value); -} - -void led_3_on(void) { - ergodox_right_led_3_on(); - ergodox_right_led_3_set(max_led_value); -} - -// The onboard LED doesn't support brightness, but this function keeps -// things consistent. -void led_board_on(void) { - ergodox_board_led_on(); -} - -void led_1_off(void) { - ergodox_right_led_1_off(); -} - -void led_2_off(void) { - ergodox_right_led_2_off(); -} - -void led_3_off(void) { - ergodox_right_led_3_off(); -} - -void led_board_off(void) { - ergodox_board_led_off(); -} - -void set_leds_by_system_state(uint8_t led_state) { - led_t host_led_state = host_keyboard_led_state(); - - if (led_state & host_led_state.num_lock) { - led_1_on(); - } - else { - led_1_off(); - } - - if (led_state & host_led_state.caps_lock) { - led_2_on(); - } - else { - led_2_off(); - } - - if (led_state & host_led_state.scroll_lock) { - led_3_on(); - } - else { - led_3_off(); - } -} - -void set_leds_by_layer_state(uint32_t layer_state) { - if (LAYER_ON(layer_state, L_FN)) { - led_1_on(); - led_2_on(); - led_3_on(); - led_board_off(); - } - else if (LAYER_ON(layer_state, L_GAMING)) { - led_1_off(); - led_2_off(); - led_3_off(); - led_board_on(); - } - else if (LAYER_ON(layer_state, L_NUMBERS)) { - led_1_on(); - led_2_off(); - led_3_off(); - led_board_off(); - } - else if (LAYER_ON(layer_state, L_NAVIGATION)) { - led_1_off(); - led_2_on(); - led_3_off(); - led_board_off(); - } - else { - led_1_on(); - led_2_off(); - led_3_off(); - led_board_off(); - } -} - -void led_set_kb(uint8_t usb_led) { - sys_led_state = usb_led; - - if (LAYER_ON(current_layer_state, L_SYSLEDS)) { - set_leds_by_system_state(sys_led_state); - } - else { - set_leds_by_layer_state(current_layer_state); - } - - led_set_user(usb_led); -} - -layer_state_t layer_state_set_kb(layer_state_t state) { - current_layer_state = state; - - if (LAYER_ON(state, L_SYSLEDS)) { - set_leds_by_system_state(sys_led_state); - } - else { - set_leds_by_layer_state(state); - } - - return update_tri_layer_state(state, L_SYMBOLS, L_NAVIGATION, L_MACROS); -} diff --git a/layouts/community/ergodox/replicaJunction/readme.md b/layouts/community/ergodox/replicaJunction/readme.md deleted file mode 100644 index 57e4480474..0000000000 --- a/layouts/community/ergodox/replicaJunction/readme.md +++ /dev/null @@ -1,5 +0,0 @@ -# replicaJunction - Ergodox (EZ) Layout - -Most of the goodies in this layout are defined in [my userspace folder](../../../../users/replicaJunction/readme.md). Better explanations of the interesting features are provided there. - -One feature is worth pointing out here, since it's keyboard-specific: handling of the LEDs. Normally, I use the LEDs to indicate layer state, but it's occasionally useful to be able to view the system state as well (num lock, caps lock, scroll lock). The final layer in the keymap, `L_SYSLEDS`, is used to indicate this. I have a MO key that temporarily switches the LED behavior to show system state, and on this layer, the three keys with LEDs are each used to toggle the respective lock. diff --git a/layouts/community/ergodox/replicaJunction/rules.mk b/layouts/community/ergodox/replicaJunction/rules.mk deleted file mode 100644 index 523639cc46..0000000000 --- a/layouts/community/ergodox/replicaJunction/rules.mk +++ /dev/null @@ -1,33 +0,0 @@ -# https://docs.qmk.fm/getting_started_make_guide.html - -# Userspace options -USER_CAPS_WORD_ENABLE = yes -USER_NUM_WORD_ENABLE = yes -USER_SECRETS_ENABLE = yes -USER_SUPER_ALT_TAB_ENABLE = yes - -# Features to enable -DYNAMIC_MACRO_ENABLE = yes -KEY_LOCK_ENABLE = yes - -# Extra features that are nice but takes space. Enable only if they're -# used in the layout. -WPM_ENABLE = no -# EXTRAKEY_ENABLE = no # For volume keys and similar -# MOUSEKEY_ENABLE = no # Them mouse keys yo -KEY_OVERRIDE_ENABLE = no -LEADER_ENABLE = no -TAP_DANCE_ENABLE = no -# RGBLIGHT_ENABLE = no # Keyboard RGB underglow -RGB_MATRIX_ENABLE = no - -# Features I definitely don't care aboud -LTO_ENABLE = yes -CONSOLE_ENABLE = no -VERBOSE = no -DEBUG_MATRIX_SCAN_RATE = no -DEBUG_MATRIX = no -MAGIC_ENABLE = no -SPACE_CADET_ENABLE = no -GRAVE_ESC_ENABLE = no - diff --git a/layouts/community/ergodox/videck/keymap.c b/layouts/community/ergodox/videck/keymap.c index 1a17657da1..e0a3cec912 100644 --- a/layouts/community/ergodox/videck/keymap.c +++ b/layouts/community/ergodox/videck/keymap.c @@ -106,7 +106,7 @@ typedef struct videck_tap_dance_trigger_t trigger; } videck_tap_dance_tuple_t; -static void videck_tap_dance_finished (qk_tap_dance_state_t *state, void *user_data) { +static void videck_tap_dance_finished (tap_dance_state_t *state, void *user_data) { videck_tap_dance_tuple_t *const tuple = (videck_tap_dance_tuple_t *)user_data; if (state->count == 1) { @@ -116,7 +116,7 @@ static void videck_tap_dance_finished (qk_tap_dance_state_t *state, void *user_d } } -static void videck_tap_dance_reset (qk_tap_dance_state_t *state, void *user_data) { +static void videck_tap_dance_reset (tap_dance_state_t *state, void *user_data) { videck_tap_dance_tuple_t *const tuple = (videck_tap_dance_tuple_t *)user_data; if (state->count == 1) { @@ -139,7 +139,7 @@ static void videck_caps_trigger (const uint16_t kc) { .user_data = (void *)&((videck_tap_dance_tuple_t) { kc1, kc2, double_trigger }), \ } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_L] = ACTION_TAP_DANCE_DOUBLE_TRIGGER(KC_LSFT, KC_CAPS, videck_caps_trigger), [TD_R] = ACTION_TAP_DANCE_DOUBLE_TRIGGER(KC_RSFT, KC_CAPS, videck_caps_trigger) }; diff --git a/layouts/community/ortho_4x12/wanleg/readme.md b/layouts/community/ortho_4x12/wanleg/readme.md index 1cd41d116d..3fc1fc65ad 100644 --- a/layouts/community/ortho_4x12/wanleg/readme.md +++ b/layouts/community/ortho_4x12/wanleg/readme.md @@ -23,14 +23,6 @@ In `qmk_firmware/keyboards/lets_split/rev2/rev2.c`, replace contents with ``` #include "lets_split.h" - -#ifdef SSD1306OLED -void led_set_kb(uint8_t usb_led) { - // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here - led_set_user(usb_led); -} -#endif - void matrix_init_kb(void) { // // green led on diff --git a/layouts/community/ortho_5x12/riblee/keymap.c b/layouts/community/ortho_5x12/riblee/keymap.c index 7a786de79d..c5a84d25c6 100644 --- a/layouts/community/ortho_5x12/riblee/keymap.c +++ b/layouts/community/ortho_5x12/riblee/keymap.c @@ -17,7 +17,7 @@ // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_A] = ACTION_TAP_DANCE_FN(dance_key_a), [TD_E] = ACTION_TAP_DANCE_FN(dance_key_e), [TD_I] = ACTION_TAP_DANCE_FN(dance_key_i), diff --git a/layouts/community/split_3x6_3/drashna/config.h b/layouts/community/split_3x6_3/drashna/config.h index 0ef36d1f32..e43ad5e3ac 100644 --- a/layouts/community/split_3x6_3/drashna/config.h +++ b/layouts/community/split_3x6_3/drashna/config.h @@ -26,7 +26,7 @@ #undef USE_I2C #undef SSD1306OLED -// #define TAPPING_FORCE_HOLD +// #define QUICK_TAP_TERM 0 // #define TAPPING_TERM 100 #ifdef RGBLIGHT_ENABLE diff --git a/lib/chibios-contrib b/lib/chibios-contrib -Subproject bb8356fb5a3a9bbc1561826f174a9a631c61454 +Subproject 1130173eae6b7402443aff18ad68228acbe25cc diff --git a/lib/lvgl b/lib/lvgl new file mode 160000 +Subproject e19410f8f8a256609da72cff549598e0df6fa4c diff --git a/lib/python/qmk/cli/__init__.py b/lib/python/qmk/cli/__init__.py index 9190af4e50..a6d53c1cb6 100644 --- a/lib/python/qmk/cli/__init__.py +++ b/lib/python/qmk/cli/__init__.py @@ -57,6 +57,7 @@ subcommands = [ 'qmk.cli.generate.keyboard_c', 'qmk.cli.generate.keyboard_h', 'qmk.cli.generate.keycodes', + 'qmk.cli.generate.keycodes_tests', 'qmk.cli.generate.rgb_breathe_table', 'qmk.cli.generate.rules_mk', 'qmk.cli.generate.version_h', @@ -71,6 +72,7 @@ subcommands = [ 'qmk.cli.list.keymaps', 'qmk.cli.list.layouts', 'qmk.cli.kle2json', + 'qmk.cli.migrate', 'qmk.cli.multibuild', 'qmk.cli.new.keyboard', 'qmk.cli.new.keymap', diff --git a/lib/python/qmk/cli/generate/api.py b/lib/python/qmk/cli/generate/api.py index 8650a36b84..dd4830f543 100755 --- a/lib/python/qmk/cli/generate/api.py +++ b/lib/python/qmk/cli/generate/api.py @@ -11,7 +11,7 @@ from qmk.info import info_json from qmk.json_encoders import InfoJSONEncoder from qmk.json_schema import json_load from qmk.keyboard import find_readme, list_keyboards -from qmk.keycodes import load_spec, list_versions +from qmk.keycodes import load_spec, list_versions, list_languages DATA_PATH = Path('data') TEMPLATE_PATH = DATA_PATH / 'templates/api/' @@ -44,6 +44,13 @@ def _resolve_keycode_specs(output_folder): output_file = output_folder / f'constants/keycodes_{version}.json' output_file.write_text(json.dumps(overall, indent=4), encoding='utf-8') + for lang in list_languages(): + for version in list_versions(lang): + overall = load_spec(version, lang) + + output_file = output_folder / f'constants/keycodes_{lang}_{version}.json' + output_file.write_text(json.dumps(overall, indent=4), encoding='utf-8') + # Purge files consumed by 'load_spec' shutil.rmtree(output_folder / 'constants/keycodes/') diff --git a/lib/python/qmk/cli/generate/keycodes.py b/lib/python/qmk/cli/generate/keycodes.py index 29b7db3c80..2ed84cd589 100644 --- a/lib/python/qmk/cli/generate/keycodes.py +++ b/lib/python/qmk/cli/generate/keycodes.py @@ -8,6 +8,24 @@ from qmk.path import normpath from qmk.keycodes import load_spec +def _render_key(key): + width = 7 + if 'S(' in key: + width += len('S()') + if 'A(' in key: + width += len('A()') + if 'RCTL(' in key: + width += len('RCTL()') + if 'ALGR(' in key: + width += len('ALGR()') + return key.ljust(width) + + +def _render_label(label): + label = label.replace("\\", "(backslash)") + return label + + def _generate_ranges(lines, keycodes): lines.append('') lines.append('enum qk_keycode_ranges {') @@ -67,6 +85,23 @@ def _generate_helpers(lines, keycodes): lines.append(f'#define IS_{ group.upper() }_KEYCODE(code) ((code) >= {lo} && (code) <= {hi})') +def _generate_aliases(lines, keycodes): + lines.append('') + lines.append('// Aliases') + for key, value in keycodes["aliases"].items(): + define = _render_key(value.get("key")) + val = _render_key(key) + if 'label' in value: + lines.append(f'#define {define} {val} // {_render_label(value.get("label"))}') + else: + lines.append(f'#define {define} {val}') + + lines.append('') + for key, value in keycodes["aliases"].items(): + for alias in value.get("aliases", []): + lines.append(f'#define {alias} {value.get("key")}') + + @cli.argument('-v', '--version', arg_only=True, required=True, help='Version of keycodes to generate.') @cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to') @cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages") @@ -86,3 +121,23 @@ def generate_keycodes(cli): # Show the results dump_lines(cli.args.output, keycodes_h_lines, cli.args.quiet) + + +@cli.argument('-v', '--version', arg_only=True, required=True, help='Version of keycodes to generate.') +@cli.argument('-l', '--lang', arg_only=True, required=True, help='Language of keycodes to generate.') +@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to') +@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages") +@cli.subcommand('Used by the make system to generate keymap_{lang}.h from keycodes_{lang}_{version}.json', hidden=True) +def generate_keycode_extras(cli): + """Generates the header file. + """ + + # Build the header file. + keycodes_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once', '#include "keymap.h"', '// clang-format off'] + + keycodes = load_spec(cli.args.version, cli.args.lang) + + _generate_aliases(keycodes_h_lines, keycodes) + + # Show the results + dump_lines(cli.args.output, keycodes_h_lines, cli.args.quiet) diff --git a/lib/python/qmk/cli/generate/keycodes_tests.py b/lib/python/qmk/cli/generate/keycodes_tests.py new file mode 100644 index 0000000000..453b4693a7 --- /dev/null +++ b/lib/python/qmk/cli/generate/keycodes_tests.py @@ -0,0 +1,39 @@ +"""Used by the make system to generate a keycode lookup table from keycodes_{version}.json +""" +from milc import cli + +from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE +from qmk.commands import dump_lines +from qmk.path import normpath +from qmk.keycodes import load_spec + + +def _generate_defines(lines, keycodes): + lines.append('') + lines.append('std::map<uint16_t, std::string> KEYCODE_ID_TABLE = {') + for key, value in keycodes["keycodes"].items(): + lines.append(f' {{{value.get("key")}, "{value.get("key")}"}},') + lines.append('};') + + +@cli.argument('-v', '--version', arg_only=True, required=True, help='Version of keycodes to generate.') +@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to') +@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages") +@cli.subcommand('Used by the make system to generate a keycode lookup table from keycodes_{version}.json', hidden=True) +def generate_keycodes_tests(cli): + """Generates a keycode to identifier lookup table for unit test output. + """ + + # Build the keycodes.h file. + keycodes_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '// clang-format off'] + keycodes_h_lines.append('extern "C" {\n#include <keycode.h>\n}') + keycodes_h_lines.append('#include <map>') + keycodes_h_lines.append('#include <string>') + keycodes_h_lines.append('#include <cstdint>') + + keycodes = load_spec(cli.args.version) + + _generate_defines(keycodes_h_lines, keycodes) + + # Show the results + dump_lines(cli.args.output, keycodes_h_lines, cli.args.quiet) diff --git a/lib/python/qmk/cli/migrate.py b/lib/python/qmk/cli/migrate.py new file mode 100644 index 0000000000..4164f9c8ad --- /dev/null +++ b/lib/python/qmk/cli/migrate.py @@ -0,0 +1,81 @@ +"""Migrate keyboard configuration to "Data Driven" +""" +import json +from pathlib import Path +from dotty_dict import dotty + +from milc import cli + +from qmk.keyboard import keyboard_completer, keyboard_folder, resolve_keyboard +from qmk.info import info_json, find_info_json +from qmk.json_encoders import InfoJSONEncoder +from qmk.json_schema import json_load + + +def _candidate_files(keyboard): + kb_dir = Path(resolve_keyboard(keyboard)) + + cur_dir = Path('keyboards') + files = [] + for dir in kb_dir.parts: + cur_dir = cur_dir / dir + files.append(cur_dir / 'config.h') + files.append(cur_dir / 'rules.mk') + + return [file for file in files if file.exists()] + + +@cli.argument('-f', '--filter', arg_only=True, action='append', default=[], help="Filter the performed migrations based on the supplied value. Supported format is 'KEY' located from 'data/mappings'. May be passed multiple times.") +@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, required=True, help='The keyboard\'s name') +@cli.subcommand('Migrate keyboard config to "Data Driven".', hidden=True) +def migrate(cli): + """Migrate keyboard configuration to "Data Driven" + """ + # Merge mappings as we do not care to where "KEY" is found just that its removed + info_config_map = json_load(Path('data/mappings/info_config.hjson')) + info_rules_map = json_load(Path('data/mappings/info_rules.hjson')) + info_map = {**info_config_map, **info_rules_map} + + # Parse target info.json which will receive updates + target_info = Path(find_info_json(cli.args.keyboard)[0]) + info_data = dotty(json_load(target_info)) + + # Already parsed used for updates + kb_info_json = dotty(info_json(cli.args.keyboard)) + + # List of candidate files + files = _candidate_files(cli.args.keyboard) + + # Filter down keys if requested + keys = info_map.keys() + if cli.args.filter: + keys = list(set(keys) & set(cli.args.filter)) + + cli.log.info(f'{{fg_green}}Migrating keyboard {{fg_cyan}}{cli.args.keyboard}{{fg_green}}.{{fg_reset}}') + + # Start migration + for file in files: + cli.log.info(f' Migrating file {file}') + file_contents = file.read_text(encoding='utf-8').split('\n') + for key in keys: + for num, line in enumerate(file_contents): + if line.startswith(f'{key} =') or line.startswith(f'#define {key} '): + cli.log.info(f' Migrating {key}...') + + while line.rstrip().endswith('\\'): + file_contents.pop(num) + line = file_contents[num] + file_contents.pop(num) + + update_key = info_map[key]["info_key"] + if update_key in kb_info_json: + info_data[update_key] = kb_info_json[update_key] + + file.write_text('\n'.join(file_contents), encoding='utf-8') + + # Finally write out updated info.json + cli.log.info(f' Updating {target_info}') + target_info.write_text(json.dumps(info_data.to_dict(), cls=InfoJSONEncoder)) + + cli.log.info(f'{{fg_green}}Migration of keyboard {{fg_cyan}}{cli.args.keyboard}{{fg_green}} complete!{{fg_reset}}') + cli.log.info(f"Verify build with {{fg_yellow}}qmk compile -kb {cli.args.keyboard} -km default{{fg_reset}}.") diff --git a/lib/python/qmk/cli/new/keyboard.py b/lib/python/qmk/cli/new/keyboard.py index 251ad919dd..cdd3919168 100644 --- a/lib/python/qmk/cli/new/keyboard.py +++ b/lib/python/qmk/cli/new/keyboard.py @@ -195,11 +195,6 @@ def new_keyboard(cli): cli.echo('') kb_name = cli.args.keyboard if cli.args.keyboard else prompt_keyboard() - user_name = cli.config.new_keyboard.name if cli.config.new_keyboard.name else prompt_user() - real_name = cli.args.realname or cli.config.new_keyboard.name if cli.args.realname or cli.config.new_keyboard.name else prompt_name(user_name) - default_layout = cli.args.layout if cli.args.layout else prompt_layout() - mcu = cli.args.type if cli.args.type else prompt_mcu() - if not validate_keyboard_name(kb_name): cli.log.error('Keyboard names must contain only {fg_cyan}lowercase a-z{fg_reset}, {fg_cyan}0-9{fg_reset}, and {fg_cyan}_{fg_reset}! Please choose a different name.') return 1 @@ -208,6 +203,11 @@ def new_keyboard(cli): cli.log.error(f'Keyboard {{fg_cyan}}{kb_name}{{fg_reset}} already exists! Please choose a different name.') return 1 + user_name = cli.config.new_keyboard.name if cli.config.new_keyboard.name else prompt_user() + real_name = cli.args.realname or cli.config.new_keyboard.name if cli.args.realname or cli.config.new_keyboard.name else prompt_name(user_name) + default_layout = cli.args.layout if cli.args.layout else prompt_layout() + mcu = cli.args.type if cli.args.type else prompt_mcu() + # Preprocess any development_board presets if mcu in dev_boards: defaults_map = json_load(Path('data/mappings/defaults.hjson')) diff --git a/lib/python/qmk/cli/new/keymap.py b/lib/python/qmk/cli/new/keymap.py index 60cb743cb6..e7823bc46d 100755 --- a/lib/python/qmk/cli/new/keymap.py +++ b/lib/python/qmk/cli/new/keymap.py @@ -1,12 +1,32 @@ """This script automates the copying of the default keymap into your own keymap. """ import shutil -from pathlib import Path -import qmk.path +from milc import cli +from milc.questions import question + +from qmk.path import is_keyboard, keymap +from qmk.git import git_get_username from qmk.decorators import automagic_keyboard, automagic_keymap from qmk.keyboard import keyboard_completer, keyboard_folder -from milc import cli + + +def prompt_keyboard(): + prompt = """{fg_yellow}Select Keyboard{style_reset_all} +If you`re unsure you can view a full list of supported keyboards with {fg_yellow}qmk list-keyboards{style_reset_all}. + +Keyboard Name? """ + + return question(prompt) + + +def prompt_user(): + prompt = """ +{fg_yellow}Name Your Keymap{style_reset_all} +Used for maintainer, copyright, etc + +Your GitHub Username? """ + return question(prompt, default=git_get_username()) @cli.argument('-kb', '--keyboard', type=keyboard_folder, completer=keyboard_completer, help='Specify keyboard name. Example: 1upkeyboards/1up60hse') @@ -17,32 +37,34 @@ from milc import cli def new_keymap(cli): """Creates a new keymap for the keyboard of your choosing. """ - # ask for user input if keyboard or keymap was not provided in the command line - keyboard = cli.config.new_keymap.keyboard if cli.config.new_keymap.keyboard else input("Keyboard Name: ") - keymap = cli.config.new_keymap.keymap if cli.config.new_keymap.keymap else input("Keymap Name: ") + cli.log.info('{style_bright}Generating a new keymap{style_normal}') + cli.echo('') - # generate keymap paths - kb_path = Path('keyboards') / keyboard - keymap_path = qmk.path.keymap(keyboard) - keymap_path_default = keymap_path / 'default' - keymap_path_new = keymap_path / keymap + # ask for user input if keyboard or keymap was not provided in the command line + kb_name = cli.config.new_keymap.keyboard if cli.config.new_keymap.keyboard else prompt_keyboard() + user_name = cli.config.new_keymap.keymap if cli.config.new_keymap.keymap else prompt_user() # check directories - if not kb_path.exists(): - cli.log.error('Keyboard %s does not exist!', kb_path) + if not is_keyboard(kb_name): + cli.log.error(f'Keyboard {{fg_cyan}}{kb_name}{{fg_reset}} does not exist! Please choose a valid name.') return False + # generate keymap paths + km_path = keymap(kb_name) + keymap_path_default = km_path / 'default' + keymap_path_new = km_path / user_name + if not keymap_path_default.exists(): - cli.log.error('Keyboard default %s does not exist!', keymap_path_default) + cli.log.error(f'Default keymap {{fg_cyan}}{keymap_path_default}{{fg_reset}} does not exist!') return False if keymap_path_new.exists(): - cli.log.error('Keymap %s already exists!', keymap_path_new) + cli.log.error(f'Keymap {{fg_cyan}}{user_name}{{fg_reset}} already exists! Please choose a different name.') return False # create user directory with default keymap files shutil.copytree(keymap_path_default, keymap_path_new, symlinks=True) # end message to user - cli.log.info("%s keymap directory created in: %s", keymap, keymap_path_new) - cli.log.info("Compile a firmware with your new keymap by typing: \n\n\tqmk compile -kb %s -km %s\n", keyboard, keymap) + cli.log.info(f'{{fg_green}}Created a new keymap called {{fg_cyan}}{user_name}{{fg_green}} in: {{fg_cyan}}{keymap_path_new}.{{fg_reset}}') + cli.log.info(f"Compile a firmware with your new keymap by typing: {{fg_yellow}}qmk compile -kb {kb_name} -km {user_name}{{fg_reset}}.") diff --git a/lib/python/qmk/keycodes.py b/lib/python/qmk/keycodes.py index cf1ee0767a..600163bab9 100644 --- a/lib/python/qmk/keycodes.py +++ b/lib/python/qmk/keycodes.py @@ -2,7 +2,42 @@ from pathlib import Path from qmk.json_schema import deep_update, json_load, validate -CONSTANTS_PATH = Path('data/constants/keycodes/') +CONSTANTS_PATH = Path('data/constants/') +KEYCODES_PATH = CONSTANTS_PATH / 'keycodes' +EXTRAS_PATH = KEYCODES_PATH / 'extras' + + +def _find_versions(path, prefix): + ret = [] + for file in path.glob(f'{prefix}_[0-9].[0-9].[0-9].hjson'): + ret.append(file.stem.split('_')[-1]) + + ret.sort(reverse=True) + return ret + + +def _load_fragments(path, prefix, version): + file = path / f'{prefix}_{version}.hjson' + if not file.exists(): + raise ValueError(f'Requested keycode spec ({prefix}:{version}) is invalid!') + + # Load base + spec = json_load(file) + + # Merge in fragments + fragments = path.glob(f'{prefix}_{version}_*.hjson') + for file in fragments: + deep_update(spec, json_load(file)) + + return spec + + +def _search_path(lang=None): + return EXTRAS_PATH if lang else KEYCODES_PATH + + +def _search_prefix(lang=None): + return f'keycodes_{lang}' if lang else 'keycodes' def _validate(spec): @@ -19,26 +54,20 @@ def _validate(spec): raise ValueError(f'Keycode spec contains duplicate keycodes! ({",".join(duplicates)})') -def load_spec(version): +def load_spec(version, lang=None): """Build keycode data from the requested spec file """ if version == 'latest': - version = list_versions()[0] + version = list_versions(lang)[0] - file = CONSTANTS_PATH / f'keycodes_{version}.hjson' - if not file.exists(): - raise ValueError(f'Requested keycode spec ({version}) is invalid!') + path = _search_path(lang) + prefix = _search_prefix(lang) # Load base - spec = json_load(file) - - # Merge in fragments - fragments = CONSTANTS_PATH.glob(f'keycodes_{version}_*.hjson') - for file in fragments: - deep_update(spec, json_load(file)) + spec = _load_fragments(path, prefix, version) # Sort? - spec['keycodes'] = dict(sorted(spec['keycodes'].items())) + spec['keycodes'] = dict(sorted(spec.get('keycodes', {}).items())) # Validate? _validate(spec) @@ -46,12 +75,20 @@ def load_spec(version): return spec -def list_versions(): +def list_versions(lang=None): """Return available versions - sorted newest first """ - ret = [] - for file in CONSTANTS_PATH.glob('keycodes_[0-9].[0-9].[0-9].hjson'): - ret.append(file.stem.split('_')[1]) + path = _search_path(lang) + prefix = _search_prefix(lang) + + return _find_versions(path, prefix) + + +def list_languages(): + """Return available languages + """ + ret = set() + for file in EXTRAS_PATH.glob('keycodes_*_[0-9].[0-9].[0-9].hjson'): + ret.add(file.stem.split('_')[1]) - ret.sort(reverse=True) return ret diff --git a/lib/python/qmk/submodules.py b/lib/python/qmk/submodules.py index 52efa602a0..d37ca5e644 100644 --- a/lib/python/qmk/submodules.py +++ b/lib/python/qmk/submodules.py @@ -40,7 +40,7 @@ def status(): else: raise ValueError('Unknown `git submodule status` sha-1 prefix character: "%s"' % status) - submodule_logs = cli.run(['git', 'submodule', '-q', 'foreach', 'git --no-pager log --pretty=format:"$sm_path%x01%h%x01%ad%x01%s%x0A" --date=iso -n1']) + submodule_logs = cli.run(['git', 'submodule', '-q', 'foreach', 'git --no-pager log --no-show-signature --pretty=format:"$sm_path%x01%h%x01%ad%x01%s%x0A" --date=iso -n1']) for log_line in submodule_logs.stdout.split('\n'): if not log_line: continue diff --git a/platforms/chibios/boards/GENERIC_PROMICRO_RP2040/configs/config.h b/platforms/chibios/boards/GENERIC_PROMICRO_RP2040/configs/config.h index 7fe9b654e1..9209e99e76 100644 --- a/platforms/chibios/boards/GENERIC_PROMICRO_RP2040/configs/config.h +++ b/platforms/chibios/boards/GENERIC_PROMICRO_RP2040/configs/config.h @@ -8,7 +8,7 @@ *========================**/ #if !defined(I2C_DRIVER) -# define I2C_DRIVER I2CD2 +# define I2C_DRIVER I2CD1 #endif #if !defined(I2C1_SDA_PIN) diff --git a/platforms/chibios/boards/PJRC_TEENSY_3_5/board/board.mk b/platforms/chibios/boards/PJRC_TEENSY_3_5/board/board.mk new file mode 100644 index 0000000000..e129836b08 --- /dev/null +++ b/platforms/chibios/boards/PJRC_TEENSY_3_5/board/board.mk @@ -0,0 +1,11 @@ +include $(CHIBIOS_CONTRIB)/os/hal/boards/PJRC_TEENSY_3_5/board.mk + +# List of all the board related files. +BOARDSRC += $(BOARD_PATH)/board/extra.c + +# Required include directories +BOARDINC += $(BOARD_PATH)/board + +# Shared variables +ALLCSRC += $(BOARDSRC) +ALLINC += $(BOARDINC) diff --git a/platforms/chibios/boards/PJRC_TEENSY_3_5/board/extra.c b/platforms/chibios/boards/PJRC_TEENSY_3_5/board/extra.c new file mode 100644 index 0000000000..4940d6d99b --- /dev/null +++ b/platforms/chibios/boards/PJRC_TEENSY_3_5/board/extra.c @@ -0,0 +1,7 @@ +#include <hal.h> + +void restart_usb_driver(USBDriver *usbp) { + // Do nothing. Restarting the USB driver on the Teensy 3.6 breaks it, + // resulting in a keyboard which can wake up a PC from Suspend-to-RAM, but + // does not actually produce any keypresses until you un-plug and re-plug. +} diff --git a/platforms/chibios/boards/PJRC_TEENSY_3_6/board/board.mk b/platforms/chibios/boards/PJRC_TEENSY_3_6/board/board.mk new file mode 100644 index 0000000000..aba195db04 --- /dev/null +++ b/platforms/chibios/boards/PJRC_TEENSY_3_6/board/board.mk @@ -0,0 +1,11 @@ +include $(CHIBIOS_CONTRIB)/os/hal/boards/PJRC_TEENSY_3_6/board.mk + +# List of all the board related files. +BOARDSRC += $(BOARD_PATH)/board/extra.c + +# Required include directories +BOARDINC += $(BOARD_PATH)/board + +# Shared variables +ALLCSRC += $(BOARDSRC) +ALLINC += $(BOARDINC) diff --git a/platforms/chibios/boards/PJRC_TEENSY_3_6/board/extra.c b/platforms/chibios/boards/PJRC_TEENSY_3_6/board/extra.c new file mode 100644 index 0000000000..4940d6d99b --- /dev/null +++ b/platforms/chibios/boards/PJRC_TEENSY_3_6/board/extra.c @@ -0,0 +1,7 @@ +#include <hal.h> + +void restart_usb_driver(USBDriver *usbp) { + // Do nothing. Restarting the USB driver on the Teensy 3.6 breaks it, + // resulting in a keyboard which can wake up a PC from Suspend-to-RAM, but + // does not actually produce any keypresses until you un-plug and re-plug. +} diff --git a/platforms/chibios/boards/QMK_PM2040/configs/config.h b/platforms/chibios/boards/QMK_PM2040/configs/config.h index 8c773f8b19..ec85ae0cf4 100644 --- a/platforms/chibios/boards/QMK_PM2040/configs/config.h +++ b/platforms/chibios/boards/QMK_PM2040/configs/config.h @@ -4,7 +4,7 @@ #pragma once #ifndef I2C_DRIVER -# define I2C_DRIVER I2CD2 +# define I2C_DRIVER I2CD1 #endif #ifndef I2C1_SDA_PIN # define I2C1_SDA_PIN D1 diff --git a/platforms/lv_conf.h b/platforms/lv_conf.h new file mode 100644 index 0000000000..d02d87bfc7 --- /dev/null +++ b/platforms/lv_conf.h @@ -0,0 +1,756 @@ +/** + * @file lv_conf.h + * Configuration file for v8.2.0 + */ + +/* + * Copy this file as `lv_conf.h` + * 1. simply next to the `lvgl` folder + * 2. or any other places and + * - define `LV_CONF_INCLUDE_SIMPLE` + * - add the path as include path + */ + +/* clang-format off */ +#if 1 /*Set it to "1" to enable content*/ + +#ifndef LV_CONF_H +#define LV_CONF_H + +#include <stdint.h> + +/*==================== + COLOR SETTINGS + *====================*/ + +/*Color depth: 1 (1 byte per pixel), 8 (RGB332), 16 (RGB565), 32 (ARGB8888)*/ +#define LV_COLOR_DEPTH 16 + +/*Swap the 2 bytes of RGB565 color. Useful if the display has an 8-bit interface (e.g. SPI)*/ +#define LV_COLOR_16_SWAP 1 + +/*Enable more complex drawing routines to manage screens transparency. + *Can be used if the UI is above another layer, e.g. an OSD menu or video player. + *Requires `LV_COLOR_DEPTH = 32` colors and the screen's `bg_opa` should be set to non LV_OPA_COVER value*/ +#define LV_COLOR_SCREEN_TRANSP 0 + +/* Adjust color mix functions rounding. GPUs might calculate color mix (blending) differently. + * 0: round down, 64: round up from x.75, 128: round up from half, 192: round up from x.25, 254: round up */ +#define LV_COLOR_MIX_ROUND_OFS (LV_COLOR_DEPTH == 32 ? 0: 128) + +/*Images pixels with this color will not be drawn if they are chroma keyed)*/ +#define LV_COLOR_CHROMA_KEY lv_color_hex(0x00ff00) /*pure green*/ + +/*========================= + MEMORY SETTINGS + *=========================*/ + +/*1: use custom malloc/free, 0: use the built-in `lv_mem_alloc()` and `lv_mem_free()`*/ +#ifndef LV_MEM_CUSTOM +#define LV_MEM_CUSTOM 1 +#endif // LV_MEM_CUSTOM +#if LV_MEM_CUSTOM == 0 + /*Size of the memory available for `lv_mem_alloc()` in bytes (>= 2kB)*/ + #define LV_MEM_SIZE (48U * 1024U) /*[bytes]*/ + + /*Set an address for the memory pool instead of allocating it as a normal array. Can be in external SRAM too.*/ + #define LV_MEM_ADR 0 /*0: unused*/ + /*Instead of an address give a memory allocator that will be called to get a memory pool for LVGL. E.g. my_malloc*/ + #if LV_MEM_ADR == 0 + //#define LV_MEM_POOL_INCLUDE your_alloc_library /* Uncomment if using an external allocator*/ + //#define LV_MEM_POOL_ALLOC your_alloc /* Uncomment if using an external allocator*/ + #endif + +#else /*LV_MEM_CUSTOM*/ + #define LV_MEM_CUSTOM_INCLUDE <stdlib.h> /*Header for the dynamic memory function*/ + #define LV_MEM_CUSTOM_ALLOC malloc + #define LV_MEM_CUSTOM_FREE free + #define LV_MEM_CUSTOM_REALLOC realloc +#endif /*LV_MEM_CUSTOM*/ + +/*Number of the intermediate memory buffer used during rendering and other internal processing mechanisms. + *You will see an error log message if there wasn't enough buffers. */ +#define LV_MEM_BUF_MAX_NUM 16 + +/*Use the standard `memcpy` and `memset` instead of LVGL's own functions. (Might or might not be faster).*/ +#define LV_MEMCPY_MEMSET_STD 0 + +/*==================== + HAL SETTINGS + *====================*/ + +/*Default display refresh period. LVG will redraw changed areas with this period time*/ +#define LV_DISP_DEF_REFR_PERIOD 30 /*[ms]*/ + +/*Input device read period in milliseconds*/ +#define LV_INDEV_DEF_READ_PERIOD 30 /*[ms]*/ + +/*Use a custom tick source that tells the elapsed time in milliseconds. + *It removes the need to manually update the tick with `lv_tick_inc()`)*/ +#ifndef LV_TICK_CUSTOM +#define LV_TICK_CUSTOM 0 +#endif // LV_TICK_CUSTOM +#if LV_TICK_CUSTOM + #define LV_TICK_CUSTOM_INCLUDE "Arduino.h" /*Header for the system time function*/ + #define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis()) /*Expression evaluating to current system time in ms*/ +#endif /*LV_TICK_CUSTOM*/ + +/*Default Dot Per Inch. Used to initialize default sizes such as widgets sized, style paddings. + *(Not so important, you can adjust it to modify default sizes and spaces)*/ +#define LV_DPI_DEF 130 /*[px/inch]*/ + +/*======================= + * FEATURE CONFIGURATION + *=======================*/ + +/*------------- + * Drawing + *-----------*/ + +/*Enable complex draw engine. + *Required to draw shadow, gradient, rounded corners, circles, arc, skew lines, image transformations or any masks*/ +#ifndef LV_DRAW_COMPLEX +#define LV_DRAW_COMPLEX 1 +#endif // LV_DRAW_COMPLEX +#if LV_DRAW_COMPLEX != 0 + + /*Allow buffering some shadow calculation. + *LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer, where shadow size is `shadow_width + radius` + *Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/ + #define LV_SHADOW_CACHE_SIZE 0 + + /* Set number of maximally cached circle data. + * The circumference of 1/4 circle are saved for anti-aliasing + * radius * 4 bytes are used per circle (the most often used radiuses are saved) + * 0: to disable caching */ + #define LV_CIRCLE_CACHE_SIZE 4 +#endif /*LV_DRAW_COMPLEX*/ + +/*Default image cache size. Image caching keeps the images opened. + *If only the built-in image formats are used there is no real advantage of caching. (I.e. if no new image decoder is added) + *With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images. + *However the opened images might consume additional RAM. + *0: to disable caching*/ +#define LV_IMG_CACHE_DEF_SIZE 0 + +/*Number of stops allowed per gradient. Increase this to allow more stops. + *This adds (sizeof(lv_color_t) + 1) bytes per additional stop*/ +#define LV_GRADIENT_MAX_STOPS 2 + +/*Default gradient buffer size. + *When LVGL calculates the gradient "maps" it can save them into a cache to avoid calculating them again. + *LV_GRAD_CACHE_DEF_SIZE sets the size of this cache in bytes. + *If the cache is too small the map will be allocated only while it's required for the drawing. + *0 mean no caching.*/ +#define LV_GRAD_CACHE_DEF_SIZE 0 + +/*Allow dithering the gradients (to achieve visual smooth color gradients on limited color depth display) + *LV_DITHER_GRADIENT implies allocating one or two more lines of the object's rendering surface + *The increase in memory consumption is (32 bits * object width) plus 24 bits * object width if using error diffusion */ +#ifndef LV_DITHER_GRADIENT +#define LV_DITHER_GRADIENT 0 +#endif +#if LV_DITHER_GRADIENT + /*Add support for error diffusion dithering. + *Error diffusion dithering gets a much better visual result, but implies more CPU consumption and memory when drawing. + *The increase in memory consumption is (24 bits * object's width)*/ + #define LV_DITHER_ERROR_DIFFUSION 0 +#endif + +/*Maximum buffer size to allocate for rotation. + *Only used if software rotation is enabled in the display driver.*/ +#define LV_DISP_ROT_MAX_BUF (10*1024) + +/*------------- + * GPU + *-----------*/ + +/*Use STM32's DMA2D (aka Chrom Art) GPU*/ +#ifndef LV_USE_GPU_STM32_DMA2D +#define LV_USE_GPU_STM32_DMA2D 0 +#endif // LV_USE_GPU_STM32_DMA2D +#if LV_USE_GPU_STM32_DMA2D + /*Must be defined to include path of CMSIS header of target processor + e.g. "stm32f769xx.h" or "stm32f429xx.h"*/ + #define LV_GPU_DMA2D_CMSIS_INCLUDE +#endif + +/*Use NXP's PXP GPU iMX RTxxx platforms*/ +#ifndef LV_USE_GPU_NXP_PXP +#define LV_USE_GPU_NXP_PXP 0 +#endif // LV_USE_GPU_NXP_PXP +#if LV_USE_GPU_NXP_PXP + /*1: Add default bare metal and FreeRTOS interrupt handling routines for PXP (lv_gpu_nxp_pxp_osa.c) + * and call lv_gpu_nxp_pxp_init() automatically during lv_init(). Note that symbol SDK_OS_FREE_RTOS + * has to be defined in order to use FreeRTOS OSA, otherwise bare-metal implementation is selected. + *0: lv_gpu_nxp_pxp_init() has to be called manually before lv_init() + */ + #define LV_USE_GPU_NXP_PXP_AUTO_INIT 0 +#endif + +/*Use NXP's VG-Lite GPU iMX RTxxx platforms*/ +#define LV_USE_GPU_NXP_VG_LITE 0 + +/*Use SDL renderer API*/ +#ifndef LV_USE_GPU_SDL +#define LV_USE_GPU_SDL 0 +#endif // LV_USE_GPU_SDL +#if LV_USE_GPU_SDL + #define LV_GPU_SDL_INCLUDE_PATH <SDL2/SDL.h> + /*Texture cache size, 8MB by default*/ + #define LV_GPU_SDL_LRU_SIZE (1024 * 1024 * 8) + /*Custom blend mode for mask drawing, disable if you need to link with older SDL2 lib*/ + #define LV_GPU_SDL_CUSTOM_BLEND_MODE (SDL_VERSION_ATLEAST(2, 0, 6)) +#endif + +/*------------- + * Logging + *-----------*/ + +/*Enable the log module*/ +#ifndef LV_USE_LOG +#define LV_USE_LOG 0 +#endif // LV_USE_LOG +#if LV_USE_LOG + + /*How important log should be added: + *LV_LOG_LEVEL_TRACE A lot of logs to give detailed information + *LV_LOG_LEVEL_INFO Log important events + *LV_LOG_LEVEL_WARN Log if something unwanted happened but didn't cause a problem + *LV_LOG_LEVEL_ERROR Only critical issue, when the system may fail + *LV_LOG_LEVEL_USER Only logs added by the user + *LV_LOG_LEVEL_NONE Do not log anything*/ + #define LV_LOG_LEVEL LV_LOG_LEVEL_WARN + + /*1: Print the log with 'printf'; + *0: User need to register a callback with `lv_log_register_print_cb()`*/ + #define LV_LOG_PRINTF 0 + + /*Enable/disable LV_LOG_TRACE in modules that produces a huge number of logs*/ + #define LV_LOG_TRACE_MEM 1 + #define LV_LOG_TRACE_TIMER 1 + #define LV_LOG_TRACE_INDEV 1 + #define LV_LOG_TRACE_DISP_REFR 1 + #define LV_LOG_TRACE_EVENT 1 + #define LV_LOG_TRACE_OBJ_CREATE 1 + #define LV_LOG_TRACE_LAYOUT 1 + #define LV_LOG_TRACE_ANIM 1 + +#endif /*LV_USE_LOG*/ + +/*------------- + * Asserts + *-----------*/ + +/*Enable asserts if an operation is failed or an invalid data is found. + *If LV_USE_LOG is enabled an error message will be printed on failure*/ +#define LV_USE_ASSERT_NULL 1 /*Check if the parameter is NULL. (Very fast, recommended)*/ +#define LV_USE_ASSERT_MALLOC 1 /*Checks is the memory is successfully allocated or no. (Very fast, recommended)*/ +#define LV_USE_ASSERT_STYLE 0 /*Check if the styles are properly initialized. (Very fast, recommended)*/ +#define LV_USE_ASSERT_MEM_INTEGRITY 0 /*Check the integrity of `lv_mem` after critical operations. (Slow)*/ +#define LV_USE_ASSERT_OBJ 0 /*Check the object's type and existence (e.g. not deleted). (Slow)*/ + +/*Add a custom handler when assert happens e.g. to restart the MCU*/ +#define LV_ASSERT_HANDLER_INCLUDE <stdint.h> +#define LV_ASSERT_HANDLER while(1); /*Halt by default*/ + +/*------------- + * Others + *-----------*/ + +/*1: Show CPU usage and FPS count*/ +#ifndef LV_USE_PERF_MONITOR +#define LV_USE_PERF_MONITOR 0 +#endif // LV_USE_PERF_MONITOR +#if LV_USE_PERF_MONITOR + #define LV_USE_PERF_MONITOR_POS LV_ALIGN_BOTTOM_RIGHT +#endif + +/*1: Show the used memory and the memory fragmentation + * Requires LV_MEM_CUSTOM = 0*/ +#ifndef LV_USE_MEM_MONITOR +#define LV_USE_MEM_MONITOR 0 +#endif // LV_USE_MEM_MONITOR +#if LV_USE_MEM_MONITOR + #define LV_USE_MEM_MONITOR_POS LV_ALIGN_BOTTOM_LEFT +#endif + +/*1: Draw random colored rectangles over the redrawn areas*/ +#define LV_USE_REFR_DEBUG 0 + +/*Change the built in (v)snprintf functions*/ +#ifndef LV_SPRINTF_CUSTOM +#define LV_SPRINTF_CUSTOM 1 +#endif // LV_SPRINTF_CUSTOM +#if LV_SPRINTF_CUSTOM + #define LV_SPRINTF_INCLUDE <stdio.h> + #define lv_snprintf snprintf + #define lv_vsnprintf vsnprintf +#else /*LV_SPRINTF_CUSTOM*/ + #define LV_SPRINTF_USE_FLOAT 0 +#endif /*LV_SPRINTF_CUSTOM*/ + +#define LV_USE_USER_DATA 1 + +/*Garbage Collector settings + *Used if lvgl is bound to higher level language and the memory is managed by that language*/ +#ifndef LV_ENABLE_GC +#define LV_ENABLE_GC 0 +#endif // LV_ENABLE_GC +#if LV_ENABLE_GC != 0 + #define LV_GC_INCLUDE "gc.h" /*Include Garbage Collector related things*/ +#endif /*LV_ENABLE_GC*/ + +/*===================== + * COMPILER SETTINGS + *====================*/ + +/*For big endian systems set to 1*/ +#define LV_BIG_ENDIAN_SYSTEM 0 + +/*Define a custom attribute to `lv_tick_inc` function*/ +#define LV_ATTRIBUTE_TICK_INC + +/*Define a custom attribute to `lv_timer_handler` function*/ +#define LV_ATTRIBUTE_TIMER_HANDLER + +/*Define a custom attribute to `lv_disp_flush_ready` function*/ +#define LV_ATTRIBUTE_FLUSH_READY + +/*Required alignment size for buffers*/ +#define LV_ATTRIBUTE_MEM_ALIGN_SIZE 1 + +/*Will be added where memories needs to be aligned (with -Os data might not be aligned to boundary by default). + * E.g. __attribute__((aligned(4)))*/ +#define LV_ATTRIBUTE_MEM_ALIGN + +/*Attribute to mark large constant arrays for example font's bitmaps*/ +#define LV_ATTRIBUTE_LARGE_CONST + +/*Compiler prefix for a big array declaration in RAM*/ +#define LV_ATTRIBUTE_LARGE_RAM_ARRAY + +/*Place performance critical functions into a faster memory (e.g RAM)*/ +#define LV_ATTRIBUTE_FAST_MEM + +/*Prefix variables that are used in GPU accelerated operations, often these need to be placed in RAM sections that are DMA accessible*/ +#define LV_ATTRIBUTE_DMA + +/*Export integer constant to binding. This macro is used with constants in the form of LV_<CONST> that + *should also appear on LVGL binding API such as Micropython.*/ +#define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning /*The default value just prevents GCC warning*/ + +/*Extend the default -32k..32k coordinate range to -4M..4M by using int32_t for coordinates instead of int16_t*/ +#define LV_USE_LARGE_COORD 0 + +/*================== + * FONT USAGE + *===================*/ + +/*Montserrat fonts with ASCII range and some symbols using bpp = 4 + *https://fonts.google.com/specimen/Montserrat*/ +#define LV_FONT_MONTSERRAT_8 0 +#define LV_FONT_MONTSERRAT_10 0 +#define LV_FONT_MONTSERRAT_12 0 +#define LV_FONT_MONTSERRAT_14 1 +#define LV_FONT_MONTSERRAT_16 0 +#define LV_FONT_MONTSERRAT_18 0 +#define LV_FONT_MONTSERRAT_20 0 +#define LV_FONT_MONTSERRAT_22 0 +#define LV_FONT_MONTSERRAT_24 0 +#define LV_FONT_MONTSERRAT_26 0 +#define LV_FONT_MONTSERRAT_28 0 +#define LV_FONT_MONTSERRAT_30 0 +#define LV_FONT_MONTSERRAT_32 0 +#define LV_FONT_MONTSERRAT_34 0 +#define LV_FONT_MONTSERRAT_36 0 +#define LV_FONT_MONTSERRAT_38 0 +#define LV_FONT_MONTSERRAT_40 0 +#define LV_FONT_MONTSERRAT_42 0 +#define LV_FONT_MONTSERRAT_44 0 +#define LV_FONT_MONTSERRAT_46 0 +#define LV_FONT_MONTSERRAT_48 0 + +/*Demonstrate special features*/ +#define LV_FONT_MONTSERRAT_12_SUBPX 0 +#define LV_FONT_MONTSERRAT_28_COMPRESSED 0 /*bpp = 3*/ +#define LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0 /*Hebrew, Arabic, Persian letters and all their forms*/ +#define LV_FONT_SIMSUN_16_CJK 0 /*1000 most common CJK radicals*/ + +/*Pixel perfect monospace fonts*/ +#define LV_FONT_UNSCII_8 0 +#define LV_FONT_UNSCII_16 0 + +/*Optionally declare custom fonts here. + *You can use these fonts as default font too and they will be available globally. + *E.g. #define LV_FONT_CUSTOM_DECLARE LV_FONT_DECLARE(my_font_1) LV_FONT_DECLARE(my_font_2)*/ +#define LV_FONT_CUSTOM_DECLARE + +/*Always set a default font*/ +#define LV_FONT_DEFAULT &lv_font_montserrat_14 + +/*Enable handling large font and/or fonts with a lot of characters. + *The limit depends on the font size, font face and bpp. + *Compiler error will be triggered if a font needs it.*/ +#define LV_FONT_FMT_TXT_LARGE 0 + +/*Enables/disables support for compressed fonts.*/ +#define LV_USE_FONT_COMPRESSED 0 + +/*Enable subpixel rendering*/ +#ifndef LV_USE_FONT_SUBPX +#define LV_USE_FONT_SUBPX 0 +#endif // LV_USE_FONT_SUBPX +#if LV_USE_FONT_SUBPX + /*Set the pixel order of the display. Physical order of RGB channels. Doesn't matter with "normal" fonts.*/ + #define LV_FONT_SUBPX_BGR 0 /*0: RGB; 1:BGR order*/ +#endif + +/*================= + * TEXT SETTINGS + *=================*/ + +/** + * Select a character encoding for strings. + * Your IDE or editor should have the same character encoding + * - LV_TXT_ENC_UTF8 + * - LV_TXT_ENC_ASCII + */ +#define LV_TXT_ENC LV_TXT_ENC_UTF8 + +/*Can break (wrap) texts on these chars*/ +#define LV_TXT_BREAK_CHARS " ,.;:-_" + +/*If a word is at least this long, will break wherever "prettiest" + *To disable, set to a value <= 0*/ +#define LV_TXT_LINE_BREAK_LONG_LEN 0 + +/*Minimum number of characters in a long word to put on a line before a break. + *Depends on LV_TXT_LINE_BREAK_LONG_LEN.*/ +#define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN 3 + +/*Minimum number of characters in a long word to put on a line after a break. + *Depends on LV_TXT_LINE_BREAK_LONG_LEN.*/ +#define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 3 + +/*The control character to use for signalling text recoloring.*/ +#define LV_TXT_COLOR_CMD "#" + +/*Support bidirectional texts. Allows mixing Left-to-Right and Right-to-Left texts. + *The direction will be processed according to the Unicode Bidirectional Algorithm: + *https://www.w3.org/International/articles/inline-bidi-markup/uba-basics*/ +#ifndef LV_USE_BIDI +#define LV_USE_BIDI 0 +#endif // LV_USE_BIDI +#if LV_USE_BIDI + /*Set the default direction. Supported values: + *`LV_BASE_DIR_LTR` Left-to-Right + *`LV_BASE_DIR_RTL` Right-to-Left + *`LV_BASE_DIR_AUTO` detect texts base direction*/ + #define LV_BIDI_BASE_DIR_DEF LV_BASE_DIR_AUTO +#endif + +/*Enable Arabic/Persian processing + *In these languages characters should be replaced with an other form based on their position in the text*/ +#define LV_USE_ARABIC_PERSIAN_CHARS 0 + +/*================== + * WIDGET USAGE + *================*/ + +/*Documentation of the widgets: https://docs.lvgl.io/latest/en/html/widgets/index.html*/ + +#define LV_USE_ARC 1 + +#define LV_USE_ANIMIMG 1 + +#define LV_USE_BAR 1 + +#define LV_USE_BTN 1 + +#define LV_USE_BTNMATRIX 1 + +#define LV_USE_CANVAS 1 + +#define LV_USE_CHECKBOX 1 + +#define LV_USE_DROPDOWN 1 /*Requires: lv_label*/ + +#define LV_USE_IMG 1 /*Requires: lv_label*/ + +#ifndef LV_USE_LABEL +#define LV_USE_LABEL 1 +#endif // LV_USE_LABEL +#if LV_USE_LABEL + #define LV_LABEL_TEXT_SELECTION 1 /*Enable selecting text of the label*/ + #define LV_LABEL_LONG_TXT_HINT 1 /*Store some extra info in labels to speed up drawing of very long texts*/ +#endif + +#define LV_USE_LINE 1 + +#ifndef LV_USE_ROLLER +#define LV_USE_ROLLER 1 /*Requires: lv_label*/ +#endif // LV_USE_ROLLER +#if LV_USE_ROLLER + #define LV_ROLLER_INF_PAGES 7 /*Number of extra "pages" when the roller is infinite*/ +#endif + +#define LV_USE_SLIDER 1 /*Requires: lv_bar*/ + +#define LV_USE_SWITCH 1 + +#ifndef LV_USE_TEXTAREA +#define LV_USE_TEXTAREA 1 /*Requires: lv_label*/ +#endif // LV_USE_TEXTAREA +#if LV_USE_TEXTAREA != 0 + #define LV_TEXTAREA_DEF_PWD_SHOW_TIME 1500 /*ms*/ +#endif + +#define LV_USE_TABLE 1 + +/*================== + * EXTRA COMPONENTS + *==================*/ + +/*----------- + * Widgets + *----------*/ +#ifndef LV_USE_CALENDAR +#define LV_USE_CALENDAR 1 +#endif // LV_USE_CALENDAR +#if LV_USE_CALENDAR + #define LV_CALENDAR_WEEK_STARTS_MONDAY 0 + #if LV_CALENDAR_WEEK_STARTS_MONDAY + #define LV_CALENDAR_DEFAULT_DAY_NAMES {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"} + #else + #define LV_CALENDAR_DEFAULT_DAY_NAMES {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"} + #endif + + #define LV_CALENDAR_DEFAULT_MONTH_NAMES {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"} + #define LV_USE_CALENDAR_HEADER_ARROW 1 + #define LV_USE_CALENDAR_HEADER_DROPDOWN 1 +#endif /*LV_USE_CALENDAR*/ + +#define LV_USE_CHART 1 + +#define LV_USE_COLORWHEEL 1 + +#define LV_USE_IMGBTN 1 + +#define LV_USE_KEYBOARD 1 + +#define LV_USE_LED 1 + +#define LV_USE_LIST 1 + +#define LV_USE_MENU 1 + +#define LV_USE_METER 1 + +#define LV_USE_MSGBOX 1 + +#define LV_USE_SPINBOX 1 + +#define LV_USE_SPINNER 1 + +#define LV_USE_TABVIEW 1 + +#define LV_USE_TILEVIEW 1 + +#define LV_USE_WIN 1 + +#ifndef LV_USE_SPAN +#define LV_USE_SPAN 1 +#endif // LV_USE_SPAN +#if LV_USE_SPAN + /*A line text can contain maximum num of span descriptor */ + #define LV_SPAN_SNIPPET_STACK_SIZE 64 +#endif + +/*----------- + * Themes + *----------*/ + +/*A simple, impressive and very complete theme*/ +#ifndef LV_USE_THEME_DEFAULT +#define LV_USE_THEME_DEFAULT 1 +#endif // LV_USE_THEME_DEFAULT +#if LV_USE_THEME_DEFAULT + + /*0: Light mode; 1: Dark mode*/ + #define LV_THEME_DEFAULT_DARK 0 + + /*1: Enable grow on press*/ + #define LV_THEME_DEFAULT_GROW 1 + + /*Default transition time in [ms]*/ + #define LV_THEME_DEFAULT_TRANSITION_TIME 80 +#endif /*LV_USE_THEME_DEFAULT*/ + +/*A very simple theme that is a good starting point for a custom theme*/ +#define LV_USE_THEME_BASIC 1 + +/*A theme designed for monochrome displays*/ +#define LV_USE_THEME_MONO 1 + +/*----------- + * Layouts + *----------*/ + +/*A layout similar to Flexbox in CSS.*/ +#define LV_USE_FLEX 1 + +/*A layout similar to Grid in CSS.*/ +#define LV_USE_GRID 1 + +/*--------------------- + * 3rd party libraries + *--------------------*/ + +/*File system interfaces for common APIs */ + +/*API for fopen, fread, etc*/ +#ifndef LV_USE_FS_STDIO +#define LV_USE_FS_STDIO 0 +#endif // LV_USE_FS_STDIO +#if LV_USE_FS_STDIO + #define LV_FS_STDIO_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/ + #define LV_FS_STDIO_PATH "" /*Set the working directory. File/directory paths will be appended to it.*/ + #define LV_FS_STDIO_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/ +#endif + +/*API for open, read, etc*/ +#ifndef LV_USE_FS_POSIX +#define LV_USE_FS_POSIX 0 +#endif // LV_USE_FS_POSIX +#if LV_USE_FS_POSIX + #define LV_FS_POSIX_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/ + #define LV_FS_POSIX_PATH "" /*Set the working directory. File/directory paths will be appended to it.*/ + #define LV_FS_POSIX_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/ +#endif + +/*API for CreateFile, ReadFile, etc*/ +#ifndef LV_USE_FS_WIN32 +#define LV_USE_FS_WIN32 0 +#endif // LV_USE_FS_WIN32 +#if LV_USE_FS_WIN32 + #define LV_FS_WIN32_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/ + #define LV_FS_WIN32_PATH "" /*Set the working directory. File/directory paths will be appended to it.*/ + #define LV_FS_WIN32_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/ +#endif + +/*API for FATFS (needs to be added separately). Uses f_open, f_read, etc*/ +#ifndef LV_USE_FS_FATFS +#define LV_USE_FS_FATFS 0 +#endif // LV_USE_FS_FATFS +#if LV_USE_FS_FATFS + #define LV_FS_FATFS_LETTER '\0' /*Set an upper cased letter on which the drive will accessible (e.g. 'A')*/ + #define LV_FS_FATFS_CACHE_SIZE 0 /*>0 to cache this number of bytes in lv_fs_read()*/ +#endif + +/*PNG decoder library*/ +#define LV_USE_PNG 0 + +/*BMP decoder library*/ +#define LV_USE_BMP 0 + +/* JPG + split JPG decoder library. + * Split JPG is a custom format optimized for embedded systems. */ +#define LV_USE_SJPG 0 + +/*GIF decoder library*/ +#define LV_USE_GIF 0 + +/*QR code library*/ +#define LV_USE_QRCODE 0 + +/*FreeType library*/ +#ifndef LV_USE_FREETYPE +#define LV_USE_FREETYPE 0 +#endif // LV_USE_FREETYPE +#if LV_USE_FREETYPE + /*Memory used by FreeType to cache characters [bytes] (-1: no caching)*/ + #define LV_FREETYPE_CACHE_SIZE (16 * 1024) + #if LV_FREETYPE_CACHE_SIZE >= 0 + /* 1: bitmap cache use the sbit cache, 0:bitmap cache use the image cache. */ + /* sbit cache:it is much more memory efficient for small bitmaps(font size < 256) */ + /* if font size >= 256, must be configured as image cache */ + #define LV_FREETYPE_SBIT_CACHE 0 + /* Maximum number of opened FT_Face/FT_Size objects managed by this cache instance. */ + /* (0:use system defaults) */ + #define LV_FREETYPE_CACHE_FT_FACES 0 + #define LV_FREETYPE_CACHE_FT_SIZES 0 + #endif +#endif + +/*Rlottie library*/ +#define LV_USE_RLOTTIE 0 + +/*FFmpeg library for image decoding and playing videos + *Supports all major image formats so do not enable other image decoder with it*/ +#ifndef LV_USE_FFMPEG +#define LV_USE_FFMPEG 0 +#endif // LV_USE_FFMPEG +#if LV_USE_FFMPEG + /*Dump input information to stderr*/ + #define LV_FFMPEG_AV_DUMP_FORMAT 0 +#endif + +/*----------- + * Others + *----------*/ + +/*1: Enable API to take snapshot for object*/ +#define LV_USE_SNAPSHOT 0 + +/*1: Enable Monkey test*/ +#define LV_USE_MONKEY 0 + +/*1: Enable grid navigation*/ +#define LV_USE_GRIDNAV 0 + +/*================== +* EXAMPLES +*==================*/ + +/*Enable the examples to be built with the library*/ +#define LV_BUILD_EXAMPLES 1 + +/*=================== + * DEMO USAGE + ====================*/ + +/*Show some widget. It might be required to increase `LV_MEM_SIZE` */ +#ifndef LV_USE_DEMO_WIDGETS +#define LV_USE_DEMO_WIDGETS 0 +#endif // LV_USE_DEMO_WIDGETS +#if LV_USE_DEMO_WIDGETS +#define LV_DEMO_WIDGETS_SLIDESHOW 0 +#endif + +/*Demonstrate the usage of encoder and keyboard*/ +#define LV_USE_DEMO_KEYPAD_AND_ENCODER 0 + +/*Benchmark your system*/ +#define LV_USE_DEMO_BENCHMARK 0 + +/*Stress test for LVGL*/ +#define LV_USE_DEMO_STRESS 0 + +/*Music player demo*/ +#ifndef LV_USE_DEMO_MUSIC +#define LV_USE_DEMO_MUSIC 0 +#endif // LV_USE_DEMO_MUSIC +#if LV_USE_DEMO_MUSIC +# define LV_DEMO_MUSIC_SQUARE 0 +# define LV_DEMO_MUSIC_LANDSCAPE 0 +# define LV_DEMO_MUSIC_ROUND 0 +# define LV_DEMO_MUSIC_LARGE 0 +# define LV_DEMO_MUSIC_AUTO_PLAY 0 +#endif + +/*--END OF LV_CONF_H--*/ + +#endif /*LV_CONF_H*/ + +#endif /*End of "Content enable"*/ diff --git a/platforms/test/timer.c b/platforms/test/timer.c index e0acd1b16d..320cc57782 100644 --- a/platforms/test/timer.c +++ b/platforms/test/timer.c @@ -15,8 +15,9 @@ */ #include "timer.h" +#include <stdatomic.h> -static uint32_t current_time = 0; +static atomic_uint_least32_t current_time = 0; void timer_init(void) { current_time = 0; diff --git a/quantum/action.c b/quantum/action.c index abf9834d2f..f6fbb999c8 100644 --- a/quantum/action.c +++ b/quantum/action.c @@ -16,12 +16,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <limits.h> -#ifdef DEBUG_ACTION -# include "debug.h" -#else -# include "nodebug.h" -#endif - #include "host.h" #include "keycode.h" #include "keyboard.h" @@ -55,8 +49,8 @@ int retro_tapping_counter = 0; # include "process_auto_shift.h" #endif -#ifdef IGNORE_MOD_TAP_INTERRUPT_PER_KEY -__attribute__((weak)) bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { +#ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY +__attribute__((weak)) bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) { return false; } #endif @@ -76,11 +70,11 @@ __attribute__((weak)) bool pre_process_record_quantum(keyrecord_t *record) { * FIXME: Needs documentation. */ void action_exec(keyevent_t event) { - if (!IS_NOEVENT(event)) { - dprint("\n---- action_exec: start -----\n"); - dprint("EVENT: "); + if (IS_EVENT(event)) { + ac_dprintf("\n---- action_exec: start -----\n"); + ac_dprintf("EVENT: "); debug_event(event); - dprintln(); + ac_dprintf("\n"); #if defined(RETRO_TAPPING) || defined(RETRO_TAPPING_PER_KEY) || (defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT)) retro_tapping_counter++; #endif @@ -93,7 +87,7 @@ void action_exec(keyevent_t event) { #ifdef SWAP_HANDS_ENABLE // Swap hands handles both keys and encoders, if ENCODER_MAP_ENABLE is defined. - if (!IS_NOEVENT(event)) { + if (IS_EVENT(event)) { process_hand_swap(&event); } #endif @@ -131,8 +125,8 @@ void action_exec(keyevent_t event) { if (IS_NOEVENT(record.event) || pre_process_record_quantum(&record)) { process_record(&record); } - if (!IS_NOEVENT(record.event)) { - dprint("processed: "); + if (IS_EVENT(record.event)) { + ac_dprintf("processed: "); debug_record(record); dprintln(); } @@ -280,15 +274,15 @@ void process_record_handler(keyrecord_t *record) { #else action_t action = store_or_get_action(record->event.pressed, record->event.key); #endif - dprint("ACTION: "); + ac_dprintf("ACTION: "); debug_action(action); #ifndef NO_ACTION_LAYER - dprint(" layer_state: "); + ac_dprintf(" layer_state: "); layer_debug(); - dprint(" default_layer_state: "); + ac_dprintf(" default_layer_state: "); default_layer_debug(); #endif - dprintln(); + ac_dprintf("\n"); process_action(record, action); } @@ -432,14 +426,14 @@ void process_action(keyrecord_t *record, action_t action) { } else { if (event.pressed) { if (tap_count == 0) { - dprint("MODS_TAP: Oneshot: 0\n"); + ac_dprintf("MODS_TAP: Oneshot: 0\n"); register_mods(mods | get_oneshot_mods()); } else if (tap_count == 1) { - dprint("MODS_TAP: Oneshot: start\n"); + ac_dprintf("MODS_TAP: Oneshot: start\n"); set_oneshot_mods(mods | get_oneshot_mods()); # if defined(ONESHOT_TAP_TOGGLE) && ONESHOT_TAP_TOGGLE > 1 } else if (tap_count == ONESHOT_TAP_TOGGLE) { - dprint("MODS_TAP: Toggling oneshot"); + ac_dprintf("MODS_TAP: Toggling oneshot"); register_mods(mods); clear_oneshot_mods(); set_oneshot_locked_mods(mods | get_oneshot_locked_mods()); @@ -484,29 +478,29 @@ void process_action(keyrecord_t *record, action_t action) { default: if (event.pressed) { if (tap_count > 0) { -# if !defined(IGNORE_MOD_TAP_INTERRUPT) || defined(IGNORE_MOD_TAP_INTERRUPT_PER_KEY) +# if !defined(IGNORE_MOD_TAP_INTERRUPT) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) if ( -# ifdef IGNORE_MOD_TAP_INTERRUPT_PER_KEY - !get_ignore_mod_tap_interrupt(get_event_keycode(record->event, false), record) && +# ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY + get_hold_on_other_key_press(get_event_keycode(record->event, false), record) && # endif record->tap.interrupted) { - dprint("mods_tap: tap: cancel: add_mods\n"); + ac_dprintf("mods_tap: tap: cancel: add_mods\n"); // ad hoc: set 0 to cancel tap record->tap.count = 0; register_mods(mods); } else # endif { - dprint("MODS_TAP: Tap: register_code\n"); + ac_dprintf("MODS_TAP: Tap: register_code\n"); register_code(action.key.code); } } else { - dprint("MODS_TAP: No tap: add_mods\n"); + ac_dprintf("MODS_TAP: No tap: add_mods\n"); register_mods(mods); } } else { if (tap_count > 0) { - dprint("MODS_TAP: Tap: unregister_code\n"); + ac_dprintf("MODS_TAP: Tap: unregister_code\n"); if (action.layer_tap.code == KC_CAPS_LOCK) { wait_ms(TAP_HOLD_CAPS_DELAY); } else { @@ -514,7 +508,7 @@ void process_action(keyrecord_t *record, action_t action) { } unregister_code(action.key.code); } else { - dprint("MODS_TAP: No tap: add_mods\n"); + ac_dprintf("MODS_TAP: No tap: add_mods\n"); unregister_mods(mods); } } @@ -666,15 +660,15 @@ void process_action(keyrecord_t *record, action_t action) { /* tap key */ if (event.pressed) { if (tap_count > 0) { - dprint("KEYMAP_TAP_KEY: Tap: register_code\n"); + ac_dprintf("KEYMAP_TAP_KEY: Tap: register_code\n"); register_code(action.layer_tap.code); } else { - dprint("KEYMAP_TAP_KEY: No tap: On on press\n"); + ac_dprintf("KEYMAP_TAP_KEY: No tap: On on press\n"); layer_on(action.layer_tap.val); } } else { if (tap_count > 0) { - dprint("KEYMAP_TAP_KEY: Tap: unregister_code\n"); + ac_dprintf("KEYMAP_TAP_KEY: Tap: unregister_code\n"); if (action.layer_tap.code == KC_CAPS_LOCK) { wait_ms(TAP_HOLD_CAPS_DELAY); } else { @@ -682,7 +676,7 @@ void process_action(keyrecord_t *record, action_t action) { } unregister_code(action.layer_tap.code); } else { - dprint("KEYMAP_TAP_KEY: No tap: Off on release\n"); + ac_dprintf("KEYMAP_TAP_KEY: No tap: Off on release\n"); layer_off(action.layer_tap.val); } } @@ -882,32 +876,15 @@ __attribute__((weak)) void register_code(uint8_t code) { // TODO: should push command_proc out of this block? if (command_proc(code)) return; -#ifndef NO_ACTION_ONESHOT -/* TODO: remove - if (oneshot_state.mods && !oneshot_state.disabled) { - uint8_t tmp_mods = get_mods(); - add_mods(oneshot_state.mods); - - add_key(code); - send_keyboard_report(); - - set_mods(tmp_mods); - send_keyboard_report(); - oneshot_cancel(); - } else -*/ -#endif - { - // Force a new key press if the key is already pressed - // without this, keys with the same keycode, but different - // modifiers will be reported incorrectly, see issue #1708 - if (is_key_pressed(keyboard_report, code)) { - del_key(code); - send_keyboard_report(); - } - add_key(code); + // Force a new key press if the key is already pressed + // without this, keys with the same keycode, but different + // modifiers will be reported incorrectly, see issue #1708 + if (is_key_pressed(keyboard_report, code)) { + del_key(code); send_keyboard_report(); } + add_key(code); + send_keyboard_report(); } else if IS_MOD (code) { add_mods(MOD_BIT(code)); send_keyboard_report(); @@ -1139,7 +1116,7 @@ bool is_tap_action(action_t action) { * FIXME: Needs documentation. */ void debug_event(keyevent_t event) { - dprintf("%04X%c(%u)", (event.key.row << 8 | event.key.col), (event.pressed ? 'd' : 'u'), event.time); + ac_dprintf("%04X%c(%u)", (event.key.row << 8 | event.key.col), (event.pressed ? 'd' : 'u'), event.time); } /** \brief Debug print (FIXME: Needs better description) * @@ -1148,7 +1125,7 @@ void debug_event(keyevent_t event) { void debug_record(keyrecord_t record) { debug_event(record.event); #ifndef NO_ACTION_TAPPING - dprintf(":%u%c", record.tap.count, (record.tap.interrupted ? '-' : ' ')); + ac_dprintf(":%u%c", record.tap.count, (record.tap.interrupted ? '-' : ' ')); #endif } @@ -1159,41 +1136,41 @@ void debug_record(keyrecord_t record) { void debug_action(action_t action) { switch (action.kind.id) { case ACT_LMODS: - dprint("ACT_LMODS"); + ac_dprintf("ACT_LMODS"); break; case ACT_RMODS: - dprint("ACT_RMODS"); + ac_dprintf("ACT_RMODS"); break; case ACT_LMODS_TAP: - dprint("ACT_LMODS_TAP"); + ac_dprintf("ACT_LMODS_TAP"); break; case ACT_RMODS_TAP: - dprint("ACT_RMODS_TAP"); + ac_dprintf("ACT_RMODS_TAP"); break; case ACT_USAGE: - dprint("ACT_USAGE"); + ac_dprintf("ACT_USAGE"); break; case ACT_MOUSEKEY: - dprint("ACT_MOUSEKEY"); + ac_dprintf("ACT_MOUSEKEY"); break; case ACT_LAYER: - dprint("ACT_LAYER"); + ac_dprintf("ACT_LAYER"); break; case ACT_LAYER_MODS: - dprint("ACT_LAYER_MODS"); + ac_dprintf("ACT_LAYER_MODS"); break; case ACT_LAYER_TAP: - dprint("ACT_LAYER_TAP"); + ac_dprintf("ACT_LAYER_TAP"); break; case ACT_LAYER_TAP_EXT: - dprint("ACT_LAYER_TAP_EXT"); + ac_dprintf("ACT_LAYER_TAP_EXT"); break; case ACT_SWAP_HANDS: - dprint("ACT_SWAP_HANDS"); + ac_dprintf("ACT_SWAP_HANDS"); break; default: - dprint("UNKNOWN"); + ac_dprintf("UNKNOWN"); break; } - dprintf("[%X:%02X]", action.kind.param >> 8, action.kind.param & 0xff); + ac_dprintf("[%X:%02X]", action.kind.param >> 8, action.kind.param & 0xff); } diff --git a/quantum/action.h b/quantum/action.h index 2bc46429b2..e4d28ba947 100644 --- a/quantum/action.h +++ b/quantum/action.h @@ -112,7 +112,19 @@ bool is_tap_action(action_t action); void process_record_tap_hint(keyrecord_t *record); #endif -/* debug */ +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Helpers + +#ifdef ACTION_DEBUG +# include "debug.h" +# include "print.h" +# define ac_dprintf(...) dprintf(__VA_ARGS__) +#else +# define ac_dprintf(...) \ + do { \ + } while (0) +#endif + void debug_event(keyevent_t event); void debug_record(keyrecord_t record); void debug_action(action_t action); diff --git a/quantum/action_layer.c b/quantum/action_layer.c index 31cfdfe13a..74e8137920 100644 --- a/quantum/action_layer.c +++ b/quantum/action_layer.c @@ -1,12 +1,6 @@ #include <limits.h> #include <stdint.h> -#ifdef DEBUG_ACTION -# include "debug.h" -#else -# include "nodebug.h" -#endif - #include "keyboard.h" #include "keymap.h" #include "action.h" @@ -39,12 +33,12 @@ __attribute__((weak)) layer_state_t default_layer_state_set_kb(layer_state_t sta */ static void default_layer_state_set(layer_state_t state) { state = default_layer_state_set_kb(state); - debug("default_layer_state: "); + ac_dprintf("default_layer_state: "); default_layer_debug(); - debug(" to "); + ac_dprintf(" to "); default_layer_state = state; default_layer_debug(); - debug("\n"); + ac_dprintf("\n"); #if defined(STRICT_LAYER_RELEASE) clear_keyboard_but_mods(); // To avoid stuck keys #elif defined(SEMI_STRICT_LAYER_RELEASE) @@ -57,7 +51,7 @@ static void default_layer_state_set(layer_state_t state) { * Print out the hex value of the 32-bit default layer state, as well as the value of the highest bit. */ void default_layer_debug(void) { - dprintf("%08lX(%u)", default_layer_state, get_highest_layer(default_layer_state)); + ac_dprintf("%08hX(%u)", default_layer_state, get_highest_layer(default_layer_state)); } /** \brief Default Layer Set @@ -119,12 +113,12 @@ __attribute__((weak)) layer_state_t layer_state_set_kb(layer_state_t state) { */ void layer_state_set(layer_state_t state) { state = layer_state_set_kb(state); - dprint("layer_state: "); + ac_dprintf("layer_state: "); layer_debug(); - dprint(" to "); + ac_dprintf(" to "); layer_state = state; layer_debug(); - dprintln(); + ac_dprintf("\n"); # if defined(STRICT_LAYER_RELEASE) clear_keyboard_but_mods(); // To avoid stuck keys # elif defined(SEMI_STRICT_LAYER_RELEASE) @@ -218,7 +212,7 @@ void layer_xor(layer_state_t state) { * Print out the hex value of the 32-bit layer state, as well as the value of the highest bit. */ void layer_debug(void) { - dprintf("%08lX(%u)", layer_state, get_highest_layer(layer_state)); + ac_dprintf("%08hX(%u)", layer_state, get_highest_layer(layer_state)); } #endif diff --git a/quantum/action_tapping.c b/quantum/action_tapping.c index df3317ac05..821265d399 100644 --- a/quantum/action_tapping.c +++ b/quantum/action_tapping.c @@ -1,12 +1,6 @@ #include <stdint.h> #include <stdbool.h> -#ifdef DEBUG_ACTION -# include "debug.h" -#else -# include "nodebug.h" -#endif - #include "action.h" #include "action_layer.h" #include "action_tapping.h" @@ -15,7 +9,15 @@ #ifndef NO_ACTION_TAPPING -# define IS_TAPPING() !IS_NOEVENT(tapping_key.event) +# if defined(IGNORE_MOD_TAP_INTERRUPT_PER_KEY) +# error "IGNORE_MOD_TAP_INTERRUPT_PER_KEY has been removed; the code needs to be ported to use HOLD_ON_OTHER_KEY_PRESS_PER_KEY instead." +# elif !defined(IGNORE_MOD_TAP_INTERRUPT) +# if !defined(PERMISSIVE_HOLD) && !defined(PERMISSIVE_HOLD_PER_KEY) && !defined(HOLD_ON_OTHER_KEY_PRESS) && !defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) +# pragma message "The default behavior of mod-taps will change to mimic IGNORE_MOD_TAP_INTERRUPT in the future.\nIf you wish to keep the old default behavior of mod-taps, please use HOLD_ON_OTHER_KEY_PRESS." +# endif +# endif + +# define IS_TAPPING() IS_EVENT(tapping_key.event) # define IS_TAPPING_PRESSED() (IS_TAPPING() && tapping_key.event.pressed) # define IS_TAPPING_RELEASED() (IS_TAPPING() && !tapping_key.event.pressed) # define IS_TAPPING_KEY(k) (IS_TAPPING() && KEYEQ(tapping_key.event.key, (k))) @@ -25,6 +27,7 @@ # define IS_TAPPING_RECORD(r) (IS_TAPPING() && KEYEQ(tapping_key.event.key, (r->event.key)) && tapping_key.keycode == r->keycode) # endif # define WITHIN_TAPPING_TERM(e) (TIMER_DIFF_16(e.time, tapping_key.event.time) < GET_TAPPING_TERM(get_record_keycode(&tapping_key, false), &tapping_key)) +# define WITHIN_QUICK_TAP_TERM(e) (TIMER_DIFF_16(e.time, tapping_key.event.time) < GET_QUICK_TAP_TERM(get_record_keycode(&tapping_key, false), &tapping_key)) # ifdef DYNAMIC_TAPPING_TERM_ENABLE uint16_t g_tapping_term = TAPPING_TERM; @@ -40,9 +43,9 @@ __attribute__((weak)) uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *r } # endif -# ifdef TAPPING_FORCE_HOLD_PER_KEY -__attribute__((weak)) bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { - return false; +# ifdef QUICK_TAP_TERM_PER_KEY +__attribute__((weak)) uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { + return QUICK_TAP_TERM; } # endif @@ -82,15 +85,15 @@ static void debug_waiting_buffer(void); */ void action_tapping_process(keyrecord_t record) { if (process_tapping(&record)) { - if (!IS_NOEVENT(record.event)) { - debug("processed: "); + if (IS_EVENT(record.event)) { + ac_dprintf("processed: "); debug_record(record); - debug("\n"); + ac_dprintf("\n"); } } else { if (!waiting_buffer_enq(record)) { // clear all in case of overflow. - debug("OVERFLOW: CLEAR ALL STATES\n"); + ac_dprintf("OVERFLOW: CLEAR ALL STATES\n"); clear_keyboard(); waiting_buffer_clear(); tapping_key = (keyrecord_t){}; @@ -98,25 +101,73 @@ void action_tapping_process(keyrecord_t record) { } // process waiting_buffer - if (!IS_NOEVENT(record.event) && waiting_buffer_head != waiting_buffer_tail) { - debug("---- action_exec: process waiting_buffer -----\n"); + if (IS_EVENT(record.event) && waiting_buffer_head != waiting_buffer_tail) { + ac_dprintf("---- action_exec: process waiting_buffer -----\n"); } for (; waiting_buffer_tail != waiting_buffer_head; waiting_buffer_tail = (waiting_buffer_tail + 1) % WAITING_BUFFER_SIZE) { if (process_tapping(&waiting_buffer[waiting_buffer_tail])) { - debug("processed: waiting_buffer["); - debug_dec(waiting_buffer_tail); - debug("] = "); + ac_dprintf("processed: waiting_buffer[%u] =", waiting_buffer_tail); debug_record(waiting_buffer[waiting_buffer_tail]); - debug("\n\n"); + ac_dprintf("\n\n"); } else { break; } } - if (!IS_NOEVENT(record.event)) { - debug("\n"); + if (IS_EVENT(record.event)) { + ac_dprintf("\n"); } } +/* Some conditionally defined helper macros to keep process_tapping more + * readable. The conditional definition of tapping_keycode and all the + * conditional uses of it are hidden inside macros named TAP_... + */ +# if (defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT)) || defined(PERMISSIVE_HOLD_PER_KEY) || defined(QUICK_TAP_TERM_PER_KEY) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) +# define TAP_DEFINE_KEYCODE uint16_t tapping_keycode = get_record_keycode(&tapping_key, false) +# else +# define TAP_DEFINE_KEYCODE +# endif + +# if defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT) +# ifdef RETRO_TAPPING_PER_KEY +# define TAP_GET_RETRO_TAPPING get_retro_tapping(tapping_keycode, &tapping_key) +# else +# define TAP_GET_RETRO_TAPPING true +# endif +# define MAYBE_RETRO_SHIFTING(ev) (TAP_GET_RETRO_TAPPING && (RETRO_SHIFT + 0) != 0 && TIMER_DIFF_16((ev).time, tapping_key.event.time) < (RETRO_SHIFT + 0)) +# define TAP_IS_LT IS_QK_LAYER_TAP(tapping_keycode) +# define TAP_IS_MT IS_QK_MOD_TAP(tapping_keycode) +# define TAP_IS_RETRO IS_RETRO(tapping_keycode) +# else +# define TAP_GET_RETRO_TAPPING false +# define MAYBE_RETRO_SHIFTING(ev) false +# define TAP_IS_LT false +# define TAP_IS_MT false +# define TAP_IS_RETRO false +# endif + +# ifdef PERMISSIVE_HOLD_PER_KEY +# define TAP_GET_PERMISSIVE_HOLD get_permissive_hold(tapping_keycode, &tapping_key) +# elif defined(PERMISSIVE_HOLD) +# define TAP_GET_PERMISSIVE_HOLD true +# else +# define TAP_GET_PERMISSIVE_HOLD false +# endif + +# ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY +# define TAP_GET_HOLD_ON_OTHER_KEY_PRESS get_hold_on_other_key_press(tapping_keycode, &tapping_key) +# elif defined(HOLD_ON_OTHER_KEY_PRESS) +# define TAP_GET_HOLD_ON_OTHER_KEY_PRESS true +# else +# define TAP_GET_HOLD_ON_OTHER_KEY_PRESS false +# endif + +# if defined(IGNORE_MOD_TAP_INTERRUPT) +# define TAP_GET_IGNORE_MOD_TAP_INTERRUPT true +# else +# define TAP_GET_IGNORE_MOD_TAP_INTERRUPT false +# endif + /** \brief Tapping * * Rule: Tap key is typed(pressed and released) within TAPPING_TERM. @@ -125,31 +176,18 @@ void action_tapping_process(keyrecord_t record) { /* return true when key event is processed or consumed. */ bool process_tapping(keyrecord_t *keyp) { keyevent_t event = keyp->event; -# if (defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT)) || defined(PERMISSIVE_HOLD_PER_KEY) || defined(TAPPING_FORCE_HOLD_PER_KEY) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) - uint16_t tapping_keycode = get_record_keycode(&tapping_key, false); -# endif + TAP_DEFINE_KEYCODE; // if tapping if (IS_TAPPING_PRESSED()) { - // clang-format off - if (WITHIN_TAPPING_TERM(event) -# if defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT) - || ( -# ifdef RETRO_TAPPING_PER_KEY - get_retro_tapping(tapping_keycode, &tapping_key) && -# endif - (RETRO_SHIFT + 0) != 0 && TIMER_DIFF_16(event.time, tapping_key.event.time) < (RETRO_SHIFT + 0) - ) -# endif - ) { - // clang-format on + if (WITHIN_TAPPING_TERM(event) || MAYBE_RETRO_SHIFTING(event)) { if (tapping_key.tap.count == 0) { if (IS_TAPPING_RECORD(keyp) && !event.pressed) { # if defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT) retroshift_swap_times(); # endif // first tap! - debug("Tapping: First tap(0->1).\n"); + ac_dprintf("Tapping: First tap(0->1).\n"); tapping_key.tap.count = 1; debug_tapping_key(); process_record(&tapping_key); @@ -164,73 +202,46 @@ bool process_tapping(keyrecord_t *keyp) { * useful for long TAPPING_TERM but may prevent fast typing. */ // clang-format off -# if defined(PERMISSIVE_HOLD) || defined(PERMISSIVE_HOLD_PER_KEY) || (defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT)) else if ( ( - IS_RELEASED(event) && waiting_buffer_typed(event) -# ifdef PERMISSIVE_HOLD_PER_KEY - && get_permissive_hold(tapping_keycode, &tapping_key) -# elif defined(PERMISSIVE_HOLD) - && true -# endif + IS_RELEASED(event) && waiting_buffer_typed(event) && + TAP_GET_PERMISSIVE_HOLD ) // Causes nested taps to not wait past TAPPING_TERM/RETRO_SHIFT // unnecessarily and fixes them for Layer Taps. -# if defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT) - || ( -# ifdef RETRO_TAPPING_PER_KEY - get_retro_tapping(tapping_keycode, &tapping_key) && -# endif + || (TAP_GET_RETRO_TAPPING && ( // Rolled over the two keys. - ( - ( - false -# if defined(HOLD_ON_OTHER_KEY_PRESS) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) - || ( - IS_LT(tapping_keycode) -# ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY - && get_hold_on_other_key_press(tapping_keycode, &tapping_key) -# endif - ) -# endif -# if !defined(IGNORE_MOD_TAP_INTERRUPT) || defined(IGNORE_MOD_TAP_INTERRUPT_PER_KEY) - || ( - IS_MT(tapping_keycode) -# ifdef IGNORE_MOD_TAP_INTERRUPT_PER_KEY - && !get_ignore_mod_tap_interrupt(tapping_keycode, &tapping_key) -# endif - ) -# endif - ) && tapping_key.tap.interrupted == true + (tapping_key.tap.interrupted == true && ( + (TAP_IS_LT && TAP_GET_HOLD_ON_OTHER_KEY_PRESS) || + (TAP_IS_MT && TAP_GET_HOLD_ON_OTHER_KEY_PRESS) + ) ) // Makes Retro Shift ignore [IGNORE_MOD_TAP_INTERRUPT's // effects on nested taps for MTs and the default // behavior of LTs] below TAPPING_TERM or RETRO_SHIFT. || ( - IS_RETRO(tapping_keycode) + TAP_IS_RETRO && (event.key.col != tapping_key.event.key.col || event.key.row != tapping_key.event.key.row) && IS_RELEASED(event) && waiting_buffer_typed(event) ) ) ) -# endif ) { // clang-format on - debug("Tapping: End. No tap. Interfered by typing key\n"); + ac_dprintf("Tapping: End. No tap. Interfered by typing key\n"); process_record(&tapping_key); tapping_key = (keyrecord_t){}; debug_tapping_key(); // enqueue return false; } -# endif /* Process release event of a key pressed before tapping starts * Without this unexpected repeating will occur with having fast repeating setting * https://github.com/tmk/tmk_keyboard/issues/60 */ else if (IS_RELEASED(event) && !waiting_buffer_typed(event)) { - // Modifier should be retained till end of this tapping. + // Modifier/Layer should be retained till end of this tapping. action_t action = layer_switch_get_action(event.key); switch (action.kind.id) { case ACT_LMODS: @@ -243,28 +254,33 @@ bool process_tapping(keyrecord_t *keyp) { if (action.key.mods && keyp->tap.count == 0) return false; if (IS_MOD(action.key.code)) return false; break; + case ACT_LAYER_TAP: + case ACT_LAYER_TAP_EXT: + switch (action.layer_tap.code) { + case 0 ...(OP_TAP_TOGGLE - 1): + case OP_ON_OFF: + case OP_OFF_ON: + case OP_SET_CLEAR: + return false; + } + break; } // Release of key should be process immediately. - debug("Tapping: release event of a key pressed before tapping\n"); + ac_dprintf("Tapping: release event of a key pressed before tapping\n"); process_record(keyp); return true; } else { // set interrupted flag when other key preesed during tapping if (event.pressed) { tapping_key.tap.interrupted = true; -# if defined(HOLD_ON_OTHER_KEY_PRESS) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) -# if defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) - if (get_hold_on_other_key_press(tapping_keycode, &tapping_key)) -# endif - { - debug("Tapping: End. No tap. Interfered by pressed key\n"); + if (TAP_GET_HOLD_ON_OTHER_KEY_PRESS) { + ac_dprintf("Tapping: End. No tap. Interfered by pressed key\n"); process_record(&tapping_key); tapping_key = (keyrecord_t){}; debug_tapping_key(); // enqueue return false; } -# endif } // enqueue return false; @@ -273,9 +289,7 @@ bool process_tapping(keyrecord_t *keyp) { // tap_count > 0 else { if (IS_TAPPING_RECORD(keyp) && !event.pressed) { - debug("Tapping: Tap release("); - debug_dec(tapping_key.tap.count); - debug(")\n"); + ac_dprintf("Tapping: Tap release(%u)\n", tapping_key.tap.count); keyp->tap = tapping_key.tap; process_record(keyp); tapping_key = *keyp; @@ -283,7 +297,7 @@ bool process_tapping(keyrecord_t *keyp) { return true; } else if (is_tap_record(keyp) && event.pressed) { if (tapping_key.tap.count > 1) { - debug("Tapping: Start new tap with releasing last tap(>1).\n"); + ac_dprintf("Tapping: Start new tap with releasing last tap(>1).\n"); // unregister key process_record(&(keyrecord_t){ .tap = tapping_key.tap, @@ -295,15 +309,15 @@ bool process_tapping(keyrecord_t *keyp) { # endif }); } else { - debug("Tapping: Start while last tap(1).\n"); + ac_dprintf("Tapping: Start while last tap(1).\n"); } tapping_key = *keyp; waiting_buffer_scan_tap(); debug_tapping_key(); return true; } else { - if (!IS_NOEVENT(event)) { - debug("Tapping: key event while last tap(>0).\n"); + if (IS_EVENT(event)) { + ac_dprintf("Tapping: key event while last tap(>0).\n"); } process_record(keyp); return true; @@ -313,23 +327,23 @@ bool process_tapping(keyrecord_t *keyp) { // after TAPPING_TERM else { if (tapping_key.tap.count == 0) { - debug("Tapping: End. Timeout. Not tap(0): "); + ac_dprintf("Tapping: End. Timeout. Not tap(0): "); debug_event(event); - debug("\n"); + ac_dprintf("\n"); process_record(&tapping_key); tapping_key = (keyrecord_t){}; debug_tapping_key(); return false; } else { if (IS_TAPPING_RECORD(keyp) && !event.pressed) { - debug("Tapping: End. last timeout tap release(>0)."); + ac_dprintf("Tapping: End. last timeout tap release(>0)."); keyp->tap = tapping_key.tap; process_record(keyp); tapping_key = (keyrecord_t){}; return true; } else if (is_tap_record(keyp) && event.pressed) { if (tapping_key.tap.count > 1) { - debug("Tapping: Start new tap with releasing last timeout tap(>1).\n"); + ac_dprintf("Tapping: Start new tap with releasing last timeout tap(>1).\n"); // unregister key process_record(&(keyrecord_t){ .tap = tapping_key.tap, @@ -341,15 +355,15 @@ bool process_tapping(keyrecord_t *keyp) { # endif }); } else { - debug("Tapping: Start while last timeout tap(1).\n"); + ac_dprintf("Tapping: Start while last timeout tap(1).\n"); } tapping_key = *keyp; waiting_buffer_scan_tap(); debug_tapping_key(); return true; } else { - if (!IS_NOEVENT(event)) { - debug("Tapping: key event while last timeout tap(>0).\n"); + if (IS_EVENT(event)) { + ac_dprintf("Tapping: key event while last timeout tap(>0).\n"); } process_record(keyp); return true; @@ -357,45 +371,25 @@ bool process_tapping(keyrecord_t *keyp) { } } } else if (IS_TAPPING_RELEASED()) { - // clang-format off - if (WITHIN_TAPPING_TERM(event) -# if defined(AUTO_SHIFT_ENABLE) && defined(RETRO_SHIFT) - || ( -# ifdef RETRO_TAPPING_PER_KEY - get_retro_tapping(tapping_keycode, &tapping_key) && -# endif - (RETRO_SHIFT + 0) != 0 && TIMER_DIFF_16(event.time, tapping_key.event.time) < (RETRO_SHIFT + 0) - ) -# endif - ) { - // clang-format on + if (WITHIN_TAPPING_TERM(event) || MAYBE_RETRO_SHIFTING(event)) { if (event.pressed) { if (IS_TAPPING_RECORD(keyp)) { -//# ifndef TAPPING_FORCE_HOLD -# if !defined(TAPPING_FORCE_HOLD) || defined(TAPPING_FORCE_HOLD_PER_KEY) - if ( -# ifdef TAPPING_FORCE_HOLD_PER_KEY - !get_tapping_force_hold(tapping_keycode, &tapping_key) && -# endif - !tapping_key.tap.interrupted && tapping_key.tap.count > 0) { + if (WITHIN_QUICK_TAP_TERM(event) && !tapping_key.tap.interrupted && tapping_key.tap.count > 0) { // sequential tap. keyp->tap = tapping_key.tap; if (keyp->tap.count < 15) keyp->tap.count += 1; - debug("Tapping: Tap press("); - debug_dec(keyp->tap.count); - debug(")\n"); + ac_dprintf("Tapping: Tap press(%u)\n", keyp->tap.count); process_record(keyp); tapping_key = *keyp; debug_tapping_key(); return true; } -# endif // FIX: start new tap again tapping_key = *keyp; return true; } else if (is_tap_record(keyp)) { // Sequential tap can be interfered with other tap key. - debug("Tapping: Start with interfering other tap.\n"); + ac_dprintf("Tapping: Start with interfering other tap.\n"); tapping_key = *keyp; waiting_buffer_scan_tap(); debug_tapping_key(); @@ -408,16 +402,16 @@ bool process_tapping(keyrecord_t *keyp) { return true; } } else { - if (!IS_NOEVENT(event)) debug("Tapping: other key just after tap.\n"); + if (IS_EVENT(event)) ac_dprintf("Tapping: other key just after tap.\n"); process_record(keyp); return true; } } else { // FIX: process_action here? // timeout. no sequential tap. - debug("Tapping: End(Timeout after releasing last tap): "); + ac_dprintf("Tapping: End(Timeout after releasing last tap): "); debug_event(event); - debug("\n"); + ac_dprintf("\n"); tapping_key = (keyrecord_t){}; debug_tapping_key(); return false; @@ -426,7 +420,7 @@ bool process_tapping(keyrecord_t *keyp) { // not tapping state else { if (event.pressed && is_tap_record(keyp)) { - debug("Tapping: Start(Press tap key).\n"); + ac_dprintf("Tapping: Start(Press tap key).\n"); tapping_key = *keyp; process_record_tap_hint(&tapping_key); waiting_buffer_scan_tap(); @@ -449,14 +443,14 @@ bool waiting_buffer_enq(keyrecord_t record) { } if ((waiting_buffer_head + 1) % WAITING_BUFFER_SIZE == waiting_buffer_tail) { - debug("waiting_buffer_enq: Over flow.\n"); + ac_dprintf("waiting_buffer_enq: Over flow.\n"); return false; } waiting_buffer[waiting_buffer_head] = record; waiting_buffer_head = (waiting_buffer_head + 1) % WAITING_BUFFER_SIZE; - debug("waiting_buffer_enq: "); + ac_dprintf("waiting_buffer_enq: "); debug_waiting_buffer(); return true; } @@ -510,9 +504,7 @@ void waiting_buffer_scan_tap(void) { waiting_buffer[i].tap.count = 1; process_record(&tapping_key); - debug("waiting_buffer_scan_tap: found at ["); - debug_dec(i); - debug("]\n"); + ac_dprintf("waiting_buffer_scan_tap: found at [%u]\n", i); debug_waiting_buffer(); return; } @@ -524,9 +516,9 @@ void waiting_buffer_scan_tap(void) { * FIXME: Needs docs */ static void debug_tapping_key(void) { - debug("TAPPING_KEY="); + ac_dprintf("TAPPING_KEY="); debug_record(tapping_key); - debug("\n"); + ac_dprintf("\n"); } /** \brief Waiting buffer debug print @@ -534,15 +526,13 @@ static void debug_tapping_key(void) { * FIXME: Needs docs */ static void debug_waiting_buffer(void) { - debug("{ "); + ac_dprintf("{ "); for (uint8_t i = waiting_buffer_tail; i != waiting_buffer_head; i = (i + 1) % WAITING_BUFFER_SIZE) { - debug("["); - debug_dec(i); - debug("]="); + ac_dprintf("[%u]=", i); debug_record(waiting_buffer[i]); - debug(" "); + ac_dprintf(" "); } - debug("}\n"); + ac_dprintf("}\n"); } #endif diff --git a/quantum/action_tapping.h b/quantum/action_tapping.h index bcccc7ac45..c078488c04 100644 --- a/quantum/action_tapping.h +++ b/quantum/action_tapping.h @@ -22,6 +22,11 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. # define TAPPING_TERM 200 #endif +/* period of quick tap(ms) */ +#if !defined(QUICK_TAP_TERM) || QUICK_TAP_TERM > TAPPING_TERM +# define QUICK_TAP_TERM TAPPING_TERM +#endif + /* tap count needed for toggling a feature */ #ifndef TAPPING_TOGGLE # define TAPPING_TOGGLE 5 @@ -36,9 +41,9 @@ void action_tapping_process(keyrecord_t record); #endif uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record); +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record); bool get_permissive_hold(uint16_t keycode, keyrecord_t *record); bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record); -bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record); bool get_retro_tapping(uint16_t keycode, keyrecord_t *record); bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record); @@ -53,3 +58,9 @@ extern uint16_t g_tapping_term; #else # define GET_TAPPING_TERM(keycode, record) (TAPPING_TERM) #endif + +#ifdef QUICK_TAP_TERM_PER_KEY +# define GET_QUICK_TAP_TERM(keycode, record) get_quick_tap_term(keycode, record) +#else +# define GET_QUICK_TAP_TERM(keycode, record) (QUICK_TAP_TERM) +#endif diff --git a/quantum/keyboard.h b/quantum/keyboard.h index 86ce65aac1..d0b52dd13a 100644 --- a/quantum/keyboard.h +++ b/quantum/keyboard.h @@ -53,6 +53,9 @@ typedef struct { static inline bool IS_NOEVENT(keyevent_t event) { return event.time == 0 || (event.key.row == KEYLOC_TICK && event.key.col == KEYLOC_TICK); } +static inline bool IS_EVENT(keyevent_t event) { + return !IS_NOEVENT(event); +} static inline bool IS_KEYEVENT(keyevent_t event) { return event.key.row < MATRIX_ROWS && event.key.col < MATRIX_COLS; } @@ -63,10 +66,10 @@ static inline bool IS_ENCODEREVENT(keyevent_t event) { return event.key.row == KEYLOC_ENCODER_CW || event.key.row == KEYLOC_ENCODER_CCW; } static inline bool IS_PRESSED(keyevent_t event) { - return !IS_NOEVENT(event) && event.pressed; + return IS_EVENT(event) && event.pressed; } static inline bool IS_RELEASED(keyevent_t event) { - return !IS_NOEVENT(event) && !event.pressed; + return IS_EVENT(event) && !event.pressed; } /* Common keyevent object factory */ diff --git a/quantum/keymap_extras/keymap_belgian.h b/quantum/keymap_extras/keymap_belgian.h index 207905b291..235ebde30e 100644 --- a/quantum/keymap_extras/keymap_belgian.h +++ b/quantum/keymap_extras/keymap_belgian.h @@ -1,39 +1,33 @@ -/* Copyright 2015-2016 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ² │ & │ é │ " │ ' │ ( │ § │ è │ ! │ ç │ à │ ) │ - │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ A │ Z │ E │ R │ T │ Y │ U │ I │ O │ P │ ^ │ $ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Q │ S │ D │ F │ G │ H │ J │ K │ L │ M │ ù │ µ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ W │ X │ C │ V │ B │ N │ , │ ; │ : │ = │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define BE_SUP2 KC_GRV // ² #define BE_AMPR KC_1 // & #define BE_EACU KC_2 // é @@ -47,7 +41,6 @@ #define BE_AGRV KC_0 // à #define BE_RPRN KC_MINS // ) #define BE_MINS KC_EQL // - -// Row 2 #define BE_A KC_Q // A #define BE_Z KC_W // Z #define BE_E KC_E // E @@ -60,7 +53,6 @@ #define BE_P KC_P // P #define BE_DCIR KC_LBRC // ^ (dead) #define BE_DLR KC_RBRC // $ -// Row 3 #define BE_Q KC_A // Q #define BE_S KC_S // S #define BE_D KC_D // D @@ -73,7 +65,6 @@ #define BE_M KC_SCLN // M #define BE_UGRV KC_QUOT // ù #define BE_MICR KC_NUHS // µ -// Row 4 #define BE_LABK KC_NUBS // < #define BE_W KC_Z // W #define BE_X KC_X // X @@ -85,21 +76,6 @@ #define BE_SCLN KC_COMM // ; #define BE_COLN KC_DOT // : #define BE_EQL KC_SLSH // = - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ³ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ° │ _ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ * │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ % │ £ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ ? │ . │ / │ + │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define BE_SUP3 S(BE_SUP2) // ³ #define BE_1 S(BE_AMPR) // 1 #define BE_2 S(BE_EACU) // 2 @@ -113,46 +89,25 @@ #define BE_0 S(BE_AGRV) // 0 #define BE_DEG S(BE_RPRN) // ° #define BE_UNDS S(BE_MINS) // _ -// Row 2 #define BE_DIAE S(BE_DCIR) // ¨ (dead) #define BE_ASTR S(BE_DLR) // * -// Row 3 #define BE_PERC S(BE_UGRV) // % #define BE_PND S(BE_MICR) // £ -// Row 4 #define BE_RABK S(BE_LABK) // > #define BE_QUES S(BE_COMM) // ? #define BE_DOT S(BE_SCLN) // . #define BE_SLSH S(BE_COLN) // / #define BE_PLUS S(BE_EQL) // + - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ | │ @ │ # │ │ │ ^ │ │ │ { │ } │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ ´ │ ` │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ \ │ │ │ │ │ │ │ │ │ │ ~ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define BE_PIPE ALGR(BE_AMPR) // | #define BE_AT ALGR(BE_EACU) // @ #define BE_HASH ALGR(BE_DQUO) // # #define BE_CIRC ALGR(BE_SECT) // ^ #define BE_LCBR ALGR(BE_CCED) // { #define BE_RCBR ALGR(BE_AGRV) // } -// Row 2 #define BE_EURO ALGR(BE_E) // € #define BE_LBRC ALGR(BE_DCIR) // [ #define BE_RBRC ALGR(BE_DLR) // ] -// Row 3 #define BE_ACUT ALGR(BE_UGRV) // ´ (dead) #define BE_GRV ALGR(BE_MICR) // ` (dead) -// Row 4 #define BE_BSLS ALGR(BE_LABK) // (backslash) #define BE_TILD ALGR(BE_EQL) // ~ diff --git a/quantum/keymap_extras/keymap_bepo.h b/quantum/keymap_extras/keymap_bepo.h index 6361823242..7dc2aa9095 100644 --- a/quantum/keymap_extras/keymap_bepo.h +++ b/quantum/keymap_extras/keymap_bepo.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ $ │ " │ « │ » │ ( │ ) │ @ │ + │ - │ / │ * │ = │ % │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ B │ É │ P │ O │ È │ ^ │ V │ D │ L │ J │ Z │ W │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ U │ I │ E │ , │ C │ T │ S │ R │ N │ M │ Ç │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ Ê │ À │ Y │ X │ . │ K │ ' │ Q │ G │ H │ F │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define BP_DLR KC_GRV // $ #define BP_DQUO KC_1 // " #define BP_LDAQ KC_2 // « @@ -47,7 +41,6 @@ #define BP_ASTR KC_0 // * #define BP_EQL KC_MINS // = #define BP_PERC KC_EQL // % -// Row 2 #define BP_B KC_Q // B #define BP_EACU KC_W // É #define BP_P KC_E // P @@ -60,7 +53,6 @@ #define BP_J KC_P // J #define BP_Z KC_LBRC // Z #define BP_W KC_RBRC // W -// Row 3 #define BP_A KC_A // A #define BP_U KC_S // U #define BP_I KC_D // I @@ -73,7 +65,6 @@ #define BP_N KC_SCLN // N #define BP_M KC_QUOT // M #define BP_CCED KC_BSLS // Ç -// Row 4 #define BP_ECIR KC_NUBS // Ê #define BP_AGRV KC_Z // À #define BP_Y KC_X // Y @@ -85,21 +76,6 @@ #define BP_G KC_COMM // G #define BP_H KC_DOT // H #define BP_F KC_SLSH // F - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ # │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ° │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ ! │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ ; │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ : │ │ ? │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define BP_HASH S(BP_DLR) // # #define BP_1 S(BP_DQUO) // 1 #define BP_2 S(BP_LDAQ) // 2 @@ -113,30 +89,11 @@ #define BP_0 S(BP_ASTR) // 0 #define BP_DEG S(BP_EQL) // ° #define BP_GRV S(BP_PERC) // ` -// Row 2 #define BP_EXLM S(BP_DCIR) // ! -// Row 3 #define BP_SCLN S(BP_COMM) // ; -// Row 4 #define BP_COLN S(BP_DOT) // : #define BP_QUES S(BP_QUOT) // ? -// Row 5 -#define BP_NBSP S(KC_SPC) //  (non-breaking space) - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ – │ — │ < │ > │ [ │ ] │ ^ │ ± │ − │ ÷ │ × │ ≠│ ‰ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ | │ ´ │ & │ Å’ │ ` │ ¡ │ ˇ │ à │ / │ IJ │ Æ â”‚ ˘ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Æ │ Ù │ ¨ │ € │ │ © │ Þ │ ẞ │ ® │ ~ │ ¯ │ ¸ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ \ │ { │ } │ … │ ~ │ ¿ │ ° │ │ †│ Ë› │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ _ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +#define BP_NBSP S(KC_SPC) // (non-breaking space) #define BP_NDSH ALGR(BP_DLR) // – #define BP_MDSH ALGR(BP_DQUO) // — #define BP_LABK ALGR(BP_LDAQ) // < @@ -150,7 +107,6 @@ #define BP_MUL ALGR(BP_ASTR) // × #define BP_NEQL ALGR(BP_EQL) // ≠#define BP_PERM ALGR(BP_PERC) // ‰ -// Row 2 #define BP_PIPE ALGR(BP_B) // | #define BP_ACUT ALGR(BP_EACU) // ´ (dead) #define BP_AMPR ALGR(BP_P) // & @@ -163,7 +119,6 @@ #define BP_IJ ALGR(BP_J) // IJ #define BP_SCHW ALGR(BP_Z) // Æ #define BP_BREV ALGR(BP_W) // ˘ (dead) -// Row 3 #define BP_AE ALGR(BP_A) // Æ #define BP_UGRV ALGR(BP_U) // Ù #define BP_DIAE ALGR(BP_I) // ¨ (dead) @@ -175,7 +130,6 @@ #define BP_DTIL ALGR(BP_N) // ~ (dead) #define BP_MACR ALGR(BP_M) // ¯ (dead) #define BP_CEDL ALGR(BP_CCED) // ¸ (dead) -// Row 4 #define BP_BSLS ALGR(BP_AGRV) // (backslash) #define BP_LCBR ALGR(BP_Y) // { #define BP_RCBR ALGR(BP_X) // } @@ -186,23 +140,7 @@ #define BP_DGRK ALGR(BP_G) // µ (dead Greek key) #define BP_DAGG ALGR(BP_H) // †#define BP_OGON ALGR(BP_F) // Ë› (dead) -// Row 5 #define BP_UNDS ALGR(KC_SPC) // _ - -/* Shift+AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¶ │ „ │ “ │ †│ ≤ │ ≥ │ │ ¬ │ ¼ │ ½ │ ¾ │ ′ │ ″ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ ¦ │ Ë â”‚ § │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ Ë™ │ ¤ │ Ì› │ Å¿ │ │ │ â„¢ │ │ º │ , │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ ‘ │ ’ │ · │ ⌨ │ ̉ │ Ì£ │ │ ‡ │ ª │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define BP_PARA S(ALGR(BP_DLR)) // ¶ #define BP_DLQU S(ALGR(BP_DQUO)) // „ #define BP_LDQU S(ALGR(BP_LDAQ)) // “ @@ -215,26 +153,22 @@ #define BP_TQTR S(ALGR(BP_ASTR)) // ¾ #define BP_PRIM S(ALGR(BP_EQL)) // ′ #define BP_DPRM S(ALGR(BP_PERC)) // ″ -// Row 2 #define BP_BRKP S(ALGR(BP_B)) // ¦ #define BP_DACU S(ALGR(BP_EACU)) // Ë (dead) #define BP_SECT S(ALGR(BP_P)) // § -// Row 3 #define BP_DOTA S(ALGR(BP_I)) // Ë™ (dead) #define BP_CURR S(ALGR(BP_E)) // ¤ (dead) -#define BP_HORN S(ALGR(BP_COMM)) // Ì› (dead) +#define BP_HORN S(ALGR(BP_COMM)) // Ì› (dead) #define BP_LNGS S(ALGR(BP_C)) // Å¿ #define BP_TM S(ALGR(BP_R)) // â„¢ #define BP_MORD S(ALGR(BP_M)) // º #define BP_DCMM S(ALGR(BP_CCED)) // , (dead) -// Row 4 #define BP_LSQU S(ALGR(BP_Y)) // ‘ #define BP_RSQU S(ALGR(BP_X)) // ’ #define BP_MDDT S(ALGR(BP_DOT)) // · #define BP_KEYB S(ALGR(BP_K)) // ⌨ -#define BP_HOKA S(ALGR(BP_QUOT)) // ̉ (dead) -#define BP_DOTB S(ALGR(BP_Q)) // Ì£ (dead) +#define BP_HOKA S(ALGR(BP_QUOT)) // ̉ (dead) +#define BP_DOTB S(ALGR(BP_Q)) // Ì£ (dead) #define BP_DDAG S(ALGR(BP_H)) // ‡ #define BP_FORD S(ALGR(BP_F)) // ª -// Row 5 -#define BP_NNBS S(ALGR(KC_SPC)) //   (narrow non-breaking space) +#define BP_NNBS S(ALGR(KC_SPC)) // (narrow non-breaking space) diff --git a/quantum/keymap_extras/keymap_brazilian_abnt2.h b/quantum/keymap_extras/keymap_brazilian_abnt2.h index b5892183be..64395bf017 100644 --- a/quantum/keymap_extras/keymap_brazilian_abnt2.h +++ b/quantum/keymap_extras/keymap_brazilian_abnt2.h @@ -1,39 +1,33 @@ -/* Copyright 2017 Potiguar Faga - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ' │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ ´ │ [ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ç │ ~ │ ] │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┤ - * │ │ \ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ ; │ / │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬──┴─┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define BR_QUOT KC_GRV // ' #define BR_1 KC_1 // 1 #define BR_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define BR_0 KC_0 // 0 #define BR_MINS KC_MINS // - #define BR_EQL KC_EQL // = -// Row 2 #define BR_Q KC_Q // Q #define BR_W KC_W // W #define BR_E KC_E // E @@ -60,7 +53,6 @@ #define BR_P KC_P // P #define BR_ACUT KC_LBRC // ´ (dead) #define BR_LBRC KC_RBRC // [ -// Row 3 #define BR_A KC_A // A #define BR_S KC_S // S #define BR_D KC_D // D @@ -73,7 +65,6 @@ #define BR_CCED KC_SCLN // Ç #define BR_TILD KC_QUOT // ~ (dead) #define BR_RBRC KC_BSLS // ] -// Row 4 #define BR_BSLS KC_NUBS // (backslash) #define BR_Z KC_Z // Z #define BR_X KC_X // X @@ -86,24 +77,8 @@ #define BR_DOT KC_DOT // . #define BR_SCLN KC_SLSH // ; #define BR_SLSH KC_INT1 // / -// Numpad #define BR_PDOT KC_PCMM // . #define BR_PCMM KC_PDOT // , - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ " │ ! │ @ │ # │ $ │ % │ ¨ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ ` │ { │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ ^ │ } │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┤ - * │ │ | │ │ │ │ │ │ │ │ < │ > │ : │ ? │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬──┴─┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define BR_DQUO S(BR_QUOT) // " #define BR_EXLM S(BR_1) // ! #define BR_AT S(BR_2) // @ @@ -117,33 +92,15 @@ #define BR_RPRN S(BR_0) // ) #define BR_UNDS S(BR_MINS) // _ #define BR_PLUS S(BR_EQL) // + -// Row 2 #define BR_GRV S(BR_ACUT) // ` (dead) #define BR_LCBR S(BR_LBRC) // { -// Row 3 #define BR_CIRC S(BR_TILD) // ^ (dead) #define BR_RCBR S(BR_RBRC) // } -// Row 4 #define BR_PIPE S(BR_BSLS) // | #define BR_LABK S(BR_COMM) // < #define BR_RABK S(BR_DOT) // > #define BR_COLN S(BR_SCLN) // : #define BR_QUES S(BR_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ¹ │ ² │ ³ │ £ │ ¢ │ ¬ │ │ │ │ │ │ § │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ ° │ │ │ │ │ │ │ │ │ ª │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ º │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┤ - * │ │ │ │ │ â‚¢ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬──┴─┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define BR_SUP1 ALGR(BR_1) // ¹ #define BR_SUP2 ALGR(BR_2) // ² #define BR_SUP3 ALGR(BR_3) // ³ @@ -151,10 +108,7 @@ #define BR_CENT ALGR(BR_5) // ¢ #define BR_NOT ALGR(BR_6) // ¬ #define BR_SECT ALGR(BR_EQL) // § -// Row 2 #define BR_DEG ALGR(BR_E) // ° #define BR_FORD ALGR(BR_LBRC) // ª -// Row 3 #define BR_MORD ALGR(BR_RBRC) // º -// Row 4 #define BR_CRUZ ALGR(BR_C) // â‚¢ diff --git a/quantum/keymap_extras/keymap_canadian_multilingual.h b/quantum/keymap_extras/keymap_canadian_multilingual.h index e328cf65e6..1a7223644c 100644 --- a/quantum/keymap_extras/keymap_canadian_multilingual.h +++ b/quantum/keymap_extras/keymap_canadian_multilingual.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ / │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ ^ │ Ç │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ È │ À │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ Ù │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ É │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define CA_SLSH KC_GRV // / #define CA_1 KC_1 // 1 #define CA_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define CA_0 KC_0 // 0 #define CA_MINS KC_MINS // - #define CA_EQL KC_EQL // = -// Row 2 #define CA_Q KC_Q // Q #define CA_W KC_W // W #define CA_E KC_E // E @@ -60,7 +53,6 @@ #define CA_P KC_P // P #define CA_CIRC KC_LBRC // ^ (dead) #define CA_CCED KC_RBRC // Ç -// Row 3 #define CA_A KC_A // A #define CA_S KC_S // S #define CA_D KC_D // D @@ -73,7 +65,6 @@ #define CA_SCLN KC_SCLN // ; #define CA_EGRV KC_QUOT // É #define CA_AGRV KC_NUHS // À -// Row 4 #define CA_UGRV KC_NUBS // Ù #define CA_Z KC_Z // Z #define CA_X KC_X // X @@ -85,21 +76,6 @@ #define CA_COMM KC_COMM // , #define CA_DOT KC_DOT // . #define CA_EACU KC_SLSH // É - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ \ │ ! │ @ │ # │ $ │ % │ ? │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ : │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ ' │ " │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CA_BSLS S(CA_SLSH) // (backslash) #define CA_EXLM S(CA_1) // ! #define CA_AT S(CA_2) // @ @@ -113,28 +89,10 @@ #define CA_RPRN S(CA_0) // ) #define CA_UNDS S(CA_MINS) // _ #define CA_PLUS S(CA_EQL) // + -// Row 2 #define CA_DIAE S(CA_CIRC) // ¨ (dead) -// Row 3 #define CA_COLN S(CA_SCLN) // : -// Row 4 #define CA_QUOT S(CA_COMM) // ' #define CA_DQUO S(CA_DOT) // " - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ | │ │ │ │ ¤ │ │ │ { │ } │ [ │ ] │ │ ¬ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ ` │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ ° │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ « │ » │ │ │ │ │ │ < │ > │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CA_PIPE ALGR(CA_SLSH) // | #define CA_CURR ALGR(CA_4) // ¤ #define CA_LCBR ALGR(CA_7) // { @@ -142,32 +100,14 @@ #define CA_LBRC ALGR(CA_9) // [ #define CA_RBRC ALGR(CA_0) // ] #define CA_NOT ALGR(CA_EQL) // ¬ -// Row 2 #define CA_EURO ALGR(CA_E) // € #define CA_GRV ALGR(CA_CIRC) // ` (dead) #define CA_DTIL ALGR(CA_CCED) // ~ (dead) -// Row 3 #define CA_DEG ALGR(CA_SCLN) // ° -// Row 4 #define CA_LDAQ ALGR(CA_Z) // « #define CA_RDAQ ALGR(CA_X) // » #define CA_LABK ALGR(CA_COMM) // < #define CA_RABK ALGR(CA_DOT) // > - -/* Right Ctrl symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ¹ │ ² │ ³ │ ¼ │ ½ │ ¾ │ │ │ │ │ │ ¸ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Ω │ Š│ Å’ │ ¶ │ Ŧ │ ↠│ ↓ │ → │ Ø │ Þ │ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Æ │ ß │ à │ │ ÅŠ │ Ħ │ IJ │ ĸ │ Ä¿ │ ´ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ ¢ │ “ │ †│ ʼn │ μ │ ― │ Ë™ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CA_SUP1 RCTL(CA_1) // ¹ #define CA_SUP2 RCTL(CA_2) // ² #define CA_SUP3 RCTL(CA_3) // ³ @@ -175,7 +115,6 @@ #define CA_HALF RCTL(CA_5) // ½ #define CA_TQTR RCTL(CA_6) // ¾ #define CA_CEDL RCTL(CA_EQL) // ¸ (dead) -// Row 2 #define CA_OMEG RCTL(CA_Q) // Ω #define CA_LSTR RCTL(CA_W) // Å #define CA_OE RCTL(CA_E) // Å’ @@ -187,7 +126,6 @@ #define CA_OSTR RCTL(CA_O) // Ø #define CA_THRN RCTL(CA_P) // Þ #define CA_TILD RCTL(CA_CCED) // ~ -// Row 3 #define CA_AE RCTL(CA_A) // Æ #define CA_SS RCTL(CA_S) // ß #define CA_ETH RCTL(CA_D) // à @@ -197,7 +135,6 @@ #define CA_KRA RCTL(CA_K) // ĸ #define CA_LMDT RCTL(CA_L) // Ä¿ #define CA_ACUT RCTL(CA_SCLN) // ´ (dead) -// Row 4 #define CA_CENT RCTL(CA_C) // ¢ #define CA_LDQU RCTL(CA_V) // “ #define CA_RDQU RCTL(CA_B) // †@@ -205,21 +142,6 @@ #define CA_MICR RCTL(CA_M) // μ #define CA_HRZB RCTL(CA_COMM) // ― #define CA_DOTA RCTL(CA_DOT) // Ë™ (dead) - -/* Shift+Right Ctrl symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ - │ ¡ │ │ £ │ │ â…œ │ â… â”‚ â…ž │ â„¢ │ ± │ │ ¿ │ Ë› │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ ® │ │ Â¥ │ ↑ │ ı │ │ │ ° │ ¯ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ § │ │ ª │ │ │ │ │ │ Ë â”‚ ˇ │ ˘ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ ¦ │ │ │ © │ ‘ │ ’ │ ♪ │ º │ × │ ÷ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CA_SHYP RCTL(S(CA_SLSH)) //  (soft hyphen) #define CA_IEXL RCTL(S(CA_1)) // ¡ #define CA_PND RCTL(S(CA_3)) // £ @@ -230,20 +152,17 @@ #define CA_PLMN RCTL(S(CA_9)) // ± #define CA_IQUE RCTL(S(CA_MINS)) // ¿ #define CA_OGON RCTL(S(CA_EQL)) // Ë› (dead) -// Row 2 #define CA_REGD RCTL(S(CA_R)) // ® #define CA_YEN RCTL(S(CA_Y)) // Â¥ #define CA_UARR RCTL(S(CA_U)) // ↑ #define CA_DLSI RCTL(S(CA_I)) // ı #define CA_RNGA RCTL(S(CA_CIRC)) // ° (dead) #define CA_MACR RCTL(S(CA_CCED)) // ¯ (dead) -// Row 3 #define CA_SECT RCTL(S(CA_S)) // § #define CA_FORD RCTL(S(CA_F)) // ª #define CA_DACU RCTL(S(CA_SCLN)) // Ë (dead) #define CA_CARN RCTL(S(CA_EGRV)) // ˇ (dead) #define CA_BREV RCTL(S(CA_AGRV)) // ˘ (dead) -// Row 4 #define CA_BRKP RCTL(S(CA_UGRV)) // ¦ #define CA_COPY RCTL(S(CA_C)) // © #define CA_LSQU RCTL(S(CA_V)) // ‘ diff --git a/quantum/keymap_extras/keymap_colemak.h b/quantum/keymap_extras/keymap_colemak.h index e7b5c97ccb..1363751ff1 100644 --- a/quantum/keymap_extras/keymap_colemak.h +++ b/quantum/keymap_extras/keymap_colemak.h @@ -1,39 +1,33 @@ -/* Copyright 2015-2016 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ F │ P │ G │ J │ L │ U │ Y │ ; │ [ │ ] │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ R │ S │ T │ D │ H │ N │ E │ I │ O │ ' │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Z │ X │ C │ V │ B │ K │ M │ , │ . │ / │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define CM_GRV KC_GRV // ` #define CM_1 KC_1 // 1 #define CM_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define CM_0 KC_0 // 0 #define CM_MINS KC_MINS // - #define CM_EQL KC_EQL // = -// Row 2 #define CM_Q KC_Q // Q #define CM_W KC_W // W #define CM_F KC_E // F @@ -61,7 +54,6 @@ #define CM_LBRC KC_LBRC // [ #define CM_RBRC KC_RBRC // ] #define CM_BSLS KC_BSLS // (backslash) -// Row 3 #define CM_A KC_A // A #define CM_R KC_S // R #define CM_S KC_D // S @@ -73,7 +65,6 @@ #define CM_I KC_L // I #define CM_O KC_SCLN // O #define CM_QUOT KC_QUOT // ' -// Row 4 #define CM_Z KC_Z // Z #define CM_X KC_X // X #define CM_C KC_C // C @@ -84,21 +75,6 @@ #define CM_COMM KC_COMM // , #define CM_DOT KC_DOT // . #define CM_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CM_TILD S(CM_GRV) // ~ #define CM_EXLM S(CM_1) // ! #define CM_AT S(CM_2) // @ @@ -112,14 +88,11 @@ #define CM_RPRN S(CM_0) // ) #define CM_UNDS S(CM_MINS) // _ #define CM_PLUS S(CM_EQL) // + -// Row 2 #define CM_COLN S(CM_SCLN) // : #define CM_LCBR S(CM_LBRC) // { #define CM_RCBR S(CM_RBRC) // } #define CM_PIPE S(CM_BSLS) // | -// Row 3 #define CM_DQUO S(CM_QUOT) // " -// Row 4 #define CM_LABK S(CM_COMM) // < #define CM_RABK S(CM_DOT) // > #define CM_QUES S(CM_SLSH) // ? diff --git a/quantum/keymap_extras/keymap_croatian.h b/quantum/keymap_extras/keymap_croatian.h index e67b99a9a2..3151d4cffb 100644 --- a/quantum/keymap_extras/keymap_croatian.h +++ b/quantum/keymap_extras/keymap_croatian.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¸ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Š│ Ä â”‚ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ÄŒ │ Ć │ Ž │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define HR_CEDL KC_GRV // ¸ (dead) #define HR_1 KC_1 // 1 #define HR_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define HR_0 KC_0 // 0 #define HR_QUOT KC_MINS // ' #define HR_PLUS KC_EQL // + -// Row 2 #define HR_Q KC_Q // Q #define HR_W KC_W // W #define HR_E KC_E // E @@ -60,7 +53,6 @@ #define HR_P KC_P // P #define HR_SCAR KC_LBRC // Å #define HR_DSTR KC_RBRC // Ä -// Row 3 #define HR_A KC_A // A #define HR_S KC_S // S #define HR_D KC_D // D @@ -73,7 +65,6 @@ #define HR_CCAR KC_SCLN // ÄŒ #define HR_CACU KC_QUOT // Ć #define HR_ZCAR KC_NUHS // Ž -// Row 4 #define HR_LABK KC_NUBS // < #define HR_Y KC_Z // Y #define HR_X KC_X // X @@ -85,21 +76,6 @@ #define HR_COMM KC_COMM // , #define HR_DOT KC_DOT // . #define HR_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¨ │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ * │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define HR_DIAE S(HR_CEDL) // ¨ (dead) #define HR_EXLM S(HR_1) // ! #define HR_DQUO S(HR_2) // " @@ -113,26 +89,10 @@ #define HR_EQL S(HR_0) // = #define HR_QUES S(HR_QUOT) // ? #define HR_ASTR S(HR_PLUS) // * -// Row 4 #define HR_RABK S(HR_LABK) // > #define HR_SCLN S(HR_COMM) // ; #define HR_COLN S(HR_DOT) // : #define HR_UNDS S(HR_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ~ │ ˇ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ ´ │ Ë â”‚ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ \ │ | │ € │ │ │ │ │ │ │ │ ÷ │ × │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ [ │ ] │ │ │ Å‚ │ Š│ │ ß │ ¤ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ @ │ { │ } │ § │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define HR_TILD ALGR(HR_1) // ~ #define HR_CARN ALGR(HR_2) // ˇ (dead) #define HR_CIRC ALGR(HR_3) // ^ (dead) @@ -143,20 +103,17 @@ #define HR_DOTA ALGR(HR_8) // Ë™ (dead) #define HR_ACUT ALGR(HR_9) // ´ (dead) #define HR_DACU ALGR(HR_0) // Ë (dead) -// Row 2 #define HR_BSLS ALGR(HR_Q) // (backslash) #define HR_PIPE ALGR(HR_W) // | #define HR_EURO ALGR(HR_E) // € #define HR_DIV ALGR(HR_SCAR) // ÷ #define HR_MUL ALGR(HR_DSTR) // × -// Row 3 #define HR_LBRC ALGR(HR_F) // [ #define HR_RBRC ALGR(HR_G) // ] #define HR_LLST ALGR(HR_K) // Å‚ #define HR_CLST ALGR(HR_L) // Å #define HR_SS ALGR(HR_CACU) // ß #define HR_CURR ALGR(HR_ZCAR) // ¤ -// Row 4 #define HR_AT ALGR(HR_V) // @ #define HR_LCBR ALGR(HR_B) // { #define HR_RCBR ALGR(HR_N) // } diff --git a/quantum/keymap_extras/keymap_czech.h b/quantum/keymap_extras/keymap_czech.h index a8f522d31c..dadfc9c59b 100644 --- a/quantum/keymap_extras/keymap_czech.h +++ b/quantum/keymap_extras/keymap_czech.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ; │ + │ Ä› │ Å¡ │ Ä â”‚ Å™ │ ž │ ý │ á │ à │ é │ = │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ ú │ ) │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ů │ § │ ¨ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ \ │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define CZ_SCLN KC_GRV // ; #define CZ_PLUS KC_1 // + #define CZ_ECAR KC_2 // Ä› @@ -47,7 +41,6 @@ #define CZ_EACU KC_0 // é #define CZ_EQL KC_MINS // = #define CZ_ACUT KC_EQL // ´ (dead) -// Row 2 #define CZ_Q KC_Q // Q #define CZ_W KC_W // W #define CZ_E KC_E // E @@ -60,7 +53,6 @@ #define CZ_P KC_P // P #define CZ_UACU KC_LBRC // ú #define CZ_RPRN KC_RBRC // ) -// Row 3 #define CZ_A KC_A // A #define CZ_S KC_S // S #define CZ_D KC_D // D @@ -73,7 +65,6 @@ #define CZ_URNG KC_SCLN // ů #define CZ_SECT KC_QUOT // § #define CZ_DIAE KC_NUHS // ¨ (dead) -// Row 4 #define CZ_BSLS KC_NUBS // (backslash) #define CZ_Y KC_Z // Y #define CZ_X KC_X // X @@ -85,21 +76,6 @@ #define CZ_COMM KC_COMM // , #define CZ_DOT KC_DOT // . #define CZ_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ° │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ % │ ˇ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ / │ ( │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ " │ ! │ ' │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ | │ │ │ │ │ │ │ │ ? │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CZ_RNGA S(CZ_SCLN) // ° (dead) #define CZ_1 S(CZ_PLUS) // 1 #define CZ_2 S(CZ_ECAR) // 2 @@ -113,33 +89,15 @@ #define CZ_0 S(CZ_EACU) // 0 #define CZ_PERC S(CZ_EQL) // % #define CZ_CARN S(CZ_ACUT) // ˇ (dead) -// Row 2 #define CZ_SLSH S(CZ_UACU) // / #define CZ_LPRN S(CZ_RPRN) // ( -// Row 3 #define CZ_DQUO S(CZ_URNG) // " #define CZ_EXLM S(CZ_SECT) // ! #define CZ_QUOT S(CZ_DIAE) // ' -// Row 4 #define CZ_PIPE S(CZ_BSLS) // | #define CZ_QUES S(CZ_COMM) // ? #define CZ_COLN S(CZ_DOT) // : #define CZ_UNDS S(CZ_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ~ │ │ ^ │ ˘ │ │ Ë› │ ` │ Ë™ │ │ Ë â”‚ │ ¸ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ ÷ │ × │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ Ä‘ │ Ä â”‚ [ │ ] │ │ │ Å‚ │ Š│ $ │ ß │ ¤ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ # │ & │ @ │ { │ } │ │ < │ > │ * │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CZ_TILD ALGR(CZ_PLUS) // ~ #define CZ_CIRC ALGR(CZ_SCAR) // ^ (dead) #define CZ_BREV ALGR(CZ_CCAR) // ˘ (dead) @@ -148,11 +106,9 @@ #define CZ_DOTA ALGR(CZ_AACU) // Ë™ (dead) #define CZ_DACU ALGR(CZ_EACU) // Ë (dead) #define CZ_CEDL ALGR(CZ_ACUT) // ¸ (dead) -// Row 2 #define CZ_EURO ALGR(CZ_E) // € #define CZ_DIV ALGR(CZ_UACU) // ÷ #define CZ_MUL ALGR(CZ_RPRN) // × -// Row 3 #define CZ_LDST ALGR(CZ_S) // Ä‘ #define CZ_CDST ALGR(CZ_D) // Ä #define CZ_LBRC ALGR(CZ_F) // [ @@ -162,7 +118,6 @@ #define CZ_DLR ALGR(CZ_URNG) // $ #define CZ_SS ALGR(CZ_SECT) // ß #define CZ_CURR ALGR(CZ_DIAE) // ¤ -// Row 4 #define CZ_HASH ALGR(CZ_X) // # #define CZ_AMPR ALGR(CZ_C) // & #define CZ_AT ALGR(CZ_V) // @ diff --git a/quantum/keymap_extras/keymap_danish.h b/quantum/keymap_extras/keymap_danish.h index 9cf688d6f5..de45c4e864 100644 --- a/quantum/keymap_extras/keymap_danish.h +++ b/quantum/keymap_extras/keymap_danish.h @@ -1,39 +1,33 @@ -/* Copyright 2019 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ½ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Æ │ Ø │ ' │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define DK_HALF KC_GRV // ½ #define DK_1 KC_1 // 1 #define DK_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define DK_0 KC_0 // 0 #define DK_PLUS KC_MINS // + #define DK_ACUT KC_EQL // ´ (dead) -// Row 2 #define DK_Q KC_Q // Q #define DK_W KC_W // W #define DK_E KC_E // E @@ -60,7 +53,6 @@ #define DK_P KC_P // P #define DK_ARNG KC_LBRC // Ã… #define DK_DIAE KC_RBRC // ¨ (dead) -// Row 3 #define DK_A KC_A // A #define DK_S KC_S // S #define DK_D KC_D // D @@ -73,7 +65,6 @@ #define DK_AE KC_SCLN // Æ #define DK_OSTR KC_QUOT // Ø #define DK_QUOT KC_NUHS // ' -// Row 4 #define DK_LABK KC_NUBS // < #define DK_Z KC_Z // Z #define DK_X KC_X // X @@ -85,21 +76,6 @@ #define DK_COMM KC_COMM // , #define DK_DOT KC_DOT // . #define DK_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ § │ ! │ " │ # │ ¤ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define DK_SECT S(DK_HALF) // § #define DK_EXLM S(DK_1) // ! #define DK_DQUO S(DK_2) // " @@ -113,30 +89,12 @@ #define DK_EQL S(DK_0) // = #define DK_QUES S(DK_PLUS) // ? #define DK_GRV S(DK_ACUT) // ` (dead) -// Row 2 #define DK_CIRC S(DK_DIAE) // ^ (dead) -// Row 3 #define DK_ASTR S(DK_QUOT) // * -// Row 4 #define DK_RABK S(DK_LABK) // > #define DK_SCLN S(DK_COMM) // ; #define DK_COLN S(DK_DOT) // : #define DK_UNDS S(DK_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ @ │ £ │ $ │ € │ │ { │ [ │ ] │ } │ │ | │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ \ │ │ │ │ │ │ │ µ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define DK_AT ALGR(DK_2) // @ #define DK_PND ALGR(DK_3) // £ #define DK_DLR ALGR(DK_4) // $ @@ -146,8 +104,6 @@ #define DK_RBRC ALGR(DK_9) // ] #define DK_RCBR ALGR(DK_0) // } #define DK_PIPE ALGR(DK_ACUT) // | -// Row 2 #define DK_TILD ALGR(DK_DIAE) // ~ (dead) -// Row 4 #define DK_BSLS ALGR(DK_LABK) // (backslash) #define DK_MICR ALGR(DK_M) // µ diff --git a/quantum/keymap_extras/keymap_dvorak.h b/quantum/keymap_extras/keymap_dvorak.h index 7aa112ebcc..83fd59a6f9 100644 --- a/quantum/keymap_extras/keymap_dvorak.h +++ b/quantum/keymap_extras/keymap_dvorak.h @@ -1,39 +1,33 @@ -/* Copyright 2015-2016 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ [ │ ] │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ ' │ , │ . │ P │ Y │ F │ G │ C │ R │ L │ / │ = │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ O │ E │ U │ I │ D │ H │ T │ N │ S │ - │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ ; │ Q │ J │ K │ X │ B │ M │ W │ V │ Z │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define DV_GRV KC_GRV // ` #define DV_1 KC_1 // 1 #define DV_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define DV_0 KC_0 // 0 #define DV_LBRC KC_MINS // [ #define DV_RBRC KC_EQL // ] -// Row 2 #define DV_QUOT KC_Q // ' #define DV_COMM KC_W // , #define DV_DOT KC_E // . @@ -61,7 +54,6 @@ #define DV_SLSH KC_LBRC // / #define DV_EQL KC_RBRC // = #define DV_BSLS KC_BSLS // (backslash) -// Row 3 #define DV_A KC_A // A #define DV_O KC_S // O #define DV_E KC_D // E @@ -73,7 +65,6 @@ #define DV_N KC_L // N #define DV_S KC_SCLN // S #define DV_MINS KC_QUOT // - -// Row 4 #define DV_SCLN KC_Z // ; #define DV_Q KC_X // Q #define DV_J KC_C // J @@ -84,21 +75,6 @@ #define DV_W KC_COMM // W #define DV_V KC_DOT // V #define DV_Z KC_SLSH // Z - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ { │ } │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ " │ < │ > │ │ │ │ │ │ │ │ ? │ + │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ _ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ : │ │ │ │ │ │ │ │ │ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define DV_TILD S(DV_GRV) // ~ #define DV_EXLM S(DV_1) // ! #define DV_AT S(DV_2) // @ @@ -112,14 +88,11 @@ #define DV_RPRN S(DV_0) // ) #define DV_LCBR S(DV_LBRC) // { #define DV_RCBR S(DV_RBRC) // } -// Row 2 #define DV_DQUO S(DV_QUOT) // " #define DV_LABK S(DV_COMM) // < #define DV_RABK S(DV_DOT) // > #define DV_QUES S(DV_SLSH) // ? #define DV_PLUS S(DV_EQL) // + #define DV_PIPE S(DV_BSLS) // | -// Row 3 #define DV_UNDS S(DV_MINS) // _ -// Row 4 #define DV_COLN S(DV_SCLN) // : diff --git a/quantum/keymap_extras/keymap_dvorak_fr.h b/quantum/keymap_extras/keymap_dvorak_fr.h index 2dee8e32e7..a305e7bf09 100644 --- a/quantum/keymap_extras/keymap_dvorak_fr.h +++ b/quantum/keymap_extras/keymap_dvorak_fr.h @@ -1,47 +1,33 @@ -/* Copyright 2020 Guillaume Gérard - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -/* Dvorak for the French language - * Version: 2 - * - * The layout is designed by Francis Leboutte <dvorak-fr@algo.be> - * - * Source: https://algo.be/ergo/dvorak-fr.html - */ +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ #pragma once - #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ « │ » │ / │ - │ è │ \ │ ^ │ ( │ ` │ ) │ _ │ [ │ ] │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ : │ ' │ é │ G │ . │ H │ V │ C │ M │ K │ Z │ ¨ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ O │ A │ U │ E │ B │ F │ S │ T │ N │ D │ W │ ~ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ à │ ; │ Q │ , │ I │ Y │ X │ R │ L │ P │ J │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define DV_LDAQ KC_GRV // « #define DV_RDAQ KC_1 // » #define DV_SLSH KC_2 // / @@ -55,7 +41,6 @@ #define DV_UNDS KC_0 // _ #define DV_LBRC KC_MINS // [ #define DV_RBRC KC_EQL // ] -// Row 2 #define DV_COLN KC_Q // : #define DV_QUOT KC_W // ' #define DV_EACU KC_E // é @@ -68,7 +53,6 @@ #define DV_K KC_P // K #define DV_Z KC_LBRC // Z #define DV_DIAE KC_RBRC // ¨ (dead) -// Row 3 #define DV_O KC_A // O #define DV_A KC_S // A #define DV_U KC_D // U @@ -81,7 +65,6 @@ #define DV_D KC_SCLN // D #define DV_W KC_QUOT // W #define DV_TILD KC_NUHS // ~ (dead) -// Row 4 #define DV_AGRV KC_NUBS // à #define DV_SCLN KC_Z // ; #define DV_Q KC_X // Q @@ -93,21 +76,6 @@ #define DV_L KC_COMM // L #define DV_P KC_DOT // P #define DV_J KC_SLSH // J - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ * │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 0 │ 0 │ + │ % │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ ? │ < │ > │ │ ! │ │ │ │ │ │ │ = │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ # │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ ç │ | │ │ @ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define DV_ASTR S(DV_LDAQ) // * #define DV_1 S(DV_RDAQ) // 1 #define DV_2 S(DV_SLSH) // 2 @@ -121,15 +89,12 @@ #define DV_0 S(DV_UNDS) // 0 #define DV_PLUS S(DV_LBRC) // + #define DV_PERC S(DV_RBRC) // % -// Row 2 #define DV_QUES S(DV_COLN) // ? #define DV_LABK S(DV_QUOT) // < #define DV_RABK S(DV_EACU) // > #define DV_EXLM S(DV_DOT) // ! #define DV_EQL S(DV_DIAE) // = -// Row 3 #define DV_HASH S(DV_TILD) // # -// Row 4 #define DV_CCED S(DV_AGRV) // ç #define DV_PIPE S(DV_SCLN) // | #define DV_AT S(DV_COMM) // @ diff --git a/quantum/keymap_extras/keymap_dvorak_programmer.h b/quantum/keymap_extras/keymap_dvorak_programmer.h index 6de7033cb4..b6e754e3d0 100644 --- a/quantum/keymap_extras/keymap_dvorak_programmer.h +++ b/quantum/keymap_extras/keymap_dvorak_programmer.h @@ -1,39 +1,33 @@ -/* Copyright 2016 Artyom Mironov - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ $ │ & │ [ │ { │ } │ ( │ = │ * │ ) │ + │ ] │ ! │ # │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ ; │ , │ . │ P │ Y │ F │ G │ C │ R │ L │ / │ @ │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ O │ E │ U │ I │ D │ H │ T │ N │ S │ - │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ ' │ Q │ J │ K │ X │ B │ M │ W │ V │ Z │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define DP_DLR KC_GRV // $ #define DP_AMPR KC_1 // & #define DP_LBRC KC_2 // [ @@ -47,7 +41,6 @@ #define DP_RBRC KC_0 // ] #define DP_EXLM KC_MINS // ! #define DP_HASH KC_EQL // # -// Row 2 #define DP_SCLN KC_Q // ; #define DP_COMM KC_W // , #define DP_DOT KC_E // . @@ -61,7 +54,6 @@ #define DP_SLSH KC_LBRC // / #define DP_AT KC_RBRC // @ #define DP_BSLS KC_BSLS // (backslash) -// Row 3 #define DP_A KC_A // A #define DP_O KC_S // O #define DP_E KC_D // E @@ -73,7 +65,6 @@ #define DP_N KC_L // N #define DP_S KC_SCLN // S #define DP_MINS KC_QUOT // - -// Row 4 #define DP_QUOT KC_Z // ' #define DP_Q KC_X // Q #define DP_J KC_C // J @@ -84,21 +75,6 @@ #define DP_W KC_COMM // W #define DP_V KC_DOT // V #define DP_Z KC_SLSH // Z - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ % │ 7 │ 5 │ 3 │ 1 │ 9 │ 0 │ 2 │ 4 │ 6 │ 8 │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ : │ < │ > │ │ │ │ │ │ │ │ ? │ ^ │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ _ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ " │ │ │ │ │ │ │ │ │ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define DP_TILD S(DP_DLR) // ~ #define DP_PERC S(DP_AMPR) // % #define DP_7 S(DP_LBRC) // 7 @@ -112,14 +88,11 @@ #define DP_6 S(DP_RBRC) // 6 #define DP_8 S(DP_EXLM) // 8 #define DP_GRV S(DP_HASH) // ` -// Row 2 #define DP_COLN S(DP_SCLN) // : #define DP_LABK S(DP_COMM) // < #define DP_RABK S(DP_DOT) // > #define DP_QUES S(DP_SLSH) // ? #define DP_CIRC S(DP_AT) // ^ #define DP_PIPE S(DP_BSLS) // | -// Row 3 #define DP_UNDS S(DP_MINS) // _ -// Row 4 #define DP_DQUO S(DP_QUOT) // " diff --git a/quantum/keymap_extras/keymap_estonian.h b/quantum/keymap_extras/keymap_estonian.h index 6951baed5a..b59ecc3351 100644 --- a/quantum/keymap_extras/keymap_estonian.h +++ b/quantum/keymap_extras/keymap_estonian.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ˇ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ãœ │ Õ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ ' │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define EE_CARN KC_GRV // ˇ (dead) #define EE_1 KC_1 // 1 #define EE_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define EE_0 KC_0 // 0 #define EE_PLUS KC_MINS // + #define EE_ACUT KC_EQL // ´ (dead) -// Row 2 #define EE_Q KC_Q // Q #define EE_W KC_W // W #define EE_E KC_E // E @@ -60,7 +53,6 @@ #define EE_P KC_P // P #define EE_UDIA KC_LBRC // Ãœ #define EE_OTIL KC_RBRC // Õ -// Row 3 #define EE_A KC_A // A #define EE_S KC_S // S #define EE_D KC_D // D @@ -73,7 +65,6 @@ #define EE_ODIA KC_SCLN // Ö #define EE_ADIA KC_QUOT // Ä #define EE_QUOT KC_NUHS // ' -// Row 4 #define EE_LABK KC_NUBS // < #define EE_Z KC_Z // Z #define EE_X KC_X // X @@ -85,21 +76,6 @@ #define EE_COMM KC_COMM // , #define EE_DOT KC_DOT // . #define EE_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ " │ # │ ¤ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define EE_TILD S(EE_CARN) // ~ (dead) #define EE_EXLM S(EE_1) // ! #define EE_DQUO S(EE_2) // " @@ -113,28 +89,11 @@ #define EE_EQL S(EE_0) // = #define EE_QUES S(EE_PLUS) // ? #define EE_GRV S(EE_ACUT) // ` (dead) -// Row 3 #define EE_ASTR S(EE_QUOT) // * -// Row 4 #define EE_RABK S(EE_LABK) // > #define EE_SCLN S(EE_COMM) // ; #define EE_COLN S(EE_DOT) // : #define EE_UNDS S(EE_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ @ │ £ │ $ │ € │ │ { │ [ │ ] │ } │ \ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ § │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ Å¡ │ │ │ │ │ │ │ │ │ ^ │ ½ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ | │ ž │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define EE_AT ALGR(EE_2) // @ #define EE_PND ALGR(EE_3) // £ #define EE_DLR ALGR(EE_4) // $ @@ -144,12 +103,9 @@ #define EE_RBRC ALGR(EE_9) // ] #define EE_RCBR ALGR(EE_0) // } #define EE_BSLS ALGR(EE_PLUS) // (backslash) -// Row 2 #define EE_SECT ALGR(EE_OTIL) // § -// Row 3 #define EE_SCAR ALGR(EE_S) // Å¡ #define EE_CIRC ALGR(EE_ADIA) // ^ (dead) #define EE_HALF ALGR(EE_QUOT) // ½ -// Row 4 #define EE_PIPE ALGR(EE_LABK) // | #define EE_ZCAR ALGR(EE_Z) // ž diff --git a/quantum/keymap_extras/keymap_finnish.h b/quantum/keymap_extras/keymap_finnish.h index faca4e01d4..6d9cd09868 100644 --- a/quantum/keymap_extras/keymap_finnish.h +++ b/quantum/keymap_extras/keymap_finnish.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ ' │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define FI_SECT KC_GRV // § #define FI_1 KC_1 // 1 #define FI_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define FI_0 KC_0 // 0 #define FI_PLUS KC_MINS // + #define FI_ACUT KC_EQL // ´ (dead) -// Row 2 #define FI_Q KC_Q // Q #define FI_W KC_W // W #define FI_E KC_E // E @@ -60,7 +53,6 @@ #define FI_P KC_P // P #define FI_ARNG KC_LBRC // Ã… #define FI_DIAE KC_RBRC // ¨ (dead) -// Row 3 #define FI_A KC_A // A #define FI_S KC_S // S #define FI_D KC_D // D @@ -73,7 +65,6 @@ #define FI_ODIA KC_SCLN // Ö #define FI_ADIA KC_QUOT // Ä #define FI_QUOT KC_NUHS // ' -// Row 4 #define FI_LABK KC_NUBS // < #define FI_Z KC_Z // Z #define FI_X KC_X // X @@ -85,21 +76,6 @@ #define FI_COMM KC_COMM // , #define FI_DOT KC_DOT // . #define FI_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ½ │ ! │ " │ # │ ¤ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define FI_HALF S(FI_SECT) // ½ #define FI_EXLM S(FI_1) // ! #define FI_DQUO S(FI_2) // " @@ -113,30 +89,12 @@ #define FI_EQL S(FI_0) // = #define FI_QUES S(FI_PLUS) // ? #define FI_GRV S(FI_ACUT) // ` (dead) -// Row 2 #define FI_CIRC S(FI_DIAE) // ^ (dead) -// Row 3 #define FI_ASTR S(FI_QUOT) // * -// Row 4 #define FI_RABK S(FI_LABK) // > #define FI_SCLN S(FI_COMM) // ; #define FI_COLN S(FI_DOT) // : #define FI_UNDS S(FI_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ @ │ £ │ $ │ € │ │ { │ [ │ ] │ } │ \ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ | │ │ │ │ │ │ │ µ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define FI_AT ALGR(FI_2) // @ #define FI_PND ALGR(FI_3) // £ #define FI_DLR ALGR(FI_4) // $ @@ -146,8 +104,6 @@ #define FI_RBRC ALGR(FI_9) // ] #define FI_RCBR ALGR(FI_0) // } #define FI_BSLS ALGR(FI_PLUS) // (backslash) -// Row 2 #define FI_TILD ALGR(FI_DIAE) // ~ (dead) -// Row 4 #define FI_PIPE ALGR(FI_LABK) // | #define FI_MICR ALGR(FI_M) // µ diff --git a/quantum/keymap_extras/keymap_french.h b/quantum/keymap_extras/keymap_french.h index 0be53f0a9c..b08cee68ad 100644 --- a/quantum/keymap_extras/keymap_french.h +++ b/quantum/keymap_extras/keymap_french.h @@ -1,39 +1,33 @@ -/* Copyright 2015-2016 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ² │ & │ é │ " │ ' │ ( │ - │ è │ _ │ ç │ à │ ) │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ A │ Z │ E │ R │ T │ Y │ U │ I │ O │ P │ ^ │ $ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Q │ S │ D │ F │ G │ H │ J │ K │ L │ M │ ù │ * │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ W │ X │ C │ V │ B │ N │ , │ ; │ : │ ! │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define FR_SUP2 KC_GRV // ² #define FR_AMPR KC_1 // & #define FR_EACU KC_2 // é @@ -47,7 +41,6 @@ #define FR_AGRV KC_0 // à #define FR_RPRN KC_MINS // ) #define FR_EQL KC_EQL // = -// Row 2 #define FR_A KC_Q // A #define FR_Z KC_W // Z #define FR_E KC_E // E @@ -60,7 +53,6 @@ #define FR_P KC_P // P #define FR_CIRC KC_LBRC // ^ (dead) #define FR_DLR KC_RBRC // $ -// Row 3 #define FR_Q KC_A // Q #define FR_S KC_S // S #define FR_D KC_D // D @@ -73,7 +65,6 @@ #define FR_M KC_SCLN // M #define FR_UGRV KC_QUOT // ù #define FR_ASTR KC_NUHS // * -// Row 4 #define FR_LABK KC_NUBS // < #define FR_W KC_Z // W #define FR_X KC_X // X @@ -85,21 +76,6 @@ #define FR_SCLN KC_COMM // ; #define FR_COLN KC_DOT // : #define FR_EXLM KC_SLSH // ! - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ° │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ £ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ % │ µ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ ? │ . │ / │ § │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define FR_1 S(FR_AMPR) // 1 #define FR_2 S(FR_EACU) // 2 #define FR_3 S(FR_DQUO) // 3 @@ -112,33 +88,15 @@ #define FR_0 S(FR_AGRV) // 0 #define FR_DEG S(FR_RPRN) // ° #define FR_PLUS S(FR_EQL) // + -// Row 2 #define FR_DIAE S(FR_CIRC) // ¨ (dead) #define FR_PND S(FR_DLR) // £ -// Row 3 #define FR_PERC S(FR_UGRV) // % #define FR_MICR S(FR_ASTR) // µ -// Row 4 #define FR_RABK S(FR_LABK) // > #define FR_QUES S(FR_COMM) // ? #define FR_DOT S(FR_SCLN) // . #define FR_SLSH S(FR_COLN) // / #define FR_SECT S(FR_EXLM) // § - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ ~ │ # │ { │ [ │ | │ ` │ \ │ │ @ │ ] │ } │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ │ ¤ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define FR_TILD ALGR(FR_EACU) // ~ (dead) #define FR_HASH ALGR(FR_DQUO) // # #define FR_LCBR ALGR(FR_QUOT) // { @@ -149,6 +107,5 @@ #define FR_AT ALGR(FR_AGRV) // @ #define FR_RBRC ALGR(FR_RPRN) // ] #define FR_RCBR ALGR(FR_EQL) // } -// Row 2 -#define FR_EURO ALGR(KC_E) // € -#define FR_CURR ALGR(FR_DLR) // ¤ +#define FR_EURO ALGR(KC_E) // € +#define FR_CURR ALGR(FR_DLR) // ¤ diff --git a/quantum/keymap_extras/keymap_french_afnor.h b/quantum/keymap_extras/keymap_french_afnor.h index 4b7961724f..46f64bfb98 100644 --- a/quantum/keymap_extras/keymap_french_afnor.h +++ b/quantum/keymap_extras/keymap_french_afnor.h @@ -1,63 +1,33 @@ -/* Copyright 2020 Guillaume Gérard - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -/* French AZERTY - AFNOR NF Z71-300 - * - * A standard for the French keyboard - * - * The project was launched at the end of 2015 on the proposal of the General - * Delegation for the French language and the languages of France (Ministry - * of Culture), starting from the observation that the current "azerty" - * keyboards constrain the writing of French, languages regional and European - * languages with Latin alphabet. - * - * For the first time, a standard (NF Z71-300) defines the placement of - * characters on the French keyboard. It offers two layouts, one of which - * closely follows the QWERTY keyboard used by most people who write in French. - * - * However, it is in many ways superior to the old keyboard: - * - * - it contains all the characters required to enter text in French (for example É, Å“ and ") - * - it is designed to be more ergonomic and allow faster typing - * - it includes almost 60 additional characters for entering foreign languages, technical content, etc - * - however, the characters remain easy to locate thanks to intuitive groupings - * - * Source: https://norme-azerty.fr - */ +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ #pragma once - #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ @ │ à │ é │ è │ ê │ ( │ ) │ ‘ │ ’ │ « │ » │ ' │ ^ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ A │ Z │ E │ R │ T │ Y │ U │ I │ O │ P │ - │ + │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Q │ S │ D │ F │ G │ H │ J │ K │ L │ M │ / │ * │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ W │ X │ C │ V │ B │ N │ . │ , │ : │ ; │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define FR_AT KC_GRV // @ #define FR_AGRV KC_1 // à #define FR_EACU KC_2 // é @@ -71,7 +41,6 @@ #define FR_RDAQ KC_0 // » #define FR_QUOT KC_MINS // ' #define FR_DCIR KC_EQL // ^ (dead) -// Row 2 #define FR_A KC_Q // A #define FR_Z KC_W // Z #define FR_E KC_E // E @@ -84,7 +53,6 @@ #define FR_P KC_P // P #define FR_MINS KC_LBRC // - #define FR_PLUS KC_RBRC // + -// Row 3 #define FR_Q KC_A // Q #define FR_S KC_S // S #define FR_D KC_D // D @@ -97,7 +65,6 @@ #define FR_M KC_SCLN // M #define FR_SLSH KC_QUOT // / #define FR_ASTR KC_NUHS // * -// Row 4 #define FR_LABK KC_NUBS // < #define FR_W KC_Z // W #define FR_X KC_X // X @@ -109,21 +76,6 @@ #define FR_COMM KC_COMM // , #define FR_COLN KC_DOT // : #define FR_SCLN KC_SLSH // ; - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ # │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ " │ ¨ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ – │ ± │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ \ │ ½ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ ? │ ! │ … │ = │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define FR_HASH S(FR_AT) // # #define FR_1 S(FR_AGRV) // 1 #define FR_2 S(FR_EACU) // 2 @@ -137,33 +89,15 @@ #define FR_0 S(FR_RDAQ) // 0 #define FR_DQUO S(FR_QUOT) // " #define FR_DIAE S(FR_DCIR) // ¨ (dead) -// Row 2 #define FR_NDSH S(FR_MINS) // – #define FR_PLMN S(FR_PLUS) // ± -// Row 3 #define FR_BSLS S(FR_SLSH) // (backslash) #define FR_HALF S(FR_ASTR) // ½ -// Row 4 #define FR_RABK S(FR_LABK) // > #define FR_QUES S(FR_DOT) // ? #define FR_EXLM S(FR_COMM) // ! #define FR_ELLP S(FR_COLN) // … #define FR_EQL S(FR_SCLN) // = - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ˘ │ § │ ´ │ ` │ & │ [ │ ] │ ¯ │ _ │ “ │ †│ ° │ ˇ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ æ │ £ │ € │ ® │ { │ } │ ù │ Ë™ │ Å“ │ % │ − │ †│ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ θ │ ß │ $ │ ¤ │ µ │ Eu│ │ ∕ │ | │ ∞ │ ÷ │ × │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ ≤ │ Ê’ │ © │ ç │ ¸ │ − │ ~ │ ¿ │ ¡ │ · │ ≃ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define FR_BREV ALGR(FR_AT) // ˘ (dead) #define FR_SECT ALGR(FR_AGRV) // § #define FR_ACUT ALGR(FR_EACU) // ´ (dead) @@ -177,7 +111,6 @@ #define FR_RDQU ALGR(FR_RDAQ) // †#define FR_DEG ALGR(FR_QUOT) // ° #define FR_CARN ALGR(FR_DCIR) // ˇ (dead) -// Row 2 #define FR_AE ALGR(FR_A) // æ #define FR_PND ALGR(FR_Z) // £ #define FR_EURO ALGR(FR_E) // € @@ -190,7 +123,6 @@ #define FR_PERC ALGR(FR_P) // % #define FR_MMNS ALGR(FR_MINS) // − #define FR_DAGG ALGR(FR_PLUS) // †-// Row 3 #define FR_THET ALGR(FR_Q) // θ #define FR_SS ALGR(FR_S) // ß #define FR_DLR ALGR(FR_D) // $ @@ -202,7 +134,6 @@ #define FR_INFN ALGR(FR_M) // ∞ #define FR_DIV ALGR(FR_SLSH) // ÷ #define FR_MUL ALGR(FR_ASTR) // × -// Row 4 #define FR_LEQL ALGR(FR_LABK) // ≤ #define FR_EZH ALGR(FR_W) // Ê’ #define FR_COPY ALGR(FR_X) // © @@ -214,40 +145,22 @@ #define FR_IEXL ALGR(FR_COMM) // ¡ #define FR_MDDT ALGR(FR_COLN) // · #define FR_AEQL ALGR(FR_SCLN) // ≃ - -/* Shift+AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ Ì‘ │ │ │ │ │ Ë â”‚ Ì â”‚ │ — │ ‹ │ › │ Ëš │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ â„¢ │ │ │ Ì£ │ │ ‰ │ ‑ │ ‡ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ Ë â”‚ │ │ │ │ √ │ ¼ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ ≥ │ │ │ │ Ë› │ │ │ │ ̦ │ │ ≠│ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 -#define FR_IBRV S(ALGR(FR_AT)) // Ì‘ (dead) +#define FR_IBRV S(ALGR(FR_AT)) // Ì‘ (dead) #define FR_DACU S(ALGR(FR_LPRN)) // Ë (dead) -#define FR_DGRV S(ALGR(FR_RPRN)) // Ì (dead) +#define FR_DGRV S(ALGR(FR_RPRN)) // Ì (dead) #define FR_MDSH S(ALGR(FR_RSQU)) // — #define FR_LSAQ S(ALGR(FR_LDAQ)) // ‹ #define FR_RSAQ S(ALGR(FR_RDAQ)) // › #define FR_RNGA S(ALGR(FR_QUOT)) // Ëš (dead) -// Row 2 #define FR_TM S(ALGR(FR_T)) // â„¢ -#define FR_DOTB S(ALGR(FR_I)) // Ì£ (dead) +#define FR_DOTB S(ALGR(FR_I)) // Ì£ (dead) #define FR_PERM S(ALGR(FR_P)) // ‰ #define FR_NBHY S(ALGR(FR_MINS)) // ‑ (non-breaking hyphen) #define FR_DDAG S(ALGR(FR_PLUS)) // ‡ -// Row 3 #define FR_MACB S(ALGR(FR_H)) // Ë (dead) #define FR_SQRT S(ALGR(FR_SLSH)) // √ #define FR_QRTR S(ALGR(FR_ASTR)) // ¼ -// Row 4 #define FR_GEQL S(ALGR(FR_LABK)) // ≥ #define FR_OGON S(ALGR(FR_V)) // Ë› (dead) -#define FR_DCMM S(ALGR(FR_COMM)) // ̦ (dead) +#define FR_DCMM S(ALGR(FR_COMM)) // ̦ (dead) #define FR_NEQL S(ALGR(FR_SCLN)) // ≠diff --git a/quantum/keymap_extras/keymap_french_mac_iso.h b/quantum/keymap_extras/keymap_french_mac_iso.h index 590a57e55c..91fbdef7ab 100644 --- a/quantum/keymap_extras/keymap_french_mac_iso.h +++ b/quantum/keymap_extras/keymap_french_mac_iso.h @@ -1,39 +1,33 @@ -/* Copyright 2016 Sébastien Pérochon - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ @ │ & │ é │ " │ ' │ ( │ § │ è │ ! │ ç │ à │ ) │ - │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ A │ Z │ E │ R │ T │ Y │ U │ I │ O │ P │ ^ │ $ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Q │ S │ D │ F │ G │ H │ J │ K │ L │ M │ ù │ ` │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ < │ W │ X │ C │ V │ B │ N │ , │ ; │ : │ = │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 +// Aliases #define FR_AT KC_GRV // @ #define FR_AMPR KC_1 // & #define FR_LEAC KC_2 // é @@ -47,7 +41,6 @@ #define FR_LAGR KC_0 // à #define FR_RPRN KC_MINS // ) #define FR_MINS KC_EQL // - -// Row 2 #define FR_A KC_Q // A #define FR_Z KC_W // Z #define FR_E KC_E // E @@ -60,7 +53,6 @@ #define FR_P KC_P // P #define FR_CIRC KC_LBRC // ^ #define FR_DLR KC_RBRC // $ -// Row 3 #define FR_Q KC_A // Q #define FR_S KC_S // S #define FR_D KC_D // D @@ -73,7 +65,6 @@ #define FR_M KC_SCLN // M #define FR_LUGR KC_QUOT // ù #define FR_GRV KC_NUHS // ` -// Row 4 #define FR_LABK KC_NUBS // < #define FR_W KC_Z // W #define FR_X KC_X // X @@ -85,21 +76,6 @@ #define FR_SCLN KC_COMM // ; #define FR_COLN KC_DOT // : #define FR_EQL KC_SLSH // = - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ # │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ° │ _ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ * │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ % │ £ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ > │ │ │ │ │ │ │ ? │ . │ / │ + │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define FR_HASH S(FR_AT) // # #define FR_1 S(FR_AMPR) // 1 #define FR_2 S(FR_LEAC) // 2 @@ -113,33 +89,15 @@ #define FR_0 S(FR_LAGR) // 0 #define FR_DEG S(FR_RPRN) // ° #define FR_UNDS S(FR_MINS) // _ -// Row 2 #define FR_DIAE S(FR_CIRC) // ¨ (dead) #define FR_ASTR S(FR_DLR) // * -// Row 3 #define FR_PERC S(FR_LUGR) // % #define FR_PND S(FR_GRV) // £ -// Row 4 #define FR_RABK S(FR_LABK) // > #define FR_QUES S(FR_COMM) // ? #define FR_DOT S(FR_SCLN) // . #define FR_SLSH S(FR_COLN) // / #define FR_PLUS S(FR_EQL) // + - -/* Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ • │  │ ë │ “ │ ‘ │ { │ ¶ │ « │ ¡ │ Ç │ Ø │ } │ — │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ Æ │  │ Ê │ ® │ †│ Ú │ º │ î │ Å’ │ Ï€ │ Ô │ € │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ ‡ │ Ã’ │ ∂ │ Æ’ │ ï¬ â”‚ ÃŒ │ à │ È │ ¬ │ µ │ Ù │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≤ │ ‹ │ ≈ │ © │ â—Š │ ß │ ~ │ ∞ │ … │ ÷ │ ≠│ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define FR_BULT A(FR_AT) // • #define FR_APPL A(FR_AMPR) //  (Apple logo) #define FR_LEDI A(FR_LEAC) // ë @@ -153,7 +111,6 @@ #define FR_OSTR A(FR_LAGR) // Ø #define FR_RCBR A(FR_RPRN) // } #define FR_MDSH A(FR_MINS) // — -// Row 2 #define FR_AE A(FR_A) // Æ #define FR_CACI A(FR_Z) //  #define FR_ECIR A(FR_E) // Ê @@ -166,7 +123,6 @@ #define FR_PI A(FR_P) // Ï€ #define FR_OCIR A(FR_CIRC) // Ô #define FR_EURO A(FR_DLR) // € -// Row 3 #define FR_DDAG A(FR_Q) // ‡ #define FR_COGR A(FR_S) // Ã’ #define FR_PDIF A(FR_D) // ∂ @@ -178,7 +134,6 @@ #define FR_NOT A(FR_L) // ¬ #define FR_MICR A(FR_M) // µ #define FR_CUGR A(FR_LUGR) // Ù -// Row 4 #define FR_LTEQ A(FR_LABK) // ≤ #define FR_LSAQ A(FR_W) // ‹ #define FR_AEQL A(FR_X) // ≈ @@ -190,21 +145,6 @@ #define FR_ELLP A(FR_SCLN) // … #define FR_DIV A(FR_COLN) // ÷ #define FR_NEQL A(FR_EQL) // ≠- -/* Shift+Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ Ÿ │ ´ │ „ │ │ │ [ │ Ã¥ │ » │ Û │ à │ │ ] │ – │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ Ã… │ │ ‚ │ â„¢ │ │ ª │ ï │ │ ∠│ │ Â¥ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Ω │ ∑ │ ∆ │ · │ fl │ ÃŽ │ à │ Ë │ | │ Ó │ ‰ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≥ │ › │ ℠│ ¢ │ √ │ ∫ │ ı │ ¿ │ │ \ │ ± │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define FR_CYDI S(A(FR_AT)) // Ÿ #define FR_ACUT S(A(FR_AMPR)) // ´ (dead) #define FR_DLQU S(A(FR_LEAC)) // „ @@ -215,7 +155,6 @@ #define FR_CAAC S(A(FR_LCCE)) // à #define FR_RBRC S(A(FR_RPRN)) // ] #define FR_NDSH S(A(FR_MINS)) // – -// Row 2 #define FR_CARI S(A(FR_Z)) // Ã… #define FR_SLQU S(A(FR_R)) // ‚ #define FR_TM S(A(FR_T)) // â„¢ @@ -223,7 +162,6 @@ #define FR_LIDI S(A(FR_I)) // ï #define FR_NARP S(A(FR_P)) // ∠#define FR_YEN S(A(FR_DLR)) // Â¥ -// Row 3 #define FR_OMEG S(A(FR_Q)) // Ω #define FR_NARS S(A(FR_S)) // ∑ #define FR_INCR S(A(FR_D)) // ∆ @@ -235,7 +173,6 @@ #define FR_PIPE S(A(FR_L)) // | #define FR_COAC S(A(FR_M)) // Ó #define FR_PERM S(A(FR_LUGR)) // ‰ -// Row 4 #define FR_GTEQ S(A(FR_LABK)) // ≥ #define FR_RSAQ S(A(FR_W)) // › #define FR_FRSL S(A(FR_X)) // â„ diff --git a/quantum/keymap_extras/keymap_german.h b/quantum/keymap_extras/keymap_german.h index 085995b0c6..789df22fc3 100644 --- a/quantum/keymap_extras/keymap_german.h +++ b/quantum/keymap_extras/keymap_german.h @@ -1,39 +1,33 @@ -/* Copyright 2015-2016 Matthias Schmidtt - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ^ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ß │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Ãœ │ + │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ # │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define DE_CIRC KC_GRV // ^ (dead) #define DE_1 KC_1 // 1 #define DE_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define DE_0 KC_0 // 0 #define DE_SS KC_MINS // ß #define DE_ACUT KC_EQL // ´ (dead) -// Row 2 #define DE_Q KC_Q // Q #define DE_W KC_W // W #define DE_E KC_E // E @@ -60,7 +53,6 @@ #define DE_P KC_P // P #define DE_UDIA KC_LBRC // Ãœ #define DE_PLUS KC_RBRC // + -// Row 3 #define DE_A KC_A // A #define DE_S KC_S // S #define DE_D KC_D // D @@ -73,7 +65,6 @@ #define DE_ODIA KC_SCLN // Ö #define DE_ADIA KC_QUOT // Ä #define DE_HASH KC_NUHS // # -// Row 4 #define DE_LABK KC_NUBS // < #define DE_Y KC_Z // Y #define DE_X KC_X // X @@ -85,21 +76,6 @@ #define DE_COMM KC_COMM // , #define DE_DOT KC_DOT // . #define DE_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ° │ ! │ " │ § │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ' │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define DE_DEG S(DE_CIRC) // ° #define DE_EXLM S(DE_1) // ! #define DE_DQUO S(DE_2) // " @@ -113,30 +89,12 @@ #define DE_EQL S(DE_0) // = #define DE_QUES S(DE_SS) // ? #define DE_GRV S(DE_ACUT) // ` (dead) -// Row 2 #define DE_ASTR S(DE_PLUS) // * -// Row 3 #define DE_QUOT S(DE_HASH) // ' -// Row 4 #define DE_RABK S(DE_LABK) // > #define DE_SCLN S(DE_COMM) // ; #define DE_COLN S(DE_DOT) // : #define DE_UNDS S(DE_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ ² │ ³ │ │ │ │ { │ [ │ ] │ } │ \ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ @ │ │ € │ │ │ │ │ │ │ │ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ | │ │ │ │ │ │ │ µ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define DE_SUP2 ALGR(DE_2) // ² #define DE_SUP3 ALGR(DE_3) // ³ #define DE_LCBR ALGR(DE_7) // { @@ -144,10 +102,8 @@ #define DE_RBRC ALGR(DE_9) // ] #define DE_RCBR ALGR(DE_0) // } #define DE_BSLS ALGR(DE_SS) // (backslash) -// Row 2 #define DE_AT ALGR(DE_Q) // @ #define DE_EURO ALGR(DE_E) // € #define DE_TILD ALGR(DE_PLUS) // ~ -// Row 4 #define DE_PIPE ALGR(DE_LABK) // | #define DE_MICR ALGR(DE_M) // µ diff --git a/quantum/keymap_extras/keymap_german_mac_iso.h b/quantum/keymap_extras/keymap_german_mac_iso.h index 82404fa5fd..588b41091b 100644 --- a/quantum/keymap_extras/keymap_german_mac_iso.h +++ b/quantum/keymap_extras/keymap_german_mac_iso.h @@ -1,39 +1,33 @@ -/* Copyright 2016 Stephen Bösebeck - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ^ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ß │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Ãœ │ + │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ # │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 +// Aliases #define DE_CIRC KC_GRV // ^ (dead) #define DE_1 KC_1 // 1 #define DE_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define DE_0 KC_0 // 0 #define DE_SS KC_MINS // ß #define DE_ACUT KC_EQL // ´ (dead) -// Row 2 #define DE_Q KC_Q // Q #define DE_W KC_W // W #define DE_E KC_E // E @@ -60,7 +53,6 @@ #define DE_P KC_P // P #define DE_UDIA KC_LBRC // Ãœ #define DE_PLUS KC_RBRC // + -// Row 3 #define DE_A KC_A // A #define DE_S KC_S // S #define DE_D KC_D // D @@ -73,7 +65,6 @@ #define DE_ODIA KC_SCLN // Ö #define DE_ADIA KC_QUOT // Ä #define DE_HASH KC_NUHS // # -// Row 4 #define DE_LABK KC_NUBS // < #define DE_Y KC_Z // Y #define DE_X KC_X // X @@ -85,21 +76,6 @@ #define DE_COMM KC_COMM // , #define DE_DOT KC_DOT // . #define DE_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ° │ ! │ " │ § │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ' │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define DE_DEG S(DE_CIRC) // ° #define DE_EXLM S(DE_1) // ! #define DE_DQUO S(DE_2) // " @@ -113,30 +89,12 @@ #define DE_EQL S(DE_0) // = #define DE_QUES S(DE_SS) // ? #define DE_GRV S(DE_ACUT) // ` (dead) -// Row 2 #define DE_ASTR S(DE_PLUS) // * -// Row 3 #define DE_QUOT S(DE_HASH) // ' -// Row 4 #define DE_RABK S(DE_LABK) // > #define DE_SCLN S(DE_COMM) // ; #define DE_COLN S(DE_DOT) // : #define DE_UNDS S(DE_MINS) // _ - -/* Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ „ │ ¡ │ “ │ ¶ │ ¢ │ [ │ ] │ | │ { │ } │ ≠│ ¿ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ « │ ∑ │ € │ ® │ †│ Ω │ ¨ │ ℠│ Ø │ Ï€ │ • │ ± │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Ã… │ ‚ │ ∂ │ Æ’ │ © │ ª │ º │ ∆ │ @ │ Å’ │ Æ │ ‘ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≤ │ Â¥ │ ≈ │ Ç │ √ │ ∫ │ ~ │ µ │ ∞ │ … │ – │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define DE_DLQU A(DE_CIRC) // „ #define DE_IEXL A(DE_1) // ¡ #define DE_LDQU A(DE_2) // “ @@ -149,7 +107,6 @@ #define DE_RCBR A(DE_9) // } #define DE_NEQL A(DE_0) // ≠#define DE_IQUE A(DE_SS) // ¿ -// Row 2 #define DE_LDAQ A(DE_Q) // « #define DE_NARS A(DE_W) // ∑ #define DE_EURO A(DE_E) // € @@ -162,7 +119,6 @@ #define DE_PI A(DE_P) // Ï€ #define DE_BULT A(DE_UDIA) // • #define DE_PLMN A(DE_PLUS) // ± -// Row 3 #define DE_ARNG A(DE_A) // Ã… #define DE_SLQU A(DE_S) // ‚ #define DE_PDIF A(DE_D) // ∂ @@ -175,7 +131,6 @@ #define DE_OE A(DE_ODIA) // Å’ #define DE_AE A(DE_ADIA) // Æ #define DE_LSQU A(DE_HASH) // ‘ -// Row 4 #define DE_LTEQ A(DE_LABK) // ≤ #define DE_YEN A(DE_Y) // Â¥ #define DE_AEQL A(DE_X) // ≈ @@ -187,21 +142,6 @@ #define DE_INFN A(DE_COMM) // ∞ #define DE_ELLP A(DE_DOT) // … #define DE_NDSH A(DE_MINS) // – - -/* Shift+Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ │ ¬ │ †│ │ £ │ ï¬ â”‚ │ \ │ Ëœ │ · │ ¯ │ Ë™ │ Ëš │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ » │ │ ‰ │ ¸ │ Ë â”‚ ˇ │ à │ Û │ │ ∠│ │  │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ à │ â„¢ │ à │ ÃŒ │ Ó │ ı │ │ fl │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≥ │ ‡ │ Ù │ │ â—Š │ ‹ │ › │ ˘ │ Ë› │ ÷ │ — │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define DE_NOT S(A(DE_1)) // ¬ #define DE_RDQU S(A(DE_2)) // †#define DE_PND S(A(DE_4)) // £ @@ -212,7 +152,6 @@ #define DE_MACR S(A(DE_0)) // ¯ #define DE_DOTA S(A(DE_SS)) // Ë™ #define DE_RNGA S(A(DE_ACUT)) // Ëš -// Row 2 #define DE_RDAQ S(A(DE_Q)) // » #define DE_PERM S(A(DE_E)) // ‰ #define DE_CEDL S(A(DE_R)) // ¸ @@ -222,7 +161,6 @@ #define DE_UCIR S(A(DE_I)) // Û #define DE_NARP S(A(DE_P)) // ∠#define DE_APPL S(A(DE_PLUS)) //  (Apple logo) -// Row 3 #define DE_IACU S(A(DE_S)) // à #define DE_TM S(A(DE_D)) // â„¢ #define DE_IDIA S(A(DE_F)) // à @@ -230,7 +168,6 @@ #define DE_OACU S(A(DE_H)) // Ó #define DE_DLSI S(A(DE_J)) // ı #define DE_FL S(A(DE_L)) // fl -// Row 4 #define DE_GTEQ S(A(DE_LABK)) // ≥ #define DE_DDAG S(A(DE_Y)) // ‡ #define DE_UGRV S(A(DE_X)) // Ù diff --git a/quantum/keymap_extras/keymap_greek.h b/quantum/keymap_extras/keymap_greek.h index 8c23381204..f0d96f905f 100644 --- a/quantum/keymap_extras/keymap_greek.h +++ b/quantum/keymap_extras/keymap_greek.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ ; │ Ï‚ │ Ε │ Ρ │ Τ │ Î¥ │ Θ │ Ι │ Ο │ Π│ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Α │ Σ │ Δ │ Φ │ Γ │ Η │ Ξ │ Κ │ Λ │ ΄ │ ' │ \ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ Ζ │ Χ │ Ψ │ Ω │ Î’ │ Π│ Îœ │ , │ . │ / │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define GR_GRV KC_GRV // ` #define GR_1 KC_1 // 1 #define GR_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define GR_0 KC_0 // 0 #define GR_MINS KC_MINS // - #define GR_EQL KC_EQL // = -// Row 2 #define GR_SCLN KC_Q // ; #define GR_FSIG KC_W // Ï‚ #define GR_EPSL KC_E // Ε @@ -60,7 +53,6 @@ #define GR_PI KC_P // Î #define GR_LBRC KC_LBRC // [ #define GR_RBRC KC_RBRC // ] -// Row 3 #define GR_ALPH KC_A // Α #define GR_SIGM KC_S // Σ #define GR_DELT KC_D // Δ @@ -73,7 +65,6 @@ #define GR_TONS KC_SCLN // ΄ (dead) #define GR_QUOT KC_QUOT // ' #define GR_BSLS KC_NUHS // (backslash) -// Row 4 #define GR_ZETA KC_Z // Ζ #define GR_CHI KC_X // Χ #define GR_PSI KC_C // Ψ @@ -84,21 +75,6 @@ #define GR_COMM KC_COMM // , #define GR_DOT KC_DOT // . #define GR_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ : │ Î… │ │ │ │ │ │ │ │ │ { │ } │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ ¨ │ " │ | │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define GR_TILD S(GR_GRV) // ~ #define GR_EXLM S(GR_1) // ! #define GR_AT S(GR_2) // @ @@ -112,34 +88,16 @@ #define GR_RPRN S(GR_0) // ) #define GR_UNDS S(GR_MINS) // _ #define GR_PLUS S(GR_EQL) // + -// Row 2 #define GR_COLN S(GR_SCLN) // : #define GR_DIAT S(GR_FSIG) // Î… (dead) #define GR_LCBR S(GR_LBRC) // { #define GR_RCBR S(GR_RBRC) // } -// Row 3 #define GR_DIAE S(GR_TONS) // ¨ (dead) #define GR_DQUO S(GR_QUOT) // " #define GR_PIPE S(GR_BSLS) // | -// Row 4 #define GR_LABK S(GR_COMM) // < #define GR_RABK S(GR_DOT) // > #define GR_QUES S(GR_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ ² │ ³ │ £ │ § │ ¶ │ │ ¤ │ ¦ │ ° │ ± │ ½ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ ® │ │ Â¥ │ │ │ │ │ « │ » │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ¬ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ © │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define GR_SUP2 ALGR(GR_2) // ² #define GR_SUP3 ALGR(GR_3) // ³ #define GR_PND ALGR(GR_4) // £ @@ -150,13 +108,10 @@ #define GR_DEG ALGR(GR_0) // ° #define GR_PLMN ALGR(GR_MINS) // ± #define GR_HALF ALGR(GR_EQL) // ½ -// Row 2 #define GR_EURO ALGR(GR_EPSL) // € #define GR_REGD ALGR(GR_RHO) // ® #define GR_YEN ALGR(GR_UPSL) // Â¥ #define GR_LDAQ ALGR(GR_LBRC) // « #define GR_RDAQ ALGR(GR_RBRC) // » -// Row 3 #define GR_NOT ALGR(GR_BSLS) // ¬ -// Row 4 #define GR_COPY ALGR(GR_PSI) // © diff --git a/quantum/keymap_extras/keymap_hebrew.h b/quantum/keymap_extras/keymap_hebrew.h index 87b488f04d..edfd5e70c3 100644 --- a/quantum/keymap_extras/keymap_hebrew.h +++ b/quantum/keymap_extras/keymap_hebrew.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ; │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ / │ ' │ פ │ × â”‚ ן │ ו │ ט │ × â”‚ ר │ ק │ ] │ [ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ ×£ │ ך │ ל │ ×— │ ×™ │ ×¢ │ ×› │ ×’ │ ד │ ש │ , │ \ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ ×¥ │ ת │ צ │ מ │ × â”‚ ×” │ ב │ ס │ ×– │ . │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define IL_SCLN KC_GRV // ; #define IL_1 KC_1 // 1 #define IL_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define IL_0 KC_0 // 0 #define IL_MINS KC_MINS // - #define IL_EQL KC_EQL // = -// Row 2 #define IL_SLSH KC_Q // / #define IL_QUOT KC_W // ' #define IL_QOF KC_E // ק @@ -60,7 +53,6 @@ #define IL_PE KC_P // פ #define IL_RBRC KC_LBRC // ] #define IL_LBRC KC_RBRC // [ -// Row 3 #define IL_SHIN KC_A // ש #define IL_DALT KC_S // ד #define IL_GIML KC_D // ×’ @@ -73,7 +65,6 @@ #define IL_FPE KC_SCLN // ×£ #define IL_COMM KC_QUOT // , #define IL_BSLS KC_NUHS // (backslash) -// Row 4 #define IL_ZAYN KC_Z // ×– #define IL_SMKH KC_X // ס #define IL_BET KC_C // ב @@ -84,21 +75,6 @@ #define IL_TAV KC_COMM // ת #define IL_FTSD KC_DOT // ×¥ #define IL_DOT KC_SLSH // . - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ) │ ( │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ } │ { │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ : │ " │ | │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ > │ < │ ? │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define IL_TILD S(IL_SCLN) // ~ #define IL_EXLM S(IL_1) // ! #define IL_AT S(IL_2) // @ @@ -112,40 +88,19 @@ #define IL_LPRN S(IL_0) // ( #define IL_UNDS S(IL_MINS) // _ #define IL_PLUS S(IL_EQL) // + -// Row 2 #define IL_RCBR S(IL_RBRC) // } #define IL_LCBR S(IL_LBRC) // { -// Row 3 #define IL_COLN S(IL_FPE) // : #define IL_DQUO S(IL_COMM) // " #define IL_PIPE S(IL_BSLS) // | -// Row 4 #define IL_RABK S(IL_TAV) // > #define IL_LABK S(IL_FTSD) // < #define IL_QUES S(IL_DOT) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ │ € │ ₪ │ ° │ │ │ × │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ ×° │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ ײ │ ×± │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ ÷ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define IL_EURO ALGR(IL_3) // € #define IL_SHKL ALGR(IL_4) // ₪ #define IL_DEG ALGR(IL_5) // ° #define IL_MUL ALGR(IL_8) // × -// Row 2 #define IL_DVAV ALGR(IL_TET) // ×° -// Row 3 #define IL_VYOD ALGR(IL_AYIN) // ×± #define IL_DYOD ALGR(IL_YOD) // ײ -// Row 4 #define IL_DIV ALGR(IL_DOT) // ÷ diff --git a/quantum/keymap_extras/keymap_hungarian.h b/quantum/keymap_extras/keymap_hungarian.h index a4e4b1a522..911f2ac5fa 100644 --- a/quantum/keymap_extras/keymap_hungarian.h +++ b/quantum/keymap_extras/keymap_hungarian.h @@ -1,39 +1,33 @@ -/* Copyright 2018 fuge - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ Ö │ Ãœ │ Ó │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Š│ Ú │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ É │ à │ Å° │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ à │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define HU_0 KC_GRV // 0 #define HU_1 KC_1 // 1 #define HU_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define HU_ODIA KC_0 // Ö #define HU_UDIA KC_MINS // Ãœ #define HU_OACU KC_EQL // Ó -// Row 2 #define HU_Q KC_Q // Q #define HU_W KC_W // W #define HU_E KC_E // E @@ -60,7 +53,6 @@ #define HU_P KC_P // P #define HU_ODAC KC_LBRC // Å #define HU_UACU KC_RBRC // Ú -// Row 3 #define HU_A KC_A // A #define HU_S KC_S // S #define HU_D KC_D // D @@ -73,7 +65,6 @@ #define HU_EACU KC_SCLN // É #define HU_AACU KC_QUOT // à #define HU_UDAC KC_NUHS // Å° -// Row 4 #define HU_IACU KC_NUBS // à #define HU_Y KC_Z // Y #define HU_X KC_X // X @@ -85,21 +76,6 @@ #define HU_COMM KC_COMM // , #define HU_DOT KC_DOT // . #define HU_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ § │ ' │ " │ + │ ! │ % │ / │ = │ ( │ ) │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ ? │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define HU_SECT S(HU_0) // § #define HU_QUOT S(HU_1) // ' #define HU_DQUO S(HU_2) // " @@ -110,25 +86,9 @@ #define HU_EQL S(HU_7) // = #define HU_LPRN S(HU_8) // ( #define HU_RPRN S(HU_9) // ) -// Row 4 #define HU_QUES S(HU_COMM) // ? #define HU_COLN S(HU_DOT) // : #define HU_UNDS S(HU_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ~ │ ˇ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ ´ │ Ë â”‚ ¨ │ ¸ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ \ │ | │ Ä │ │ │ │ € │ │ │ │ ÷ │ × │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ ä │ Ä‘ │ Ä â”‚ [ │ ] │ │ │ Å‚ │ Š│ $ │ ß │ ¤ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ > │ # │ & │ @ │ { │ } │ │ ; │ │ * │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define HU_TILD ALGR(HU_1) // ~ #define HU_CARN ALGR(HU_2) // ˇ (dead) #define HU_CIRC ALGR(HU_3) // ^ (dead) @@ -141,14 +101,12 @@ #define HU_DACU ALGR(HU_ODIA) // Ë (dead) #define HU_DIAE ALGR(HU_UDIA) // ¨ (dead) #define HU_CEDL ALGR(HU_OACU) // ¸ (dead) -// Row 2 #define HU_BSLS ALGR(HU_Q) // (backslash) #define HU_PIPE ALGR(HU_W) // | #define HU_CADI ALGR(HU_E) // Ä #define HU_EURO ALGR(HU_U) // € #define HU_DIV ALGR(HU_ODAC) // ÷ #define HU_MUL ALGR(HU_UACU) // × -// Row 3 #define HU_LADI ALGR(HU_A) // ä #define HU_LDST ALGR(HU_S) // Ä‘ #define HU_CDST ALGR(HU_D) // Ä @@ -159,7 +117,6 @@ #define HU_DLR ALGR(HU_EACU) // $ #define HU_SS ALGR(HU_AACU) // ß #define HU_CURR ALGR(HU_UDAC) // ¤ -// Row 4 #define HU_LABK ALGR(HU_IACU) // < #define HU_RABK ALGR(HU_Y) // > #define HU_HASH ALGR(HU_X) // # diff --git a/quantum/keymap_extras/keymap_icelandic.h b/quantum/keymap_extras/keymap_icelandic.h index 43e4a6e872..72ba66c01d 100644 --- a/quantum/keymap_extras/keymap_icelandic.h +++ b/quantum/keymap_extras/keymap_icelandic.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ° │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ Ö │ - │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ à │ ' │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Æ │ ´ │ + │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ Þ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define IS_RNGA KC_GRV // ° (dead) #define IS_1 KC_1 // 1 #define IS_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define IS_0 KC_0 // 0 #define IS_ODIA KC_MINS // Ö #define IS_MINS KC_EQL // - -// Row 2 #define IS_Q KC_Q // Q #define IS_W KC_W // W #define IS_E KC_E // E @@ -60,7 +53,6 @@ #define IS_P KC_P // P #define IS_ETH KC_LBRC // à #define IS_QUOT KC_RBRC // ' -// Row 3 #define IS_A KC_A // A #define IS_S KC_S // S #define IS_D KC_D // D @@ -73,7 +65,6 @@ #define IS_AE KC_SCLN // Æ #define IS_ACUT KC_QUOT // ´ (dead) #define IS_PLUS KC_NUHS // + -// Row 4 #define IS_LABK KC_NUBS // < #define IS_Z KC_Z // Z #define IS_X KC_X // X @@ -85,21 +76,6 @@ #define IS_COMM KC_COMM // , #define IS_DOT KC_DOT // . #define IS_THRN KC_SLSH // Þ - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¨ │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ │ _ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ? │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define IS_DIAE S(IS_RNGA) // ¨ (dead) #define IS_EXLM S(IS_1) // ! #define IS_DQUO S(IS_2) // " @@ -112,42 +88,21 @@ #define IS_RPRN S(IS_9) // ) #define IS_EQL S(IS_0) // = #define IS_UNDS S(IS_MINS) // _ -// Row 2 #define IS_QUES S(IS_QUOT) // ? -// Row 3 #define IS_ASTR S(IS_PLUS) // * -// Row 4 #define IS_RABK S(IS_LABK) // > #define IS_SCLN S(IS_COMM) // ; #define IS_COLN S(IS_DOT) // : - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ° │ │ │ │ │ │ │ { │ [ │ ] │ } │ \ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ @ │ │ € │ │ │ │ │ │ │ │ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ ^ │ ` │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ | │ │ │ │ │ │ │ µ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define IS_DEG ALGR(IS_RNGA) // ° #define IS_LCBR ALGR(IS_7) // { #define IS_LBRC ALGR(IS_8) // [ #define IS_RBRC ALGR(IS_9) // ] #define IS_RCBR ALGR(IS_0) // } #define IS_BSLS ALGR(IS_ODIA) // (backslash) -// Row 2 #define IS_AT ALGR(IS_Q) // @ #define IS_EURO ALGR(IS_E) // € #define IS_TILD ALGR(IS_QUOT) // ~ -// Row 3 #define IS_CIRC ALGR(IS_ACUT) // ^ (dead) #define IS_GRV ALGR(IS_PLUS) // ` (dead) -// Row 4 #define IS_PIPE ALGR(IS_LABK) // | #define IS_MICR ALGR(IS_M) // µ diff --git a/quantum/keymap_extras/keymap_irish.h b/quantum/keymap_extras/keymap_irish.h index 73a4c8028d..95348d2ed1 100644 --- a/quantum/keymap_extras/keymap_irish.h +++ b/quantum/keymap_extras/keymap_irish.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ # │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ \ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define IE_GRV KC_GRV // ` #define IE_1 KC_1 // 1 #define IE_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define IE_0 KC_0 // 0 #define IE_MINS KC_MINS // - #define IE_EQL KC_EQL // = -// Row 2 #define IE_Q KC_Q // Q #define IE_W KC_W // W #define IE_E KC_E // E @@ -60,7 +53,6 @@ #define IE_P KC_P // P #define IE_LBRC KC_LBRC // [ #define IE_RBRC KC_RBRC // ] -// Row 3 #define IE_A KC_A // A #define IE_S KC_S // S #define IE_D KC_D // D @@ -73,7 +65,6 @@ #define IE_SCLN KC_SCLN // ; #define IE_QUOT KC_QUOT // ' #define IE_HASH KC_NUHS // # -// Row 4 #define IE_BSLS KC_NUBS // (backslash) #define IE_Z KC_Z // Z #define IE_X KC_X // X @@ -85,21 +76,6 @@ #define IE_COMM KC_COMM // , #define IE_DOT KC_DOT // . #define IE_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¬ │ ! │ " │ £ │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ : │ @ │ ~ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ | │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define IE_NOT S(IE_GRV) // ¬ #define IE_EXLM S(IE_1) // ! #define IE_DQUO S(IE_2) // " @@ -113,40 +89,20 @@ #define IE_RPRN S(IE_0) // ) #define IE_UNDS S(IE_MINS) // _ #define IE_PLUS S(IE_EQL) // + -// Row 2 #define IE_LCBR S(IE_LBRC) // { #define IE_RCBR S(IE_RBRC) // } -// Row 3 #define IE_COLN S(IE_SCLN) // : #define IE_AT S(IE_QUOT) // @ #define IE_TILD S(IE_HASH) // ~ -// Row 4 #define IE_PIPE S(IE_BSLS) // | #define IE_LABK S(IE_COMM) // < #define IE_RABK S(IE_DOT) // > #define IE_QUES S(IE_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¦ │ │ │ │ € │ │ │ │ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ É │ │ │ │ Ú │ à │ Ó │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ à │ │ │ │ │ │ │ │ │ │ ´ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define IE_BRKP ALGR(IE_GRV) // ¦ #define IE_EURO ALGR(IE_4) // € -// Row 2 #define IE_EACU ALGR(IE_E) // É #define IE_UACU ALGR(IE_U) // Ú #define IE_IACU ALGR(IE_I) // à #define IE_OACU ALGR(IE_O) // Ó -// Row 3 #define IE_AACU ALGR(IE_A) // à #define IE_ACUT ALGR(IE_QUOT) // ´ (dead) diff --git a/quantum/keymap_extras/keymap_italian.h b/quantum/keymap_extras/keymap_italian.h index ece60d06b7..fd14b377c5 100644 --- a/quantum/keymap_extras/keymap_italian.h +++ b/quantum/keymap_extras/keymap_italian.h @@ -1,39 +1,33 @@ -/* Copyright 2015-2016 Matthias Schmidtt - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ \ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ì │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ è │ + │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ò │ à │ ù │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define IT_BSLS KC_GRV // (backslash) #define IT_1 KC_1 // 1 #define IT_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define IT_0 KC_0 // 0 #define IT_QUOT KC_MINS // ' #define IT_IGRV KC_EQL // ì -// Row 2 #define IT_Q KC_Q // Q #define IT_W KC_W // W #define IT_E KC_E // E @@ -60,7 +53,6 @@ #define IT_P KC_P // P #define IT_EGRV KC_LBRC // è #define IT_PLUS KC_RBRC // + -// Row 3 #define IT_A KC_A // A #define IT_S KC_S // S #define IT_D KC_D // D @@ -73,7 +65,6 @@ #define IT_OGRV KC_SCLN // ò #define IT_AGRV KC_QUOT // à #define IT_UGRV KC_NUHS // ù -// Row 4 #define IT_LABK KC_NUBS // < #define IT_Z KC_Z // Z #define IT_X KC_X // X @@ -85,21 +76,6 @@ #define IT_COMM KC_COMM // , #define IT_DOT KC_DOT // . #define IT_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ | │ ! │ " │ £ │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ^ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ é │ * │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ ç │ ° │ § │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define IT_PIPE S(IT_BSLS) // | #define IT_EXLM S(IT_1) // ! #define IT_DQUO S(IT_2) // " @@ -113,53 +89,19 @@ #define IT_EQL S(IT_0) // = #define IT_QUES S(IT_QUOT) // ? #define IT_CIRC S(IT_IGRV) // ^ -// Row 2 #define IT_EACU S(IT_EGRV) // é #define IT_ASTR S(IT_PLUS) // * -// Row 3 #define IT_CCED S(IT_OGRV) // ç #define IT_DEG S(IT_AGRV) // ° #define IT_SECT S(IT_UGRV) // § -// Row 4 #define IT_RABK S(IT_LABK) // > #define IT_COLN S(IT_DOT) // : #define IT_SCLN S(IT_COMM) // ; #define IT_UNDS S(IT_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ @ │ # │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 2 #define IT_EURO ALGR(IT_E) // € #define IT_LBRC ALGR(IT_EGRV) // [ #define IT_RBRC ALGR(IT_PLUS) // ] -// Row 3 #define IT_AT ALGR(IT_OGRV) // @ #define IT_HASH ALGR(IT_AGRV) // # - -/* Shift+AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 2 #define IT_LCBR S(ALGR(IT_EGRV)) // { #define IT_RCBR S(ALGR(IT_PLUS)) // } diff --git a/quantum/keymap_extras/keymap_italian_mac_ansi.h b/quantum/keymap_extras/keymap_italian_mac_ansi.h index c2b8e3cad6..d072c6fe57 100644 --- a/quantum/keymap_extras/keymap_italian_mac_ansi.h +++ b/quantum/keymap_extras/keymap_italian_mac_ansi.h @@ -1,39 +1,33 @@ -/* Copyright 2015-2016 Matthias Schmidtt - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ < │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ì │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ è │ + │ ù │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ò │ à │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 +// Aliases #define IT_LABK KC_GRV // < #define IT_1 KC_1 // 1 #define IT_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define IT_0 KC_0 // 0 #define IT_QUOT KC_MINS // ' #define IT_IGRV KC_EQL // ì -// Row 2 #define IT_Q KC_Q // Q #define IT_W KC_W // W #define IT_E KC_E // E @@ -61,7 +54,6 @@ #define IT_EGRV KC_LBRC // è #define IT_PLUS KC_RBRC // + #define IT_UGRV KC_BSLS // ù -// Row 3 #define IT_A KC_A // A #define IT_S KC_S // S #define IT_D KC_D // D @@ -73,7 +65,6 @@ #define IT_L KC_L // L #define IT_OGRV KC_SCLN // ò #define IT_AGRV KC_QUOT // à -// Row 4 #define IT_BSLS KC_NUBS // (backslash, not physically present) #define IT_Z KC_Z // Z #define IT_X KC_X // X @@ -85,21 +76,6 @@ #define IT_COMM KC_COMM // , #define IT_DOT KC_DOT // . #define IT_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ > │ ! │ " │ £ │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ^ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ é │ * │ § │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │ │ │ │ │ │ │ │ │ │ ç │ ° │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define IT_RABK S(IT_LABK) // > #define IT_EXLM S(IT_1) // ! #define IT_DQUO S(IT_2) // " @@ -113,33 +89,15 @@ #define IT_EQL S(IT_0) // = #define IT_QUES S(IT_QUOT) // ? #define IT_CIRC S(IT_IGRV) // ^ -// Row 2 #define IT_EACU S(IT_EGRV) // é #define IT_ASTR S(IT_PLUS) // * #define IT_SECT S(IT_UGRV) // § -// Row 3 #define IT_LCCE S(IT_OGRV) // ç #define IT_DEG S(IT_AGRV) // ° -// Row 4 #define IT_PIPE S(IT_BSLS) // | (not physically present) #define IT_SCLN S(IT_COMM) // ; #define IT_COLN S(IT_DOT) // : #define IT_UNDS S(IT_MINS) // _ - -/* Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ≤ │ « │ “ │ ‘ │ Â¥ │ ~ │ ‹ │ ÷ │ ´ │ ` │ ≠│ ¡ │ ˆ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ „ │ Ω │ € │ ® │ â„¢ │ Æ │ ¨ │ Å’ │ Ø │ Ï€ │ [ │ ] │ ¶ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │ Ã… │ ß │ ∂ │ Æ’ │ ∞ │ ∆ │ ª │ º │ ¬ │ @ │ # │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ ∑ │ †│ © │ √ │ ∫ │ Ëœ │ µ │ … │ • │ – │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define IT_LTEQ A(IT_LABK) // ≤ #define IT_LDAQ A(IT_1) // « #define IT_LDQU A(IT_2) // “ @@ -153,7 +111,6 @@ #define IT_NEQL A(IT_0) // ≠#define IT_IEXL A(IT_QUOT) // ¡ #define IT_DCIR A(IT_IGRV) // ˆ (dead) -// Row 2 #define IT_DLQU A(IT_Q) // „ #define IT_OMEG A(IT_W) // Ω #define IT_EURO A(IT_E) // € @@ -166,7 +123,6 @@ #define IT_PI A(IT_P) // Ï€ #define IT_LBRC A(IT_EGRV) // [ #define IT_RBRC A(IT_PLUS) // ] -// Row 3 #define IT_ARNG A(IT_A) // Ã… #define IT_SS A(IT_S) // ß #define IT_PDIF A(IT_D) // ∂ @@ -179,7 +135,6 @@ #define IT_AT A(IT_OGRV) // @ #define IT_HASH A(IT_AGRV) // # #define IT_PILC A(IT_UGRV) // ¶ -// Row 4 #define IT_GRV A(IT_BSLS) // ` (not physically present) #define IT_NARS A(IT_Z) // ∑ #define IT_DAGG A(IT_X) // †@@ -191,21 +146,6 @@ #define IT_ELLP A(IT_COMM) // … #define IT_BULT A(IT_DOT) // • #define IT_NDSH A(IT_MINS) // – - -/* Shift+Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ≥ │ » │ †│ ’ │ ¢ │ ‰ │ › │ ℠│  │ │ ≈ │ ¿ │ ± │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ ‚ │ À │ È │ ÃŒ │ Ã’ │ │ Ù │ │ │ ∠│ { │ } │ â—Š │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │ │ ¯ │ ˘ │ Ë™ │ Ëš │ ¸ │ Ë â”‚ Ë› │ ˇ │ Ç │ ∞ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ │ ‡ │ à │ É │ à │ Ó │ Ú │ │ · │ — │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define IT_GTEQ S(A(IT_LABK)) // ≥ #define IT_RDAQ S(A(IT_1)) // » #define IT_RDQU S(A(IT_2)) // †@@ -218,7 +158,6 @@ #define IT_AEQL S(A(IT_0)) // ≈ #define IT_IQUE S(A(IT_QUOT)) // ¿ #define IT_PLMN S(A(IT_IGRV)) // ± -// Row 2 #define IT_SLQU S(A(IT_Q)) // ‚ #define IT_CAGR S(A(IT_W)) // À #define IT_CEGR S(A(IT_E)) // È @@ -229,7 +168,6 @@ #define IT_LCBR S(A(IT_EGRV)) // { #define IT_RCBR S(A(IT_PLUS)) // } #define IT_LOZN S(A(IT_UGRV)) // â—Š -// Row 3 #define IT_MACR S(A(IT_S)) // ¯ #define IT_BREV S(A(IT_D)) // ˘ #define IT_DOTA S(A(IT_F)) // Ë™ @@ -239,7 +177,6 @@ #define IT_OGON S(A(IT_K)) // Ë› #define IT_CARN S(A(IT_L)) // ˇ #define IT_CCCE S(A(IT_OGRV)) // Ç -// Row 4 #define IT_DDAG S(A(IT_X)) // ‡ #define IT_CAAC S(A(IT_C)) // à #define IT_CEAC S(A(IT_V)) // É diff --git a/quantum/keymap_extras/keymap_italian_mac_iso.h b/quantum/keymap_extras/keymap_italian_mac_iso.h index 61f76ddba7..b93a583a41 100644 --- a/quantum/keymap_extras/keymap_italian_mac_iso.h +++ b/quantum/keymap_extras/keymap_italian_mac_iso.h @@ -1,39 +1,33 @@ -/* Copyright 2015-2016 Matthias Schmidtt - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ \ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ì │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ è │ + │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ò │ à │ ù │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 +// Aliases #define IT_BSLS KC_GRV // (backslash) #define IT_1 KC_1 // 1 #define IT_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define IT_0 KC_0 // 0 #define IT_QUOT KC_MINS // ' #define IT_IGRV KC_EQL // ì -// Row 2 #define IT_Q KC_Q // Q #define IT_W KC_W // W #define IT_E KC_E // E @@ -60,7 +53,6 @@ #define IT_P KC_P // P #define IT_EGRV KC_LBRC // è #define IT_PLUS KC_RBRC // + -// Row 3 #define IT_A KC_A // A #define IT_S KC_S // S #define IT_D KC_D // D @@ -73,7 +65,6 @@ #define IT_OGRV KC_SCLN // ò #define IT_AGRV KC_QUOT // à #define IT_UGRV KC_NUHS // ù -// Row 4 #define IT_LABK KC_NUBS // < #define IT_Z KC_Z // Z #define IT_X KC_X // X @@ -85,21 +76,6 @@ #define IT_COMM KC_COMM // , #define IT_DOT KC_DOT // . #define IT_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ | │ ! │ " │ £ │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ^ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ é │ * │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ ç │ ° │ § │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define IT_PIPE S(IT_BSLS) // | #define IT_EXLM S(IT_1) // ! #define IT_DQUO S(IT_2) // " @@ -113,33 +89,15 @@ #define IT_EQL S(IT_0) // = #define IT_QUES S(IT_QUOT) // ? #define IT_CIRC S(IT_IGRV) // ^ -// Row 2 #define IT_EACU S(IT_EGRV) // é #define IT_ASTR S(IT_PLUS) // * -// Row 3 #define IT_LCCE S(IT_OGRV) // ç #define IT_DEG S(IT_AGRV) // ° #define IT_SECT S(IT_UGRV) // § -// Row 4 #define IT_RABK S(IT_LABK) // > #define IT_SCLN S(IT_COMM) // ; #define IT_COLN S(IT_DOT) // : #define IT_UNDS S(IT_MINS) // _ - -/* Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ` │ « │ “ │ ‘ │ Â¥ │ ~ │ ‹ │ ÷ │ ´ │ ` │ ≠│ ¡ │ ˆ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ „ │ Ω │ € │ ® │ â„¢ │ Æ │ ¨ │ Å’ │ Ø │ Ï€ │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Ã… │ ß │ ∂ │ Æ’ │ ∞ │ ∆ │ ª │ º │ ¬ │ @ │ # │ ¶ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≤ │ ∑ │ †│ © │ √ │ ∫ │ Ëœ │ µ │ … │ • │ – │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define IT_GRV A(IT_BSLS) // ` #define IT_LDAQ A(IT_1) // « #define IT_LDQU A(IT_2) // “ @@ -153,7 +111,6 @@ #define IT_NEQL A(IT_0) // ≠#define IT_IEXL A(IT_QUOT) // ¡ #define IT_DCIR A(IT_IGRV) // ˆ (dead) -// Row 2 #define IT_DLQU A(IT_Q) // „ #define IT_OMEG A(IT_W) // Ω #define IT_EURO A(IT_E) // € @@ -166,7 +123,6 @@ #define IT_PI A(IT_P) // Ï€ #define IT_LBRC A(IT_EGRV) // [ #define IT_RBRC A(IT_PLUS) // ] -// Row 3 #define IT_ARNG A(IT_A) // Ã… #define IT_SS A(IT_S) // ß #define IT_PDIF A(IT_D) // ∂ @@ -179,7 +135,6 @@ #define IT_AT A(IT_OGRV) // @ #define IT_HASH A(IT_AGRV) // # #define IT_PILC A(IT_UGRV) // ¶ -// Row 4 #define IT_LTEQ A(IT_LABK) // ≤ #define IT_NARS A(IT_Z) // ∑ #define IT_DAGG A(IT_X) // †@@ -191,21 +146,6 @@ #define IT_ELLP A(IT_COMM) // … #define IT_BULT A(IT_DOT) // • #define IT_NDSH A(IT_MINS) // – - -/* Shift+Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ı │ » │ †│ ’ │ ¢ │ ‰ │ › │ ℠│  │ │ ≈ │ ¿ │ ± │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ ‚ │ À │ È │ ÃŒ │ Ã’ │ │ Ù │ │ │ ∠│ { │ } │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ ¯ │ ˘ │ Ë™ │ Ëš │ ¸ │ Ë â”‚ Ë› │ ˇ │ Ç │ │ â—Š │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≥ │ │ ‡ │ à │ É │ à │ Ó │ Ú │ │ · │ — │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define IT_DLSI S(A(IT_BSLS)) // ı #define IT_RDAQ S(A(IT_1)) // » #define IT_RDQU S(A(IT_2)) // †@@ -218,7 +158,6 @@ #define IT_AEQL S(A(IT_0)) // ≈ #define IT_IQUE S(A(IT_QUOT)) // ¿ #define IT_PLMN S(A(IT_IGRV)) // ± -// Row 2 #define IT_SLQU S(A(IT_Q)) // ‚ #define IT_CAGR S(A(IT_W)) // À #define IT_CEGR S(A(IT_E)) // È @@ -228,7 +167,6 @@ #define IT_NARP S(A(IT_P)) // ∠#define IT_LCBR S(A(IT_EGRV)) // { #define IT_RCBR S(A(IT_PLUS)) // } -// Row 3 #define IT_MACR S(A(IT_S)) // ¯ #define IT_BREV S(A(IT_D)) // ˘ #define IT_DOTA S(A(IT_F)) // Ë™ @@ -239,7 +177,6 @@ #define IT_CARN S(A(IT_L)) // ˇ #define IT_CCCE S(A(IT_OGRV)) // Ç #define IT_LOZN S(A(IT_UGRV)) // â—Š -// Row 4 #define IT_GTEQ S(A(IT_LABK)) // ≥ #define IT_DDAG S(A(IT_X)) // ‡ #define IT_CAAC S(A(IT_C)) // à diff --git a/quantum/keymap_extras/keymap_japanese.h b/quantum/keymap_extras/keymap_japanese.h index df78af8399..4a3ce490f8 100644 --- a/quantum/keymap_extras/keymap_japanese.h +++ b/quantum/keymap_extras/keymap_japanese.h @@ -1,45 +1,33 @@ -/* Copyright 2016 h-youhei - * - * 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/>. - * - * JP106-layout (Japanese Standard) - * - * For more information, see - * http://www2d.biglobe.ne.jp/~msyk/keyboard/layout/usbkeycode.html - * note: This website is written in Japanese. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┠- * │Z↔H│ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ ^ │ Â¥ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ @ │ [ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ EisÅ« │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ : │ ] │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┤ - * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ \ │ │ - * ├─────┬──┴┬──┴──┬┴───┴┬──┴───┴──┬┴───┴┬──┴┬──┴┬──┴┬──┴┬─────┤ - * │ │ │ │Muhen│ │ Hen │K↔H│ │ │ │ │ - * └─────┴───┴─────┴─────┴─────────┴─────┴───┴───┴───┴───┴─────┘ - */ -// Row 1 +// Aliases #define JP_ZKHK KC_GRV // Zenkaku ↔ Hankaku ↔ Kanji (åŠè§’ ↔ 全角 ↔ æ¼¢å—) #define JP_1 KC_1 // 1 #define JP_2 KC_2 // 2 @@ -54,7 +42,6 @@ #define JP_MINS KC_MINS // - #define JP_CIRC KC_EQL // ^ #define JP_YEN KC_INT3 // Â¥ -// Row 2 #define JP_Q KC_Q // Q #define JP_W KC_W // W #define JP_E KC_E // E @@ -67,7 +54,6 @@ #define JP_P KC_P // P #define JP_AT KC_LBRC // @ #define JP_LBRC KC_RBRC // [ -// Row 3 #define JP_EISU KC_CAPS // EisÅ« (英数) #define JP_A KC_A // A #define JP_S KC_S // S @@ -81,7 +67,6 @@ #define JP_SCLN KC_SCLN // ; #define JP_COLN KC_QUOT // : #define JP_RBRC KC_NUHS // ] -// Row 4 #define JP_Z KC_Z // Z #define JP_X KC_X // X #define JP_C KC_C // C @@ -93,25 +78,9 @@ #define JP_DOT KC_DOT // . #define JP_SLSH KC_SLSH // / #define JP_BSLS KC_INT1 // (backslash) -// Row 5 #define JP_MHEN KC_INT5 // Muhenkan (無変æ›) #define JP_HENK KC_INT4 // Henkan (変æ›) #define JP_KANA KC_INT2 // Katakana ↔ Hiragana ↔ RÅmaji (カタカナ ↔ ã²ã‚‰ãŒãª ↔ ãƒãƒ¼ãƒžå—) - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┠- * │ │ ! │ " │ # │ $ │ % │ & │ ' │ ( │ ) │ │ = │ ~ │ | │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ ` │ { │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ Caps │ │ │ │ │ │ │ │ │ │ + │ * │ } │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ _ │ │ - * ├─────┬──┴┬──┴──┬┴───┴┬──┴───┴──┬┴───┴┬──┴┬──┴┬──┴┬──┴┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ - * └─────┴───┴─────┴─────┴─────────┴─────┴───┴───┴───┴───┴─────┘ - */ -// Row 1 #define JP_EXLM S(JP_1) // ! #define JP_DQUO S(JP_2) // " #define JP_HASH S(JP_3) // # @@ -124,15 +93,12 @@ #define JP_EQL S(JP_MINS) // = #define JP_TILD S(JP_CIRC) // ~ #define JP_PIPE S(JP_YEN) // | -// Row 2 #define JP_GRV S(JP_AT) // ` #define JP_LCBR S(JP_LBRC) // { -// Row 3 #define JP_CAPS S(JP_EISU) // Caps Lock #define JP_PLUS S(JP_SCLN) // + #define JP_ASTR S(JP_COLN) // * #define JP_RCBR S(JP_RBRC) // } -// Row 4 #define JP_LABK S(JP_COMM) // < #define JP_RABK S(JP_DOT) // > #define JP_QUES S(JP_SLSH) // ? diff --git a/quantum/keymap_extras/keymap_korean.h b/quantum/keymap_extras/keymap_korean.h index 3d41a98b88..514bf44a29 100644 --- a/quantum/keymap_extras/keymap_korean.h +++ b/quantum/keymap_extras/keymap_korean.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ â‚© │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ - * ├─────┬──┴┬──┴──┬┴──┬┴───┴───┴───┴──┬┴──┬┴───┴┬──┴┬───┬─────┤ - * │ │ │ │Hnj│ │H↔Y│ │ │ │ │ - * └─────┴───┴─────┴───┴───────────────┴───┴─────┴───┴───┴─────┘ - */ -// Row 1 +// Aliases #define KR_GRV KC_GRV // ` #define KR_1 KC_1 // 1 #define KR_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define KR_0 KC_0 // 0 #define KR_MINS KC_MINS // - #define KR_EQL KC_EQL // = -// Row 2 #define KR_Q KC_Q // Q #define KR_W KC_W // W #define KR_E KC_E // E @@ -61,7 +54,6 @@ #define KR_LBRC KC_LBRC // [ #define KR_RBRC KC_RBRC // ] #define KR_WON KC_BSLS // â‚© -// Row 3 #define KR_A KC_A // A #define KR_S KC_S // S #define KR_D KC_D // D @@ -73,7 +65,6 @@ #define KR_L KC_L // L #define KR_SCLN KC_SCLN // ; #define KR_QUOT KC_QUOT // ' -// Row 4 #define KR_Z KC_Z // Z #define KR_X KC_X // X #define KR_C KC_C // C @@ -84,24 +75,8 @@ #define KR_COMM KC_COMM // , #define KR_DOT KC_DOT // . #define KR_SLSH KC_SLSH // / -// Row 5 #define KR_HANJ KC_LNG2 // Hanja (í•œìž) #define KR_HAEN KC_LNG1 // Han ↔ Yeong (í•œ ↔ ì˜) - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├─────┬──┴┬──┴──┬┴──┬┴───┴───┴───┴──┬┴──┬┴───┴┬──┴┬───┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ - * └─────┴───┴─────┴───┴───────────────┴───┴─────┴───┴───┴─────┘ - */ -// Row 1 #define KR_TILD S(KR_GRV) // ~ #define KR_EXLM S(KR_1) // ! #define KR_AT S(KR_2) // @ @@ -115,14 +90,11 @@ #define KR_RPRN S(KR_0) // ) #define KR_UNDS S(KR_MINS) // _ #define KR_PLUS S(KR_EQL) // + -// Row 2 #define KR_LCBR S(KR_LBRC) // { #define KR_RCBR S(KR_RBRC) // } #define KR_PIPE S(KR_WON) // | -// Row 3 #define KR_COLN S(KR_SCLN) // : #define KR_DQUO S(KR_QUOT) // " -// Row 4 #define KR_LABK S(KR_COMM) // < #define KR_RABK S(KR_DOT) // > #define KR_QUES S(KR_SLSH) // ? diff --git a/quantum/keymap_extras/keymap_latvian.h b/quantum/keymap_extras/keymap_latvian.h index 087138cb72..d2cbda1471 100644 --- a/quantum/keymap_extras/keymap_latvian.h +++ b/quantum/keymap_extras/keymap_latvian.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ \ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ \ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define LV_GRV KC_GRV // ` #define LV_1 KC_1 // 1 #define LV_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define LV_0 KC_0 // 0 #define LV_MINS KC_MINS // - #define LV_EQL KC_EQL // = -// Row 2 #define LV_Q KC_Q // Q #define LV_W KC_W // W #define LV_E KC_E // E @@ -60,7 +53,6 @@ #define LV_P KC_P // P #define LV_LBRC KC_LBRC // [ #define LV_RBRC KC_RBRC // ] -// Row 3 #define LV_A KC_A // A #define LV_S KC_S // S #define LV_D KC_D // D @@ -73,7 +65,6 @@ #define LV_SCLN KC_SCLN // ; #define LV_QUOT KC_QUOT // ' (dead) #define LV_BSLS KC_NUHS // (backslash) -// Row 4 #define LV_NUBS KC_NUBS // (backslash) #define LV_Z KC_Z // Z #define LV_X KC_X // X @@ -85,21 +76,6 @@ #define LV_COMM KC_COMM // , #define LV_DOT KC_DOT // . #define LV_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ : │ " │ | │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define LV_TILD S(LV_GRV) // ~ #define LV_EXLM S(LV_1) // ! #define LV_AT S(LV_2) // @ @@ -113,75 +89,38 @@ #define LV_RPRN S(LV_0) // ) #define LV_UNDS S(LV_MINS) // _ #define LV_PLUS S(LV_EQL) // + -// Row 2 #define LV_LCBR S(LV_LBRC) // { #define LV_RCBR S(LV_RBRC) // } -// Row 3 #define LV_COLN S(LV_SCLN) // : #define LV_DQUO S(LV_QUOT) // " (dead) #define LV_PIPE S(LV_BSLS) // | -// Row 4 #define LV_LABK S(LV_COMM) // < #define LV_RABK S(LV_DOT) // > #define LV_QUES S(LV_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ - │ │ « │ » │ € │ │ ’ │ │ │ │ │ – │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ Ä’ │ Å– │ │ │ Ū │ Ī │ ÅŒ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Ä€ │ Š│ │ │ Ä¢ │ │ │ Ķ │ Ä» │ │ ´ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ Ž │ │ ÄŒ │ │ │ Å… │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define LV_SHYP ALGR(LV_GRV) //  (soft hyphen) -#define LV_NBSP ALGR(LV_1) //  (non-breaking space) +#define LV_NBSP ALGR(LV_1) // (non-breaking space) #define LV_LDAQ ALGR(LV_2) // « #define LV_RDAQ ALGR(LV_3) // » #define LV_EURO ALGR(LV_4) // € #define LV_RSQU ALGR(LV_6) // ’ #define LV_NDSH ALGR(LV_MINS) // – -// Row 2 #define LV_EMAC ALGR(LV_E) // Ä’ #define LV_RCED ALGR(LV_R) // Å– #define LV_UMAC ALGR(LV_U) // Ū #define LV_IMAC ALGR(LV_I) // Ī #define LV_OMAC ALGR(LV_O) // ÅŒ -// Row 3 #define LV_AMAC ALGR(LV_A) // Ä€ #define LV_SCAR ALGR(LV_S) // Å #define LV_GCED ALGR(LV_G) // Ä¢ #define LV_KCED ALGR(LV_K) // Ķ #define LV_LCED ALGR(LV_L) // Ä» #define LV_ACUT ALGR(LV_QUOT) // ´ (dead) -// Row 4 #define LV_ZCAR ALGR(LV_Z) // Ž #define LV_CCAR ALGR(LV_C) // ÄŒ #define LV_NCED ALGR(LV_N) // Å… - -/* Shift+AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ │ │ § │ ° │ │ ± │ × │ │ │ — │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define LV_SECT S(ALGR(LV_4)) // § #define LV_DEG S(ALGR(LV_5)) // ° #define LV_PLMN S(ALGR(LV_7)) // ± #define LV_MUL S(ALGR(LV_8)) // × #define LV_MDSH S(ALGR(LV_MINS)) // — -// Row 3 #define LV_DIAE S(ALGR(LV_QUOT)) // ¨ (dead) diff --git a/quantum/keymap_extras/keymap_lithuanian_azerty.h b/quantum/keymap_extras/keymap_lithuanian_azerty.h index 6f47b16702..e6a6fa5c8d 100644 --- a/quantum/keymap_extras/keymap_lithuanian_azerty.h +++ b/quantum/keymap_extras/keymap_lithuanian_azerty.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ ! │ - │ / │ ; │ : │ , │ . │ = │ ( │ ) │ ? │ X │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Ä„ │ Ž │ E │ R │ T │ Y │ U │ I │ O │ P │ Ä® │ W │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ Š│ G │ H │ J │ K │ L │ Ų │ Ä– │ Q │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ Ū │ C │ V │ B │ N │ M │ ÄŒ │ F │ Ę │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define LT_GRV KC_GRV // ` #define LT_EXLM KC_1 // ! #define LT_MINS KC_2 // - @@ -47,7 +41,6 @@ #define LT_RPRN KC_0 // ) #define LT_QUES KC_MINS // ? #define LT_X KC_EQL // X -// Row 2 #define LT_AOGO KC_Q // Ä„ #define LT_ZCAR KC_W // Ž #define LT_E KC_E // E @@ -60,7 +53,6 @@ #define LT_P KC_P // P #define LT_IOGO KC_LBRC // Ä® #define LT_W KC_RBRC // W -// Row 3 #define LT_A KC_A // A #define LT_S KC_S // S #define LT_D KC_D // D @@ -73,7 +65,6 @@ #define LT_UOGO KC_SCLN // Ų #define LT_EDOT KC_QUOT // Ä– #define LT_Q KC_NUHS // Q -// Row 4 #define LT_LABK KC_NUBS // < #define LT_Z KC_Z // Z #define LT_UMAC KC_X // Ū @@ -85,21 +76,6 @@ #define LT_CCAR KC_COMM // ÄŒ #define LT_F KC_DOT // F #define LT_EOGO KC_SLSH // Ę - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define LT_TILD S(LT_GRV) // ~ #define LT_1 S(LT_EXLM) // 1 #define LT_2 S(LT_MINS) // 2 @@ -112,23 +88,7 @@ #define LT_9 S(LT_LPRN) // 9 #define LT_0 S(LT_RPRN) // 0 #define LT_PLUS S(LT_QUES) // + -// Row 4 #define LT_RABK S(LT_LABK) // > - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ´ │ @ │ _ │ # │ $ │ § │ ^ │ & │ * │ [ │ ] │ ' │ % │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ { │ } │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ " │ | │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ – │ │ │ │ │ │ │ │ „ │ “ │ \ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define LT_ACUT ALGR(LT_GRV) // ´ #define LT_AT ALGR(LT_EXLM) // @ #define LT_UNDS ALGR(LT_MINS) // _ @@ -142,14 +102,11 @@ #define LT_RBRC ALGR(LT_RPRN) // ] #define LT_QUOT ALGR(LT_QUES) // ' #define LT_PERC ALGR(LT_X) // % -// Row 2 #define LT_EURO ALGR(LT_E) // € #define LT_LCBR ALGR(LT_IOGO) // { #define LT_RCBR ALGR(LT_W) // } -// Row 3 #define LT_DQUO ALGR(LT_EDOT) // " #define LT_PIPE ALGR(LT_Q) // | -// Row 4 #define LT_NDSH ALGR(LT_LABK) // – #define LT_DLQU ALGR(LT_CCAR) // „ #define LT_LDQU ALGR(LT_F) // “ diff --git a/quantum/keymap_extras/keymap_lithuanian_qwerty.h b/quantum/keymap_extras/keymap_lithuanian_qwerty.h index afca2dc750..97687daceb 100644 --- a/quantum/keymap_extras/keymap_lithuanian_qwerty.h +++ b/quantum/keymap_extras/keymap_lithuanian_qwerty.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ Ä„ │ ÄŒ │ Ę │ Ä– │ Ä® │ Š│ Ų │ Ū │ 9 │ 0 │ - │ Ž │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define LT_GRV KC_GRV // ` #define LT_AOGO KC_1 // Ä„ #define LT_CCAR KC_2 // ÄŒ @@ -47,7 +41,6 @@ #define LT_0 KC_0 // 0 #define LT_MINS KC_MINS // - #define LT_ZCAR KC_EQL // Ž -// Row 2 #define LT_Q KC_Q // Q #define LT_W KC_W // W #define LT_E KC_E // E @@ -60,7 +53,6 @@ #define LT_P KC_P // P #define LT_LBRC KC_LBRC // [ #define LT_RBRC KC_RBRC // ] -// Row 3 #define LT_A KC_A // A #define LT_S KC_S // S #define LT_D KC_D // D @@ -73,7 +65,6 @@ #define LT_SCLN KC_SCLN // ; #define LT_QUOT KC_QUOT // ' #define LT_BSLS KC_BSLS // (backslash) -// Row 4 #define LT_Z KC_Z // Z #define LT_X KC_X // X #define LT_C KC_C // C @@ -84,51 +75,18 @@ #define LT_COMM KC_COMM // , #define LT_DOT KC_DOT // . #define LT_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ │ │ │ │ │ │ │ │ ( │ ) │ _ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define LT_TILD S(LT_GRV) // ~ #define LT_LPRN S(LT_9) // ( #define LT_RPRN S(LT_0) // ) #define LT_UNDS S(LT_MINS) // _ -// Row 2 #define LT_LCBR S(LT_LBRC) // { #define LT_RCBR S(LT_RBRC) // } -// Row 3 #define LT_COLN S(LT_SCLN) // : #define LT_DQUO S(LT_QUOT) // " #define LT_PIPE S(LT_BSLS) // | -// Row 4 #define LT_LABK S(LT_COMM) // < #define LT_RABK S(LT_DOT) // > #define LT_QUES S(LT_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ │ │ │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define LT_1 ALGR(LT_AOGO) // 1 #define LT_2 ALGR(LT_CCAR) // 2 #define LT_3 ALGR(LT_EOGO) // 3 @@ -138,23 +96,7 @@ #define LT_7 ALGR(LT_UOGO) // 7 #define LT_8 ALGR(LT_UMAC) // 8 #define LT_EQL ALGR(LT_ZCAR) // = -// Row 2 #define LT_EURO ALGR(LT_E) // € - -/* Shift+AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ │ │ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define LT_EXLM S(ALGR(LT_AOGO)) // ! #define LT_AT S(ALGR(LT_CCAR)) // @ #define LT_HASH S(ALGR(LT_EOGO)) // # diff --git a/quantum/keymap_extras/keymap_neo2.h b/quantum/keymap_extras/keymap_neo2.h index f9fc00d794..8b4b81bd7b 100644 --- a/quantum/keymap_extras/keymap_neo2.h +++ b/quantum/keymap_extras/keymap_neo2.h @@ -1,39 +1,33 @@ -/* Copyright 2016 Matthias Schmitt - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ^ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ X │ V │ L │ C │ W │ K │ H │ G │ F │ Q │ ß │ ´ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ L3 │ U │ I │ A │ E │ O │ S │ N │ R │ T │ D │ Y │ L3│ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │L4 │ Ãœ │ Ö │ Ä │ P │ Z │ B │ M │ , │ . │ J │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ L4 │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define NE_CIRC KC_GRV // ^ (dead) #define NE_1 KC_1 // 1 #define NE_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define NE_0 KC_0 // 0 #define NE_MINS KC_MINS // - #define NE_GRV KC_EQL // ` (dead) -// Row 2 #define NE_X KC_Q // X #define NE_V KC_W // V #define NE_L KC_E // L @@ -60,7 +53,6 @@ #define NE_Q KC_P // Q #define NE_SS KC_LBRC // ß #define NE_ACUT KC_RBRC // ´ (dead) -// Row 3 #define NE_L3L KC_CAPS // (layer 3) #define NE_U KC_A // U #define NE_I KC_S // I @@ -74,7 +66,6 @@ #define NE_D KC_SCLN // D #define NE_Y KC_QUOT // Y #define NE_L3R KC_NUHS // (layer 3) -// Row 4 #define NE_L4L KC_NUBS // (layer 4) #define NE_UDIA KC_Z // Ãœ #define NE_ODIA KC_X // Ö @@ -86,5 +77,4 @@ #define NE_COMM KC_COMM // , #define NE_DOT KC_DOT // . #define NE_J KC_SLSH // J -// Row 5 #define NE_L4R KC_ALGR // (layer 4) diff --git a/quantum/keymap_extras/keymap_nordic.h b/quantum/keymap_extras/keymap_nordic.h index 55a58a25b0..36f1cc4c2f 100644 --- a/quantum/keymap_extras/keymap_nordic.h +++ b/quantum/keymap_extras/keymap_nordic.h @@ -1,38 +1,43 @@ -/* Copyright 2015-2016 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" +// clang-format off -// Normal characters -#define NO_HALF KC_GRV +// Aliases +#define NO_HALF KC_GRV #define NO_PLUS KC_MINS -#define NO_ACUT KC_EQL - -#define NO_AM KC_LBRC +#define NO_ACUT KC_EQL +#define NO_AM KC_LBRC #define NO_QUOT KC_RBRC // this is the "umlaut" char on Nordic keyboards, Apple layout -#define NO_AE KC_SCLN +#define NO_AE KC_SCLN #define NO_OSLH KC_QUOT #define NO_APOS KC_NUHS - #define NO_LESS KC_NUBS #define NO_MINS KC_SLSH - -// Shifted characters #define NO_SECT LSFT(NO_HALF) #define NO_QUO2 LSFT(KC_2) #define NO_BULT LSFT(KC_4) @@ -40,29 +45,23 @@ #define NO_SLSH LSFT(KC_7) #define NO_LPRN LSFT(KC_8) #define NO_RPRN LSFT(KC_9) -#define NO_EQL LSFT(KC_0) +#define NO_EQL LSFT(KC_0) #define NO_QUES LSFT(NO_PLUS) -#define NO_GRV LSFT(NO_ACUT) - +#define NO_GRV LSFT(NO_ACUT) #define NO_CIRC LSFT(NO_QUOT) - #define NO_GRTR LSFT(NO_LESS) #define NO_SCLN LSFT(KC_COMM) #define NO_COLN LSFT(KC_DOT) #define NO_UNDS LSFT(NO_MINS) - -// Alt Gr-ed characters -#define NO_AT ALGR(KC_2) -#define NO_PND ALGR(KC_3) -#define NO_DLR ALGR(KC_4) -#define NO_LCBR ALGR(KC_7) -#define NO_LBRC ALGR(KC_8) -#define NO_RBRC ALGR(KC_9) -#define NO_RCBR ALGR(KC_0) +#define NO_AT ALGR(KC_2) +#define NO_PND ALGR(KC_3) +#define NO_DLR ALGR(KC_4) +#define NO_LCBR ALGR(KC_7) +#define NO_LBRC ALGR(KC_8) +#define NO_RBRC ALGR(KC_9) +#define NO_RCBR ALGR(KC_0) #define NO_PIPE ALGR(KC_NUBS) - -#define NO_EURO ALGR(KC_E) +#define NO_EURO ALGR(KC_E) #define NO_TILD ALGR(NO_QUOT) - #define NO_BSLS ALGR(KC_MINS) -#define NO_MU ALGR(KC_M) +#define NO_MU ALGR(KC_M) diff --git a/quantum/keymap_extras/keymap_norman.h b/quantum/keymap_extras/keymap_norman.h index 9f20f66873..6096ac6bff 100644 --- a/quantum/keymap_extras/keymap_norman.h +++ b/quantum/keymap_extras/keymap_norman.h @@ -1,39 +1,33 @@ -/* Copyright 2019 Torben Hoffmann - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ D │ F │ K │ J │ U │ R │ L │ ; │ [ │ ] │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ S │ E │ T │ G │ Y │ N │ I │ O │ H │ ' │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Z │ X │ C │ V │ B │ P │ M │ , │ . │ / │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define NM_GRV KC_GRV // ` #define NM_1 KC_1 // 1 #define NM_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define NM_0 KC_0 // 0 #define NM_MINS KC_MINS // - #define NM_EQL KC_EQL // = -// Row 2 #define NM_Q KC_Q // Q #define NM_W KC_W // W #define NM_D KC_E // D @@ -61,7 +54,6 @@ #define NM_LBRC KC_LBRC // [ #define NM_RBRC KC_RBRC // ] #define NM_BSLS KC_BSLS // (backslash) -// Row 3 #define NM_A KC_A // A #define NM_S KC_S // S #define NM_E KC_D // E @@ -73,7 +65,6 @@ #define NM_O KC_L // O #define NM_H KC_SCLN // H #define NM_QUOT KC_QUOT // ' -// Row 4 #define NM_Z KC_Z // Z #define NM_X KC_X // X #define NM_C KC_C // C @@ -84,21 +75,6 @@ #define NM_COMM KC_COMM // , #define NM_DOT KC_DOT // . #define NM_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define NM_TILD S(NM_GRV) // ~ #define NM_EXLM S(NM_1) // ! #define NM_AT S(NM_2) // @ @@ -112,14 +88,11 @@ #define NM_RPRN S(NM_0) // ) #define NM_UNDS S(NM_MINS) // _ #define NM_PLUS S(NM_EQL) // + -// Row 2 #define NM_COLN S(NM_SCLN) // : #define NM_LCBR S(NM_LBRC) // { #define NM_RCBR S(NM_RBRC) // } #define NM_PIPE S(NM_BSLS) // | -// Row 3 #define NM_DQUO S(NM_QUOT) // " -// Row 4 #define NM_LABK S(NM_COMM) // < #define NM_RABK S(NM_DOT) // > #define NM_QUES S(NM_SLSH) // ? diff --git a/quantum/keymap_extras/keymap_norwegian.h b/quantum/keymap_extras/keymap_norwegian.h index b2499f4fda..45b0c1c56e 100644 --- a/quantum/keymap_extras/keymap_norwegian.h +++ b/quantum/keymap_extras/keymap_norwegian.h @@ -1,39 +1,33 @@ -/* Copyright 2016 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ | │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ \ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ø │ Æ │ ' │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define NO_PIPE KC_GRV // | #define NO_1 KC_1 // 1 #define NO_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define NO_0 KC_0 // 0 #define NO_PLUS KC_MINS // + #define NO_BSLS KC_EQL // (backslash) -// Row 2 #define NO_Q KC_Q // Q #define NO_W KC_W // W #define NO_E KC_E // E @@ -60,7 +53,6 @@ #define NO_P KC_P // P #define NO_ARNG KC_LBRC // Ã… #define NO_DIAE KC_RBRC // ¨ (dead) -// Row 3 #define NO_A KC_A // A #define NO_S KC_S // S #define NO_D KC_D // D @@ -73,7 +65,6 @@ #define NO_OSTR KC_SCLN // Ø #define NO_AE KC_QUOT // Æ #define NO_QUOT KC_NUHS // ' -// Row 4 #define NO_LABK KC_NUBS // < #define NO_Z KC_Z // Z #define NO_X KC_X // X @@ -85,21 +76,6 @@ #define NO_COMM KC_COMM // , #define NO_DOT KC_DOT // . #define NO_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ § │ ! │ " │ # │ ¤ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define NO_SECT S(NO_PIPE) // § #define NO_EXLM S(NO_1) // ! #define NO_DQUO S(NO_2) // " @@ -113,30 +89,12 @@ #define NO_EQL S(NO_0) // = #define NO_QUES S(NO_PLUS) // ? #define NO_GRV S(NO_BSLS) // ` (dead) -// Row 2 #define NO_CIRC S(NO_DIAE) // ^ (dead) -// Row 3 #define NO_ASTR S(NO_QUOT) // * -// Row 4 #define NO_RABK S(NO_LABK) // > #define NO_SCLN S(NO_COMM) // ; #define NO_COLN S(NO_DOT) // : #define NO_UNDS S(NO_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ @ │ £ │ $ │ € │ │ { │ [ │ ] │ } │ │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ µ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define NO_AT ALGR(NO_2) // @ #define NO_PND ALGR(NO_3) // £ #define NO_DLR ALGR(NO_4) // $ @@ -146,7 +104,5 @@ #define NO_RBRC ALGR(NO_9) // ] #define NO_RCBR ALGR(NO_0) // } #define NO_ACUT ALGR(NO_BSLS) // ´ (dead) -// Row 2 #define NO_TILD ALGR(NO_DIAE) // ~ (dead) -// Row 4 #define NO_MICR ALGR(NO_M) // µ diff --git a/quantum/keymap_extras/keymap_plover.h b/quantum/keymap_extras/keymap_plover.h index cd07211bca..fbeee4fc49 100644 --- a/quantum/keymap_extras/keymap_plover.h +++ b/quantum/keymap_extras/keymap_plover.h @@ -1,65 +1,53 @@ -/* Copyright 2016 James Kay - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │Num│ │ │ │ │ │ │ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ S │ T │ P │ H │ │ * │ F │ P │ L │ T │ D │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ K │ W │ R │ │ │ R │ B │ G │ S │ Z │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ A │ O │ │ E │ U │ │ │ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 -#define PV_NUM KC_1 - -// Row 2 -#define PV_LS KC_Q -#define PV_LT KC_W -#define PV_LP KC_E -#define PV_LH KC_R -#define PV_STAR KC_Y -#define PV_RF KC_U -#define PV_RP KC_I -#define PV_RL KC_O -#define PV_RT KC_P +// Aliases +#define PV_NUM KC_1 +#define PV_LS KC_Q +#define PV_LT KC_W +#define PV_LP KC_E +#define PV_LH KC_R +#define PV_STAR KC_Y +#define PV_RF KC_U +#define PV_RP KC_I +#define PV_RL KC_O +#define PV_RT KC_P #define PV_RD KC_LBRC - -// Row 3 -#define PV_LK KC_S -#define PV_LW KC_D -#define PV_LR KC_F -#define PV_RR KC_J -#define PV_RB KC_K -#define PV_RG KC_L +#define PV_LK KC_S +#define PV_LW KC_D +#define PV_LR KC_F +#define PV_RR KC_J +#define PV_RB KC_K +#define PV_RG KC_L #define PV_RS KC_SCLN #define PV_RZ KC_QUOT - -// Row 4 -#define PV_A KC_C -#define PV_O KC_V -#define PV_E KC_N -#define PV_U KC_M +#define PV_A KC_C +#define PV_O KC_V +#define PV_E KC_N +#define PV_U KC_M diff --git a/quantum/keymap_extras/keymap_plover_dvorak.h b/quantum/keymap_extras/keymap_plover_dvorak.h index 445a123151..282ef9848b 100644 --- a/quantum/keymap_extras/keymap_plover_dvorak.h +++ b/quantum/keymap_extras/keymap_plover_dvorak.h @@ -1,45 +1,53 @@ -/* Copyright 2016 James Kay - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once - -#include "keymap_dvorak.h" +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ -#define PD_NUM DV_1 -#define PD_LS DV_Q -#define PD_LT DV_W -#define PD_LP DV_E -#define PD_LH DV_R -#define PD_LK DV_S -#define PD_LW DV_D -#define PD_LR DV_F - -#define PD_STAR DV_Y -#define PD_RF DV_U -#define PD_RP DV_I -#define PD_RL DV_O -#define PD_RT DV_P -#define PD_RD DV_LBRC -#define PD_RR DV_J -#define PD_RB DV_K -#define PD_RG DV_L -#define PD_RS DV_SCLN -#define PD_RZ DV_QUOT +#pragma once +#include "keymap.h" +// clang-format off -#define PD_A DV_C -#define PD_O DV_V -#define PD_E DV_N -#define PD_U DV_M +// Aliases +#define PD_NUM DV_1 +#define PD_LS DV_Q +#define PD_LT DV_W +#define PD_LP DV_E +#define PD_LH DV_R +#define PD_LK DV_S +#define PD_LW DV_D +#define PD_LR DV_F +#define PD_STAR DV_Y +#define PD_RF DV_U +#define PD_RP DV_I +#define PD_RL DV_O +#define PD_RT DV_P +#define PD_RD DV_LBRC +#define PD_RR DV_J +#define PD_RB DV_K +#define PD_RG DV_L +#define PD_RS DV_SCLN +#define PD_RZ DV_QUOT +#define PD_A DV_C +#define PD_O DV_V +#define PD_E DV_N +#define PD_U DV_M diff --git a/quantum/keymap_extras/keymap_polish.h b/quantum/keymap_extras/keymap_polish.h index e5a32f22db..84cb9cc1b3 100644 --- a/quantum/keymap_extras/keymap_polish.h +++ b/quantum/keymap_extras/keymap_polish.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define PL_GRV KC_GRV // ` #define PL_1 KC_1 // 1 #define PL_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define PL_0 KC_0 // 0 #define PL_MINS KC_MINS // - #define PL_EQL KC_EQL // = -// Row 2 #define PL_Q KC_Q // Q #define PL_W KC_W // W #define PL_E KC_E // E @@ -61,7 +54,6 @@ #define PL_LBRC KC_LBRC // [ #define PL_RBRC KC_RBRC // ] #define PL_BSLS KC_BSLS // (backslash) -// Row 3 #define PL_A KC_A // A #define PL_S KC_S // S #define PL_D KC_D // D @@ -73,7 +65,6 @@ #define PL_L KC_L // L #define PL_SCLN KC_SCLN // ; #define PL_QUOT KC_QUOT // ' -// Row 4 #define PL_Z KC_Z // Z #define PL_X KC_X // X #define PL_C KC_C // C @@ -84,21 +75,6 @@ #define PL_COMM KC_COMM // , #define PL_DOT KC_DOT // . #define PL_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define PL_TILD S(PL_GRV) // ~ #define PL_EXLM S(PL_1) // ! #define PL_AT S(PL_2) // @ @@ -112,41 +88,21 @@ #define PL_RPRN S(PL_0) // ) #define PL_UNDS S(PL_MINS) // _ #define PL_PLUS S(PL_EQL) // + -// Row 2 #define PL_LCBR S(PL_LBRC) // { #define PL_RCBR S(PL_RBRC) // } #define PL_PIPE S(PL_BSLS) // | -// Row 3 #define PL_COLN S(PL_SCLN) // : #define PL_DQUO S(PL_QUOT) // " -// Row 4 #define PL_LABK S(PL_COMM) // < #define PL_RABK S(PL_DOT) // > #define PL_QUES S(PL_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ Ę │ │ │ │ € │ │ Ó │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ Ä„ │ Åš │ │ │ │ │ │ │ Š│ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Å» │ Ź │ Ć │ │ │ Ń │ │ │ │ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 2 -#define PL_EOGO ALGR(PL_E) // Ę -#define PL_EURO ALGR(PL_U) // € -#define PL_OACU ALGR(PL_O) // Ó -// Row 3 -#define PL_AOGO ALGR(PL_A) // Ä„ -#define PL_SACU ALGR(PL_S) // Åš -#define PL_LSTR ALGR(PL_L) // Å -// Row 4 -#define PL_ZDOT ALGR(PL_Z) // Å» -#define PL_ZACU ALGR(PL_X) // Ź -#define PL_CACU ALGR(PL_C) // Ć -#define PL_NACU ALGR(PL_N) // Ń +#define PL_EOGO ALGR(PL_E) // Ę +#define PL_EURO ALGR(PL_U) // € +#define PL_OACU ALGR(PL_O) // Ó +#define PL_AOGO ALGR(PL_A) // Ä„ +#define PL_SACU ALGR(PL_S) // Åš +#define PL_LSTR ALGR(PL_L) // Å +#define PL_ZDOT ALGR(PL_Z) // Å» +#define PL_ZACU ALGR(PL_X) // Ź +#define PL_CACU ALGR(PL_C) // Ć +#define PL_NACU ALGR(PL_N) // Ń diff --git a/quantum/keymap_extras/keymap_portuguese.h b/quantum/keymap_extras/keymap_portuguese.h index 19d7dcd817..6e55838f8d 100644 --- a/quantum/keymap_extras/keymap_portuguese.h +++ b/quantum/keymap_extras/keymap_portuguese.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ \ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ « │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ + │ ´ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ç │ º │ ~ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define PT_BSLS KC_GRV // (backslash) #define PT_1 KC_1 // 1 #define PT_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define PT_0 KC_0 // 0 #define PT_QUOT KC_MINS // ' #define PT_LDAQ KC_EQL // « -// Row 2 #define PT_Q KC_Q // Q #define PT_W KC_W // W #define PT_E KC_E // E @@ -60,7 +53,6 @@ #define PT_P KC_P // P #define PT_PLUS KC_LBRC // + #define PT_ACUT KC_RBRC // ´ (dead) -// Row 3 #define PT_A KC_A // A #define PT_S KC_S // S #define PT_D KC_D // D @@ -73,7 +65,6 @@ #define PT_CCED KC_SCLN // Ç #define PT_MORD KC_QUOT // º #define PT_TILD KC_NUHS // ~ (dead) -// Row 4 #define PT_LABK KC_NUBS // < #define PT_Z KC_Z // Z #define PT_X KC_X // X @@ -85,21 +76,6 @@ #define PT_COMM KC_COMM // , #define PT_DOT KC_DOT // . #define PT_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ | │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ » │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ * │ ` │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ ª │ ^ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define PT_PIPE S(PT_BSLS) // | #define PT_EXLM S(PT_1) // ! #define PT_DQUO S(PT_2) // " @@ -113,32 +89,14 @@ #define PT_EQL S(PT_0) // = #define PT_QUES S(PT_QUOT) // ? #define PT_RDAQ S(PT_LDAQ) // » -// Row 2 #define PT_ASTR S(PT_PLUS) // * #define PT_GRV S(PT_ACUT) // ` (dead) -// Row 3 #define PT_FORD S(PT_MORD) // ª #define PT_CIRC S(PT_TILD) // ^ (dead) -// Row 4 #define PT_RABK S(PT_LABK) // > #define PT_SCLN S(PT_COMM) // ; #define PT_COLN S(PT_DOT) // : #define PT_UNDS S(PT_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ @ │ £ │ § │ │ │ { │ [ │ ] │ } │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ ¨ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define PT_AT ALGR(PT_2) // @ #define PT_PND ALGR(PT_3) // £ #define PT_SECT ALGR(PT_4) // § @@ -146,6 +104,5 @@ #define PT_LBRC ALGR(PT_8) // [ #define PT_RBRC ALGR(PT_9) // ] #define PT_RCBR ALGR(PT_0) // } -// Row 2 #define PT_DIAE ALGR(PT_PLUS) // ¨ (dead) #define PT_EURO ALGR(PT_E) // € diff --git a/quantum/keymap_extras/keymap_portuguese_mac_iso.h b/quantum/keymap_extras/keymap_portuguese_mac_iso.h index 78346af285..65a74ee86c 100644 --- a/quantum/keymap_extras/keymap_portuguese_mac_iso.h +++ b/quantum/keymap_extras/keymap_portuguese_mac_iso.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ º │ ´ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ç │ ~ │ \ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 +// Aliases #define PT_SECT KC_GRV // § #define PT_1 KC_1 // 1 #define PT_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define PT_0 KC_0 // 0 #define PT_QUOT KC_MINS // ' #define PT_PLUS KC_EQL // + -// Row 2 #define PT_Q KC_Q // Q #define PT_W KC_W // W #define PT_E KC_E // E @@ -60,7 +53,6 @@ #define PT_P KC_P // P #define PT_MORD KC_LBRC // º #define PT_ACUT KC_RBRC // ´ (dead) -// Row 3 #define PT_A KC_A // A #define PT_S KC_S // S #define PT_D KC_D // D @@ -73,7 +65,6 @@ #define PT_CCED KC_SCLN // Ç #define PT_TILD KC_QUOT // ~ (dead) #define PT_BSLS KC_NUHS // (backslash) -// Row 4 #define PT_LABK KC_NUBS // < #define PT_Z KC_Z // Z #define PT_X KC_X // X @@ -85,21 +76,6 @@ #define PT_COMM KC_COMM // , #define PT_DOT KC_DOT // . #define PT_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ± │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ * │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ ª │ ` │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ ^ │ | │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define PT_PLMN S(PT_SECT) // ± #define PT_EXLM S(PT_1) // ! #define PT_DQUO S(PT_2) // " @@ -113,32 +89,14 @@ #define PT_EQL S(PT_0) // = #define PT_QUES S(PT_QUOT) // ? #define PT_ASTR S(PT_PLUS) // * -// Row 2 #define PT_FORD S(PT_MORD) // ª #define PT_GRV S(PT_ACUT) // ` (dead) -// Row 3 #define PT_CIRC S(PT_TILD) // ^ (dead) #define PT_PIPE S(PT_BSLS) // | -// Row 4 #define PT_RABK S(PT_LABK) // > #define PT_SCLN S(PT_COMM) // ; #define PT_COLN S(PT_DOT) // : #define PT_UNDS S(PT_MINS) // _ - -/* Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ │  │ @ │ € │ £ │ ‰ │ ¶ │ ÷ │ [ │ ] │ ≠│ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ Å’ │ ∑ │ Æ │ ® │ â„¢ │ Â¥ │ †│ ı │ Ø │ Ï€ │ ° │ ¨ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Ã… │ ß │ ∂ │ Æ’ │ Ë™ │ ˇ │ ¯ │ „ │ ‘ │ ¸ │ Ëœ │ ‹ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≤ │ Ω │ « │ © │ √ │ ∫ │ ¬ │ µ │ “ │ … │ — │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define PT_APPL A(PT_1) //  (Apple logo) #define PT_AT A(PT_2) // @ #define PT_EURO A(PT_3) // € @@ -149,7 +107,6 @@ #define PT_LBRC A(PT_8) // [ #define PT_RBRC A(PT_9) // ] #define PT_NEQL A(PT_0) // ≠-// Row 2 #define PT_OE A(PT_Q) // Å’ #define PT_NARS A(PT_W) // ∑ #define PT_AE A(PT_E) // Æ @@ -162,7 +119,6 @@ #define PT_PI A(PT_P) // Ï€ #define PT_DEG A(PT_MORD) // ° #define PT_DIAE A(PT_ACUT) // ¨ (dead) -// Row 3 #define PT_ARNG A(PT_A) // Ã¥ #define PT_SS A(PT_S) // ß #define PT_PDIF A(PT_D) // ∂ @@ -175,7 +131,6 @@ #define PT_CEDL A(PT_CCED) // ¸ #define PT_STIL A(PT_TILD) // Ëœ (dead) #define PT_LSAQ A(PT_BSLS) // ‹ -// Row 4 #define PT_LTEQ A(PT_LABK) // ≤ #define PT_OMEG A(PT_Z) // Ω #define PT_LDAQ A(PT_X) // « @@ -187,21 +142,6 @@ #define PT_LDQU A(PT_COMM) // “ #define PT_ELLP A(PT_DOT) // … #define PT_MDSH A(PT_MINS) // — - -/* Shift+Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ │ ¡ │ ï¬ â”‚ fl │ ¢ │ ∞ │ • │ ℠│ { │ } │ ≈ │ ¿ │ â—Š │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ │ │ │ │ │ ‡ │ Ëš │ │ ∠│ │ Ë â”‚ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ ∆ │ │ │ │ │ ‚ │ ’ │ Ë› │ ˆ │ › │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≥ │ │ » │ │ │ │ │ │ †│ · │ – │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define PT_IEXL S(A(PT_1)) // ¡ #define PT_FI S(A(PT_2)) // ï¬ #define PT_FL S(A(PT_3)) // fl @@ -214,19 +154,16 @@ #define PT_AEQL S(A(PT_0)) // ≈ #define PT_IQUE S(A(PT_QUOT)) // ¿ #define PT_LOZN S(A(PT_PLUS)) // â—Š -// Row 2 #define PT_DDAG S(A(PT_U)) // ‡ #define PT_RNGA S(A(PT_I)) // Ëš #define PT_NARP S(A(PT_P)) // ∠#define PT_DACU S(A(PT_ACUT)) // Ë -// Row 3 #define PT_INCR S(A(PT_D)) // ∆ #define PT_SLQU S(A(PT_K)) // ‚ #define PT_RSQU S(A(PT_L)) // ’ #define PT_OGON S(A(PT_CCED)) // Ë› #define PT_DCIR S(A(PT_TILD)) // ˆ (dead) #define PT_RSAQ S(A(PT_BSLS)) // › -// Row 4 #define PT_GTEQ S(A(PT_LABK)) // ≥ #define PT_RDAQ S(A(PT_X)) // » #define PT_RDQU S(A(PT_COMM)) // †diff --git a/quantum/keymap_extras/keymap_romanian.h b/quantum/keymap_extras/keymap_romanian.h index 27086d684c..01552b3e32 100644 --- a/quantum/keymap_extras/keymap_romanian.h +++ b/quantum/keymap_extras/keymap_romanian.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ „ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ä‚ │ ÃŽ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ș │ Èš │  │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ \ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define RO_DLQU KC_GRV // „ #define RO_1 KC_1 // 1 #define RO_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define RO_0 KC_0 // 0 #define RO_MINS KC_MINS // - #define RO_EQL KC_EQL // = -// Row 2 #define RO_Q KC_Q // Q #define RO_W KC_W // W #define RO_E KC_E // E @@ -60,7 +53,6 @@ #define RO_P KC_P // P #define RO_ABRV KC_LBRC // Ä‚ #define RO_ICIR KC_RBRC // ÃŽ -// Row 3 #define RO_A KC_A // A #define RO_S KC_S // S #define RO_D KC_D // D @@ -73,7 +65,6 @@ #define RO_SCOM KC_SCLN // Ș #define RO_TCOM KC_QUOT // Èš #define RO_ACIR KC_NUHS //  -// Row 4 #define RO_BSLS KC_NUBS // (backslash) #define RO_Z KC_Z // Z #define RO_X KC_X // X @@ -85,21 +76,6 @@ #define RO_COMM KC_COMM // , #define RO_DOT KC_DOT // . #define RO_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ †│ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ | │ │ │ │ │ │ │ │ ; │ : │ ? │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define RO_RDQU S(RO_DLQU) // †#define RO_EXLM S(RO_1) // ! #define RO_AT S(RO_2) // @ @@ -113,26 +89,10 @@ #define RO_RPRN S(RO_0) // ) #define RO_UNDS S(RO_MINS) // _ #define RO_PLUS S(RO_EQL) // + -// Row 4 #define RO_PIPE S(RO_BSLS) // | #define RO_SCLN S(RO_COMM) // ; #define RO_COLN S(RO_DOT) // : #define RO_QUES S(RO_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ ~ │ ˇ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ ´ │ Ë â”‚ ¨ │ ¸ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ § │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ ß │ Ä â”‚ │ │ │ │ │ Š│ │ ' │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ © │ │ │ │ │ < │ > │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define RO_GRV ALGR(RO_DLQU) // ` #define RO_DTIL ALGR(RO_1) // ~ (dead) #define RO_CARN ALGR(RO_2) // ˇ (dead) @@ -146,43 +106,22 @@ #define RO_DACU ALGR(RO_0) // Ë (dead) #define RO_DIAE ALGR(RO_MINS) // ¨ (dead) #define RO_CEDL ALGR(RO_EQL) // ¸ (dead) -// Row 2 #define RO_EURO ALGR(RO_E) // € #define RO_SECT ALGR(RO_P) // § #define RO_LBRC ALGR(RO_ABRV) // [ #define RO_RBRC ALGR(RO_ICIR) // ] -// Row 3 #define RO_SS ALGR(RO_S) // ß #define RO_DSTR ALGR(RO_D) // Ä #define RO_LSTR ALGR(RO_L) // Å #define RO_QUOT ALGR(RO_TCOM) // ' -// Row 4 #define RO_COPY ALGR(RO_C) // © #define RO_LABK ALGR(RO_COMM) // < #define RO_RABK ALGR(RO_DOT) // > - -/* Shift+AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ │ │ │ │ │ │ │ │ │ │ – │ ± │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ " │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ « │ » │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define RO_TILD S(ALGR(RO_DLQU)) // ~ #define RO_NDSH S(ALGR(RO_MINS)) // – #define RO_PLMN S(ALGR(RO_EQL)) // ± -// Row 2 #define RO_LCBR S(ALGR(RO_ABRV)) // { #define RO_RCBR S(ALGR(RO_ICIR)) // } -// Row 3 #define RO_DQUO S(ALGR(RO_TCOM)) // " -// Row 4 #define RO_LDAQ S(ALGR(RO_COMM)) // « #define RO_RDAQ S(ALGR(RO_DOT)) // » diff --git a/quantum/keymap_extras/keymap_russian.h b/quantum/keymap_extras/keymap_russian.h index 71aece677d..03978de5fb 100644 --- a/quantum/keymap_extras/keymap_russian.h +++ b/quantum/keymap_extras/keymap_russian.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ Р│ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Й │ Ц │ У │ К │ Е │ Р│ Г │ Ш │ Щ │ З │ Ð¥ │ Ъ │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ Ф │ Ы │ Ð’ │ Р│ П │ Р│ О │ Л │ Д │ Ж │ Р│ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Я │ Ч │ С │ Ðœ │ И │ Т │ Ь │ Б │ Ю │ . │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define RU_YO KC_GRV // Ð #define RU_1 KC_1 // 1 #define RU_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define RU_0 KC_0 // 0 #define RU_MINS KC_MINS // - #define RU_EQL KC_EQL // = -// Row 2 #define RU_SHTI KC_Q // Й #define RU_TSE KC_W // Ц #define RU_U KC_E // У @@ -61,7 +54,6 @@ #define RU_HA KC_LBRC // Ð¥ #define RU_HARD KC_RBRC // Ъ #define RU_BSLS KC_BSLS // (backslash) -// Row 3 #define RU_EF KC_A // Ф #define RU_YERU KC_S // Ы #define RU_VE KC_D // Ð’ @@ -73,7 +65,6 @@ #define RU_DE KC_L // Д #define RU_ZHE KC_SCLN // Ж #define RU_E KC_QUOT // Ð -// Row 4 #define RU_YA KC_Z // Я #define RU_CHE KC_X // Ч #define RU_ES KC_C // С @@ -84,21 +75,6 @@ #define RU_BE KC_COMM // Б #define RU_YU KC_DOT // Ю #define RU_DOT KC_SLSH // . - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ! │ " │ â„– │ ; │ % │ : │ ? │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ / │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ │ │ , │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define RU_EXLM S(RU_1) // ! #define RU_DQUO S(RU_2) // " #define RU_NUM S(RU_3) // â„– @@ -111,23 +87,6 @@ #define RU_RPRN S(RU_0) // ) #define RU_UNDS S(RU_MINS) // _ #define RU_PLUS S(RU_EQL) // + -// Row 2 #define RU_SLSH S(RU_BSLS) // / -// Row 4 #define RU_COMM S(RU_DOT) // , - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ │ │ │ │ │ │ ₽ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 -#define RU_RUBL ALGR(RU_8) // ₽ +#define RU_RUBL ALGR(RU_8) // ₽ diff --git a/quantum/keymap_extras/keymap_serbian.h b/quantum/keymap_extras/keymap_serbian.h index a17dcc5f34..ff6b4dad02 100644 --- a/quantum/keymap_extras/keymap_serbian.h +++ b/quantum/keymap_extras/keymap_serbian.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Љ │ Њ │ Е │ Р│ Т │ З │ У │ И │ О │ П │ Ш │ Ђ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Р│ С │ Д │ Ф │ Г │ Ð¥ │ Ј │ К │ Л │ Ч │ Ћ │ Ж │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Ð… │ Р│ Ц │ Ð’ │ Б │ Р│ Ðœ │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define RS_GRV KC_GRV // ` #define RS_1 KC_1 // 1 #define RS_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define RS_0 KC_0 // 0 #define RS_QUOT KC_MINS // ' (dead) #define RS_PLUS KC_EQL // + -// Row 2 #define RS_LJE KC_Q // Љ #define RS_NJE KC_W // Њ #define RS_IE KC_E // Е @@ -60,7 +53,6 @@ #define RS_PE KC_P // П #define RS_SHA KC_LBRC // Ш #define RS_DJE KC_RBRC // Ђ -// Row 3 #define RS_A KC_A // Ð #define RS_ES KC_S // С #define RS_DE KC_D // Д @@ -73,7 +65,6 @@ #define RS_CHE KC_SCLN // Ч #define RS_TSHE KC_QUOT // Ћ #define RS_ZHE KC_NUHS // Ж -// Row 4 #define RS_LABK KC_NUBS // < #define RS_DZE KC_Z // Ð… #define RS_DZHE KC_X // Ð @@ -85,21 +76,6 @@ #define RS_COMM KC_COMM // , #define RS_DOT KC_DOT // . #define RS_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ * │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define RS_TILD S(RS_GRV) // ~ #define RS_EXLM S(RS_1) // ! #define RS_DQUO S(RS_2) // " @@ -113,24 +89,8 @@ #define RS_EQL S(RS_0) // = #define RS_QUES S(RS_QUOT) // ? #define RS_ASTR S(RS_PLUS) // * -// Row 4 #define RS_RABK S(RS_LABK) // > #define RS_SCLN S(RS_COMM) // ; #define RS_COLN S(RS_DOT) // : #define RS_UNDS S(RS_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 2 #define RS_EURO ALGR(RS_IE) // € diff --git a/quantum/keymap_extras/keymap_serbian_latin.h b/quantum/keymap_extras/keymap_serbian_latin.h index 13c82eb405..56d468c0cf 100644 --- a/quantum/keymap_extras/keymap_serbian_latin.h +++ b/quantum/keymap_extras/keymap_serbian_latin.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ‚ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Š│ Ä â”‚ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ÄŒ │ Ć │ Ž │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define RS_SLQU KC_GRV // ‚ (dead) #define RS_1 KC_1 // 1 #define RS_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define RS_0 KC_0 // 0 #define RS_QUOT KC_MINS // ' #define RS_PLUS KC_EQL // + -// Row 2 #define RS_Q KC_Q // Q #define RS_W KC_W // W #define RS_E KC_E // E @@ -60,7 +53,6 @@ #define RS_P KC_P // P #define RS_SCAR KC_LBRC // Å #define RS_DSTR KC_RBRC // Ä -// Row 3 #define RS_A KC_A // A #define RS_S KC_S // S #define RS_D KC_D // D @@ -73,7 +65,6 @@ #define RS_CCAR KC_SCLN // ÄŒ #define RS_CACU KC_QUOT // Ć #define RS_ZCAR KC_NUHS // Ž -// Row 4 #define RS_LABK KC_NUBS // < #define RS_Y KC_Z // Y #define RS_X KC_X // X @@ -85,21 +76,6 @@ #define RS_COMM KC_COMM // , #define RS_DOT KC_DOT // . #define RS_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ * │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define RS_TILD S(RS_SLQU) // ~ #define RS_EXLM S(RS_1) // ! #define RS_DQUO S(RS_2) // " @@ -113,26 +89,10 @@ #define RS_EQL S(RS_0) // = #define RS_QUES S(RS_QUOT) // ? #define RS_ASTR S(RS_PLUS) // * -// Row 4 #define RS_RABK S(RS_LABK) // > #define RS_SCLN S(RS_COMM) // ; #define RS_COLN S(RS_DOT) // : #define RS_UNDS S(RS_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ ˇ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ ´ │ Ë â”‚ ¨ │ ¸ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ \ │ | │ € │ │ │ │ │ │ │ │ ÷ │ × │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ [ │ ] │ │ │ Å‚ │ Š│ │ ß │ ¤ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ @ │ { │ } │ § │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define RS_CARN ALGR(RS_2) // ˇ (dead) #define RS_CIRC ALGR(RS_3) // ^ (dead) #define RS_BREV ALGR(RS_4) // ˘ (dead) @@ -144,20 +104,17 @@ #define RS_DACU ALGR(RS_0) // Ë (dead) #define RS_DIAE ALGR(RS_QUOT) // ¨ (dead) #define RS_CEDL ALGR(RS_PLUS) // ¸ (dead) -// Row 2 #define RS_BSLS ALGR(RS_Q) // (backslash) #define RS_PIPE ALGR(RS_W) // | #define RS_EURO ALGR(RS_E) // € #define RS_DIV ALGR(RS_SCAR) // ÷ #define RS_MUL ALGR(RS_DSTR) // × -// Row 3 #define RS_LBRC ALGR(RS_F) // [ #define RS_RBRC ALGR(RS_G) // ] #define RS_LLST ALGR(RS_K) // Å‚ #define RS_CLST ALGR(RS_L) // Å #define RS_SS ALGR(RS_CACU) // ß #define RS_CURR ALGR(RS_ZCAR) // ¤ -// Row 4 #define RS_AT ALGR(RS_V) // @ #define RS_LCBR ALGR(RS_B) // { #define RS_RCBR ALGR(RS_N) // } diff --git a/quantum/keymap_extras/keymap_slovak.h b/quantum/keymap_extras/keymap_slovak.h index bf0b7275ce..5cdf74fb40 100644 --- a/quantum/keymap_extras/keymap_slovak.h +++ b/quantum/keymap_extras/keymap_slovak.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ; │ + │ ľ │ Å¡ │ Ä â”‚ Å¥ │ ž │ ý │ á │ à │ é │ = │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ ú │ ä │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ô │ § │ ň │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ & │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define SK_SCLN KC_GRV // ; #define SK_PLUS KC_1 // + #define SK_LCAR KC_2 // ľ @@ -47,7 +41,6 @@ #define SK_EACU KC_0 // é #define SK_EQL KC_MINS // = #define SK_ACUT KC_EQL // ´ (dead) -// Row 2 #define SK_Q KC_Q // Q #define SK_W KC_W // W #define SK_E KC_E // E @@ -60,7 +53,6 @@ #define SK_P KC_P // P #define SK_UACU KC_LBRC // ú #define SK_ADIA KC_RBRC // ä -// Row 3 #define SK_A KC_A // A #define SK_S KC_S // S #define SK_D KC_D // D @@ -73,7 +65,6 @@ #define SK_OCIR KC_SCLN // ô #define SK_SECT KC_QUOT // § #define SK_NCAR KC_NUHS // ň -// Row 4 #define SK_AMPR KC_NUBS // & #define SK_Y KC_Z // Y #define SK_X KC_X // X @@ -85,21 +76,6 @@ #define SK_COMM KC_COMM // , #define SK_DOT KC_DOT // . #define SK_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ° │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ % │ ˇ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ / │ ( │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ " │ ! │ ) │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ * │ │ │ │ │ │ │ │ ? │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define SK_RNGA S(SK_SCLN) // ° (dead) #define SK_1 S(SK_PLUS) // 1 #define SK_2 S(SK_LCAR) // 2 @@ -113,33 +89,15 @@ #define SK_0 S(SK_EACU) // 0 #define SK_PERC S(SK_EQL) // % #define SK_CARN S(SK_ACUT) // ˇ (dead) -// Row 2 #define SK_SLSH S(SK_UACU) // / #define SK_LPRN S(SK_ADIA) // ( -// Row 3 #define SK_DQUO S(SK_OCIR) // " #define SK_EXLM S(SK_SECT) // ! #define SK_RPRN S(SK_NCAR) // ) -// Row 4 #define SK_ASTR S(SK_AMPR) // * #define SK_QUES S(SK_COMM) // ? #define SK_COLN S(SK_DOT) // : #define SK_UNDS S(SK_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ~ │ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ │ Ë â”‚ ¨ │ ¸ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ \ │ | │ € │ │ │ │ │ │ │ ' │ ÷ │ × │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ Ä‘ │ Ä â”‚ [ │ ] │ │ │ Å‚ │ Š│ $ │ ß │ ¤ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ > │ # │ │ @ │ { │ } │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define SK_TILD ALGR(SK_PLUS) // ~ #define SK_CIRC ALGR(SK_SCAR) // ^ (dead) #define SK_BREV ALGR(SK_CCAR) // ˘ (dead) @@ -149,14 +107,12 @@ #define SK_DACU ALGR(SK_EACU) // Ë (dead) #define SK_DIAE ALGR(SK_EQL) // ¨ (dead) #define SK_CEDL ALGR(SK_ACUT) // ¸ (dead) -// Row 2 #define SK_BSLS ALGR(SK_Q) // (backslash) #define SK_PIPE ALGR(SK_W) // | #define SK_EURO ALGR(SK_E) // € #define SK_QUOT ALGR(SK_P) // ' #define SK_DIV ALGR(SK_UACU) // ÷ #define SK_MUL ALGR(SK_ADIA) // × -// Row 3 #define SK_LDST ALGR(SK_S) // Ä‘ #define SK_CDST ALGR(SK_D) // Ä #define SK_LBRC ALGR(SK_F) // [ @@ -166,7 +122,6 @@ #define SK_DLR ALGR(SK_OCIR) // $ #define SK_SS ALGR(SK_SECT) // ß #define SK_CURR ALGR(SK_NCAR) // ¤ -// Row 4 #define SK_LABK ALGR(SK_AMPR) // < #define SK_RABK ALGR(SK_Y) // > #define SK_HASH ALGR(SK_X) // # diff --git a/quantum/keymap_extras/keymap_slovenian.h b/quantum/keymap_extras/keymap_slovenian.h index 827fa06c25..bd864c0e55 100644 --- a/quantum/keymap_extras/keymap_slovenian.h +++ b/quantum/keymap_extras/keymap_slovenian.h @@ -1,39 +1,33 @@ -/* Copyright 2018 Žan Pevec - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¸ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ Š│ Ä â”‚ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ÄŒ │ Ć │ Ž │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define SI_CEDL KC_GRV // ¸ (dead) #define SI_1 KC_1 // 1 #define SI_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define SI_0 KC_0 // 0 #define SI_QUOT KC_MINS // ' #define SI_PLUS KC_EQL // + -// Row 2 #define SI_Q KC_Q // Q #define SI_W KC_W // W #define SI_E KC_E // E @@ -60,7 +53,6 @@ #define SI_P KC_P // P #define SI_SCAR KC_LBRC // Å #define SI_DSTR KC_RBRC // Ä -// Row 3 #define SI_A KC_A // A #define SI_S KC_S // S #define SI_D KC_D // D @@ -73,7 +65,6 @@ #define SI_CCAR KC_SCLN // ÄŒ #define SI_CACU KC_QUOT // Ć #define SI_ZCAR KC_NUHS // Ž -// Row 4 #define SI_LABK KC_NUBS // < #define SI_Y KC_Z // Y #define SI_X KC_X // X @@ -85,21 +76,6 @@ #define SI_COMM KC_COMM // , #define SI_DOT KC_DOT // . #define SI_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¨ │ ! │ " │ # │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ * │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define SI_DIAE S(SI_CEDL) // ¨ (dead) #define SI_EXLM S(SI_1) // ! #define SI_DQUO S(SI_2) // " @@ -113,26 +89,10 @@ #define SI_EQL S(SI_0) // = #define SI_QUES S(SI_QUOT) // ? #define SI_ASTR S(SI_PLUS) // * -// Row 4 #define SI_RABK S(SI_LABK) // > #define SI_SCLN S(SI_COMM) // ; #define SI_COLN S(SI_DOT) // : #define SI_UNDS S(SI_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ~ │ ˇ │ ^ │ ˘ │ ° │ Ë› │ ` │ Ë™ │ ´ │ Ë â”‚ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ \ │ | │ € │ │ │ │ │ │ │ │ ÷ │ × │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ [ │ ] │ │ │ Å‚ │ Š│ │ ß │ ¤ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ @ │ { │ } │ § │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define SI_TILD ALGR(SI_1) // ~ #define SI_CARN ALGR(SI_2) // ˇ (dead) #define SI_CIRC ALGR(SI_3) // ^ (dead) @@ -143,20 +103,17 @@ #define SI_DOTA ALGR(SI_8) // Ë™ (dead) #define SI_ACUT ALGR(SI_9) // ´ (dead) #define SI_DACU ALGR(SI_0) // Ë (dead) -// Row 2 #define SI_BSLS ALGR(SI_Q) // (backslash) #define SI_PIPE ALGR(SI_W) // | #define SI_EURO ALGR(SI_E) // € #define SI_DIV ALGR(SI_SCAR) // ÷ #define SI_MUL ALGR(SI_DSTR) // × -// Row 3 #define SI_LBRC ALGR(SI_F) // [ #define SI_RBRC ALGR(SI_G) // ] #define SI_LLST ALGR(SI_K) // Å‚ #define SI_CLST ALGR(SI_L) // Å #define SI_SS ALGR(SI_CACU) // ß #define SI_CURR ALGR(SI_ZCAR) // ¤ -// Row 4 #define SI_AT ALGR(SI_V) // @ #define SI_LCBR ALGR(SI_B) // { #define SI_RCBR ALGR(SI_N) // } diff --git a/quantum/keymap_extras/keymap_spanish.h b/quantum/keymap_extras/keymap_spanish.h index 8432c56e99..ffdb3f14d3 100644 --- a/quantum/keymap_extras/keymap_spanish.h +++ b/quantum/keymap_extras/keymap_spanish.h @@ -1,39 +1,33 @@ -/* Copyright 2015-2016 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ º │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ¡ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ ` │ + │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ñ │ ´ │ Ç │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define ES_MORD KC_GRV // º #define ES_1 KC_1 // 1 #define ES_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define ES_0 KC_0 // 0 #define ES_QUOT KC_MINS // ' #define ES_IEXL KC_EQL // ¡ -// Row 2 #define ES_Q KC_Q // Q #define ES_W KC_W // W #define ES_E KC_E // E @@ -60,7 +53,6 @@ #define ES_P KC_P // P #define ES_GRV KC_LBRC // ` (dead) #define ES_PLUS KC_RBRC // + -// Row 3 #define ES_A KC_A // A #define ES_S KC_S // S #define ES_D KC_D // D @@ -73,7 +65,6 @@ #define ES_NTIL KC_SCLN // Ñ #define ES_ACUT KC_QUOT // ´ (dead) #define ES_CCED KC_NUHS // Ç -// Row 4 #define ES_LABK KC_NUBS // < #define ES_Z KC_Z // Z #define ES_X KC_X // X @@ -85,21 +76,6 @@ #define ES_COMM KC_COMM // , #define ES_DOT KC_DOT // . #define ES_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ª │ ! │ " │ · │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ¿ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ ^ │ * │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define ES_FORD S(ES_MORD) // ª #define ES_EXLM S(ES_1) // ! #define ES_DQUO S(ES_2) // " @@ -113,31 +89,13 @@ #define ES_EQL S(ES_0) // = #define ES_QUES S(ES_QUOT) // ? #define ES_IQUE S(ES_IEXL) // ¿ -// Row 2 #define ES_CIRC S(ES_GRV) // ^ (dead) #define ES_ASTR S(ES_PLUS) // * -// Row 3 #define ES_DIAE S(ES_ACUT) // ¨ (dead) -// Row 4 #define ES_RABK S(ES_LABK) // > #define ES_SCLN S(KC_COMM) // ; #define ES_COLN S(KC_DOT) // : #define ES_UNDS S(ES_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ \ │ | │ @ │ # │ ~ │ € │ ¬ │ │ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define ES_BSLS ALGR(ES_MORD) // (backslash) #define ES_PIPE ALGR(ES_1) // | #define ES_AT ALGR(ES_2) // @ @@ -145,9 +103,7 @@ #define ES_TILD ALGR(ES_4) // ~ #define ES_EURO ALGR(ES_5) // € #define ES_NOT ALGR(ES_6) // ¬ -// Row 2 #define ES_LBRC ALGR(ES_GRV) // [ #define ES_RBRC ALGR(ES_PLUS) // ] -// Row 3 #define ES_LCBR ALGR(ES_ACUT) // { #define ES_RCBR ALGR(ES_CCED) // } diff --git a/quantum/keymap_extras/keymap_spanish_dvorak.h b/quantum/keymap_extras/keymap_spanish_dvorak.h index ea0c93f86a..b7dfce923e 100644 --- a/quantum/keymap_extras/keymap_spanish_dvorak.h +++ b/quantum/keymap_extras/keymap_spanish_dvorak.h @@ -1,39 +1,33 @@ -/* Copyright 2020 José Andrés GarcÃa - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ º │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ¡ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ . │ , │ Ñ │ P │ Y │ F │ G │ C │ H │ L │ ` │ + │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ O │ E │ U │ I │ D │ R │ T │ N │ S │ ´ │ Ç │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ - │ Q │ J │ K │ X │ B │ M │ W │ V │ Z │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define DV_MORD KC_GRV // º #define DV_1 KC_1 // 1 #define DV_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define DV_0 KC_0 // 0 #define DV_QUOT KC_MINS // ' #define DV_IEXL KC_EQL // ¡ -// Row 2 #define DV_DOT KC_Q // . #define DV_COMM KC_W // , #define DV_NTIL KC_E // Ñ @@ -60,7 +53,6 @@ #define DV_L KC_P // L #define DV_GRV KC_LBRC // ` (dead) #define DV_PLUS KC_RBRC // + -// Row 3 #define DV_A KC_A // A #define DV_O KC_S // O #define DV_E KC_D // E @@ -73,7 +65,6 @@ #define DV_S KC_SCLN // S #define DV_ACUT KC_QUOT // ´ (dead) #define DV_CCED KC_NUHS // Ç -// Row 4 #define DV_LABK KC_NUBS // < #define DV_MINS KC_Z // - #define DV_Q KC_X // Q @@ -85,21 +76,6 @@ #define DV_W KC_COMM // W #define DV_V KC_DOT // V #define DV_Z KC_SLSH // Z - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ª │ ! │ " │ · │ $ │ % │ & │ / │ ( │ ) │ = │ ? │ ¿ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ : │ ; │ │ │ │ │ │ │ │ │ ^ │ * │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ ¨ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ _ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define DV_FORD S(DV_MORD) // ª #define DV_EXLM S(DV_1) // ! #define DV_DQUO S(DV_2) // " @@ -113,31 +89,13 @@ #define DV_EQL S(DV_0) // = #define DV_QUES S(DV_QUOT) // ? #define DV_IQUE S(DV_IEXL) // ¿ -// Row 2 #define DV_COLN S(DV_DOT) // : #define DV_SCLN S(DV_COMM) // ; #define DV_CIRC S(DV_GRV) // ^ (dead) #define DV_ASTR S(DV_PLUS) // * -// Row 3 #define DV_DIAE S(DV_ACUT) // ¨ (dead) -// Row 4 #define DV_RABK S(DV_LABK) // > #define DV_UNDS S(DV_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ \ │ | │ @ │ # │ ~ │ € │ ¬ │ │ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define DV_BSLS ALGR(DV_MORD) // (backslash) #define DV_PIPE ALGR(DV_1) // | #define DV_AT ALGR(DV_2) // @ @@ -145,9 +103,7 @@ #define DV_TILD ALGR(DV_4) // ~ #define DV_EURO ALGR(DV_5) // € #define DV_NOT ALGR(DV_6) // ¬ -// Row 2 #define DV_LBRC ALGR(DV_GRV) // [ #define DV_RBRC ALGR(DV_PLUS) // ] -// Row 3 #define DV_LCBR ALGR(DV_ACUT) // { #define DV_RCBR ALGR(DV_CCED) // } diff --git a/quantum/keymap_extras/keymap_swedish.h b/quantum/keymap_extras/keymap_swedish.h index cadb66d3bd..262ed2bcfc 100644 --- a/quantum/keymap_extras/keymap_swedish.h +++ b/quantum/keymap_extras/keymap_swedish.h @@ -1,39 +1,33 @@ -/* Copyright 2017 Andreas Lindhé - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ ' │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define SE_SECT KC_GRV // § #define SE_1 KC_1 // 1 #define SE_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define SE_0 KC_0 // 0 #define SE_PLUS KC_MINS // + #define SE_ACUT KC_EQL // ´ (dead) -// Row 2 #define SE_Q KC_Q // Q #define SE_W KC_W // W #define SE_E KC_E // E @@ -60,7 +53,6 @@ #define SE_P KC_P // P #define SE_ARNG KC_LBRC // Ã… #define SE_DIAE KC_RBRC // ¨ (dead) -// Row 3 #define SE_A KC_A // A #define SE_S KC_S // S #define SE_D KC_D // D @@ -73,7 +65,6 @@ #define SE_ODIA KC_SCLN // Ö #define SE_ADIA KC_QUOT // Ä #define SE_QUOT KC_NUHS // ' -// Row 4 #define SE_LABK KC_NUBS // < #define SE_Z KC_Z // Z #define SE_X KC_X // X @@ -85,21 +76,6 @@ #define SE_COMM KC_COMM // , #define SE_DOT KC_DOT // . #define SE_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ½ │ ! │ " │ # │ ¤ │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define SE_HALF S(SE_SECT) // ½ #define SE_EXLM S(SE_1) // ! #define SE_DQUO S(SE_2) // " @@ -113,30 +89,12 @@ #define SE_EQL S(SE_0) // = #define SE_QUES S(SE_PLUS) // ? #define SE_GRV S(SE_ACUT) // ` (dead) -// Row 2 #define SE_CIRC S(SE_DIAE) // ^ (dead) -// Row 3 #define SE_ASTR S(SE_QUOT) // * -// Row 4 #define SE_RABK S(SE_LABK) // > #define SE_SCLN S(SE_COMM) // ; #define SE_COLN S(SE_DOT) // : #define SE_UNDS S(SE_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ @ │ £ │ $ │ € │ │ { │ [ │ ] │ } │ \ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ | │ │ │ │ │ │ │ µ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define SE_AT ALGR(SE_2) // @ #define SE_PND ALGR(SE_3) // £ #define SE_DLR ALGR(SE_4) // $ @@ -146,11 +104,6 @@ #define SE_RBRC ALGR(SE_9) // ] #define SE_RCBR ALGR(SE_0) // } #define SE_BSLS ALGR(SE_PLUS) // (backslash) -// Row 2 #define SE_TILD ALGR(SE_DIAE) // ~ (dead) -// Row 4 #define SE_PIPE ALGR(SE_LABK) // | #define SE_MICR ALGR(SE_M) // µ - -// DEPRECATED -#include "keymap_nordic.h" diff --git a/quantum/keymap_extras/keymap_swedish_mac_ansi.h b/quantum/keymap_extras/keymap_swedish_mac_ansi.h index 0d0426f866..195d46c980 100644 --- a/quantum/keymap_extras/keymap_swedish_mac_ansi.h +++ b/quantum/keymap_extras/keymap_swedish_mac_ansi.h @@ -1,39 +1,33 @@ -/* Copyright 2021 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ < │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ ' │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 +// Aliases #define SE_LABK KC_GRV // < #define SE_1 KC_1 // 1 #define SE_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define SE_0 KC_0 // 0 #define SE_PLUS KC_MINS // + #define SE_ACUT KC_EQL // ´ (dead) -// Row 2 #define SE_Q KC_Q // Q #define SE_W KC_W // W #define SE_E KC_E // E @@ -61,7 +54,6 @@ #define SE_ARNG KC_LBRC // Ã… #define SE_DIAE KC_RBRC // ¨ (dead) #define SE_QUOT KC_NUHS // ' -// Row 3 #define SE_A KC_A // A #define SE_S KC_S // S #define SE_D KC_D // D @@ -73,7 +65,6 @@ #define SE_L KC_L // L #define SE_ODIA KC_SCLN // Ö #define SE_ADIA KC_QUOT // Ä -// Row 4 #define SE_Z KC_Z // Z #define SE_X KC_X // X #define SE_C KC_C // C @@ -84,21 +75,6 @@ #define SE_COMM KC_COMM // , #define SE_DOT KC_DOT // . #define SE_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ > │ ! │ " │ # │ € │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ * │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define SE_RABK S(SE_LABK) // > #define SE_EXLM S(SE_1) // ! #define SE_DQUO S(SE_2) // " @@ -112,29 +88,11 @@ #define SE_EQL S(SE_0) // = #define SE_QUES S(SE_PLUS) // ? #define SE_GRV S(SE_ACUT) // ` -// Row 2 #define SE_CIRC S(SE_DIAE) // ^ (dead) #define SE_ASTR S(SE_QUOT) // * -// Row 4 #define SE_SCLN S(SE_COMM) // ; #define SE_COLN S(SE_DOT) // : #define SE_UNDS S(SE_MINS) // _ - -/* Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ≤ │ © │ â„¢ │ £ │ $ │ ∞ │ § │ | │ [ │ ] │ ≈ │ ± │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ • │ Ω │ É │ ® │ †│ µ │ Ãœ │ ı │ Å’ │ Ï€ │ Ë™ │ ~ │ @ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │  │ ß │ ∂ │ Æ’ │ ¸ │ Ë› │ √ │ ª │ ï¬ â”‚ Ø │ Æ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ ÷ │ │ Ç │ ‹ │ › │ ‘ │ ’ │ ‚ │ … │ – │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - * - */ -// Row 1 #define SE_LTEQ A(SE_LABK) // ≤ #define SE_COPY A(SE_1) // © #define SE_TM A(SE_2) // â„¢ @@ -147,7 +105,6 @@ #define SE_RBRC A(SE_9) // ] #define SE_AEQL A(SE_0) // ≈ #define SE_PLMN A(SE_PLUS) // ± -// Row 2 #define SE_BULT A(SE_Q) // • #define SE_OMEG A(SE_W) // Ω #define SE_EACU A(SE_E) // É @@ -161,7 +118,6 @@ #define SE_DOTA A(SE_ARNG) // Ë™ #define SE_TILD A(SE_DIAE) // ~ (dead) #define SE_AT A(SE_QUOT) // @ -// Row 3 #define SE_APPL A(SE_A) //  (Apple logo) #define SE_SS A(SE_S) // ß #define SE_PDIF A(SE_D) // ∂ @@ -173,7 +129,6 @@ #define SE_FI A(SE_L) // ï¬ #define SE_OSTR A(SE_ODIA) // Ø #define SE_AE A(SE_ADIA) // Æ -// Row 4 #define SE_DIV A(SE_Z) // ÷ #define SE_CCED A(SE_C) // Ç #define SE_LSAQ A(SE_V) // ‹ @@ -183,22 +138,6 @@ #define SE_SLQU A(SE_COMM) // ‚ #define SE_ELLP A(SE_DOT) // … #define SE_NDSH A(SE_MINS) // – - -/* Shift+Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ≥ │ ¡ │ │ Â¥ │ ¢ │ ‰ │ ¶ │ \ │ { │ } │ ≠│ ¿ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ ° │ Ë â”‚ │ │ ‡ │ Ëœ │ │ ˆ │ │ ∠│ Ëš │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │ â—Š │ ∑ │ ∆ │ ∫ │ ¯ │ ˘ │ ¬ │ º │ fl │ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ ℠│ ˇ │ │ « │ » │ “ │ †│ „ │ · │ — │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - * - */ -// Row 1 #define SE_GTEQ S(A(SE_LABK)) // ≥ #define SE_IEXL S(A(SE_1)) // ¡ #define SE_YEN S(A(SE_3)) // Â¥ @@ -210,7 +149,6 @@ #define SE_RCBR S(A(SE_9)) // } #define SE_NEQL S(A(SE_0)) // ≠#define SE_IQUE S(A(SE_PLUS)) // ¿ -// Row 2 #define SE_DEG S(A(SE_Q)) // ° #define SE_DACU S(A(SE_W)) // Ë #define SE_DDAG S(A(SE_T)) // ‡ @@ -218,7 +156,6 @@ #define SE_DCIR S(A(SE_I)) // ˆ #define SE_NARP S(A(SE_P)) // ∠#define SE_RNGA S(A(SE_ARNG)) // Ëš -// Row 3 #define SE_LOZN S(A(SE_A)) // â—Š #define SE_NARS S(A(SE_S)) // ∑ #define SE_INCR S(A(SE_D)) // ∆ @@ -228,7 +165,6 @@ #define SE_NOT S(A(SE_J)) // ¬ #define SE_MORD S(A(SE_K)) // º #define SE_FL S(A(SE_L)) // fl -// Row 4 #define SE_FRSL S(A(SE_Z)) // â„ #define SE_CARN S(A(SE_X)) // ˇ #define SE_LDAQ S(A(SE_V)) // « diff --git a/quantum/keymap_extras/keymap_swedish_mac_iso.h b/quantum/keymap_extras/keymap_swedish_mac_iso.h index ab155530ae..06c3470b3b 100644 --- a/quantum/keymap_extras/keymap_swedish_mac_iso.h +++ b/quantum/keymap_extras/keymap_swedish_mac_iso.h @@ -1,39 +1,33 @@ -/* Copyright 2021 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ ' │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 +// Aliases #define SE_SECT KC_GRV // § #define SE_1 KC_1 // 1 #define SE_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define SE_0 KC_0 // 0 #define SE_PLUS KC_MINS // + #define SE_ACUT KC_EQL // ´ (dead) -// Row 2 #define SE_Q KC_Q // Q #define SE_W KC_W // W #define SE_E KC_E // E @@ -60,7 +53,6 @@ #define SE_P KC_P // P #define SE_ARNG KC_LBRC // Ã… #define SE_DIAE KC_RBRC // ¨ (dead) -// Row 3 #define SE_A KC_A // A #define SE_S KC_S // S #define SE_D KC_D // D @@ -73,7 +65,6 @@ #define SE_ODIA KC_SCLN // Ö #define SE_ADIA KC_QUOT // Ä #define SE_QUOT KC_NUHS // ' -// Row 4 #define SE_LABK KC_NUBS // < #define SE_Z KC_Z // Z #define SE_X KC_X // X @@ -85,22 +76,7 @@ #define SE_COMM KC_COMM // , #define SE_DOT KC_DOT // . #define SE_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ° │ ! │ " │ # │ € │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 -#define SE_DEG S(SE_SECT) // ° +#define SE_DEG S(SE_SECT) // ° #define SE_EXLM S(SE_1) // ! #define SE_DQUO S(SE_2) // " #define SE_HASH S(SE_3) // # @@ -113,30 +89,12 @@ #define SE_EQL S(SE_0) // = #define SE_QUES S(SE_PLUS) // ? #define SE_GRV S(SE_ACUT) // ` -// Row 2 #define SE_CIRC S(SE_DIAE) // ^ (dead) -// Row 3 #define SE_ASTR S(SE_QUOT) // * -// Row 4 #define SE_RABK S(SE_LABK) // > #define SE_SCLN S(SE_COMM) // ; #define SE_COLN S(SE_DOT) // : #define SE_UNDS S(SE_MINS) // _ - -/* Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ¶ │ © │ â„¢ │ £ │ $ │ ∞ │ │ | │ [ │ ] │ ≈ │ ± │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ • │ Ω │ É │ ® │ †│ µ │ Ãœ │ ı │ Å’ │ Ï€ │ Ë™ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │  │ ß │ ∂ │ Æ’ │ ¸ │ Ë› │ √ │ ª │ ï¬ â”‚ Ø │ Æ │ @ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≤ │ ÷ │ │ Ç │ ‹ │ › │ ‘ │ ’ │ ‚ │ … │ – │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define SE_PILC A(SE_SECT) // ¶ #define SE_COPY A(SE_1) // © #define SE_TM A(SE_2) // â„¢ @@ -148,7 +106,6 @@ #define SE_RBRC A(SE_9) // ] #define SE_AEQL A(SE_0) // ≈ #define SE_PLMN A(SE_PLUS) // ± -// Row 2 #define SE_BULT A(SE_Q) // • #define SE_OMEG A(SE_W) // Ω #define SE_EACU A(SE_E) // É @@ -161,7 +118,6 @@ #define SE_PI A(SE_P) // Ï€ #define SE_DOTA A(SE_ARNG) // Ë™ #define SE_TILD A(SE_DIAE) // ~ (dead) -// Row 3 #define SE_APPL A(SE_A) //  (Apple logo) #define SE_SS A(SE_S) // ß #define SE_PDIF A(SE_D) // ∂ @@ -174,7 +130,6 @@ #define SE_OSTR A(SE_ODIA) // Ø #define SE_AE A(SE_ADIA) // Æ #define SE_AT A(SE_QUOT) // @ -// Row 4 #define SE_LTEQ A(SE_LABK) // ≤ #define SE_DIV A(SE_Z) // ÷ #define SE_CCED A(SE_C) // Ç @@ -185,21 +140,6 @@ #define SE_SLQU A(SE_COMM) // ‚ #define SE_ELLP A(SE_DOT) // … #define SE_NDSH A(SE_MINS) // – - -/* Shift+Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ │ ¡ │ †│ Â¥ │ ¢ │ ‰ │ │ \ │ { │ } │ ≠│ ¿ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ Ë â”‚ │ │ ‡ │ Ëœ │ │ ˆ │ │ ∠│ Ëš │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ â—Š │ ∑ │ ∆ │ ∫ │ ¯ │ ˘ │ ¬ │ º │ fl │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≥ │ ℠│ ˇ │ │ « │ » │ “ │ †│ „ │ · │ — │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define SE_IEXL S(A(SE_1)) // ¡ #define SE_YEN S(A(SE_3)) // Â¥ #define SE_CENT S(A(SE_4)) // ¢ @@ -209,14 +149,12 @@ #define SE_RCBR S(A(SE_9)) // } #define SE_NEQL S(A(SE_0)) // ≠#define SE_IQUE S(A(SE_PLUS)) // ¿ -// Row 2 #define SE_DACU S(A(SE_W)) // Ë #define SE_DDAG S(A(SE_T)) // ‡ #define SE_STIL S(A(SE_Y)) // Ëœ #define SE_DCIR S(A(SE_I)) // ˆ #define SE_NARP S(A(SE_P)) // ∠#define SE_RNGA S(A(SE_ARNG)) // Ëš -// Row 3 #define SE_LOZN S(A(SE_A)) // â—Š #define SE_NARS S(A(SE_S)) // ∑ #define SE_INCR S(A(SE_D)) // ∆ @@ -226,7 +164,6 @@ #define SE_NOT S(A(SE_J)) // ¬ #define SE_MORD S(A(SE_K)) // º #define SE_FL S(A(SE_L)) // fl -// Row 4 #define SE_GTEQ S(A(SE_LABK)) // ≥ #define SE_FRSL S(A(SE_Z)) // â„ #define SE_CARN S(A(SE_X)) // ˇ diff --git a/quantum/keymap_extras/keymap_swedish_pro_mac_ansi.h b/quantum/keymap_extras/keymap_swedish_pro_mac_ansi.h index 9b44517625..4d4d7fcd81 100644 --- a/quantum/keymap_extras/keymap_swedish_pro_mac_ansi.h +++ b/quantum/keymap_extras/keymap_swedish_pro_mac_ansi.h @@ -1,39 +1,33 @@ -/* Copyright 2021 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ < │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ ' │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 +// Aliases #define SE_LABK KC_GRV // < #define SE_1 KC_1 // 1 #define SE_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define SE_0 KC_0 // 0 #define SE_PLUS KC_MINS // + #define SE_ACUT KC_EQL // ´ (dead) -// Row 2 #define SE_Q KC_Q // Q #define SE_W KC_W // W #define SE_E KC_E // E @@ -61,7 +54,6 @@ #define SE_ARNG KC_LBRC // Ã… #define SE_DIAE KC_RBRC // ¨ (dead) #define SE_QUOT KC_NUHS // ' -// Row 3 #define SE_A KC_A // A #define SE_S KC_S // S #define SE_D KC_D // D @@ -73,7 +65,6 @@ #define SE_L KC_L // L #define SE_ODIA KC_SCLN // Ö #define SE_ADIA KC_QUOT // Ä -// Row 4 #define SE_Z KC_Z // Z #define SE_X KC_X // X #define SE_C KC_C // C @@ -84,21 +75,6 @@ #define SE_COMM KC_COMM // , #define SE_DOT KC_DOT // . #define SE_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ > │ ! │ " │ # │ € │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ * │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define SE_RABK S(SE_LABK) // > #define SE_EXLM S(SE_1) // ! #define SE_DQUO S(SE_2) // " @@ -112,29 +88,11 @@ #define SE_EQL S(SE_0) // = #define SE_QUES S(SE_PLUS) // ? #define SE_GRV S(SE_ACUT) // ` -// Row 2 #define SE_CIRC S(SE_DIAE) // ^ (dead) #define SE_ASTR S(SE_QUOT) // * -// Row 4 #define SE_SCLN S(SE_COMM) // ; #define SE_COLN S(SE_DOT) // : #define SE_UNDS S(SE_MINS) // _ - -/* Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ≤ │ © │ @ │ £ │ $ │ ∞ │ § │ | │ [ │ ] │ ≈ │ ± │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ • │ Ω │ É │ ® │ †│ µ │ Ãœ │ ı │ Å’ │ Ï€ │ Ë™ │ ~ │ â„¢ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │  │ ß │ ∂ │ Æ’ │ ¸ │ Ë› │ √ │ ª │ ï¬ â”‚ Ø │ Æ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ ÷ │ │ Ç │ ‹ │ › │ ‘ │ ’ │ ‚ │ … │ – │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - * - */ -// Row 1 #define SE_LTEQ A(SE_LABK) // ≤ #define SE_COPY A(SE_1) // © #define SE_AT A(SE_2) // @ @@ -147,7 +105,6 @@ #define SE_RBRC A(SE_9) // ] #define SE_AEQL A(SE_0) // ≈ #define SE_PLMN A(SE_PLUS) // ± -// Row 2 #define SE_BULT A(SE_Q) // • #define SE_OMEG A(SE_W) // Ω #define SE_EACU A(SE_E) // É @@ -161,7 +118,6 @@ #define SE_DOTA A(SE_ARNG) // Ë™ #define SE_TILD A(SE_DIAE) // ~ (dead) #define SE_TM A(SE_QUOT) // â„¢ -// Row 3 #define SE_APPL A(SE_A) //  (Apple logo) #define SE_SS A(SE_S) // ß #define SE_PDIF A(SE_D) // ∂ @@ -173,7 +129,6 @@ #define SE_FI A(SE_L) // ï¬ #define SE_OSTR A(SE_ODIA) // Ø #define SE_AE A(SE_ADIA) // Æ -// Row 4 #define SE_DIV A(SE_Z) // ÷ #define SE_CCED A(SE_C) // Ç #define SE_LSAQ A(SE_V) // ‹ @@ -183,22 +138,6 @@ #define SE_SLQU A(SE_COMM) // ‚ #define SE_ELLP A(SE_DOT) // … #define SE_NDSH A(SE_MINS) // – - -/* Shift+Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ≥ │ ¡ │ │ Â¥ │ ¢ │ ‰ │ ¶ │ \ │ { │ } │ ≠│ ¿ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ ° │ Ë â”‚ │ │ ‡ │ Ëœ │ │ ˆ │ │ ∠│ Ëš │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴───┤ - * │ │ â—Š │ ∑ │ ∆ │ ∫ │ ¯ │ ˘ │ ¬ │ º │ fl │ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴──────┤ - * │ │ ℠│ ˇ │ │ « │ » │ “ │ †│ „ │ · │ — │ │ - * ├─────┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - * - */ -// Row 1 #define SE_GTEQ S(A(SE_LABK)) // ≥ #define SE_IEXL S(A(SE_1)) // ¡ #define SE_YEN S(A(SE_3)) // Â¥ @@ -210,7 +149,6 @@ #define SE_RCBR S(A(SE_9)) // } #define SE_NEQL S(A(SE_0)) // ≠#define SE_IQUE S(A(SE_PLUS)) // ¿ -// Row 2 #define SE_DEG S(A(SE_Q)) // ° #define SE_DACU S(A(SE_W)) // Ë #define SE_DDAG S(A(SE_T)) // ‡ @@ -218,7 +156,6 @@ #define SE_DCIR S(A(SE_I)) // ˆ #define SE_NARP S(A(SE_P)) // ∠#define SE_RNGA S(A(SE_ARNG)) // Ëš -// Row 3 #define SE_LOZN S(A(SE_A)) // â—Š #define SE_NARS S(A(SE_S)) // ∑ #define SE_INCR S(A(SE_D)) // ∆ @@ -228,7 +165,6 @@ #define SE_NOT S(A(SE_J)) // ¬ #define SE_MORD S(A(SE_K)) // º #define SE_FL S(A(SE_L)) // fl -// Row 4 #define SE_FRSL S(A(SE_Z)) // â„ #define SE_CARN S(A(SE_X)) // ˇ #define SE_LDAQ S(A(SE_V)) // « diff --git a/quantum/keymap_extras/keymap_swedish_pro_mac_iso.h b/quantum/keymap_extras/keymap_swedish_pro_mac_iso.h index f2d6605865..ea43ed5c12 100644 --- a/quantum/keymap_extras/keymap_swedish_pro_mac_iso.h +++ b/quantum/keymap_extras/keymap_swedish_pro_mac_iso.h @@ -1,39 +1,33 @@ -/* Copyright 2021 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ ´ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Ã… │ ¨ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Ö │ Ä │ ' │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 +// Aliases #define SE_SECT KC_GRV // § #define SE_1 KC_1 // 1 #define SE_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define SE_0 KC_0 // 0 #define SE_PLUS KC_MINS // + #define SE_ACUT KC_EQL // ´ (dead) -// Row 2 #define SE_Q KC_Q // Q #define SE_W KC_W // W #define SE_E KC_E // E @@ -60,7 +53,6 @@ #define SE_P KC_P // P #define SE_ARNG KC_LBRC // Ã… #define SE_DIAE KC_RBRC // ¨ (dead) -// Row 3 #define SE_A KC_A // A #define SE_S KC_S // S #define SE_D KC_D // D @@ -73,7 +65,6 @@ #define SE_ODIA KC_SCLN // Ö #define SE_ADIA KC_QUOT // Ä #define SE_QUOT KC_NUHS // ' -// Row 4 #define SE_LABK KC_NUBS // < #define SE_Z KC_Z // Z #define SE_X KC_X // X @@ -85,22 +76,7 @@ #define SE_COMM KC_COMM // , #define SE_DOT KC_DOT // . #define SE_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ° │ ! │ " │ # │ € │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ^ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ * │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 -#define SE_DEG S(SE_SECT) // ° +#define SE_DEG S(SE_SECT) // ° #define SE_EXLM S(SE_1) // ! #define SE_DQUO S(SE_2) // " #define SE_HASH S(SE_3) // # @@ -113,30 +89,12 @@ #define SE_EQL S(SE_0) // = #define SE_QUES S(SE_PLUS) // ? #define SE_GRV S(SE_ACUT) // ` -// Row 2 #define SE_CIRC S(SE_DIAE) // ^ (dead) -// Row 3 #define SE_ASTR S(SE_QUOT) // * -// Row 4 #define SE_RABK S(SE_LABK) // > #define SE_SCLN S(SE_COMM) // ; #define SE_COLN S(SE_DOT) // : #define SE_UNDS S(SE_MINS) // _ - -/* Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ ¶ │ © │ @ │ £ │ $ │ ∞ │ │ | │ [ │ ] │ ≈ │ ± │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ • │ Ω │ É │ ® │ †│ µ │ Ãœ │ ı │ Å’ │ Ï€ │ Ë™ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │  │ ß │ ∂ │ Æ’ │ ¸ │ Ë› │ √ │ ª │ ï¬ â”‚ Ø │ Æ │ â„¢ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≤ │ ÷ │ │ Ç │ ‹ │ › │ ‘ │ ’ │ ‚ │ … │ – │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define SE_PILC A(SE_SECT) // ¶ #define SE_COPY A(SE_1) // © #define SE_AT A(SE_2) // @ @@ -148,7 +106,6 @@ #define SE_RBRC A(SE_9) // ] #define SE_AEQL A(SE_0) // ≈ #define SE_PLMN A(SE_PLUS) // ± -// Row 2 #define SE_BULT A(SE_Q) // • #define SE_OMEG A(SE_W) // Ω #define SE_EACU A(SE_E) // É @@ -161,7 +118,6 @@ #define SE_PI A(SE_P) // Ï€ #define SE_DOTA A(SE_ARNG) // Ë™ #define SE_TILD A(SE_DIAE) // ~ (dead) -// Row 3 #define SE_APPL A(SE_A) //  (Apple logo) #define SE_SS A(SE_S) // ß #define SE_PDIF A(SE_D) // ∂ @@ -174,7 +130,6 @@ #define SE_OSTR A(SE_ODIA) // Ø #define SE_AE A(SE_ADIA) // Æ #define SE_TM A(SE_QUOT) // â„¢ -// Row 4 #define SE_LTEQ A(SE_LABK) // ≤ #define SE_DIV A(SE_Z) // ÷ #define SE_CCED A(SE_C) // Ç @@ -185,21 +140,6 @@ #define SE_SLQU A(SE_COMM) // ‚ #define SE_ELLP A(SE_DOT) // … #define SE_NDSH A(SE_MINS) // – - -/* Shift+Alted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬─────┠- * │ │ ¡ │ †│ Â¥ │ ¢ │ ‰ │ │ \ │ { │ } │ ≠│ ¿ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬───┤ - * │ │ │ Ë â”‚ │ │ ‡ │ Ëœ │ │ ˆ │ │ ∠│ Ëš │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ â—Š │ ∑ │ ∆ │ ∫ │ ¯ │ ˘ │ ¬ │ º │ fl │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴──┤ - * │ │ ≥ │ ℠│ ˇ │ │ « │ » │ “ │ †│ „ │ · │ — │ │ - * ├────┴┬──┴─┬─┴───┼───┴───┴───┴───┴───┴───┼───┴─┬─┴──┬─────┤ - * │ │ │ │ │ │ │ │ - * └─────┴────┴─────┴───────────────────────┴─────┴────┴─────┘ - */ -// Row 1 #define SE_IEXL S(A(SE_1)) // ¡ #define SE_YEN S(A(SE_3)) // Â¥ #define SE_CENT S(A(SE_4)) // ¢ @@ -209,14 +149,12 @@ #define SE_RCBR S(A(SE_9)) // } #define SE_NEQL S(A(SE_0)) // ≠#define SE_IQUE S(A(SE_PLUS)) // ¿ -// Row 2 #define SE_DACU S(A(SE_W)) // Ë #define SE_DDAG S(A(SE_T)) // ‡ #define SE_STIL S(A(SE_Y)) // Ëœ #define SE_DCIR S(A(SE_I)) // ˆ #define SE_NARP S(A(SE_P)) // ∠#define SE_RNGA S(A(SE_ARNG)) // Ëš -// Row 3 #define SE_LOZN S(A(SE_A)) // â—Š #define SE_NARS S(A(SE_S)) // ∑ #define SE_INCR S(A(SE_D)) // ∆ @@ -226,7 +164,6 @@ #define SE_NOT S(A(SE_J)) // ¬ #define SE_MORD S(A(SE_K)) // º #define SE_FL S(A(SE_L)) // fl -// Row 4 #define SE_GTEQ S(A(SE_LABK)) // ≥ #define SE_FRSL S(A(SE_Z)) // â„ #define SE_CARN S(A(SE_X)) // ˇ diff --git a/quantum/keymap_extras/keymap_swiss_de.h b/quantum/keymap_extras/keymap_swiss_de.h index 6723836870..366d85d3d4 100644 --- a/quantum/keymap_extras/keymap_swiss_de.h +++ b/quantum/keymap_extras/keymap_swiss_de.h @@ -1,44 +1,33 @@ -/* Copyright 2016 heartsekai - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -#ifdef CH_H -// The ChibiOS ch.h file defines this... -# undef CH_H -#endif - -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ^ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ ü │ ¨ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ö │ ä │ $ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define CH_SECT KC_GRV // § #define CH_1 KC_1 // 1 #define CH_2 KC_2 // 2 @@ -52,7 +41,6 @@ #define CH_0 KC_0 // 0 #define CH_QUOT KC_MINS // ' #define CH_CIRC KC_EQL // ^ (dead) -// Row 2 #define CH_Q KC_Q // Q #define CH_W KC_W // W #define CH_E KC_E // E @@ -65,7 +53,6 @@ #define CH_P KC_P // P #define CH_UDIA KC_LBRC // ü #define CH_DIAE KC_RBRC // ¨ (dead) -// Row 3 #define CH_A KC_A // A #define CH_S KC_S // S #define CH_D KC_D // D @@ -78,7 +65,6 @@ #define CH_ODIA KC_SCLN // ö #define CH_ADIA KC_QUOT // ä #define CH_DLR KC_NUHS // $ -// Row 4 #define CH_LABK KC_NUBS // < #define CH_Y KC_Z // Y #define CH_X KC_X // X @@ -90,21 +76,6 @@ #define CH_COMM KC_COMM // , #define CH_DOT KC_DOT // . #define CH_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ° │ + │ " │ * │ ç │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ è │ ! │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ é │ à │ £ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CH_DEG S(CH_SECT) // ° #define CH_PLUS S(CH_1) // + #define CH_DQUO S(CH_2) // " @@ -118,33 +89,15 @@ #define CH_EQL S(CH_0) // = #define CH_QUES S(CH_QUOT) // ? #define CH_GRV S(CH_CIRC) // ` (dead) -// Row 2 #define CH_EGRV S(CH_UDIA) // è #define CH_EXLM S(CH_DIAE) // ! -// Row 3 #define CH_EACU S(CH_ODIA) // é #define CH_AGRV S(CH_ADIA) // à #define CH_PND S(CH_DLR) // £ -// Row 4 #define CH_RABK S(CH_LABK) // > #define CH_SCLN S(CH_COMM) // ; #define CH_COLN S(CH_DOT) // : #define CH_UNDS S(CH_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ¦ │ @ │ # │ │ │ ¬ │ | │ ¢ │ │ │ ´ │ ~ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ \ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CH_BRKP ALGR(CH_1) // ¦ #define CH_AT ALGR(CH_2) // @ #define CH_HASH ALGR(CH_3) // # @@ -153,12 +106,9 @@ #define CH_CENT ALGR(CH_8) // ¢ #define CH_ACUT ALGR(CH_QUOT) // ´ (dead) #define CH_TILD ALGR(CH_CIRC) // ~ (dead) -// Row 2 #define CH_EURO ALGR(CH_E) // € #define CH_LBRC ALGR(CH_UDIA) // [ #define CH_RBRC ALGR(CH_DIAE) // ] -// Row 3 #define CH_LCBR ALGR(CH_ADIA) // { #define CH_RCBR ALGR(CH_DLR) // } -// Row 4 #define CH_BSLS ALGR(CH_LABK) // (backslash) diff --git a/quantum/keymap_extras/keymap_swiss_fr.h b/quantum/keymap_extras/keymap_swiss_fr.h index b1f2455a68..49fd4a0458 100644 --- a/quantum/keymap_extras/keymap_swiss_fr.h +++ b/quantum/keymap_extras/keymap_swiss_fr.h @@ -1,44 +1,33 @@ -/* Copyright 2016 Vincent Pochet - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -#ifdef CH_H -// The ChibiOS ch.h file defines this... -# undef CH_H -#endif - -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ § │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ ' │ ^ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Z │ U │ I │ O │ P │ è │ ¨ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ é │ à │ $ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Y │ X │ C │ V │ B │ N │ M │ , │ . │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define CH_SECT KC_GRV // § #define CH_1 KC_1 // 1 #define CH_2 KC_2 // 2 @@ -52,7 +41,6 @@ #define CH_0 KC_0 // 0 #define CH_QUOT KC_MINS // ' #define CH_CIRC KC_EQL // ^ (dead) -// Row 2 #define CH_Q KC_Q // Q #define CH_W KC_W // W #define CH_E KC_E // E @@ -65,7 +53,6 @@ #define CH_P KC_P // P #define CH_EGRV KC_LBRC // è #define CH_DIAE KC_RBRC // ¨ (dead) -// Row 3 #define CH_A KC_A // A #define CH_S KC_S // S #define CH_D KC_D // D @@ -78,7 +65,6 @@ #define CH_EACU KC_SCLN // é #define CH_AGRV KC_QUOT // à #define CH_DLR KC_NUHS // $ -// Row 4 #define CH_LABK KC_NUBS // < #define CH_Y KC_Z // Y #define CH_X KC_X // X @@ -90,21 +76,6 @@ #define CH_COMM KC_COMM // , #define CH_DOT KC_DOT // . #define CH_MINS KC_SLSH // - - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ° │ + │ " │ * │ ç │ % │ & │ / │ ( │ ) │ = │ ? │ ` │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ ü │ ! │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ ö │ ä │ £ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ ; │ : │ _ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CH_DEG S(CH_SECT) // ° #define CH_PLUS S(CH_1) // + #define CH_DQUO S(CH_2) // " @@ -118,33 +89,15 @@ #define CH_EQL S(CH_0) // = #define CH_QUES S(CH_QUOT) // ? #define CH_GRV S(CH_CIRC) // ` (dead) -// Row 2 #define CH_UDIA S(CH_EGRV) // ü #define CH_EXLM S(CH_DIAE) // ! -// Row 3 #define CH_ODIA S(CH_EACU) // ö #define CH_ADIA S(CH_AGRV) // ä #define CH_PND S(CH_DLR) // £ -// Row 4 #define CH_RABK S(CH_LABK) // > #define CH_SCLN S(CH_COMM) // ; #define CH_COLN S(CH_DOT) // : #define CH_UNDS S(CH_MINS) // _ - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ¦ │ @ │ # │ │ │ ¬ │ | │ ¢ │ │ │ ´ │ ~ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ € │ │ │ │ │ │ │ │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ \ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define CH_BRKP ALGR(CH_1) // ¦ #define CH_AT ALGR(CH_2) // @ #define CH_HASH ALGR(CH_3) // # @@ -153,12 +106,9 @@ #define CH_CENT ALGR(CH_8) // ¢ #define CH_ACUT ALGR(CH_QUOT) // ´ (dead) #define CH_TILD ALGR(CH_CIRC) // ~ (dead) -// Row 2 #define CH_EURO ALGR(CH_E) // € #define CH_LBRC ALGR(CH_EGRV) // [ #define CH_RBRC ALGR(CH_DIAE) // ] -// Row 3 #define CH_LCBR ALGR(CH_AGRV) // { #define CH_RCBR ALGR(CH_DLR) // } -// Row 4 #define CH_BSLS ALGR(CH_LABK) // (backslash) diff --git a/quantum/keymap_extras/keymap_turkish_f.h b/quantum/keymap_extras/keymap_turkish_f.h index aaee2aa480..78dae35ce5 100644 --- a/quantum/keymap_extras/keymap_turkish_f.h +++ b/quantum/keymap_extras/keymap_turkish_f.h @@ -1,39 +1,33 @@ -/* Copyright 2019 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ + │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ / │ - │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ F │ G │ Äž │ I │ O │ D │ R │ N │ H │ P │ Q │ W │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ U │ Ä° │ E │ A │ Ãœ │ T │ K │ M │ L │ Y │ Åž │ X │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ J │ Ö │ V │ C │ Ç │ Z │ S │ B │ . │ , │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define TR_PLUS KC_GRV // + #define TR_1 KC_1 // 1 #define TR_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define TR_0 KC_0 // 0 #define TR_SLSH KC_MINS // / #define TR_MINS KC_EQL // - -// Row 2 #define TR_F KC_Q // F #define TR_G KC_W // G #define TR_GBRV KC_E // Äž @@ -60,7 +53,6 @@ #define TR_P KC_P // P #define TR_Q KC_LBRC // Q #define TR_W KC_RBRC // W -// Row 3 #define TR_U KC_A // U #define TR_IDOT KC_S // Ä° #define TR_E KC_D // E @@ -73,7 +65,6 @@ #define TR_Y KC_SCLN // Y #define TR_SCED KC_QUOT // Åž #define TR_X KC_NUHS // X -// Row 4 #define TR_LABK KC_NUBS // < #define TR_J KC_Z // J #define TR_ODIA KC_X // Ö @@ -85,21 +76,6 @@ #define TR_B KC_COMM // B #define TR_DOT KC_DOT // . #define TR_COMM KC_SLSH // , - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ * │ ! │ " │ ^ │ $ │ % │ & │ ' │ ( │ ) │ = │ ? │ _ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ │ : │ ; │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define TR_ASTR S(TR_PLUS) // * #define TR_EXLM S(TR_1) // ! #define TR_DQUO S(TR_2) // " @@ -113,25 +89,9 @@ #define TR_EQL S(TR_0) // = #define TR_QUES S(TR_SLSH) // ? #define TR_UNDS S(TR_MINS) // _ -// Row 4 #define TR_RABK S(TR_LABK) // > #define TR_COLN S(TR_DOT) // : #define TR_SCLN S(TR_COMM) // ; - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¬ │ ¹ │ ² │ # │ ¼ │ ½ │ ¾ │ { │ [ │ ] │ } │ \ │ | │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ @ │ │ │ ¶ │ │ Â¥ │ │ │ Ø │ £ │ ¨ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Æ │ ß │ € │ │ │ ₺ │ │ │ │ ´ │ │ ` │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ « │ » │ ¢ │ │ │ │ µ │ × │ ÷ │ - │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define TR_NOT ALGR(TR_PLUS) // ¬ #define TR_SUP1 ALGR(TR_1) // ¹ #define TR_SUP2 ALGR(TR_2) // ² @@ -145,7 +105,6 @@ #define TR_RCBR ALGR(TR_0) // } #define TR_BSLS ALGR(TR_SLSH) // (backslash) #define TR_PIPE ALGR(TR_MINS) // | -// Row 2 #define TR_AT ALGR(TR_F) // @ #define TR_PILC ALGR(TR_I) // ¶ #define TR_YEN ALGR(TR_D) // Â¥ @@ -153,14 +112,12 @@ #define TR_PND ALGR(TR_P) // £ #define TR_DIAE ALGR(TR_Q) // ¨ (dead) #define TR_TILD ALGR(TR_W) // ~ (dead) -// Row 3 #define TR_AE ALGR(TR_U) // Æ #define TR_SS ALGR(TR_IDOT) // ß #define TR_EURO ALGR(TR_E) // € #define TR_LIRA ALGR(TR_T) // ₺ #define TR_ACUT ALGR(TR_Y) // ´ (dead) #define TR_GRV ALGR(TR_X) // ` (dead) -// Row 4 #define TR_LDAQ ALGR(TR_J) // « #define TR_RDAQ ALGR(TR_ODIA) // » #define TR_CENT ALGR(TR_V) // ¢ @@ -168,30 +125,12 @@ #define TR_MUL ALGR(TR_B) // × #define TR_DIV ALGR(TR_DOT) // ÷ #define TR_SHYP ALGR(TR_COMM) //  (soft hyphen) - -/* Shift+AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ │ ³ │ ¤ │ │ │ │ │ │ │ ¿ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ ® │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ § │ │ ª │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ ¦ │ │ │ © │ │ │ │ º │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define TR_SUP3 S(ALGR(TR_3)) // ³ #define TR_CURR S(ALGR(TR_4)) // ¤ #define TR_IQUE S(ALGR(TR_SLSH)) // ¿ -// Row 2 #define TR_REGD S(ALGR(TR_I)) // ® -// Row 3 #define TR_SECT S(ALGR(TR_IDOT)) // § #define TR_FORD S(ALGR(TR_A)) // ª -// Row 4 #define TR_BRKP S(ALGR(TR_LABK)) // ¦ #define TR_COPY S(ALGR(TR_V)) // © #define TR_MORD S(ALGR(TR_S)) // º diff --git a/quantum/keymap_extras/keymap_turkish_q.h b/quantum/keymap_extras/keymap_turkish_q.h index 120e2b8d92..9f291df051 100644 --- a/quantum/keymap_extras/keymap_turkish_q.h +++ b/quantum/keymap_extras/keymap_turkish_q.h @@ -1,39 +1,33 @@ -/* Copyright 2019 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ " │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ * │ - │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ Äž │ Ãœ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ Åž │ Ä° │ , │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ < │ Z │ X │ C │ V │ B │ N │ M │ Ö │ Ç │ . │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define TR_DQUO KC_GRV // " #define TR_1 KC_1 // 1 #define TR_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define TR_0 KC_0 // 0 #define TR_ASTR KC_MINS // * #define TR_MINS KC_EQL // - -// Row 2 #define TR_Q KC_Q // Q #define TR_W KC_W // W #define TR_E KC_E // E @@ -60,7 +53,6 @@ #define TR_P KC_P // P #define TR_GBRV KC_LBRC // Äž #define TR_UDIA KC_RBRC // Ãœ -// Row 3 #define TR_A KC_A // A #define TR_S KC_S // S #define TR_D KC_D // D @@ -73,7 +65,6 @@ #define TR_SCED KC_SCLN // Åž #define TR_IDOT KC_QUOT // Ä° #define TR_COMM KC_NUHS // , -// Row 4 #define TR_LABK KC_NUBS // < #define TR_Z KC_Z // Z #define TR_X KC_X // X @@ -85,21 +76,6 @@ #define TR_ODIA KC_COMM // Ö #define TR_CCED KC_DOT // Ç #define TR_DOT KC_SLSH // . - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ é │ ! │ ' │ ^ │ + │ % │ & │ / │ ( │ ) │ = │ ? │ _ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ │ │ ; │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ > │ │ │ │ │ │ │ │ │ │ : │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define TR_EACU S(TR_DQUO) // é #define TR_EXLM S(TR_1) // ! #define TR_QUOT S(TR_2) // ' @@ -113,26 +89,9 @@ #define TR_EQL S(TR_0) // = #define TR_QUES S(TR_ASTR) // ? #define TR_UNDS S(TR_MINS) // _ -// Row 3 #define TR_SCLN S(TR_COMM) // ; -// Row 4 #define TR_RABK S(TR_LABK) // > #define TR_COLN S(TR_DOT) // : - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ £ │ # │ $ │ ½ │ │ { │ [ │ ] │ } │ \ │ | │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ @ │ │ € │ │ ₺ │ │ │ │ │ │ ¨ │ ~ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ Æ │ ß │ │ │ │ │ │ │ │ ´ │ │ ` │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define TR_PND ALGR(TR_2) // £ #define TR_HASH ALGR(TR_3) // # #define TR_DLR ALGR(TR_4) // $ @@ -143,13 +102,11 @@ #define TR_RCBR ALGR(TR_0) // } #define TR_BSLS ALGR(TR_ASTR) // (backslash) #define TR_PIPE ALGR(TR_MINS) // | -// Row 2 #define TR_AT ALGR(TR_Q) // @ #define TR_EURO ALGR(TR_E) // € #define TR_LIRA ALGR(TR_T) // ₺ #define TR_DIAE ALGR(TR_GBRV) // ¨ (dead) #define TR_TILD ALGR(TR_UDIA) // ~ (dead) -// Row 3 #define TR_AE ALGR(TR_A) // Æ #define TR_SS ALGR(TR_S) // ß #define TR_ACUT ALGR(TR_SCED) // ´ (dead) diff --git a/quantum/keymap_extras/keymap_uk.h b/quantum/keymap_extras/keymap_uk.h index 03fe8149f0..f527f2bc3d 100644 --- a/quantum/keymap_extras/keymap_uk.h +++ b/quantum/keymap_extras/keymap_uk.h @@ -1,39 +1,33 @@ -/* Copyright 2015-2016 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ # │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ \ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define UK_GRV KC_GRV // ` #define UK_1 KC_1 // 1 #define UK_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define UK_0 KC_0 // 0 #define UK_MINS KC_MINS // - #define UK_EQL KC_EQL // = -// Row 2 #define UK_Q KC_Q // Q #define UK_W KC_W // W #define UK_E KC_E // E @@ -60,7 +53,6 @@ #define UK_P KC_P // P #define UK_LBRC KC_LBRC // [ #define UK_RBRC KC_RBRC // ] -// Row 3 #define UK_A KC_A // A #define UK_S KC_S // S #define UK_D KC_D // D @@ -73,7 +65,6 @@ #define UK_SCLN KC_SCLN // ; #define UK_QUOT KC_QUOT // ' #define UK_HASH KC_NUHS // # -// Row 4 #define UK_BSLS KC_NUBS // (backslash) #define UK_Z KC_Z // Z #define UK_X KC_X // X @@ -85,21 +76,6 @@ #define UK_COMM KC_COMM // , #define UK_DOT KC_DOT // . #define UK_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¬ │ ! │ " │ £ │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ │ │ │ │ │ │ │ │ │ : │ @ │ ~ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ | │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define UK_NOT S(UK_GRV) // ¬ #define UK_EXLM S(UK_1) // ! #define UK_DQUO S(UK_2) // " @@ -113,39 +89,19 @@ #define UK_RPRN S(UK_0) // ) #define UK_UNDS S(UK_MINS) // _ #define UK_PLUS S(UK_EQL) // + -// Row 2 #define UK_LCBR S(UK_LBRC) // { #define UK_RCBR S(UK_RBRC) // } -// Row 3 #define UK_COLN S(UK_SCLN) // : #define UK_AT S(UK_QUOT) // @ #define UK_TILD S(UK_HASH) // ~ -// Row 4 #define UK_PIPE S(UK_BSLS) // | #define UK_LABK S(UK_COMM) // < #define UK_RABK S(UK_DOT) // > #define UK_QUES S(UK_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ¦ │ │ │ │ € │ │ │ │ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ É │ │ │ │ Ú │ à │ Ó │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┠│ - * │ │ à │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┼───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define UK_BRKP ALGR(UK_GRV) // ¦ #define UK_EURO ALGR(UK_4) // € -// Row 2 #define UK_EACU ALGR(KC_E) // É #define UK_UACU ALGR(KC_U) // Ú #define UK_IACU ALGR(KC_I) // à #define UK_OACU ALGR(KC_O) // Ó -// Row 3 #define UK_AACU ALGR(KC_A) // à diff --git a/quantum/keymap_extras/keymap_ukrainian.h b/quantum/keymap_extras/keymap_ukrainian.h index e5cd80f3d2..a83f2dbceb 100644 --- a/quantum/keymap_extras/keymap_ukrainian.h +++ b/quantum/keymap_extras/keymap_ukrainian.h @@ -1,39 +1,33 @@ -/* Copyright 2022 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ' │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Й │ Ц │ У │ К │ Е │ Р│ Г │ Ш │ Щ │ З │ Ð¥ │ Ї │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ Ф │ І │ Ð’ │ Р│ П │ Р│ О │ Л │ Д │ Ж │ Є │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Я │ Ч │ С │ Ðœ │ И │ Т │ Ь │ Б │ Ю │ . │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define UA_QUOT KC_GRV // ' #define UA_1 KC_1 // 1 #define UA_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define UA_0 KC_0 // 0 #define UA_MINS KC_MINS // - #define UA_EQL KC_EQL // = -// Row 2 #define UA_YOT KC_Q // Й #define UA_TSE KC_W // Ц #define UA_U KC_E // У @@ -61,7 +54,6 @@ #define UA_KHA KC_LBRC // Ð¥ #define UA_YI KC_RBRC // Ї #define UA_BSLS KC_BSLS // (backslash) -// Row 3 #define UA_EF KC_A // Ф #define UA_I KC_S // І #define UA_VE KC_D // Ð’ @@ -73,7 +65,6 @@ #define UA_DE KC_L // Д #define UA_ZHE KC_SCLN // Ж #define UA_YE KC_QUOT // Є -// Row 4 #define UA_YA KC_Z // Я #define UA_CHE KC_X // Ч #define UA_ES KC_C // С @@ -84,21 +75,6 @@ #define UA_BE KC_COMM // Б #define UA_YU KC_DOT // Ю #define UA_DOT KC_SLSH // . - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ â‚´ │ ! │ " │ â„– │ ; │ % │ : │ ? │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ / │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ │ │ , │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define UA_HRYV S(UA_QUOT) // â‚´ #define UA_EXLM S(UA_1) // ! #define UA_DQUO S(UA_2) // " @@ -112,23 +88,6 @@ #define UA_RPRN S(UA_0) // ) #define UA_UNDS S(UA_MINS) // _ #define UA_PLUS S(UA_EQL) // + -// Row 2 #define UA_SLSH S(UA_BSLS) // / -// Row 4 #define UA_COMM S(UA_DOT) // , - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ Ò‘ │ │ │ │ │ │ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 2 -#define UA_GE ALGR(UA_HE) // Ò‘ +#define UA_GE ALGR(UA_HE) // Ò‘ diff --git a/quantum/keymap_extras/keymap_us.h b/quantum/keymap_extras/keymap_us.h index b18c701679..9c7fef4c7d 100644 --- a/quantum/keymap_extras/keymap_us.h +++ b/quantum/keymap_extras/keymap_us.h @@ -1,52 +1,55 @@ // Copyright 2022 QMK // SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define KC_TILD S(KC_GRAVE) // ~ -#define KC_EXLM S(KC_1) // ! -#define KC_AT S(KC_2) // @ -#define KC_HASH S(KC_3) // # -#define KC_DLR S(KC_4) // $ -#define KC_PERC S(KC_5) // % -#define KC_CIRC S(KC_6) // ^ -#define KC_AMPR S(KC_7) // & -#define KC_ASTR S(KC_8) // * -#define KC_LPRN S(KC_9) // ( -#define KC_RPRN S(KC_0) // ) +#define KC_EXLM S(KC_1) // ! +#define KC_AT S(KC_2) // @ +#define KC_HASH S(KC_3) // # +#define KC_DLR S(KC_4) // $ +#define KC_PERC S(KC_5) // % +#define KC_CIRC S(KC_6) // ^ +#define KC_AMPR S(KC_7) // & +#define KC_ASTR S(KC_8) // * +#define KC_LPRN S(KC_9) // ( +#define KC_RPRN S(KC_0) // ) #define KC_UNDS S(KC_MINUS) // _ #define KC_PLUS S(KC_EQUAL) // + -// Row 2 -#define KC_LCBR S(KC_LEFT_BRACKET) // { +#define KC_LCBR S(KC_LEFT_BRACKET) // { #define KC_RCBR S(KC_RIGHT_BRACKET) // } -#define KC_PIPE S(KC_BACKSLASH) // | -// Row 3 +#define KC_PIPE S(KC_BACKSLASH) // | #define KC_COLN S(KC_SEMICOLON) // : -#define KC_DQUO S(KC_QUOTE) // " -// Row 4 +#define KC_DQUO S(KC_QUOTE) // " #define KC_LABK S(KC_COMMA) // < -#define KC_RABK S(KC_DOT) // > +#define KC_RABK S(KC_DOT) // > #define KC_QUES S(KC_SLASH) // ? -// alias stuff #define KC_TILDE KC_TILD #define KC_EXCLAIM KC_EXLM #define KC_DOLLAR KC_DLR @@ -57,14 +60,11 @@ #define KC_LEFT_PAREN KC_LPRN #define KC_RIGHT_PAREN KC_RPRN #define KC_UNDERSCORE KC_UNDS - #define KC_LEFT_CURLY_BRACE KC_LCBR #define KC_RIGHT_CURLY_BRACE KC_RCBR - #define KC_COLON KC_COLN #define KC_DOUBLE_QUOTE KC_DQUO #define KC_DQT KC_DQUO - #define KC_LEFT_ANGLE_BRACKET KC_LABK #define KC_LT KC_LABK #define KC_RIGHT_ANGLE_BRACKET KC_RABK diff --git a/quantum/keymap_extras/keymap_us_extended.h b/quantum/keymap_extras/keymap_us_extended.h index 8e71a8de25..c3c9b79181 100644 --- a/quantum/keymap_extras/keymap_us_extended.h +++ b/quantum/keymap_extras/keymap_us_extended.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ' │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define US_GRV KC_GRV // ` #define US_1 KC_1 // 1 #define US_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define US_0 KC_0 // 0 #define US_MINS KC_MINS // - #define US_EQL KC_EQL // = -// Row 2 #define US_Q KC_Q // Q #define US_W KC_W // W #define US_E KC_E // E @@ -61,7 +54,6 @@ #define US_LBRC KC_LBRC // [ #define US_RBRC KC_RBRC // ] #define US_BSLS KC_BSLS // (backslash) -// Row 3 #define US_A KC_A // A #define US_S KC_S // S #define US_D KC_D // D @@ -73,7 +65,6 @@ #define US_L KC_L // L #define US_SCLN KC_SCLN // ; #define US_QUOT KC_QUOT // ' -// Row 4 #define US_Z KC_Z // Z #define US_X KC_X // X #define US_C KC_C // C @@ -84,21 +75,6 @@ #define US_COMM KC_COMM // , #define US_DOT KC_DOT // . #define US_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define US_TILD S(US_GRV) // ~ #define US_EXLM S(US_1) // ! #define US_AT S(US_2) // @ @@ -112,32 +88,14 @@ #define US_RPRN S(US_0) // ) #define US_UNDS S(US_MINS) // _ #define US_PLUS S(US_EQL) // + -// Row 2 #define US_LCBR S(US_LBRC) // { #define US_RCBR S(US_RBRC) // } #define US_PIPE S(US_BSLS) // | -// Row 3 #define US_COLN S(US_SCLN) // : #define US_DQUO S(US_QUOT) // " -// Row 4 #define US_LABK S(US_COMM) // < #define US_RABK S(US_DOT) // > #define US_QUES S(US_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ ¹ │ ² │ ³ │ ¤ │ € │ ^ │ Ì› │ ¾ │ ‘ │ ’ │ Â¥ │ × │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Ä │ Ã… │ É │ ® │ Þ │ Ãœ │ Ú │ à │ Ó │ Ö │ « │ » │ ¬ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ à │ ß │ à │ │ │ │ à │ Å’ │ Ø │ ¶ │ ' │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Æ │ │ © │ │ │ Ñ │ µ │ Ç │ Ë™ │ ¿ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define US_DGRV ALGR(US_GRV) // ` (dead) #define US_SUP1 ALGR(US_1) // ¹ #define US_SUP2 ALGR(US_2) // ² @@ -145,13 +103,12 @@ #define US_CURR ALGR(US_4) // ¤ #define US_EURO ALGR(US_5) // € #define US_DCIR ALGR(US_6) // ^ (dead) -#define US_HORN ALGR(US_7) // Ì› (dead) +#define US_HORN ALGR(US_7) // Ì› (dead) #define US_OGON ALGR(US_8) // Ë› (dead) #define US_LSQU ALGR(US_9) // ‘ #define US_RSQU ALGR(US_0) // ’ #define US_YEN ALGR(US_MINS) // Â¥ #define US_MUL ALGR(US_EQL) // × -// Row 2 #define US_ADIA ALGR(US_Q) // Ä #define US_ARNG ALGR(US_W) // Ã… #define US_EACU ALGR(US_E) // É @@ -165,7 +122,6 @@ #define US_LDAQ ALGR(US_LBRC) // « #define US_RDAQ ALGR(US_RBRC) // » #define US_NOT ALGR(US_BSLS) // ¬ -// Row 3 #define US_AACU ALGR(US_A) // à #define US_SS ALGR(US_S) // ß #define US_ETH ALGR(US_D) // à @@ -174,7 +130,6 @@ #define US_OSTR ALGR(US_L) // Ø #define US_PILC ALGR(US_SCLN) // ¶ #define US_ACUT ALGR(US_QUOT) // ´ (dead) -// Row 4 #define US_AE ALGR(US_Z) // Æ #define US_OE_2 ALGR(US_X) // Å’ #define US_COPY ALGR(US_C) // © @@ -184,21 +139,6 @@ #define US_CCED ALGR(US_COMM) // Ç #define US_DOTA ALGR(US_DOT) // Ë™ (dead) #define US_IQUE ALGR(US_SLSH) // ¿ - -/* Shift+AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ¡ │ Ë â”‚ ¯ │ £ │ ¸ │ ¼ │ ½ │ ¾ │ ˘ │ ° │ Ì£ │ ÷ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ “ │ †│ ¦ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ § │ │ │ │ │ │ │ │ ° │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ ¢ │ │ │ │ │ │ ˇ │ ̉ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define US_DTIL S(ALGR(US_GRV)) // ~ (dead) #define US_IEXL S(ALGR(US_1)) // ¡ #define US_DACU S(ALGR(US_2)) // Ë (dead) @@ -210,18 +150,14 @@ #define US_TQTR S(ALGR(US_8)) // ¾ #define US_BREV S(ALGR(US_9)) // ˘ (dead) #define US_RNGA S(ALGR(US_0)) // ° (dead) -#define US_DOTB S(ALGR(US_MINS)) // Ì£ (dead) +#define US_DOTB S(ALGR(US_MINS)) // Ì£ (dead) #define US_DIV S(ALGR(US_EQL)) // ÷ -// Row 2 #define US_LDQU S(ALGR(US_LBRC)) // “ #define US_RDQU S(ALGR(US_RBRC)) // †#define US_BRKP S(ALGR(US_BSLS)) // ¦ -// Row 3 #define US_SECT S(ALGR(US_S)) // § #define US_DEG S(ALGR(US_SCLN)) // ° #define US_DIAE S(ALGR(US_QUOT)) // ¨ (dead) -// Row 4 #define US_CENT S(ALGR(US_C)) // ¢ #define US_CARN S(ALGR(US_DOT)) // ˇ (dead) -#define US_HOKA S(ALGR(US_SLSH)) // ̉ (dead) - +#define US_HOKA S(ALGR(US_SLSH)) // ̉ (dead) diff --git a/quantum/keymap_extras/keymap_us_international.h b/quantum/keymap_extras/keymap_us_international.h index d491a38f52..c87dc6d544 100644 --- a/quantum/keymap_extras/keymap_us_international.h +++ b/quantum/keymap_extras/keymap_us_international.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ´ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define US_DGRV KC_GRV // ` (dead) #define US_1 KC_1 // 1 #define US_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define US_0 KC_0 // 0 #define US_MINS KC_MINS // - #define US_EQL KC_EQL // = -// Row 2 #define US_Q KC_Q // Q #define US_W KC_W // W #define US_E KC_E // E @@ -61,7 +54,6 @@ #define US_LBRC KC_LBRC // [ #define US_RBRC KC_RBRC // ] #define US_BSLS KC_BSLS // (backslash) -// Row 3 #define US_A KC_A // A #define US_S KC_S // S #define US_D KC_D // D @@ -73,7 +65,6 @@ #define US_L KC_L // L #define US_SCLN KC_SCLN // ; #define US_ACUT KC_QUOT // ´ (dead) -// Row 4 #define US_Z KC_Z // Z #define US_X KC_X // X #define US_C KC_C // C @@ -84,21 +75,6 @@ #define US_COMM KC_COMM // , #define US_DOT KC_DOT // . #define US_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ ¨ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define US_DTIL S(US_DGRV) // ~ (dead) #define US_EXLM S(US_1) // ! #define US_AT S(US_2) // @ @@ -112,32 +88,14 @@ #define US_RPRN S(US_0) // ) #define US_UNDS S(US_MINS) // _ #define US_PLUS S(US_EQL) // + -// Row 2 #define US_LCBR S(US_LBRC) // { #define US_RCBR S(US_RBRC) // } #define US_PIPE S(US_BSLS) // | -// Row 3 #define US_COLN S(US_SCLN) // : #define US_DIAE S(US_ACUT) // ¨ (dead) -// Row 4 #define US_LABK S(US_COMM) // < #define US_RABK S(US_DOT) // > #define US_QUES S(US_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ¡ │ ² │ ³ │ ¤ │ € │ ¼ │ ½ │ ¾ │ ‘ │ ’ │ Â¥ │ × │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Ä │ Ã… │ É │ ® │ Þ │ Ãœ │ Ú │ à │ Ó │ Ö │ « │ » │ ¬ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ à │ ß │ à │ │ │ │ │ │ Ø │ ¶ │ ´ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Æ │ │ © │ │ │ Ñ │ µ │ Ç │ │ ¿ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define US_IEXL ALGR(US_1) // ¡ #define US_SUP2 ALGR(US_2) // ² #define US_SUP3 ALGR(US_3) // ³ @@ -150,7 +108,6 @@ #define US_RSQU ALGR(US_0) // ’ #define US_YEN ALGR(US_MINS) // Â¥ #define US_MUL ALGR(US_EQL) // × -// Row 2 #define US_ADIA ALGR(US_Q) // Ä #define US_ARNG ALGR(US_W) // Ã… #define US_EACU ALGR(US_E) // É @@ -164,43 +121,23 @@ #define US_LDAQ ALGR(US_LBRC) // « #define US_RDAQ ALGR(US_RBRC) // » #define US_NOT ALGR(US_BSLS) // ¬ -// Row 3 #define US_AACU ALGR(US_A) // à #define US_SS ALGR(US_S) // ß #define US_ETH ALGR(US_D) // à #define US_OSTR ALGR(US_L) // Ø #define US_PILC ALGR(US_SCLN) // ¶ #define US_NDAC ALGR(US_ACUT) // ´ -// Row 4 #define US_AE ALGR(US_Z) // Æ #define US_COPY ALGR(US_C) // © #define US_NTIL ALGR(US_N) // Ñ #define US_MICR ALGR(US_M) // µ #define US_CCED ALGR(US_COMM) // Ç #define US_IQUE ALGR(US_SLSH) // ¿ - -/* Shift+AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ │ ¹ │ │ │ £ │ │ │ │ │ │ │ │ ÷ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ │ │ ¦ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ § │ │ │ │ │ │ │ │ ° │ ¨ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ ¢ │ │ │ │ │ │ │ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define US_SUP1 S(ALGR(US_1)) // ¹ #define US_PND S(ALGR(US_4)) // £ #define US_DIV S(ALGR(US_EQL)) // ÷ -// Row 2 #define US_BRKP S(ALGR(US_BSLS)) // ¦ -// Row 3 #define US_SECT S(ALGR(US_S)) // § #define US_DEG S(ALGR(US_SCLN)) // ° #define US_NDDR S(ALGR(US_ACUT)) // ¨ -// Row 4 #define US_CENT S(ALGR(US_C)) // ¢ diff --git a/quantum/keymap_extras/keymap_us_international_linux.h b/quantum/keymap_extras/keymap_us_international_linux.h index e0c08200b9..4d4222f726 100644 --- a/quantum/keymap_extras/keymap_us_international_linux.h +++ b/quantum/keymap_extras/keymap_us_international_linux.h @@ -1,39 +1,33 @@ -/* Copyright 2020 - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ [ │ ] │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ S │ D │ F │ G │ H │ J │ K │ L │ ; │ ´ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Z │ X │ C │ V │ B │ N │ M │ , │ . │ / │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define US_DGRV KC_GRV // ` (dead) #define US_1 KC_1 // 1 #define US_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define US_0 KC_0 // 0 #define US_MINS KC_MINS // - #define US_EQL KC_EQL // = -// Row 2 #define US_Q KC_Q // Q #define US_W KC_W // W #define US_E KC_E // E @@ -61,7 +54,6 @@ #define US_LBRC KC_LBRC // [ #define US_RBRC KC_RBRC // ] #define US_BSLS KC_BSLS // (backslash) -// Row 3 #define US_A KC_A // A #define US_S KC_S // S #define US_D KC_D // D @@ -73,7 +65,6 @@ #define US_L KC_L // L #define US_SCLN KC_SCLN // ; #define US_ACUT KC_QUOT // ´ (dead) -// Row 4 #define US_Z KC_Z // Z #define US_X KC_X // X #define US_C KC_C // C @@ -84,21 +75,6 @@ #define US_COMM KC_COMM // , #define US_DOT KC_DOT // . #define US_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ ¨ │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define US_DTIL S(US_DGRV) // ~ (dead) #define US_EXLM S(US_1) // ! #define US_AT S(US_2) // @ @@ -112,33 +88,14 @@ #define US_RPRN S(US_0) // ) #define US_UNDS S(US_MINS) // _ #define US_PLUS S(US_EQL) // + -// Row 2 #define US_LCBR S(US_LBRC) // { #define US_RCBR S(US_RBRC) // } #define US_PIPE S(US_BSLS) // | -// Row 3 #define US_COLN S(US_SCLN) // : #define US_DIAE S(US_ACUT) // ¨ (dead) -// Row 4 #define US_LABK S(US_COMM) // < #define US_RABK S(US_DOT) // > #define US_QUES S(US_SLSH) // ? - -/* AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ ¡ │ ² │ ³ │ ¤ │ € │ ¼ │ ½ │ ¾ │ ‘ │ ’ │ Â¥ │ × │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Ä │ Ã… │ É │ ® │ Þ │ Ãœ │ Ú │ à │ Ó │ Ö │ « │ » │ ¬ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ à │ ß │ à │ │ │ │ │ Å’ │ Ø │ ¶ │ ' │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Æ │ │ © │ │ │ Ñ │ µ │ Ç │ Ë™ │ ¿ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ - -// Row 1 #define US_GRV ALGR(US_DGRV) // ` #define US_IEXL ALGR(US_1) // ¡ #define US_SUP2 ALGR(US_2) // ² @@ -152,7 +109,6 @@ #define US_RSQU ALGR(US_0) // ’ #define US_YEN ALGR(US_MINS) // Â¥ #define US_MUL ALGR(US_EQL) // × -// Row 2 #define US_ADIA ALGR(US_Q) // Ä #define US_ARNG ALGR(US_W) // Ã… #define US_EACU ALGR(US_E) // É @@ -166,7 +122,6 @@ #define US_LDAQ ALGR(US_LBRC) // « #define US_RDAQ ALGR(US_RBRC) // » #define US_NOT ALGR(US_BSLS) // ¬ -// Row 3 #define US_AACU ALGR(US_A) // à #define US_SS ALGR(US_S) // ß #define US_ETH ALGR(US_D) // à @@ -174,7 +129,6 @@ #define US_OSTR ALGR(US_L) // Ø #define US_PILC ALGR(US_SCLN) // ¶ #define US_QUOT ALGR(US_ACUT) // ' -// Row 4 #define US_AE ALGR(US_Z) // Æ #define US_COPY ALGR(US_C) // © #define US_NTIL ALGR(US_N) // Ñ @@ -182,21 +136,6 @@ #define US_CCED ALGR(US_COMM) // Ç #define US_DOTA ALGR(US_DOT) // Ë™ (dead) #define US_IQUE ALGR(US_SLSH) // ¿ - -/* Shift+AltGr symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ¹ │ Ë â”‚ ¯ │ £ │ ¸ │ ^ │ Ì› │ Ë› │ ˘ │ ° │ Ì£ │ ÷ │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ “ │ †│ ¦ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ § │ │ │ │ │ │ │ │ ° │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ ¢ │ │ │ │ │ │ ˇ │ ̉ │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define US_TILD S(ALGR(US_DGRV)) // ~ #define US_SUP1 S(ALGR(US_1)) // ¹ #define US_DACU S(ALGR(US_2)) // Ë (dead) @@ -204,21 +143,18 @@ #define US_PND S(ALGR(US_4)) // £ #define US_CEDL S(ALGR(US_5)) // ¸ (dead) #define US_CIRC S(ALGR(US_6)) // ^ -#define US_HORN S(ALGR(US_7)) // Ì› (dead) +#define US_HORN S(ALGR(US_7)) // Ì› (dead) #define US_OGON S(ALGR(US_8)) // Ë› (dead) #define US_BREV S(ALGR(US_9)) // ˘ (dead) #define US_RNGA S(ALGR(US_0)) // ° (dead) -#define US_DOTB S(ALGR(US_MINS)) // Ì£ (dead) +#define US_DOTB S(ALGR(US_MINS)) // Ì£ (dead) #define US_DIV S(ALGR(US_EQL)) // ÷ -// Row 2 #define US_LDQU S(ALGR(US_LBRC)) // “ #define US_RDQU S(ALGR(US_RBRC)) // †#define US_BRKP S(ALGR(US_BSLS)) // ¦ -// Row 3 #define US_SECT S(ALGR(US_S)) // § #define US_DEG S(ALGR(US_SCLN)) // ° #define US_DQUO S(ALGR(US_ACUT)) // " -// Row 4 #define US_CENT S(ALGR(US_C)) // ¢ #define US_CARN S(ALGR(US_DOT)) // ˇ (dead) -#define US_HOKA S(ALGR(US_SLSH)) // ̉ (dead) +#define US_HOKA S(ALGR(US_SLSH)) // ̉ (dead) diff --git a/quantum/keymap_extras/keymap_workman.h b/quantum/keymap_extras/keymap_workman.h index 6367d68351..3b0ce7f6d6 100644 --- a/quantum/keymap_extras/keymap_workman.h +++ b/quantum/keymap_extras/keymap_workman.h @@ -1,39 +1,33 @@ -/* Copyright 2018 Jacob Jerrell - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ D │ R │ W │ B │ J │ F │ U │ P │ ; │ [ │ ] │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ S │ H │ T │ G │ Y │ N │ E │ O │ I │ ' │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Z │ X │ M │ C │ V │ K │ L │ , │ . │ / │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define WK_GRV KC_GRV // ` #define WK_1 KC_1 // 1 #define WK_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define WK_0 KC_0 // 0 #define WK_MINS KC_MINS // - #define WK_EQL KC_EQL // = -// Row 2 #define WK_Q KC_Q // Q #define WK_D KC_W // D #define WK_R KC_E // R @@ -61,7 +54,6 @@ #define WK_LBRC KC_LBRC // [ #define WK_RBRC KC_RBRC // ] #define WK_BSLS KC_BSLS // (backslash) -// Row 3 #define WK_A KC_A // A #define WK_S KC_S // S #define WK_H KC_D // H @@ -73,7 +65,6 @@ #define WK_O KC_L // O #define WK_I KC_SCLN // I #define WK_QUOT KC_QUOT // ' -// Row 4 #define WK_Z KC_Z // Z #define WK_X KC_X // X #define WK_M KC_C // M @@ -84,21 +75,6 @@ #define WK_COMM KC_COMM // , #define WK_DOT KC_DOT // . #define WK_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define WK_TILD S(WK_GRV) // ~ #define WK_EXLM S(WK_1) // ! #define WK_AT S(WK_2) // @ @@ -112,14 +88,11 @@ #define WK_RPRN S(WK_0) // ) #define WK_UNDS S(WK_MINS) // _ #define WK_PLUS S(WK_EQL) // + -// Row 2 #define WK_COLN S(WK_SCLN) // : #define WK_LCBR S(WK_LBRC) // { #define WK_RCBR S(WK_RBRC) // } #define WK_PIPE S(WK_BSLS) // | -// Row 3 #define WK_DQUO S(WK_QUOT) // " -// Row 4 #define WK_LABK S(WK_COMM) // < #define WK_RABK S(WK_DOT) // > #define WK_QUES S(WK_SLSH) // ? diff --git a/quantum/keymap_extras/keymap_workman_zxcvm.h b/quantum/keymap_extras/keymap_workman_zxcvm.h index 01eb83c397..252250cb92 100644 --- a/quantum/keymap_extras/keymap_workman_zxcvm.h +++ b/quantum/keymap_extras/keymap_workman_zxcvm.h @@ -1,39 +1,33 @@ -/* Copyright 2018 Jacob Jerrell - * - * 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/>. - */ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later -#pragma once +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +#pragma once #include "keymap.h" - // clang-format off -/* - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ` │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ - │ = │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ Q │ D │ R │ W │ B │ J │ F │ U │ P │ ; │ [ │ ] │ \ │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ A │ S │ H │ T │ G │ Y │ N │ E │ O │ I │ ' │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ Z │ X │ C │ V │ M │ K │ L │ , │ . │ / │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 +// Aliases #define WK_GRV KC_GRV // ` #define WK_1 KC_1 // 1 #define WK_2 KC_2 // 2 @@ -47,7 +41,6 @@ #define WK_0 KC_0 // 0 #define WK_MINS KC_MINS // - #define WK_EQL KC_EQL // = -// Row 2 #define WK_Q KC_Q // Q #define WK_D KC_W // D #define WK_R KC_E // R @@ -61,7 +54,6 @@ #define WK_LBRC KC_LBRC // [ #define WK_RBRC KC_RBRC // ] #define WK_BSLS KC_BSLS // (backslash) -// Row 3 #define WK_A KC_A // A #define WK_S KC_S // S #define WK_H KC_D // H @@ -73,7 +65,6 @@ #define WK_O KC_L // O #define WK_I KC_SCLN // I #define WK_QUOT KC_QUOT // ' -// Row 4 #define WK_Z KC_Z // Z #define WK_X KC_X // X #define WK_C KC_C // C @@ -84,21 +75,6 @@ #define WK_COMM KC_COMM // , #define WK_DOT KC_DOT // . #define WK_SLSH KC_SLSH // / - -/* Shifted symbols - * ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───────┠- * │ ~ │ ! │ @ │ # │ $ │ % │ ^ │ & │ * │ ( │ ) │ _ │ + │ │ - * ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─────┤ - * │ │ │ │ │ │ │ │ │ │ │ : │ { │ } │ | │ - * ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤ - * │ │ │ │ │ │ │ │ │ │ │ │ " │ │ - * ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴────────┤ - * │ │ │ │ │ │ │ │ │ < │ > │ ? │ │ - * ├────┬───┴┬──┴─┬─┴───┴───┴───┴───┴───┴──┬┴───┼───┴┬────┬────┤ - * │ │ │ │ │ │ │ │ │ - * └────┴────┴────┴────────────────────────┴────┴────┴────┴────┘ - */ -// Row 1 #define WK_TILD S(WK_GRV) // ~ #define WK_EXLM S(WK_1) // ! #define WK_AT S(WK_2) // @ @@ -112,14 +88,11 @@ #define WK_RPRN S(WK_0) // ) #define WK_UNDS S(WK_MINS) // _ #define WK_PLUS S(WK_EQL) // + -// Row 2 #define WK_COLN S(WK_SCLN) // : #define WK_LCBR S(WK_LBRC) // { #define WK_RCBR S(WK_RBRC) // } #define WK_PIPE S(WK_BSLS) // | -// Row 3 #define WK_DQUO S(WK_QUOT) // " -// Row 4 #define WK_LABK S(WK_COMM) // < #define WK_RABK S(WK_DOT) // > #define WK_QUES S(WK_SLSH) // ? diff --git a/quantum/led.c b/quantum/led.c index 7db38bb88c..42144566fd 100644 --- a/quantum/led.c +++ b/quantum/led.c @@ -69,14 +69,6 @@ uint32_t last_led_activity_elapsed(void) { */ __attribute__((weak)) void led_set_user(uint8_t usb_led) {} -/** \brief Lock LED set callback - keyboard level - * - * \deprecated Use led_update_kb() instead. - */ -__attribute__((weak)) void led_set_kb(uint8_t usb_led) { - led_set_user(usb_led); -} - /** \brief Lock LED update callback - keymap/user level * * \return True if led_update_kb() should run its own code, false otherwise. @@ -154,7 +146,7 @@ __attribute__((weak)) void led_set(uint8_t usb_led) { handle_backlight_caps_lock((led_t)usb_led); #endif - led_set_kb(usb_led); + led_set_user(usb_led); led_update_kb((led_t)usb_led); } diff --git a/quantum/led.h b/quantum/led.h index d12e519ea2..b9ad7ed9ae 100644 --- a/quantum/led.h +++ b/quantum/led.h @@ -55,9 +55,10 @@ void led_wakeup(void); void led_task(void); -/* Callbacks */ +/* Deprecated callbacks */ void led_set_user(uint8_t usb_led); -void led_set_kb(uint8_t usb_led); + +/* Callbacks */ bool led_update_user(led_t led_state); bool led_update_kb(led_t led_state); void led_update_ports(led_t led_state); diff --git a/quantum/main.c b/quantum/main.c index 2d5911b708..3b101c522c 100644 --- a/quantum/main.c +++ b/quantum/main.c @@ -60,9 +60,9 @@ int main(void) { protocol_task(); #ifdef QUANTUM_PAINTER_ENABLE - // Run Quantum Painter animations - void qp_internal_animation_tick(void); - qp_internal_animation_tick(); + // Run Quantum Painter task + void qp_internal_task(void); + qp_internal_task(); #endif #ifdef DEFERRED_EXEC_ENABLE diff --git a/quantum/matrix.c b/quantum/matrix.c index db683104ed..0de65c6cdd 100644 --- a/quantum/matrix.c +++ b/quantum/matrix.c @@ -46,6 +46,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. # define SPLIT_MUTABLE_COL const #endif +#ifndef MATRIX_INPUT_PRESSED_STATE +# define MATRIX_INPUT_PRESSED_STATE 0 +#endif + #ifdef DIRECT_PINS static SPLIT_MUTABLE pin_t direct_pins[ROWS_PER_HAND][MATRIX_COLS] = DIRECT_PINS; #elif (DIODE_DIRECTION == ROW2COL) || (DIODE_DIRECTION == COL2ROW) @@ -93,7 +97,7 @@ static inline void setPinInputHigh_atomic(pin_t pin) { static inline uint8_t readMatrixPin(pin_t pin) { if (pin != NO_PIN) { - return readPin(pin); + return (readPin(pin) == MATRIX_INPUT_PRESSED_STATE) ? 0 : 1; } else { return 1; } @@ -121,9 +125,7 @@ __attribute__((weak)) void matrix_read_cols_on_row(matrix_row_t current_matrix[] matrix_row_t row_shifter = MATRIX_ROW_SHIFTER; for (uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++, row_shifter <<= 1) { pin_t pin = direct_pins[current_row][col_index]; - if (pin != NO_PIN) { - current_row_value |= readPin(pin) ? 0 : row_shifter; - } + current_row_value |= readMatrixPin(pin) ? 0 : row_shifter; } // Update the matrix diff --git a/quantum/os_detection.c b/quantum/os_detection.c new file mode 100644 index 0000000000..b1511afb14 --- /dev/null +++ b/quantum/os_detection.c @@ -0,0 +1,129 @@ +/* Copyright 2022 Ruslan Sayfutdinov (@KapJI) + * + * 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/>. + */ + +#include "os_detection.h" + +#include <string.h> + +#ifdef OS_DETECTION_DEBUG_ENABLE +# include "eeconfig.h" +# include "eeprom.h" +# include "print.h" + +# define STORED_USB_SETUPS 50 +# define EEPROM_USER_OFFSET (uint8_t*)EECONFIG_SIZE + +uint16_t usb_setups[STORED_USB_SETUPS]; +#endif + +#ifdef OS_DETECTION_ENABLE +struct setups_data_t { + uint8_t count; + uint8_t cnt_02; + uint8_t cnt_04; + uint8_t cnt_ff; + uint16_t last_wlength; + os_variant_t detected_os; +}; + +struct setups_data_t setups_data = { + .count = 0, + .cnt_02 = 0, + .cnt_04 = 0, + .cnt_ff = 0, + .detected_os = OS_UNSURE, +}; + +// Some collected sequences of wLength can be found in tests. +void make_guess(void) { + if (setups_data.count < 3) { + return; + } + if (setups_data.cnt_ff >= 2 && setups_data.cnt_04 >= 1) { + setups_data.detected_os = OS_WINDOWS; + return; + } + if (setups_data.count == setups_data.cnt_ff) { + // Linux has 3 packets with 0xFF. + setups_data.detected_os = OS_LINUX; + return; + } + if (setups_data.count == 5 && setups_data.last_wlength == 0xFF && setups_data.cnt_ff == 1 && setups_data.cnt_02 == 2) { + setups_data.detected_os = OS_MACOS; + return; + } + if (setups_data.count == 4 && setups_data.cnt_ff == 0 && setups_data.cnt_02 == 2) { + // iOS and iPadOS don't have the last 0xFF packet. + setups_data.detected_os = OS_IOS; + return; + } + if (setups_data.cnt_ff == 0 && setups_data.cnt_02 == 3 && setups_data.cnt_04 == 1) { + // This is actually PS5. + setups_data.detected_os = OS_LINUX; + return; + } + if (setups_data.cnt_ff >= 1 && setups_data.cnt_02 == 0 && setups_data.cnt_04 == 0) { + // This is actually Quest 2 or Nintendo Switch. + setups_data.detected_os = OS_LINUX; + return; + } +} + +void process_wlength(const uint16_t w_length) { +# ifdef OS_DETECTION_DEBUG_ENABLE + usb_setups[setups_data.count] = w_length; +# endif + setups_data.count++; + setups_data.last_wlength = w_length; + if (w_length == 0x2) { + setups_data.cnt_02++; + } else if (w_length == 0x4) { + setups_data.cnt_04++; + } else if (w_length == 0xFF) { + setups_data.cnt_ff++; + } + make_guess(); +} + +os_variant_t detected_host_os(void) { + return setups_data.detected_os; +} + +void erase_wlength_data(void) { + memset(&setups_data, 0, sizeof(setups_data)); +} +#endif // OS_DETECTION_ENABLE + +#ifdef OS_DETECTION_DEBUG_ENABLE +void print_stored_setups(void) { +# ifdef CONSOLE_ENABLE + uint8_t cnt = eeprom_read_byte(EEPROM_USER_OFFSET); + for (uint16_t i = 0; i < cnt; ++i) { + uint16_t* addr = (uint16_t*)EEPROM_USER_OFFSET + i * sizeof(uint16_t) + sizeof(uint8_t); + xprintf("i: %d, wLength: 0x%02X\n", i, eeprom_read_word(addr)); + } +# endif +} + +void store_setups_in_eeprom(void) { + eeprom_update_byte(EEPROM_USER_OFFSET, setups_data.count); + for (uint16_t i = 0; i < setups_data.count; ++i) { + uint16_t* addr = (uint16_t*)EEPROM_USER_OFFSET + i * sizeof(uint16_t) + sizeof(uint8_t); + eeprom_update_word(addr, usb_setups[i]); + } +} + +#endif // OS_DETECTION_DEBUG_ENABLE diff --git a/users/replicaJunction/rj_layers.h b/quantum/os_detection.h index f6296af053..e643dcd27f 100644 --- a/users/replicaJunction/rj_layers.h +++ b/quantum/os_detection.h @@ -1,4 +1,4 @@ -/* Copyright 2021 Joshua T. +/* Copyright 2022 Ruslan Sayfutdinov (@KapJI) * * 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 @@ -16,25 +16,23 @@ #pragma once -enum rj_layers { - L_BASE, +#include <stdint.h> -#ifdef USER_INCLUDE_QWERTY - L_QWERTY, -#endif +#ifdef OS_DETECTION_ENABLE +typedef enum { + OS_UNSURE, + OS_LINUX, + OS_WINDOWS, + OS_MACOS, + OS_IOS, +} os_variant_t; -#ifdef USER_INCLUDE_GAMING_LAYER - L_GAMING, +void process_wlength(const uint16_t w_length); +os_variant_t detected_host_os(void); +void erase_wlength_data(void); #endif - L_NUMBERS, - L_SYMBOLS, - L_NAVIGATION, - L_FN, - -#ifdef USER_INCLUDE_MACRO_LAYER - L_MACROS, +#ifdef OS_DETECTION_DEBUG_ENABLE +void print_stored_setups(void); +void store_setups_in_eeprom(void); #endif - - _LAYER_SAFE_RANGE -}; diff --git a/quantum/os_detection/tests/os_detection.cpp b/quantum/os_detection/tests/os_detection.cpp new file mode 100644 index 0000000000..102349852e --- /dev/null +++ b/quantum/os_detection/tests/os_detection.cpp @@ -0,0 +1,164 @@ +/* Copyright 2022 Ruslan Sayfutdinov (@KapJI) + * + * 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/>. + */ + +#include "gtest/gtest.h" + +extern "C" { +#include "os_detection.h" +} + +class OsDetectionTest : public ::testing::Test { + protected: + void SetUp() override { + erase_wlength_data(); + } +}; + +os_variant_t check_sequence(const std::vector<uint16_t> &w_lengths) { + for (auto &w_length : w_lengths) { + process_wlength(w_length); + } + return detected_host_os(); +} + +/* Some collected data. + +ChibiOS: +Windows 10: [FF, FF, 4, 24, 4, 24, 4, FF, 24, FF, 4, FF, 24, 4, 24, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A, 20A] +Windows 10 (another host): [FF, FF, 4, 24, 4, 24, 4, 24, 4, 24, 4, 24] +macOS 12.5: [2, 24, 2, 28, FF] +iOS/iPadOS 15.6: [2, 24, 2, 28] +Linux (including Android, Raspberry Pi and WebOS TV): [FF, FF, FF] +PS5: [2, 4, 2, 28, 2, 24] +Nintendo Switch: [82, FF, 40, 40, FF, 40, 40, FF, 40, 40, FF, 40, 40, FF, 40, 40] +Quest 2: [FF, FF, FF, FE, FF, FE, FF, FE, FF, FE, FF] + +LUFA: +Windows 10 (first connect): [12, FF, FF, 4, 10, FF, FF, FF, 4, 10, 20A, 20A, 20A, 20A, 20A, 20A] +Windows 10 (subsequent connect): [FF, FF, 4, 10, FF, 4, FF, 10, FF, 20A, 20A, 20A, 20A, 20A, 20A] +Windows 10 (another host): [FF, FF, 4, 10, 4, 10] +macOS: [2, 10, 2, E, FF] +iOS/iPadOS: [2, 10, 2, E] +Linux: [FF, FF, FF] +PS5: [2, 4, 2, E, 2, 10] +Nintendo Switch: [82, FF, 40, 40, FF, 40, 40] + +V-USB: +Windows 10: [FF, FF, 4, E, FF] +Windows 10 (another host): [FF, FF, 4, E, 4] +macOS: [2, E, 2, E, FF] +iOS/iPadOS: [2, E, 2, E] +Linux: [FF, FF, FF] +PS5: [2, 4, 2, E, 2] +Nintendo Switch: [82, FF, 40, 40] +Quest 2: [FF, FF, FF, FE] + +Common parts: +Windows: [..., FF, FF, 4, ...] +macOS: [2, _, 2, _, FF] +iOS/iPadOS: [2, _, 2, _] +Linux: [FF, FF, FF] +PS5: [2, 4, 2, _, 2, ...] +Nintendo Switch: [82, FF, 40, 40, ...] +Quest 2: [FF, FF, FF, FE, ...] +*/ +TEST_F(OsDetectionTest, TestLinux) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0xFF}), OS_LINUX); +} + +TEST_F(OsDetectionTest, TestChibiosMacos) { + EXPECT_EQ(check_sequence({0x2, 0x24, 0x2, 0x28, 0xFF}), OS_MACOS); +} + +TEST_F(OsDetectionTest, TestLufaMacos) { + EXPECT_EQ(check_sequence({0x2, 0x10, 0x2, 0xE, 0xFF}), OS_MACOS); +} + +TEST_F(OsDetectionTest, TestVusbMacos) { + EXPECT_EQ(check_sequence({0x2, 0xE, 0x2, 0xE, 0xFF}), OS_MACOS); +} + +TEST_F(OsDetectionTest, TestChibiosIos) { + EXPECT_EQ(check_sequence({0x2, 0x24, 0x2, 0x28}), OS_IOS); +} + +TEST_F(OsDetectionTest, TestLufaIos) { + EXPECT_EQ(check_sequence({0x2, 0x10, 0x2, 0xE}), OS_IOS); +} + +TEST_F(OsDetectionTest, TestVusbIos) { + EXPECT_EQ(check_sequence({0x2, 0xE, 0x2, 0xE}), OS_IOS); +} + +TEST_F(OsDetectionTest, TestChibiosWindows10) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0x24, 0x4, 0x24, 0x4, 0xFF, 0x24, 0xFF, 0x4, 0xFF, 0x24, 0x4, 0x24, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A}), OS_WINDOWS); +} + +TEST_F(OsDetectionTest, TestChibiosWindows10_2) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0x24, 0x4, 0x24, 0x4, 0x24, 0x4, 0x24, 0x4, 0x24}), OS_WINDOWS); +} + +TEST_F(OsDetectionTest, TestLufaWindows10) { + EXPECT_EQ(check_sequence({0x12, 0xFF, 0xFF, 0x4, 0x10, 0xFF, 0xFF, 0xFF, 0x4, 0x10, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A}), OS_WINDOWS); +} + +TEST_F(OsDetectionTest, TestLufaWindows10_2) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0x10, 0xFF, 0x4, 0xFF, 0x10, 0xFF, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A, 0x20A}), OS_WINDOWS); +} + +TEST_F(OsDetectionTest, TestLufaWindows10_3) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0x10, 0x4, 0x10}), OS_WINDOWS); +} + +TEST_F(OsDetectionTest, TestVusbWindows10) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0xE, 0xFF}), OS_WINDOWS); +} + +TEST_F(OsDetectionTest, TestVusbWindows10_2) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0x4, 0xE, 0x4}), OS_WINDOWS); +} + +TEST_F(OsDetectionTest, TestChibiosPs5) { + EXPECT_EQ(check_sequence({0x2, 0x4, 0x2, 0x28, 0x2, 0x24}), OS_LINUX); +} + +TEST_F(OsDetectionTest, TestLufaPs5) { + EXPECT_EQ(check_sequence({0x2, 0x4, 0x2, 0xE, 0x2, 0x10}), OS_LINUX); +} + +TEST_F(OsDetectionTest, TestVusbPs5) { + EXPECT_EQ(check_sequence({0x2, 0x4, 0x2, 0xE, 0x2}), OS_LINUX); +} + +TEST_F(OsDetectionTest, TestChibiosNintendoSwitch) { + EXPECT_EQ(check_sequence({0x82, 0xFF, 0x40, 0x40, 0xFF, 0x40, 0x40, 0xFF, 0x40, 0x40, 0xFF, 0x40, 0x40, 0xFF, 0x40, 0x40}), OS_LINUX); +} + +TEST_F(OsDetectionTest, TestLufaNintendoSwitch) { + EXPECT_EQ(check_sequence({0x82, 0xFF, 0x40, 0x40, 0xFF, 0x40, 0x40}), OS_LINUX); +} + +TEST_F(OsDetectionTest, TestVusbNintendoSwitch) { + EXPECT_EQ(check_sequence({0x82, 0xFF, 0x40, 0x40}), OS_LINUX); +} + +TEST_F(OsDetectionTest, TestChibiosQuest2) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF, 0xFE, 0xFF}), OS_LINUX); +} + +TEST_F(OsDetectionTest, TestVusbQuest2) { + EXPECT_EQ(check_sequence({0xFF, 0xFF, 0xFF, 0xFE}), OS_LINUX); +} diff --git a/quantum/os_detection/tests/rules.mk b/quantum/os_detection/tests/rules.mk new file mode 100644 index 0000000000..9bfe373f46 --- /dev/null +++ b/quantum/os_detection/tests/rules.mk @@ -0,0 +1,5 @@ +os_detection_DEFS := -DOS_DETECTION_ENABLE + +os_detection_SRC := \ + $(QUANTUM_PATH)/os_detection/tests/os_detection.cpp \ + $(QUANTUM_PATH)/os_detection.c diff --git a/quantum/os_detection/tests/testlist.mk b/quantum/os_detection/tests/testlist.mk new file mode 100644 index 0000000000..405a7b82d5 --- /dev/null +++ b/quantum/os_detection/tests/testlist.mk @@ -0,0 +1 @@ +TEST_LIST += os_detection diff --git a/quantum/painter/lvgl/qp_lvgl.c b/quantum/painter/lvgl/qp_lvgl.c new file mode 100644 index 0000000000..41ca3f98c2 --- /dev/null +++ b/quantum/painter/lvgl/qp_lvgl.c @@ -0,0 +1,144 @@ +// Copyright 2022 Jose Pablo Ramirez (@jpe230) +// Copyright 2022 Nick Brassel (@tzarc) +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "qp_lvgl.h" +#include "timer.h" +#include "deferred_exec.h" +#include "lvgl.h" + +typedef struct lvgl_state_t { + uint8_t fnc_id; // Ideally this should be the pointer of the function to run + uint16_t delay_ms; + deferred_token defer_token; +} lvgl_state_t; + +static deferred_executor_t lvgl_executors[2] = {0}; // For lv_tick_inc and lv_task_handler +static lvgl_state_t lvgl_states[2] = {0}; // For lv_tick_inc and lv_task_handler + +painter_device_t selected_display = NULL; +void * color_buffer = NULL; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter LVGL Integration Internal: qp_lvgl_flush + +void qp_lvgl_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p) { + if (selected_display) { + uint32_t number_pixels = (area->x2 - area->x1 + 1) * (area->y2 - area->y1 + 1); + qp_viewport(selected_display, area->x1, area->y1, area->x2, area->y2); + qp_pixdata(selected_display, (void *)color_p, number_pixels); + qp_flush(selected_display); + lv_disp_flush_ready(disp); + } +} + +static uint32_t tick_task_callback(uint32_t trigger_time, void *cb_arg) { + lvgl_state_t * state = (lvgl_state_t *)cb_arg; + static uint32_t last_tick = 0; + switch (state->fnc_id) { + case 0: { + uint32_t now = timer_read32(); + lv_tick_inc(TIMER_DIFF_32(now, last_tick)); + last_tick = now; + } break; + case 1: + lv_task_handler(); + break; + + default: + break; + } + + // The tasks should run indefinitely + return state->delay_ms; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter LVGL Integration API: qp_lvgl_attach + +bool qp_lvgl_attach(painter_device_t device) { + qp_dprintf("qp_lvgl_start: entry\n"); + qp_lvgl_detach(); + + struct painter_driver_t *driver = (struct painter_driver_t *)device; + if (!driver->validate_ok) { + qp_dprintf("qp_lvgl_attach: fail (validation_ok == false)\n"); + qp_lvgl_detach(); + return false; + } + + // Setting up the tasks + lvgl_state_t *lv_tick_inc_state = &lvgl_states[0]; + lv_tick_inc_state->fnc_id = 0; + lv_tick_inc_state->delay_ms = 1; + lv_tick_inc_state->defer_token = defer_exec_advanced(lvgl_executors, 2, 1, tick_task_callback, lv_tick_inc_state); + + if (lv_tick_inc_state->defer_token == INVALID_DEFERRED_TOKEN) { + qp_dprintf("qp_lvgl_attach: fail (could not set up qp_lvgl executor)\n"); + qp_lvgl_detach(); + return false; + } + + lvgl_state_t *lv_task_handler_state = &lvgl_states[1]; + lv_task_handler_state->fnc_id = 1; + lv_task_handler_state->delay_ms = 5; + lv_task_handler_state->defer_token = defer_exec_advanced(lvgl_executors, 2, 5, tick_task_callback, lv_task_handler_state); + + if (lv_task_handler_state->defer_token == INVALID_DEFERRED_TOKEN) { + qp_dprintf("qp_lvgl_attach: fail (could not set up qp_lvgl executor)\n"); + qp_lvgl_detach(); + return false; + } + + // Init LVGL + lv_init(); + + // Set up lvgl display buffer + static lv_disp_draw_buf_t draw_buf; + // Allocate a buffer for 1/10 screen size + const size_t count_required = driver->panel_width * driver->panel_height / 10; + color_buffer = color_buffer ? realloc(color_buffer, sizeof(lv_color_t) * count_required) : malloc(sizeof(lv_color_t) * count_required); + if (!color_buffer) { + qp_dprintf("qp_lvgl_attach: fail (could not set up memory buffer)\n"); + qp_lvgl_detach(); + return false; + } + memset(color_buffer, 0, sizeof(lv_color_t) * count_required); + // Initialize the display buffer. + lv_disp_draw_buf_init(&draw_buf, color_buffer, NULL, count_required); + + selected_display = device; + + // Setting up display driver + static lv_disp_drv_t disp_drv; /*Descriptor of a display driver*/ + lv_disp_drv_init(&disp_drv); /*Basic initialization*/ + disp_drv.flush_cb = qp_lvgl_flush; /*Set your driver function*/ + disp_drv.draw_buf = &draw_buf; /*Assign the buffer to the display*/ + disp_drv.hor_res = driver->panel_width; /*Set the horizontal resolution of the display*/ + disp_drv.ver_res = driver->panel_height; /*Set the vertical resolution of the display*/ + lv_disp_drv_register(&disp_drv); /*Finally register the driver*/ + + return true; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter LVGL Integration API: qp_lvgl_detach + +void qp_lvgl_detach(void) { + for (int i = 0; i < 2; ++i) { + cancel_deferred_exec_advanced(lvgl_executors, 2, lvgl_states[i].defer_token); + } + if (color_buffer) { + free(color_buffer); + color_buffer = NULL; + } + selected_display = NULL; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter LVGL Integration Internal: qp_lvgl_internal_tick + +void qp_lvgl_internal_tick(void) { + static uint32_t last_lvgl_exec = 0; + deferred_exec_advanced_task(lvgl_executors, 2, &last_lvgl_exec); +} diff --git a/quantum/painter/lvgl/qp_lvgl.h b/quantum/painter/lvgl/qp_lvgl.h new file mode 100644 index 0000000000..d9ad5e8df1 --- /dev/null +++ b/quantum/painter/lvgl/qp_lvgl.h @@ -0,0 +1,25 @@ +// Copyright 2022 Jose Pablo Ramirez (@jpe230) +// Copyright 2022 Nick Brassel (@tzarc) +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "qp.h" +#include "lvgl.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter - LVGL External API + +/** + * Sets up LVGL with the supplied display. + * + * @param device[in] the handle of the device to control + * @return true if init. of LVGL succeeded + * @return false if init. of LVGL failed + */ +bool qp_lvgl_attach(painter_device_t device); + +/** + * Disconnects LVGL from any attached display + */ +void qp_lvgl_detach(void); diff --git a/quantum/painter/lvgl/rules.mk b/quantum/painter/lvgl/rules.mk new file mode 100644 index 0000000000..50226941b3 --- /dev/null +++ b/quantum/painter/lvgl/rules.mk @@ -0,0 +1,24 @@ +# LVGL Integration + +OPT_DEFS += -DQUANTUM_PAINTER_LVGL_INTEGRATION_ENABLE -DLV_CONF_INCLUDE_SIMPLE +DEFERRED_EXEC_ENABLE := yes + +LVGL_DIR_NAME = lvgl +LVGL_DIR = $(LIB_DIR) +LVGL_PATH = $(LVGL_DIR)/$(LVGL_DIR_NAME) + +COMMON_VPATH += $(PLATFORM_PATH) \ + $(QUANTUM_DIR)/painter/$(LVGL_DIR_NAME) \ + $(LVGL_PATH) + +include $(LVGL_PATH)/src/extra/extra.mk +include $(LVGL_PATH)/src/core/lv_core.mk +include $(LVGL_PATH)/src/draw/lv_draw.mk +include $(LVGL_PATH)/src/draw/sw/lv_draw_sw.mk +include $(LVGL_PATH)/src/font/lv_font.mk +include $(LVGL_PATH)/src/hal/lv_hal.mk +include $(LVGL_PATH)/src/misc/lv_misc.mk +include $(LVGL_PATH)/src/widgets/lv_widgets.mk + +SRC += qp_lvgl.c \ + $(CSRCS) diff --git a/quantum/painter/qp.h b/quantum/painter/qp.h index 69bc435961..e5f595d71d 100644 --- a/quantum/painter/qp.h +++ b/quantum/painter/qp.h @@ -463,3 +463,10 @@ int16_t qp_drawtext_recolor(painter_device_t device, uint16_t x, uint16_t y, pai #ifdef QUANTUM_PAINTER_SSD1351_ENABLE # include "qp_ssd1351.h" #endif // QUANTUM_PAINTER_SSD1351_ENABLE + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter Extras + +#ifdef QUANTUM_PAINTER_LVGL_INTEGRATION_ENABLE +# include "qp_lvgl.h" +#endif // QUANTUM_PAINTER_LVGL_INTEGRATION_ENABLE diff --git a/quantum/painter/qp_draw_image.c b/quantum/painter/qp_draw_image.c index e9b975f23a..943cbfef5b 100644 --- a/quantum/painter/qp_draw_image.c +++ b/quantum/painter/qp_draw_image.c @@ -399,3 +399,15 @@ void qp_internal_animation_tick(void) { static uint32_t last_anim_exec = 0; deferred_exec_advanced_task(animation_executors, QUANTUM_PAINTER_CONCURRENT_ANIMATIONS, &last_anim_exec); } + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// Quantum Painter Core API: qp_internal_task + +void qp_internal_task(void) { + qp_internal_animation_tick(); +#ifdef QUANTUM_PAINTER_LVGL_INTEGRATION_ENABLE + // Run LVGL ticks + void qp_lvgl_internal_tick(void); + qp_lvgl_internal_tick(); +#endif +} diff --git a/quantum/painter/rules.mk b/quantum/painter/rules.mk index 5ac374a96e..199e406dd6 100644 --- a/quantum/painter/rules.mk +++ b/quantum/painter/rules.mk @@ -2,6 +2,8 @@ QUANTUM_PAINTER_DRIVERS ?= QUANTUM_PAINTER_ANIMATIONS_ENABLE ?= yes +QUANTUM_PAINTER_LVGL_INTEGRATION ?= no + # The list of permissible drivers that can be listed in QUANTUM_PAINTER_DRIVERS VALID_QUANTUM_PAINTER_DRIVERS := \ rgb565_surface \ @@ -152,3 +154,7 @@ ifeq ($(strip $(QUANTUM_PAINTER_NEEDS_COMMS_SPI)), yes) endif endif +# Check if LVGL needs to be enabled +ifeq ($(strip $(QUANTUM_PAINTER_LVGL_INTEGRATION)), yes) + include $(QUANTUM_DIR)/painter/lvgl/rules.mk +endif diff --git a/quantum/process_keycode/process_auto_shift.c b/quantum/process_keycode/process_auto_shift.c index 35d4851ee5..aaf0cf9142 100644 --- a/quantum/process_keycode/process_auto_shift.c +++ b/quantum/process_keycode/process_auto_shift.c @@ -397,8 +397,17 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) { break; # endif } - // If Retro Shift is disabled, possible custom actions shouldn't happen. - // clang-format off + // If Retro Shift is disabled, possible custom actions shouldn't happen. + // clang-format off +# if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING) +# if defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) + const bool is_hold_on_interrupt = get_hold_on_other_key_press(keycode, record); +# elif defined(IGNORE_MOD_TAP_INTERRUPT) + const bool is_hold_on_interrupt = false; +# else + const bool is_hold_on_interrupt = IS_QK_MOD_TAP(keycode); +# endif +# endif if (IS_RETRO(keycode) # if defined(RETRO_SHIFT) && !defined(NO_ACTION_TAPPING) // Not tapped or #defines mean that rolls should use hold action. @@ -407,27 +416,7 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) { # ifdef RETRO_TAPPING_PER_KEY || !get_retro_tapping(keycode, record) # endif - || (record->tap.interrupted && (IS_LT(keycode) -# if defined(HOLD_ON_OTHER_KEY_PRESS) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) -# ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY - ? get_hold_on_other_key_press(keycode, record) -# else - ? true -# endif -# else - ? false -# endif -# if defined(IGNORE_MOD_TAP_INTERRUPT) || defined(IGNORE_MOD_TAP_INTERRUPT_PER_KEY) -# ifdef IGNORE_MOD_TAP_INTERRUPT_PER_KEY - : !get_ignore_mod_tap_interrupt(keycode, record) -# else - : false -# endif -# else - : true -# endif - )) - ) + || (record->tap.interrupted && is_hold_on_interrupt)) # endif ) { // clang-format on @@ -454,10 +443,10 @@ bool process_auto_shift(uint16_t keycode, keyrecord_t *record) { # endif ) { // Fixes modifiers not being applied to rolls with AUTO_SHIFT_MODIFIERS set. -# if !defined(IGNORE_MOD_TAP_INTERRUPT) || defined(IGNORE_MOD_TAP_INTERRUPT_PER_KEY) +# if !defined(IGNORE_MOD_TAP_INTERRUPT) || defined(HOLD_ON_OTHER_KEY_PRESS_PER_KEY) if (autoshift_flags.in_progress -# ifdef IGNORE_MOD_TAP_INTERRUPT_PER_KEY - && !get_ignore_mod_tap_interrupt(keycode, record) +# ifdef HOLD_ON_OTHER_KEY_PRESS_PER_KEY + && get_hold_on_other_key_press(keycode, record) # endif ) { autoshift_end(KC_NO, now, false, &autoshift_lastrecord); diff --git a/quantum/process_keycode/process_auto_shift.h b/quantum/process_keycode/process_auto_shift.h index 86adb04985..66a4b3138a 100644 --- a/quantum/process_keycode/process_auto_shift.h +++ b/quantum/process_keycode/process_auto_shift.h @@ -22,9 +22,8 @@ # define AUTO_SHIFT_TIMEOUT 175 #endif -#define IS_LT(kc) ((kc) >= QK_LAYER_TAP && (kc) <= QK_LAYER_TAP_MAX) -#define IS_MT(kc) ((kc) >= QK_MOD_TAP && (kc) <= QK_MOD_TAP_MAX) -#define IS_RETRO(kc) (IS_MT(kc) || IS_LT(kc)) +#define IS_RETRO(kc) (IS_QK_MOD_TAP(kc) || IS_QK_LAYER_TAP(kc)) + #define DO_GET_AUTOSHIFT_TIMEOUT(keycode, record, ...) record // clang-format off #define AUTO_SHIFT_ALPHA KC_A ... KC_Z diff --git a/quantum/process_keycode/process_leader.c b/quantum/process_keycode/process_leader.c index b74b4927a8..80bc96e65f 100644 --- a/quantum/process_keycode/process_leader.c +++ b/quantum/process_keycode/process_leader.c @@ -14,18 +14,16 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. */ -#ifdef LEADER_ENABLE +#include "process_leader.h" +#include <string.h> -# include "process_leader.h" -# include <string.h> - -# ifndef LEADER_TIMEOUT -# define LEADER_TIMEOUT 300 -# endif +#ifndef LEADER_TIMEOUT +# define LEADER_TIMEOUT 300 +#endif -__attribute__((weak)) void leader_start(void) {} +__attribute__((weak)) void leader_start_user(void) {} -__attribute__((weak)) void leader_end(void) {} +__attribute__((weak)) void leader_end_user(void) {} // Leader key stuff bool leading = false; @@ -34,52 +32,54 @@ uint16_t leader_time = 0; uint16_t leader_sequence[5] = {0, 0, 0, 0, 0}; uint8_t leader_sequence_size = 0; -void qk_leader_start(void) { +void leader_start(void) { if (leading) { return; } - leader_start(); + leader_start_user(); leading = true; leader_time = timer_read(); leader_sequence_size = 0; memset(leader_sequence, 0, sizeof(leader_sequence)); } +void leader_end(void) { + leader_end_user(); +} + bool process_leader(uint16_t keycode, keyrecord_t *record) { // Leader key set-up if (record->event.pressed) { if (leading) { -# ifndef LEADER_NO_TIMEOUT +#ifndef LEADER_NO_TIMEOUT if (timer_elapsed(leader_time) < LEADER_TIMEOUT) -# endif // LEADER_NO_TIMEOUT +#endif // LEADER_NO_TIMEOUT { -# ifndef LEADER_KEY_STRICT_KEY_PROCESSING +#ifndef LEADER_KEY_STRICT_KEY_PROCESSING if (IS_QK_MOD_TAP(keycode)) { keycode = QK_MOD_TAP_GET_TAP_KEYCODE(keycode); } else if (IS_QK_LAYER_TAP(keycode)) { keycode = QK_LAYER_TAP_GET_TAP_KEYCODE(keycode); } -# endif // LEADER_KEY_STRICT_KEY_PROCESSING +#endif // LEADER_KEY_STRICT_KEY_PROCESSING if (leader_sequence_size < ARRAY_SIZE(leader_sequence)) { leader_sequence[leader_sequence_size] = keycode; leader_sequence_size++; } else { leading = false; - leader_end(); + leader_end_user(); return true; } -# ifdef LEADER_PER_KEY_TIMING +#ifdef LEADER_PER_KEY_TIMING leader_time = timer_read(); -# endif +#endif return false; } } else { if (keycode == QK_LEADER) { - qk_leader_start(); + leader_start(); } } } return true; } - -#endif diff --git a/quantum/process_keycode/process_leader.h b/quantum/process_keycode/process_leader.h index f3fe14a432..82b4a3ed7b 100644 --- a/quantum/process_keycode/process_leader.h +++ b/quantum/process_keycode/process_leader.h @@ -20,9 +20,11 @@ bool process_leader(uint16_t keycode, keyrecord_t *record); +void leader_start_user(void); +void leader_end_user(void); + void leader_start(void); void leader_end(void); -void qk_leader_start(void); #define SEQ_ONE_KEY(key) if (leader_sequence[0] == (key) && leader_sequence[1] == 0 && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0) #define SEQ_TWO_KEYS(key1, key2) if (leader_sequence[0] == (key1) && leader_sequence[1] == (key2) && leader_sequence[2] == 0 && leader_sequence[3] == 0 && leader_sequence[4] == 0) diff --git a/quantum/process_keycode/process_tap_dance.c b/quantum/process_keycode/process_tap_dance.c index 6e8e596673..fbe4ce1d33 100644 --- a/quantum/process_keycode/process_tap_dance.c +++ b/quantum/process_keycode/process_tap_dance.c @@ -18,8 +18,8 @@ static uint16_t active_td; static uint16_t last_tap_time; -void qk_tap_dance_pair_on_each_tap(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data; +void tap_dance_pair_on_each_tap(tap_dance_state_t *state, void *user_data) { + tap_dance_pair_t *pair = (tap_dance_pair_t *)user_data; if (state->count == 2) { register_code16(pair->kc2); @@ -27,14 +27,14 @@ void qk_tap_dance_pair_on_each_tap(qk_tap_dance_state_t *state, void *user_data) } } -void qk_tap_dance_pair_finished(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data; +void tap_dance_pair_finished(tap_dance_state_t *state, void *user_data) { + tap_dance_pair_t *pair = (tap_dance_pair_t *)user_data; register_code16(pair->kc1); } -void qk_tap_dance_pair_reset(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data; +void tap_dance_pair_reset(tap_dance_state_t *state, void *user_data) { + tap_dance_pair_t *pair = (tap_dance_pair_t *)user_data; if (state->count == 1) { wait_ms(TAP_CODE_DELAY); @@ -44,8 +44,8 @@ void qk_tap_dance_pair_reset(qk_tap_dance_state_t *state, void *user_data) { } } -void qk_tap_dance_dual_role_on_each_tap(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data; +void tap_dance_dual_role_on_each_tap(tap_dance_state_t *state, void *user_data) { + tap_dance_dual_role_t *pair = (tap_dance_dual_role_t *)user_data; if (state->count == 2) { layer_move(pair->layer); @@ -53,8 +53,8 @@ void qk_tap_dance_dual_role_on_each_tap(qk_tap_dance_state_t *state, void *user_ } } -void qk_tap_dance_dual_role_finished(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data; +void tap_dance_dual_role_finished(tap_dance_state_t *state, void *user_data) { + tap_dance_dual_role_t *pair = (tap_dance_dual_role_t *)user_data; if (state->count == 1) { register_code16(pair->kc); @@ -63,8 +63,8 @@ void qk_tap_dance_dual_role_finished(qk_tap_dance_state_t *state, void *user_dat } } -void qk_tap_dance_dual_role_reset(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_dual_role_t *pair = (qk_tap_dance_dual_role_t *)user_data; +void tap_dance_dual_role_reset(tap_dance_state_t *state, void *user_data) { + tap_dance_dual_role_t *pair = (tap_dance_dual_role_t *)user_data; if (state->count == 1) { wait_ms(TAP_CODE_DELAY); @@ -72,13 +72,13 @@ void qk_tap_dance_dual_role_reset(qk_tap_dance_state_t *state, void *user_data) } } -static inline void _process_tap_dance_action_fn(qk_tap_dance_state_t *state, void *user_data, qk_tap_dance_user_fn_t fn) { +static inline void _process_tap_dance_action_fn(tap_dance_state_t *state, void *user_data, tap_dance_user_fn_t fn) { if (fn) { fn(state, user_data); } } -static inline void process_tap_dance_action_on_each_tap(qk_tap_dance_action_t *action) { +static inline void process_tap_dance_action_on_each_tap(tap_dance_action_t *action) { action->state.count++; action->state.weak_mods = get_mods(); action->state.weak_mods |= get_weak_mods(); @@ -88,17 +88,17 @@ static inline void process_tap_dance_action_on_each_tap(qk_tap_dance_action_t *a _process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_each_tap); } -static inline void process_tap_dance_action_on_reset(qk_tap_dance_action_t *action) { +static inline void process_tap_dance_action_on_reset(tap_dance_action_t *action) { _process_tap_dance_action_fn(&action->state, action->user_data, action->fn.on_reset); del_weak_mods(action->state.weak_mods); #ifndef NO_ACTION_ONESHOT del_mods(action->state.oneshot_mods); #endif send_keyboard_report(); - action->state = (const qk_tap_dance_state_t){0}; + action->state = (const tap_dance_state_t){0}; } -static inline void process_tap_dance_action_on_dance_finished(qk_tap_dance_action_t *action) { +static inline void process_tap_dance_action_on_dance_finished(tap_dance_action_t *action) { if (!action->state.finished) { action->state.finished = true; add_weak_mods(action->state.weak_mods); @@ -116,7 +116,7 @@ static inline void process_tap_dance_action_on_dance_finished(qk_tap_dance_actio } bool preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) { - qk_tap_dance_action_t *action; + tap_dance_action_t *action; if (!record->event.pressed) return false; @@ -139,7 +139,7 @@ bool preprocess_tap_dance(uint16_t keycode, keyrecord_t *record) { } bool process_tap_dance(uint16_t keycode, keyrecord_t *record) { - qk_tap_dance_action_t *action; + tap_dance_action_t *action; switch (keycode) { case QK_TAP_DANCE ... QK_TAP_DANCE_MAX: @@ -163,7 +163,7 @@ bool process_tap_dance(uint16_t keycode, keyrecord_t *record) { } void tap_dance_task() { - qk_tap_dance_action_t *action; + tap_dance_action_t *action; if (!active_td || timer_elapsed(last_tap_time) <= GET_TAPPING_TERM(active_td, &(keyrecord_t){})) return; @@ -173,7 +173,7 @@ void tap_dance_task() { } } -void reset_tap_dance(qk_tap_dance_state_t *state) { +void reset_tap_dance(tap_dance_state_t *state) { active_td = 0; - process_tap_dance_action_on_reset((qk_tap_dance_action_t *)state); + process_tap_dance_action_on_reset((tap_dance_action_t *)state); } diff --git a/quantum/process_keycode/process_tap_dance.h b/quantum/process_keycode/process_tap_dance.h index d6d6c136dc..5cb6d9202c 100644 --- a/quantum/process_keycode/process_tap_dance.h +++ b/quantum/process_keycode/process_tap_dance.h @@ -31,39 +31,39 @@ typedef struct { bool pressed : 1; bool finished : 1; bool interrupted : 1; -} qk_tap_dance_state_t; +} tap_dance_state_t; -typedef void (*qk_tap_dance_user_fn_t)(qk_tap_dance_state_t *state, void *user_data); +typedef void (*tap_dance_user_fn_t)(tap_dance_state_t *state, void *user_data); typedef struct { - qk_tap_dance_state_t state; + tap_dance_state_t state; struct { - qk_tap_dance_user_fn_t on_each_tap; - qk_tap_dance_user_fn_t on_dance_finished; - qk_tap_dance_user_fn_t on_reset; + tap_dance_user_fn_t on_each_tap; + tap_dance_user_fn_t on_dance_finished; + tap_dance_user_fn_t on_reset; } fn; void *user_data; -} qk_tap_dance_action_t; +} tap_dance_action_t; typedef struct { uint16_t kc1; uint16_t kc2; -} qk_tap_dance_pair_t; +} tap_dance_pair_t; typedef struct { uint16_t kc; uint8_t layer; void (*layer_function)(uint8_t); -} qk_tap_dance_dual_role_t; +} tap_dance_dual_role_t; # define ACTION_TAP_DANCE_DOUBLE(kc1, kc2) \ - { .fn = {qk_tap_dance_pair_on_each_tap, qk_tap_dance_pair_finished, qk_tap_dance_pair_reset}, .user_data = (void *)&((qk_tap_dance_pair_t){kc1, kc2}), } + { .fn = {tap_dance_pair_on_each_tap, tap_dance_pair_finished, tap_dance_pair_reset}, .user_data = (void *)&((tap_dance_pair_t){kc1, kc2}), } # define ACTION_TAP_DANCE_LAYER_MOVE(kc, layer) \ - { .fn = {qk_tap_dance_dual_role_on_each_tap, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset}, .user_data = (void *)&((qk_tap_dance_dual_role_t){kc, layer, layer_move}), } + { .fn = {tap_dance_dual_role_on_each_tap, tap_dance_dual_role_finished, tap_dance_dual_role_reset}, .user_data = (void *)&((tap_dance_dual_role_t){kc, layer, layer_move}), } # define ACTION_TAP_DANCE_LAYER_TOGGLE(kc, layer) \ - { .fn = {NULL, qk_tap_dance_dual_role_finished, qk_tap_dance_dual_role_reset}, .user_data = (void *)&((qk_tap_dance_dual_role_t){kc, layer, layer_invert}), } + { .fn = {NULL, tap_dance_dual_role_finished, tap_dance_dual_role_reset}, .user_data = (void *)&((tap_dance_dual_role_t){kc, layer, layer_invert}), } # define ACTION_TAP_DANCE_FN(user_fn) \ { .fn = {NULL, user_fn, NULL}, .user_data = NULL, } @@ -73,11 +73,11 @@ typedef struct { # define TD(n) (QK_TAP_DANCE | TD_INDEX(n)) # define TD_INDEX(code) ((code)&0xFF) -# define TAP_DANCE_KEYCODE(state) TD(((qk_tap_dance_action_t *)state) - tap_dance_actions) +# define TAP_DANCE_KEYCODE(state) TD(((tap_dance_action_t *)state) - tap_dance_actions) -extern qk_tap_dance_action_t tap_dance_actions[]; +extern tap_dance_action_t tap_dance_actions[]; -void reset_tap_dance(qk_tap_dance_state_t *state); +void reset_tap_dance(tap_dance_state_t *state); /* To be used internally */ @@ -85,13 +85,13 @@ bool preprocess_tap_dance(uint16_t keycode, keyrecord_t *record); bool process_tap_dance(uint16_t keycode, keyrecord_t *record); void tap_dance_task(void); -void qk_tap_dance_pair_on_each_tap(qk_tap_dance_state_t *state, void *user_data); -void qk_tap_dance_pair_finished(qk_tap_dance_state_t *state, void *user_data); -void qk_tap_dance_pair_reset(qk_tap_dance_state_t *state, void *user_data); +void tap_dance_pair_on_each_tap(tap_dance_state_t *state, void *user_data); +void tap_dance_pair_finished(tap_dance_state_t *state, void *user_data); +void tap_dance_pair_reset(tap_dance_state_t *state, void *user_data); -void qk_tap_dance_dual_role_on_each_tap(qk_tap_dance_state_t *state, void *user_data); -void qk_tap_dance_dual_role_finished(qk_tap_dance_state_t *state, void *user_data); -void qk_tap_dance_dual_role_reset(qk_tap_dance_state_t *state, void *user_data); +void tap_dance_dual_role_on_each_tap(tap_dance_state_t *state, void *user_data); +void tap_dance_dual_role_finished(tap_dance_state_t *state, void *user_data); +void tap_dance_dual_role_reset(tap_dance_state_t *state, void *user_data); #else diff --git a/quantum/process_keycode/process_ucis.c b/quantum/process_keycode/process_ucis.c index 646471bc4d..3aa09d5948 100644 --- a/quantum/process_keycode/process_ucis.c +++ b/quantum/process_keycode/process_ucis.c @@ -19,20 +19,20 @@ #include "keycode.h" #include "wait.h" -qk_ucis_state_t qk_ucis_state; +ucis_state_t ucis_state; -void qk_ucis_start(void) { - qk_ucis_state.count = 0; - qk_ucis_state.in_progress = true; +void ucis_start(void) { + ucis_state.count = 0; + ucis_state.in_progress = true; - qk_ucis_start_user(); + ucis_start_user(); } -__attribute__((weak)) void qk_ucis_start_user(void) { +__attribute__((weak)) void ucis_start_user(void) { register_unicode(0x2328); // ⌨ } -__attribute__((weak)) void qk_ucis_success(uint8_t symbol_index) {} +__attribute__((weak)) void ucis_success(uint8_t symbol_index) {} static bool is_uni_seq(char *seq) { uint8_t i; @@ -43,20 +43,20 @@ static bool is_uni_seq(char *seq) { } else { keycode = seq[i] - 'a' + KC_A; } - if (i > qk_ucis_state.count || qk_ucis_state.codes[i] != keycode) { + if (i > ucis_state.count || ucis_state.codes[i] != keycode) { return false; } } - return qk_ucis_state.codes[i] == KC_ENTER || qk_ucis_state.codes[i] == KC_SPACE; + return ucis_state.codes[i] == KC_ENTER || ucis_state.codes[i] == KC_SPACE; } -__attribute__((weak)) void qk_ucis_symbol_fallback(void) { - for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) { - tap_code(qk_ucis_state.codes[i]); +__attribute__((weak)) void ucis_symbol_fallback(void) { + for (uint8_t i = 0; i < ucis_state.count - 1; i++) { + tap_code(ucis_state.codes[i]); } } -__attribute__((weak)) void qk_ucis_cancel(void) {} +__attribute__((weak)) void ucis_cancel(void) {} void register_ucis(const uint32_t *code_points) { for (int i = 0; i < UCIS_MAX_CODE_POINTS && code_points[i]; i++) { @@ -65,38 +65,38 @@ void register_ucis(const uint32_t *code_points) { } bool process_ucis(uint16_t keycode, keyrecord_t *record) { - if (!qk_ucis_state.in_progress || !record->event.pressed) { + if (!ucis_state.in_progress || !record->event.pressed) { return true; } bool special = keycode == KC_SPACE || keycode == KC_ENTER || keycode == KC_ESCAPE || keycode == KC_BACKSPACE; - if (qk_ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH && !special) { + if (ucis_state.count >= UCIS_MAX_SYMBOL_LENGTH && !special) { return false; } - qk_ucis_state.codes[qk_ucis_state.count] = keycode; - qk_ucis_state.count++; + ucis_state.codes[ucis_state.count] = keycode; + ucis_state.count++; switch (keycode) { case KC_BACKSPACE: - if (qk_ucis_state.count >= 2) { - qk_ucis_state.count -= 2; + if (ucis_state.count >= 2) { + ucis_state.count -= 2; return true; } else { - qk_ucis_state.count--; + ucis_state.count--; return false; } case KC_SPACE: case KC_ENTER: case KC_ESCAPE: - for (uint8_t i = 0; i < qk_ucis_state.count; i++) { + for (uint8_t i = 0; i < ucis_state.count; i++) { tap_code(KC_BACKSPACE); } if (keycode == KC_ESCAPE) { - qk_ucis_state.in_progress = false; - qk_ucis_cancel(); + ucis_state.in_progress = false; + ucis_cancel(); return false; } @@ -110,12 +110,12 @@ bool process_ucis(uint16_t keycode, keyrecord_t *record) { } } if (symbol_found) { - qk_ucis_success(i); + ucis_success(i); } else { - qk_ucis_symbol_fallback(); + ucis_symbol_fallback(); } - qk_ucis_state.in_progress = false; + ucis_state.in_progress = false; return false; default: diff --git a/quantum/process_keycode/process_ucis.h b/quantum/process_keycode/process_ucis.h index 3de0707762..54eb9413d4 100644 --- a/quantum/process_keycode/process_ucis.h +++ b/quantum/process_keycode/process_ucis.h @@ -31,15 +31,15 @@ typedef struct { char * symbol; uint32_t code_points[UCIS_MAX_CODE_POINTS]; -} qk_ucis_symbol_t; +} ucis_symbol_t; typedef struct { uint8_t count; uint16_t codes[UCIS_MAX_SYMBOL_LENGTH]; bool in_progress : 1; -} qk_ucis_state_t; +} ucis_state_t; -extern qk_ucis_state_t qk_ucis_state; +extern ucis_state_t ucis_state; // clang-format off @@ -53,12 +53,12 @@ extern qk_ucis_state_t qk_ucis_state; // clang-format on -extern const qk_ucis_symbol_t ucis_symbol_table[]; +extern const ucis_symbol_t ucis_symbol_table[]; -void qk_ucis_start(void); -void qk_ucis_start_user(void); -void qk_ucis_symbol_fallback(void); -void qk_ucis_success(uint8_t symbol_index); +void ucis_start(void); +void ucis_start_user(void); +void ucis_symbol_fallback(void); +void ucis_success(uint8_t symbol_index); void register_ucis(const uint32_t *code_points); diff --git a/quantum/rgblight/rgblight.h b/quantum/rgblight/rgblight.h index 46e8e07212..7693888462 100644 --- a/quantum/rgblight/rgblight.h +++ b/quantum/rgblight/rgblight.h @@ -68,23 +68,6 @@ |-----------------|-----------------------------------| *****/ -#ifdef RGBLIGHT_ANIMATIONS -// for backward compatibility -# define RGBLIGHT_EFFECT_BREATHING -# define RGBLIGHT_EFFECT_RAINBOW_MOOD -# define RGBLIGHT_EFFECT_RAINBOW_SWIRL -# define RGBLIGHT_EFFECT_SNAKE -# define RGBLIGHT_EFFECT_KNIGHT -# define RGBLIGHT_EFFECT_CHRISTMAS -# define RGBLIGHT_EFFECT_STATIC_GRADIENT -# define RGBLIGHT_EFFECT_RGB_TEST -# define RGBLIGHT_EFFECT_ALTERNATING -#endif - -#ifdef RGBLIGHT_STATIC_PATTERNS -# define RGBLIGHT_EFFECT_STATIC_GRADIENT -#endif - // clang-format off // check dynamic animation effects chose ? @@ -1,3 +1,7 @@ +# THIS IS THE DEVELOP BRANCH + +Warning- This is the `develop` branch of QMK Firmware. You may encounter broken code here. Please see [Breaking Changes](https://docs.qmk.fm/#/breaking_changes) for more information. + # Quantum Mechanical Keyboard Firmware [](https://github.com/qmk/qmk_firmware/tags) diff --git a/tests/auto_shift/test_auto_shift.cpp b/tests/auto_shift/test_auto_shift.cpp index a83f436c33..1d80634b2f 100644 --- a/tests/auto_shift/test_auto_shift.cpp +++ b/tests/auto_shift/test_auto_shift.cpp @@ -37,14 +37,14 @@ TEST_F(AutoShift, key_release_before_timeout) { EXPECT_NO_REPORT(driver); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_REPORT(driver, (KC_A)); EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(AutoShift, key_release_after_timeout) { @@ -58,7 +58,7 @@ TEST_F(AutoShift, key_release_after_timeout) { EXPECT_NO_REPORT(driver); regular_key.press(); idle_for(AUTO_SHIFT_TIMEOUT); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_REPORT(driver, (KC_LSFT, KC_A)); @@ -66,5 +66,5 @@ TEST_F(AutoShift, key_release_after_timeout) { EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/autocorrect/test_autocorrect.cpp b/tests/autocorrect/test_autocorrect.cpp index 509c1c9ea4..9b8db3d68d 100644 --- a/tests/autocorrect/test_autocorrect.cpp +++ b/tests/autocorrect/test_autocorrect.cpp @@ -51,7 +51,7 @@ TEST_F(AutoCorrect, OnOffToggle) { autocorrect_toggle(); EXPECT_EQ(autocorrect_is_enabled(), true); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Test that typing "fales" autocorrects to "false" @@ -80,7 +80,7 @@ TEST_F(AutoCorrect, fales_to_false_autocorrection) { TapKeys(key_f, key_a, key_l, key_e, key_s); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Test that typing "fales" doesn't autocorrect if disabled @@ -109,7 +109,7 @@ TEST_F(AutoCorrect, fales_disabled_autocorrect) { TapKeys(key_f, key_a, key_l, key_e, key_s); autocorrect_enable(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Test that typing "falsify" doesn't autocorrect if disabled @@ -139,7 +139,7 @@ TEST_F(AutoCorrect, falsify_should_not_autocorrect) { TapKeys(key_f, key_a, key_l, key_s, key_i, key_f, key_y); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Test that typing "ture" autocorrect to "true" @@ -169,7 +169,7 @@ TEST_F(AutoCorrect, ture_to_true_autocorrect) { TapKeys(key_space, key_t_code, key_u, key_r, key_e); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Test that typing "overture" does not autocorrect @@ -200,5 +200,5 @@ TEST_F(AutoCorrect, overture_should_not_autocorrect) { TapKeys(key_o, key_v, key_e, key_r, key_t_code, key_u, key_r, key_e); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/basic/test_action_layer.cpp b/tests/basic/test_action_layer.cpp index d0a28d42c0..883d99b404 100644 --- a/tests/basic/test_action_layer.cpp +++ b/tests/basic/test_action_layer.cpp @@ -28,7 +28,7 @@ TEST_F(ActionLayer, LayerStateDBG) { layer_state_set(0); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerStateSet) { @@ -39,7 +39,7 @@ TEST_F(ActionLayer, LayerStateSet) { layer_state_set(0b001100); EXPECT_EQ(layer_state, 0b001100); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerStateIs) { @@ -56,7 +56,7 @@ TEST_F(ActionLayer, LayerStateIs) { EXPECT_EQ(layer_state_is(1), true); EXPECT_EQ(layer_state_is(2), false); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerStateCmp) { @@ -76,7 +76,7 @@ TEST_F(ActionLayer, LayerStateCmp) { EXPECT_EQ(layer_state_cmp(prev_layer, 1), true); EXPECT_EQ(layer_state_cmp(prev_layer, 2), false); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerClear) { @@ -85,7 +85,7 @@ TEST_F(ActionLayer, LayerClear) { layer_clear(); EXPECT_EQ(layer_state, 0); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerMove) { @@ -96,7 +96,7 @@ TEST_F(ActionLayer, LayerMove) { layer_move(3); EXPECT_EQ(layer_state, 0b1000); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerOn) { @@ -108,7 +108,7 @@ TEST_F(ActionLayer, LayerOn) { layer_on(3); EXPECT_EQ(layer_state, 0b1010); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerOff) { @@ -121,7 +121,7 @@ TEST_F(ActionLayer, LayerOff) { layer_off(2); EXPECT_EQ(layer_state, 0b0010); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, MomentaryLayerDoesNothing) { @@ -134,12 +134,12 @@ TEST_F(ActionLayer, MomentaryLayerDoesNothing) { EXPECT_NO_REPORT(driver); layer_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_NO_REPORT(driver); layer_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, MomentaryLayerWithKeypress) { @@ -155,28 +155,28 @@ TEST_F(ActionLayer, MomentaryLayerWithKeypress) { layer_key.press(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press key on layer 1 */ EXPECT_REPORT(driver, (KC_B)).Times(1); regular_key.press(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release key on layer 1 */ EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release MO */ EXPECT_NO_REPORT(driver); layer_key.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(0)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, ToggleLayerDoesNothing) { @@ -192,14 +192,14 @@ TEST_F(ActionLayer, ToggleLayerDoesNothing) { layer_key.press(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release TG. */ EXPECT_NO_REPORT(driver); layer_key.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, ToggleLayerUpAndDown) { @@ -216,26 +216,26 @@ TEST_F(ActionLayer, ToggleLayerUpAndDown) { toggle_layer_1_on_layer_0.press(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_NO_REPORT(driver); toggle_layer_1_on_layer_0.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Toggle Layer 0. */ EXPECT_NO_REPORT(driver); toggle_layer_0_on_layer_1.press(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(0)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_NO_REPORT(driver); toggle_layer_0_on_layer_1.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(0)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerTapToggleDoesNothing) { @@ -251,13 +251,13 @@ TEST_F(ActionLayer, LayerTapToggleDoesNothing) { layer_key.press(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_NO_REPORT(driver); layer_key.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(0)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerTapToggleWithKeypress) { @@ -275,25 +275,25 @@ TEST_F(ActionLayer, LayerTapToggleWithKeypress) { layer_key.press(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_REPORT(driver, (KC_B)).Times(1); regular_key.press(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_NO_REPORT(driver); layer_key.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(0)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) { @@ -344,19 +344,19 @@ TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) { run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_REPORT(driver, (KC_B)).Times(1); regular_key.press(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(ActionLayer, LayerTapReleasedBeforeKeypressReleaseWithModifiers) { @@ -373,7 +373,7 @@ TEST_F(ActionLayer, LayerTapReleasedBeforeKeypressReleaseWithModifiers) { layer_0_key_0.press(); idle_for(TAPPING_TERM); EXPECT_TRUE(layer_state_is(0)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press key with layer 1 mapping, result basically expected * altough more reports are send then necessary. */ @@ -382,14 +382,14 @@ TEST_F(ActionLayer, LayerTapReleasedBeforeKeypressReleaseWithModifiers) { layer_1_key_1.press(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release layer tap key, no report is send because key is still held. */ EXPECT_NO_REPORT(driver); layer_0_key_0.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(0)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Unregister keycode and modifier. */ EXPECT_REPORT(driver, (KC_RALT)).Times(1); @@ -397,5 +397,5 @@ TEST_F(ActionLayer, LayerTapReleasedBeforeKeypressReleaseWithModifiers) { layer_1_key_1.release(); run_one_scan_loop(); EXPECT_TRUE(layer_state_is(0)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/basic/test_keycode_util.cpp b/tests/basic/test_keycode_util.cpp new file mode 100644 index 0000000000..693334676e --- /dev/null +++ b/tests/basic/test_keycode_util.cpp @@ -0,0 +1,52 @@ +// Copyright 2022 Stefan Kerkmann +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "test_common.hpp" + +class KeycodeToIdentifierSuite : public ::testing::TestWithParam<std::pair<std::uint16_t, std::string>> {}; + +TEST_P(KeycodeToIdentifierSuite, ConversionTests) { + ASSERT_EQ(get_keycode_identifier_or_default(GetParam().first), GetParam().second); +} + +INSTANTIATE_TEST_CASE_P(ConversionTestsP, KeycodeToIdentifierSuite, + // clang-format off +::testing::Values( + // Goto layer + std::make_pair(TO(0), "TO(0)"), + std::make_pair(TO(0x1F), "TO(31)"), + // Momentary switch layer + std::make_pair(MO(0), "MO(0)"), + std::make_pair(MO(0x1F), "MO(31)"), + // Set default layer + std::make_pair(DF(0), "DF(0)"), + std::make_pair(DF(0x1F), "DF(31)"), + // Toggle layer + std::make_pair(TG(0), "TG(0)"), + std::make_pair(TG(0x1F), "TG(31)"), + // One-shot layer + std::make_pair(OSL(0), "OSL(0)"), + std::make_pair(OSL(0x1F), "OSL(31)"), + // One-shot mod + std::make_pair(OSM(MOD_LSFT), "OSM(MOD_LSFT)"), + std::make_pair(OSM(MOD_LSFT | MOD_LCTL), "OSM(MOD_LCTL | MOD_LSFT)"), + // Layer Mod + std::make_pair(LM(0, MOD_LSFT), "LM(0, MOD_LSFT)"), + std::make_pair(LM(0xF, MOD_LSFT), "LM(15, MOD_LSFT)"), + std::make_pair(LM(0xF, MOD_LSFT | MOD_LCTL), "LM(15, MOD_LCTL | MOD_LSFT)"), + // Layer tap toggle + std::make_pair(TT(0), "TT(0)"), + std::make_pair(TT(0x1F), "TT(31)"), + // Layer tap + std::make_pair(LT(0, KC_A), "LT(0, KC_A)"), + std::make_pair(LT(0xF, KC_SPACE), "LT(15, KC_SPACE)"), + std::make_pair(LT(1, KC_SPC), "LT(1, KC_SPACE)"), + // Mod tap + std::make_pair(MT(MOD_LCTL, KC_A), "MT(MOD_LCTL, KC_A)"), + std::make_pair(MT(MOD_LCTL | MOD_LSFT, KC_A), "MT(MOD_LCTL | MOD_LSFT, KC_A)"), + std::make_pair(ALT_T(KC_TAB), "MT(MOD_LALT, KC_TAB)"), + // Mods + std::make_pair(LCTL(KC_A), "QK_MODS(KC_A, QK_LCTL)"), + std::make_pair(HYPR(KC_SPACE), "QK_MODS(KC_SPACE, QK_LCTL | QK_LSFT | QK_LALT | QK_LGUI)") +)); +// clang-format on diff --git a/tests/basic/test_keypress.cpp b/tests/basic/test_keypress.cpp index 6d5b502a00..34682654b0 100644 --- a/tests/basic/test_keypress.cpp +++ b/tests/basic/test_keypress.cpp @@ -175,23 +175,23 @@ TEST_F(KeyPress, PressPlusEqualReleaseBeforePress) { EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL)); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_plus.release(); EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); EXPECT_EMPTY_REPORT(driver); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_eql.press(); EXPECT_REPORT(driver, (key_eql.report_code)); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_eql.release(); EXPECT_EMPTY_REPORT(driver); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(KeyPress, PressPlusEqualDontReleaseBeforePress) { @@ -206,24 +206,24 @@ TEST_F(KeyPress, PressPlusEqualDontReleaseBeforePress) { EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL)); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_eql.press(); EXPECT_EMPTY_REPORT(driver); EXPECT_REPORT(driver, (KC_EQUAL)); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_plus.release(); // BUG: Should really still return KC_EQUAL, but this is fine too EXPECT_EMPTY_REPORT(driver); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_eql.release(); EXPECT_NO_REPORT(driver); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(KeyPress, PressEqualPlusReleaseBeforePress) { @@ -237,24 +237,24 @@ TEST_F(KeyPress, PressEqualPlusReleaseBeforePress) { key_eql.press(); EXPECT_REPORT(driver, (KC_EQUAL)); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_eql.release(); EXPECT_EMPTY_REPORT(driver); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_plus.press(); EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL)); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_plus.release(); EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); EXPECT_EMPTY_REPORT(driver); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(KeyPress, PressEqualPlusDontReleaseBeforePress) { @@ -268,7 +268,7 @@ TEST_F(KeyPress, PressEqualPlusDontReleaseBeforePress) { key_eql.press(); EXPECT_REPORT(driver, (KC_EQUAL)); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_plus.press(); // BUG: The sequence is a bit strange, but it works, the end result is that @@ -277,16 +277,16 @@ TEST_F(KeyPress, PressEqualPlusDontReleaseBeforePress) { EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); EXPECT_REPORT(driver, (KC_LEFT_SHIFT, KC_EQUAL)); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_eql.release(); // I guess it's fine to still report shift here EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); key_plus.release(); EXPECT_EMPTY_REPORT(driver); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/basic/test_one_shot_keys.cpp b/tests/basic/test_one_shot_keys.cpp index bb14221140..2401c2c837 100644 --- a/tests/basic/test_one_shot_keys.cpp +++ b/tests/basic/test_one_shot_keys.cpp @@ -36,12 +36,12 @@ TEST_F(OneShot, OSMWithoutAdditionalKeypressDoesNothing) { run_one_scan_loop(); osm_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* OSM are added when an actual report is send */ EXPECT_REPORT(driver, (osm_key.report_code)); send_keyboard_report(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Make unit-test pass */ clear_oneshot_mods(); @@ -62,19 +62,19 @@ TEST_P(OneShotParametrizedTestFixture, OSMExpiredDoesNothing) { run_one_scan_loop(); osm_key.release(); idle_for(ONESHOT_TIMEOUT); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key */ EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } #endif @@ -92,19 +92,19 @@ TEST_P(OneShotParametrizedTestFixture, OSMWithAdditionalKeypress) { run_one_scan_loop(); osm_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key */ EXPECT_REPORT(driver, (osm_key.report_code, regular_key.report_code)).Times(1); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypress) { @@ -120,26 +120,26 @@ TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypres EXPECT_NO_REPORT(driver); osm_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key */ EXPECT_NO_REPORT(driver); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_NO_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release OSM */ EXPECT_REPORT(driver, (regular_key.report_code, osm_key.report_code)).Times(1); EXPECT_EMPTY_REPORT(driver); osm_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // clang-format off @@ -172,24 +172,24 @@ TEST_F(OneShot, OSLWithAdditionalKeypress) { EXPECT_NO_REPORT(driver); osl_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release OSL key */ EXPECT_NO_REPORT(driver); osl_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key */ EXPECT_REPORT(driver, (regular_key.report_code)).Times(1); EXPECT_EMPTY_REPORT(driver); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_NO_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/basic/test_tapping.cpp b/tests/basic/test_tapping.cpp index 6ff9cfe22b..3246f9cdfb 100644 --- a/tests/basic/test_tapping.cpp +++ b/tests/basic/test_tapping.cpp @@ -121,3 +121,72 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) { key_shift_hold_p_tap.release(); run_one_scan_loop(); } + +TEST_F(Tapping, TapA_CTL_T_KeyWhileReleasingShift) { + TestDriver driver; + InSequence s; + auto shift_key = KeymapKey(0, 7, 0, KC_LSFT); + auto mod_tap_hold_key = KeymapKey(0, 8, 0, CTL_T(KC_P)); + + set_keymap({shift_key, mod_tap_hold_key}); + + shift_key.press(); + // Shift is reported + EXPECT_REPORT(driver, (KC_LSFT)); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + mod_tap_hold_key.press(); + // Tapping keys does nothing on press + EXPECT_NO_REPORT(driver); + run_one_scan_loop(); + + shift_key.release(); + // Releasing shift is delayed while tapping is in progress + EXPECT_NO_REPORT(driver); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + mod_tap_hold_key.release(); + // Releasing mod-tap key reports the tap and releases shift + EXPECT_REPORT(driver, (KC_LSFT, KC_P)); + EXPECT_REPORT(driver, (KC_P)); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(Tapping, TapA_CTL_T_KeyWhileReleasingLayer) { + TestDriver driver; + InSequence s; + auto layer_key = KeymapKey(0, 7, 0, MO(1)); + auto trans_key = KeymapKey(1, 7, 0, KC_TRNS); + auto mod_tap_hold_key0 = KeymapKey(0, 8, 0, CTL_T(KC_P)); + auto mod_tap_hold_key1 = KeymapKey(1, 8, 0, CTL_T(KC_Q)); + + set_keymap({layer_key, trans_key, mod_tap_hold_key0, mod_tap_hold_key1}); + + layer_key.press(); + // Pressing the layer key does nothing + EXPECT_NO_REPORT(driver); + run_one_scan_loop(); + + mod_tap_hold_key1.press(); + // Tapping layer 1 mod-tap key does nothing on press + EXPECT_NO_REPORT(driver); + run_one_scan_loop(); + + layer_key.release(); + // Releasing layer is delayed while tapping is in progress + EXPECT_NO_REPORT(driver); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + mod_tap_hold_key1.release(); + // Releasing mod-tap key reports the tap of the layer 1 key + // If delayed layer release is broken, this reports the layer 0 key + EXPECT_REPORT(driver, (KC_Q)); + EXPECT_EMPTY_REPORT(driver); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} diff --git a/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp b/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp index ba21c527a6..01b1a78a5f 100644 --- a/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp +++ b/tests/caps_word/caps_word_autoshift/test_caps_word_autoshift.cpp @@ -64,7 +64,7 @@ TEST_F(CapsWord, AutoShiftKeys) { tap_key(key_spc); tap_key(key_a); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Test Caps Word + Auto Shift where keys A and B are rolled. @@ -104,7 +104,7 @@ TEST_F(CapsWord, AutoShiftRolledShiftedKeys) { run_one_scan_loop(); caps_word_off(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Tests that with tap-hold keys with Retro Shift, letter keys are shifted by @@ -133,5 +133,5 @@ TEST_F(CapsWord, RetroShiftKeys) { tap_key(key_modtap_a); // Tap A quickly. EXPECT_EQ(is_caps_word_on(), true); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/caps_word/caps_word_combo/test_caps_word_combo.cpp b/tests/caps_word/caps_word_combo/test_caps_word_combo.cpp index 3a0530b854..0876cc91a3 100644 --- a/tests/caps_word/caps_word_combo/test_caps_word_combo.cpp +++ b/tests/caps_word/caps_word_combo/test_caps_word_combo.cpp @@ -102,7 +102,7 @@ TEST_P(CapsWord, SingleCombo) { EXPECT_TRUE(is_caps_word_on()); caps_word_off(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Test a longer 4-key combo. @@ -123,7 +123,7 @@ TEST_P(CapsWord, LongerCombo) { EXPECT_TRUE(is_caps_word_on()); caps_word_off(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Test with two overlapping combos on regular keys: @@ -161,7 +161,7 @@ TEST_P(CapsWord, ComboRegularKeys) { tap_key(key_a); EXPECT_FALSE(is_caps_word_on()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Test where combo chords involve tap-hold keys: @@ -194,7 +194,7 @@ TEST_P(CapsWord, ComboModTapKey) { EXPECT_TRUE(is_caps_word_on()); caps_word_off(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // clang-format off diff --git a/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp b/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp index fb8f9333bb..01cdfd6408 100644 --- a/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp +++ b/tests/caps_word/caps_word_unicodemap/test_caps_word_unicodemap.cpp @@ -93,7 +93,7 @@ TEST_F(CapsWord, ShiftedUnicodeMapKey) { tap_keys(key_delta, key_spc, key_delta); EXPECT_EQ(is_caps_word_on(), false); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Tests typing U_ENDASH while Caps Word is on. @@ -117,5 +117,5 @@ TEST_F(CapsWord, UnshiftedUnicodeMapKey) { tap_key(key_dash); EXPECT_EQ(is_caps_word_on(), true); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/caps_word/test_caps_word.cpp b/tests/caps_word/test_caps_word.cpp index 3d0735d8c2..6d38b383f3 100644 --- a/tests/caps_word/test_caps_word.cpp +++ b/tests/caps_word/test_caps_word.cpp @@ -90,7 +90,7 @@ TEST_F(CapsWord, OnOffToggleFuns) { caps_word_toggle(); EXPECT_EQ(is_caps_word_on(), false); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Tests the default `caps_word_press_user()` function. @@ -133,7 +133,7 @@ TEST_F(CapsWord, CapswrdKey) { tap_key(key_capswrd); // Tap the QK_CAPS_WORD_TOGGLE key again. EXPECT_EQ(is_caps_word_on(), false); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Tests that being idle for CAPS_WORD_IDLE_TIMEOUT turns off Caps Word. @@ -157,7 +157,7 @@ TEST_F(CapsWord, IdleTimeout) { caps_word_on(); tap_key(key_a); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); idle_for(CAPS_WORD_IDLE_TIMEOUT); run_one_scan_loop(); @@ -171,7 +171,7 @@ TEST_F(CapsWord, IdleTimeout) { EXPECT_REPORT(driver, (KC_A)); tap_key(key_a); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Tests that typing "A, 4, A, 4" produces "Shift+A, 4, Shift+A, 4". @@ -201,7 +201,7 @@ TEST_F(CapsWord, ShiftsLettersButNotDigits) { caps_word_on(); tap_keys(key_a, key_4, key_a, key_4); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Tests that typing "A, Space, A" produces "Shift+A, Space, A". @@ -230,7 +230,7 @@ TEST_F(CapsWord, SpaceTurnsOffCapsWord) { caps_word_on(); tap_keys(key_a, key_spc, key_a); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Tests that typing "AltGr + A" produces "Shift + AltGr + A". @@ -260,7 +260,7 @@ TEST_F(CapsWord, ShiftsAltGrSymbols) { run_one_scan_loop(); key_altgr.release(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Tests typing "AltGr + A" using a mod-tap key. @@ -291,7 +291,7 @@ TEST_F(CapsWord, ShiftsModTapAltGrSymbols) { key_altgr_t.release(); EXPECT_TRUE(is_caps_word_on()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } struct CapsWordPressUserParams { @@ -326,7 +326,7 @@ TEST_P(CapsWordPressUser, KeyCode) { EXPECT_EQ(passed_keycode, GetParam().expected_passed_keycode); EXPECT_EQ(is_caps_word_on(), GetParam().continues_caps_word); clear_oneshot_mods(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } const uint16_t LT_1_KC_A = LT(1, KC_A); @@ -431,7 +431,7 @@ TEST_P(CapsWordBothShifts, PressLRLR) { EXPECT_EQ(is_caps_word_on(), true); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Pressing shifts as "Left down, Right down, Right up, Left up". @@ -468,7 +468,7 @@ TEST_P(CapsWordBothShifts, PressLRRL) { EXPECT_EQ(is_caps_word_on(), true); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // clang-format off @@ -505,7 +505,8 @@ class CapsWordDoubleTapShift : public ::testing::WithParamInterface<CapsWordDoub TEST_P(CapsWordDoubleTapShift, Activation) { TestDriver driver; KeymapKey left_shift(0, 0, 0, GetParam().left_shift_keycode); - set_keymap({left_shift}); + KeymapKey esc(0, 0, 1, KC_ESCAPE); + set_keymap({left_shift, esc}); // clang-format off EXPECT_CALL(driver, send_keyboard_mock(AnyOf( @@ -523,7 +524,13 @@ TEST_P(CapsWordDoubleTapShift, Activation) { EXPECT_EQ(is_caps_word_on(), true); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); + + // We have to manually reset the internal state of the caps word state + // machine at this point. This due to imperfect test isolation which can't + // reset the caps word double shift timer on test case setup. + idle_for(CAPS_WORD_IDLE_TIMEOUT); + tap_key(esc); } // Double tap doesn't count if another key is pressed between the taps. @@ -555,7 +562,7 @@ TEST_P(CapsWordDoubleTapShift, Interrupted) { EXPECT_EQ(is_caps_word_on(), false); // Caps Word is still off. clear_oneshot_mods(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // Double tap doesn't count if taps are more than tapping term apart. @@ -578,7 +585,7 @@ TEST_P(CapsWordDoubleTapShift, SlowTaps) { EXPECT_EQ(is_caps_word_on(), false); // Caps Word is still off. clear_oneshot_mods(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // clang-format off @@ -591,6 +598,57 @@ INSTANTIATE_TEST_CASE_P( ), CapsWordDoubleTapShiftParams::GetName ); -// clang-format on +// Tests that holding a OSL keeps caps word active and shifts keys on the layer that need to be shifted. +TEST_F(CapsWord, IgnoresOSLHold) { + TestDriver driver; + KeymapKey key_a(0, 0, 0, KC_A); + KeymapKey key_osl(0, 1, 0, OSL(1)); + KeymapKey key_b(1, 0, 0, KC_B); + set_keymap({key_a, key_osl, key_b}); + + // Allow any number of reports with no keys or only modifiers. + // clang-format off + EXPECT_CALL(driver, send_keyboard_mock(AnyOf( + KeyboardReport(), + KeyboardReport(KC_LSFT)))) + .Times(AnyNumber()); + + EXPECT_REPORT(driver, (KC_LSFT, KC_B)); + caps_word_on(); + + key_osl.press(); + run_one_scan_loop(); + tap_key(key_b); + key_osl.release(); + run_one_scan_loop(); + + VERIFY_AND_CLEAR(driver); +} + +// Tests that tapping a OSL keeps caps word active and shifts keys on the layer that need to be shifted. +TEST_F(CapsWord, IgnoresOSLTap) { + TestDriver driver; + KeymapKey key_a(0, 0, 0, KC_A); + KeymapKey key_osl(0, 1, 0, OSL(1)); + KeymapKey key_b(1, 0, 0, KC_B); + set_keymap({key_a, key_osl, key_b}); + + // Allow any number of reports with no keys or only modifiers. + // clang-format off + EXPECT_CALL(driver, send_keyboard_mock(AnyOf( + KeyboardReport(), + KeyboardReport(KC_LSFT)))) + .Times(AnyNumber()); + + EXPECT_REPORT(driver, (KC_LSFT, KC_B)); + caps_word_on(); + + tap_key(key_osl); + tap_key(key_b); + run_one_scan_loop(); + + VERIFY_AND_CLEAR(driver); +} +// clang-format on } // namespace diff --git a/tests/secure/test_secure.cpp b/tests/secure/test_secure.cpp index 6ca98d78f3..3162e9d5df 100644 --- a/tests/secure/test_secure.cpp +++ b/tests/secure/test_secure.cpp @@ -43,7 +43,7 @@ TEST_F(Secure, test_lock) { secure_lock(); EXPECT_FALSE(secure_is_unlocked()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(Secure, test_unlock_timeout) { @@ -58,7 +58,7 @@ TEST_F(Secure, test_unlock_timeout) { idle_for(SECURE_IDLE_TIMEOUT + 1); EXPECT_FALSE(secure_is_unlocked()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(Secure, test_unlock_request) { @@ -80,7 +80,7 @@ TEST_F(Secure, test_unlock_request) { tap_keys(key_a, key_b, key_c, key_d); EXPECT_TRUE(secure_is_unlocked()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(Secure, test_unlock_request_fail) { @@ -108,7 +108,7 @@ TEST_F(Secure, test_unlock_request_fail) { tap_keys(key_e, key_a, key_b, key_c, key_d); EXPECT_FALSE(secure_is_unlocked()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(Secure, test_unlock_request_timeout) { @@ -124,7 +124,7 @@ TEST_F(Secure, test_unlock_request_timeout) { EXPECT_FALSE(secure_is_unlocking()); EXPECT_FALSE(secure_is_unlocked()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(Secure, test_unlock_request_fail_mid) { @@ -151,7 +151,7 @@ TEST_F(Secure, test_unlock_request_fail_mid) { EXPECT_FALSE(secure_is_unlocking()); EXPECT_FALSE(secure_is_unlocked()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(Secure, test_unlock_request_fail_out_of_order) { @@ -179,7 +179,7 @@ TEST_F(Secure, test_unlock_request_fail_out_of_order) { EXPECT_FALSE(secure_is_unlocking()); EXPECT_FALSE(secure_is_unlocked()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(Secure, test_unlock_request_on_layer) { @@ -206,7 +206,7 @@ TEST_F(Secure, test_unlock_request_on_layer) { EXPECT_TRUE(secure_is_unlocked()); EXPECT_FALSE(layer_state_is(1)); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(Secure, test_unlock_request_mid_stroke) { @@ -231,7 +231,7 @@ TEST_F(Secure, test_unlock_request_mid_stroke) { tap_keys(key_a, key_b, key_c, key_d); EXPECT_TRUE(secure_is_unlocked()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(Secure, test_unlock_request_mods) { @@ -256,5 +256,5 @@ TEST_F(Secure, test_unlock_request_mods) { tap_keys(key_a, key_b, key_c, key_d); EXPECT_TRUE(secure_is_unlocked()); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/tap_dance/examples.c b/tests/tap_dance/examples.c index 4a5be41b08..af74388209 100644 --- a/tests/tap_dance/examples.c +++ b/tests/tap_dance/examples.c @@ -23,7 +23,7 @@ // Example 1 -void dance_egg(qk_tap_dance_state_t *state, void *user_data) { +void dance_egg(tap_dance_state_t *state, void *user_data) { if (state->count >= 100) { // SEND_STRING("Safety dance!"); tap_code(KC_C); @@ -34,7 +34,7 @@ void dance_egg(qk_tap_dance_state_t *state, void *user_data) { // Example 2 -void dance_flsh_each(qk_tap_dance_state_t *state, void *user_data) { +void dance_flsh_each(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: register_code(KC_3); @@ -54,14 +54,14 @@ void dance_flsh_each(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_flsh_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_flsh_finished(tap_dance_state_t *state, void *user_data) { if (state->count >= 4) { // reset_keyboard(); tap_code(KC_R); } } -void dance_flsh_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_flsh_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_1); // wait_ms(50); unregister_code(KC_2); @@ -79,7 +79,7 @@ typedef struct { } tap_dance_tap_hold_t; bool process_record_user(uint16_t keycode, keyrecord_t *record) { - qk_tap_dance_action_t *action; + tap_dance_action_t *action; switch (keycode) { case TD(CT_CLN): @@ -92,7 +92,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -void tap_dance_tap_hold_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_tap_hold_finished(tap_dance_state_t *state, void *user_data) { tap_dance_tap_hold_t *tap_hold = (tap_dance_tap_hold_t *)user_data; if (state->pressed) { @@ -110,7 +110,7 @@ void tap_dance_tap_hold_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void tap_dance_tap_hold_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_tap_hold_reset(tap_dance_state_t *state, void *user_data) { tap_dance_tap_hold_t *tap_hold = (tap_dance_tap_hold_t *)user_data; if (tap_hold->held) { @@ -142,7 +142,7 @@ typedef struct { td_state_t state; } td_tap_t; -td_state_t cur_dance(qk_tap_dance_state_t *state) { +td_state_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return TD_SINGLE_TAP; else return TD_SINGLE_HOLD; @@ -163,7 +163,7 @@ static td_tap_t xtap_state = { .state = TD_NONE }; -void x_finished(qk_tap_dance_state_t *state, void *user_data) { +void x_finished(tap_dance_state_t *state, void *user_data) { xtap_state.state = cur_dance(state); switch (xtap_state.state) { case TD_SINGLE_TAP: register_code(KC_X); break; @@ -175,7 +175,7 @@ void x_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void x_reset(qk_tap_dance_state_t *state, void *user_data) { +void x_reset(tap_dance_state_t *state, void *user_data) { switch (xtap_state.state) { case TD_SINGLE_TAP: unregister_code(KC_X); break; case TD_SINGLE_HOLD: unregister_code(KC_LCTL); break; @@ -188,7 +188,7 @@ void x_reset(qk_tap_dance_state_t *state, void *user_data) { } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESC_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS), [CT_EGG] = ACTION_TAP_DANCE_FN(dance_egg), [CT_FLSH] = ACTION_TAP_DANCE_FN_ADVANCED(dance_flsh_each, dance_flsh_finished, dance_flsh_reset), diff --git a/tests/tap_dance/tap_dance_layers/tap_dance_defs.c b/tests/tap_dance/tap_dance_layers/tap_dance_defs.c index 5ec900c041..fbe37f7ed0 100644 --- a/tests/tap_dance/tap_dance_layers/tap_dance_defs.c +++ b/tests/tap_dance/tap_dance_layers/tap_dance_defs.c @@ -43,7 +43,7 @@ enum lt_app_state { static enum lt_app_state saved_lt_app_state; -static enum lt_app_state get_lt_app_state(qk_tap_dance_state_t *state) { +static enum lt_app_state get_lt_app_state(tap_dance_state_t *state) { if (state->count == 1) { if (!state->pressed) { return LTA_SINGLE_TAP; @@ -57,7 +57,7 @@ static enum lt_app_state get_lt_app_state(qk_tap_dance_state_t *state) { } } -static void lt_app_finished(qk_tap_dance_state_t *state, void *user_data) { +static void lt_app_finished(tap_dance_state_t *state, void *user_data) { saved_lt_app_state = get_lt_app_state(state); switch (saved_lt_app_state) { case LTA_NONE: @@ -74,7 +74,7 @@ static void lt_app_finished(qk_tap_dance_state_t *state, void *user_data) { } } -static void lt_app_reset(qk_tap_dance_state_t *state, void *user_data) { +static void lt_app_reset(tap_dance_state_t *state, void *user_data) { switch (saved_lt_app_state) { case LTA_NONE: break; @@ -90,7 +90,7 @@ static void lt_app_reset(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_L_MOVE] = ACTION_TAP_DANCE_LAYER_MOVE(KC_APP, 1), [TD_L_TOGG] = ACTION_TAP_DANCE_LAYER_TOGGLE(KC_APP, 1), [TD_LT_APP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, lt_app_finished, lt_app_reset), diff --git a/tests/tap_hold_configurations/default_mod_tap/config.h b/tests/tap_hold_configurations/default_mod_tap/config.h index 5955b8600a..f22448845e 100644 --- a/tests/tap_hold_configurations/default_mod_tap/config.h +++ b/tests/tap_hold_configurations/default_mod_tap/config.h @@ -18,4 +18,4 @@ #include "test_common.h" -#define IGNORE_MOD_TAP_INTERRUPT
\ No newline at end of file +#define IGNORE_MOD_TAP_INTERRUPT diff --git a/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp b/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp index b70efe4aed..6d82af6725 100644 --- a/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp +++ b/tests/tap_hold_configurations/default_mod_tap/test_tap_hold.cpp @@ -38,19 +38,19 @@ TEST_F(DefaultTapHold, tap_regular_key_while_mod_tap_key_is_held) { EXPECT_NO_REPORT(driver); mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key. */ EXPECT_NO_REPORT(driver); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key. */ EXPECT_NO_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ EXPECT_REPORT(driver, (KC_P)); @@ -59,14 +59,14 @@ TEST_F(DefaultTapHold, tap_regular_key_while_mod_tap_key_is_held) { EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Idle for tapping term of mod tap hold key. */ idle_for(TAPPING_TERM - 3); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } -TEST_F(DefaultTapHold, tap_mod_tap_key_while_mod_tap_key_is_held) { +TEST_F(DefaultTapHold, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) { TestDriver driver; InSequence s; auto first_mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); @@ -78,19 +78,19 @@ TEST_F(DefaultTapHold, tap_mod_tap_key_while_mod_tap_key_is_held) { EXPECT_NO_REPORT(driver); first_mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press second tap-hold key */ EXPECT_NO_REPORT(driver); second_mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release second tap-hold key */ EXPECT_NO_REPORT(driver); second_mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release first mod-tap-hold key */ EXPECT_REPORT(driver, (KC_P)); @@ -99,7 +99,7 @@ TEST_F(DefaultTapHold, tap_mod_tap_key_while_mod_tap_key_is_held) { EXPECT_EMPTY_REPORT(driver); first_mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(DefaultTapHold, tap_regular_key_while_layer_tap_key_is_held) { @@ -115,19 +115,19 @@ TEST_F(DefaultTapHold, tap_regular_key_while_layer_tap_key_is_held) { EXPECT_NO_REPORT(driver); layer_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key */ EXPECT_NO_REPORT(driver); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_NO_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release layer-tap-hold key */ EXPECT_REPORT(driver, (KC_P)); @@ -136,7 +136,7 @@ TEST_F(DefaultTapHold, tap_regular_key_while_layer_tap_key_is_held) { EXPECT_EMPTY_REPORT(driver); layer_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(DefaultTapHold, tap_mod_tap_hold_key_two_times) { @@ -150,26 +150,26 @@ TEST_F(DefaultTapHold, tap_mod_tap_hold_key_two_times) { EXPECT_NO_REPORT(driver); mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ EXPECT_REPORT(driver, (KC_P)); EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press mod-tap-hold key again. */ EXPECT_REPORT(driver, (KC_P)); mod_tap_hold_key.press(); idle_for(TAPPING_TERM); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(DefaultTapHold, tap_mod_tap_hold_key_twice_and_hold_on_second_time) { @@ -183,26 +183,26 @@ TEST_F(DefaultTapHold, tap_mod_tap_hold_key_twice_and_hold_on_second_time) { EXPECT_NO_REPORT(driver); mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ EXPECT_REPORT(driver, (KC_P)); EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press mod-tap-hold key again. */ EXPECT_REPORT(driver, (KC_P)); mod_tap_hold_key.press(); idle_for(TAPPING_TERM); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(DefaultTapHold, tap_and_hold_mod_tap_hold_key) { @@ -216,11 +216,11 @@ TEST_F(DefaultTapHold, tap_and_hold_mod_tap_hold_key) { EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); mod_tap_hold_key.press(); idle_for(TAPPING_TERM + 1); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/tap_hold_configurations/hold_on_other_key_press/test_tap_hold.cpp b/tests/tap_hold_configurations/hold_on_other_key_press/test_tap_hold.cpp index e77c756624..84a6f6996d 100644 --- a/tests/tap_hold_configurations/hold_on_other_key_press/test_tap_hold.cpp +++ b/tests/tap_hold_configurations/hold_on_other_key_press/test_tap_hold.cpp @@ -38,26 +38,26 @@ TEST_F(HoldOnOtherKeyPress, short_distinct_taps_of_mod_tap_key_and_regular_key) EXPECT_NO_REPORT(driver); mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ EXPECT_REPORT(driver, (KC_P)); EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key. */ EXPECT_REPORT(driver, (KC_A)); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key. */ EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(HoldOnOtherKeyPress, long_distinct_taps_of_mod_tap_key_and_regular_key) { @@ -72,30 +72,30 @@ TEST_F(HoldOnOtherKeyPress, long_distinct_taps_of_mod_tap_key_and_regular_key) { EXPECT_NO_REPORT(driver); mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Idle for tapping term of mod tap hold key. */ EXPECT_REPORT(driver, (KC_LSFT)); idle_for(TAPPING_TERM + 1); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key. */ EXPECT_REPORT(driver, (KC_A)); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key. */ EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(HoldOnOtherKeyPress, short_distinct_taps_of_layer_tap_key_and_regular_key) { @@ -111,26 +111,26 @@ TEST_F(HoldOnOtherKeyPress, short_distinct_taps_of_layer_tap_key_and_regular_key EXPECT_NO_REPORT(driver); layer_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release layer-tap-hold key. */ EXPECT_REPORT(driver, (KC_P)); EXPECT_EMPTY_REPORT(driver); layer_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key. */ EXPECT_REPORT(driver, (KC_A)); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key. */ EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(HoldOnOtherKeyPress, long_distinct_taps_of_layer_tap_key_and_regular_key) { @@ -146,30 +146,30 @@ TEST_F(HoldOnOtherKeyPress, long_distinct_taps_of_layer_tap_key_and_regular_key) EXPECT_NO_REPORT(driver); layer_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Idle for tapping term of layer tap hold key. */ EXPECT_NO_REPORT(driver); idle_for(TAPPING_TERM + 1); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release layer-tap-hold key. */ EXPECT_NO_REPORT(driver); layer_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key. */ EXPECT_REPORT(driver, (KC_A)); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key. */ EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(HoldOnOtherKeyPress, tap_regular_key_while_mod_tap_key_is_held) { @@ -184,30 +184,30 @@ TEST_F(HoldOnOtherKeyPress, tap_regular_key_while_mod_tap_key_is_held) { EXPECT_NO_REPORT(driver); mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key. */ EXPECT_REPORT(driver, (KC_LSFT)); EXPECT_REPORT(driver, (KC_A, KC_LSFT)); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key. */ EXPECT_REPORT(driver, (KC_LSFT)); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Idle for tapping term of mod tap hold key. */ idle_for(TAPPING_TERM - 3); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(HoldOnOtherKeyPress, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) { @@ -222,26 +222,26 @@ TEST_F(HoldOnOtherKeyPress, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) EXPECT_NO_REPORT(driver); first_mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press second tap-hold key */ EXPECT_REPORT(driver, (KC_LSFT)); second_mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release second tap-hold key */ EXPECT_REPORT(driver, (KC_A, KC_LSFT)); EXPECT_REPORT(driver, (KC_LSFT)); second_mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release first mod-tap-hold key */ EXPECT_EMPTY_REPORT(driver); first_mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(HoldOnOtherKeyPress, tap_regular_key_while_layer_tap_key_is_held) { @@ -257,25 +257,25 @@ TEST_F(HoldOnOtherKeyPress, tap_regular_key_while_layer_tap_key_is_held) { EXPECT_NO_REPORT(driver); layer_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key */ EXPECT_REPORT(driver, (KC_B)); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release layer-tap-hold key */ EXPECT_NO_REPORT(driver); layer_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(HoldOnOtherKeyPress, nested_tap_of_layer_0_layer_tap_keys) { @@ -293,25 +293,25 @@ TEST_F(HoldOnOtherKeyPress, nested_tap_of_layer_0_layer_tap_keys) { EXPECT_NO_REPORT(driver); first_layer_tap_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press second layer-tap key */ EXPECT_REPORT(driver, (KC_Q)); second_layer_tap_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release second layer-tap key */ EXPECT_EMPTY_REPORT(driver); second_layer_tap_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release first layer-tap key */ EXPECT_NO_REPORT(driver); first_layer_tap_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(HoldOnOtherKeyPress, nested_tap_of_layer_tap_keys) { @@ -331,26 +331,26 @@ TEST_F(HoldOnOtherKeyPress, nested_tap_of_layer_tap_keys) { EXPECT_NO_REPORT(driver); first_key_layer_0.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press second layer-tap key */ EXPECT_NO_REPORT(driver); second_key_layer_0.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release second layer-tap key */ EXPECT_REPORT(driver, (KC_Q)); EXPECT_EMPTY_REPORT(driver); second_key_layer_0.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release first layer-tap key */ EXPECT_NO_REPORT(driver); first_key_layer_0.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(HoldOnOtherKeyPress, roll_mod_tap_key_with_regular_key) { @@ -365,26 +365,26 @@ TEST_F(HoldOnOtherKeyPress, roll_mod_tap_key_with_regular_key) { EXPECT_NO_REPORT(driver); mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key. */ EXPECT_REPORT(driver, (KC_LSFT)); EXPECT_REPORT(driver, (KC_A, KC_LSFT)); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ EXPECT_REPORT(driver, (KC_A)); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key. */ EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(HoldOnOtherKeyPress, roll_layer_tap_key_with_regular_key) { @@ -401,23 +401,23 @@ TEST_F(HoldOnOtherKeyPress, roll_layer_tap_key_with_regular_key) { EXPECT_NO_REPORT(driver); layer_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key */ EXPECT_REPORT(driver, (KC_B)); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release layer-tap-hold key */ EXPECT_NO_REPORT(driver); layer_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/tap_hold_configurations/ignore_mod_tap_interrupt/test_tap_hold.cpp b/tests/tap_hold_configurations/ignore_mod_tap_interrupt/test_tap_hold.cpp deleted file mode 100644 index 319de61070..0000000000 --- a/tests/tap_hold_configurations/ignore_mod_tap_interrupt/test_tap_hold.cpp +++ /dev/null @@ -1,136 +0,0 @@ -/* Copyright 2021 Stefan Kerkmann - * - * 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/>. - */ - -#include "keyboard_report_util.hpp" -#include "keycode.h" -#include "test_common.hpp" -#include "action_tapping.h" -#include "test_fixture.hpp" -#include "test_keymap_key.hpp" - -using testing::_; -using testing::InSequence; - -class IgnoreModTapInterrupt : public TestFixture {}; - -TEST_F(IgnoreModTapInterrupt, tap_regular_key_while_mod_tap_key_is_held) { - TestDriver driver; - InSequence s; - auto mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); - auto regular_key = KeymapKey(0, 2, 0, KC_A); - - set_keymap({mod_tap_hold_key, regular_key}); - - /* Press mod-tap-hold key */ - EXPECT_NO_REPORT(driver); - mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press regular key */ - EXPECT_NO_REPORT(driver); - regular_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release regular key */ - EXPECT_NO_REPORT(driver); - regular_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release mod-tap-hold key */ - EXPECT_REPORT(driver, (KC_P)); - EXPECT_REPORT(driver, (KC_A, KC_P)); - EXPECT_REPORT(driver, (KC_P)); - EXPECT_EMPTY_REPORT(driver); - mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); -} - -TEST_F(IgnoreModTapInterrupt, tap_mod_tap_key_while_mod_tap_key_is_held) { - TestDriver driver; - InSequence s; - auto first_mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); - auto second_mod_tap_hold_key = KeymapKey(0, 2, 0, RSFT_T(KC_A)); - - set_keymap({first_mod_tap_hold_key, second_mod_tap_hold_key}); - - /* Press first mod-tap-hold key */ - EXPECT_NO_REPORT(driver); - first_mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press second tap-hold key */ - EXPECT_NO_REPORT(driver); - second_mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release second tap-hold key */ - EXPECT_NO_REPORT(driver); - second_mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release first mod-tap-hold key */ - EXPECT_REPORT(driver, (KC_P)); - EXPECT_REPORT(driver, (KC_A, KC_P)); - EXPECT_REPORT(driver, (KC_P)); - EXPECT_EMPTY_REPORT(driver); - first_mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); -} - -TEST_F(IgnoreModTapInterrupt, tap_regular_key_while_layer_tap_key_is_held) { - TestDriver driver; - InSequence s; - auto layer_tap_hold_key = KeymapKey(0, 1, 0, LT(1, KC_P)); - auto regular_key = KeymapKey(0, 2, 0, KC_A); - auto layer_key = KeymapKey(1, 2, 0, KC_B); - - set_keymap({layer_tap_hold_key, regular_key, layer_key}); - - /* Press layer-tap-hold key */ - EXPECT_NO_REPORT(driver); - layer_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press regular key */ - EXPECT_NO_REPORT(driver); - regular_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release regular key */ - EXPECT_NO_REPORT(driver); - regular_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release layer-tap-hold key */ - EXPECT_REPORT(driver, (KC_P)); - EXPECT_REPORT(driver, (KC_P, regular_key.report_code)); - EXPECT_REPORT(driver, (KC_P)); - EXPECT_EMPTY_REPORT(driver); - layer_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); -} diff --git a/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp b/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp index 1328b5fc0f..81f7fe718e 100644 --- a/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp +++ b/tests/tap_hold_configurations/permissive_hold/test_one_shot_keys.cpp @@ -35,26 +35,26 @@ TEST_P(OneShotParametrizedTestFixture, OSMAsRegularModifierWithAdditionalKeypres EXPECT_NO_REPORT(driver); osm_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key */ EXPECT_NO_REPORT(driver); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_REPORT(driver, (osm_key.report_code)).Times(2); EXPECT_REPORT(driver, (regular_key.report_code, osm_key.report_code)).Times(1); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release OSM */ EXPECT_EMPTY_REPORT(driver).Times(1); osm_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } // clang-format off diff --git a/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp b/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp index 74e81f347f..8acae6ae67 100644 --- a/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp +++ b/tests/tap_hold_configurations/permissive_hold/test_tap_hold.cpp @@ -37,13 +37,13 @@ TEST_F(PermissiveHold, tap_regular_key_while_mod_tap_key_is_held) { EXPECT_NO_REPORT(driver); mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key */ EXPECT_NO_REPORT(driver); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); @@ -51,16 +51,16 @@ TEST_F(PermissiveHold, tap_regular_key_while_mod_tap_key_is_held) { EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key */ EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } -TEST_F(PermissiveHold, tap_mod_tap_key_while_mod_tap_key_is_held) { +TEST_F(PermissiveHold, tap_a_mod_tap_key_while_another_mod_tap_key_is_held) { TestDriver driver; InSequence s; auto first_mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); @@ -72,13 +72,13 @@ TEST_F(PermissiveHold, tap_mod_tap_key_while_mod_tap_key_is_held) { EXPECT_NO_REPORT(driver); first_mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press second mod-tap-hold key */ EXPECT_NO_REPORT(driver); second_mod_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release second mod-tap-hold key */ EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); @@ -86,13 +86,13 @@ TEST_F(PermissiveHold, tap_mod_tap_key_while_mod_tap_key_is_held) { EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); second_mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release first mod-tap-hold key */ EXPECT_EMPTY_REPORT(driver); first_mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(PermissiveHold, tap_regular_key_while_layer_tap_key_is_held) { @@ -108,24 +108,24 @@ TEST_F(PermissiveHold, tap_regular_key_while_layer_tap_key_is_held) { EXPECT_NO_REPORT(driver); layer_tap_hold_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press regular key */ EXPECT_NO_REPORT(driver); regular_key.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release regular key */ EXPECT_REPORT(driver, (layer_key.report_code)); EXPECT_EMPTY_REPORT(driver); regular_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release layer-tap-hold key */ EXPECT_NO_REPORT(driver); layer_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test.mk b/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test.mk deleted file mode 100644 index efecca2c22..0000000000 --- a/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test.mk +++ /dev/null @@ -1,18 +0,0 @@ -# Copyright 2021 Stefan Kerkmann -# -# 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/>. - -# -------------------------------------------------------------------------------- -# Keep this file, even if it is empty, as a marker that this folder contains tests -# -------------------------------------------------------------------------------- diff --git a/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test_tap_hold.cpp b/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test_tap_hold.cpp deleted file mode 100644 index ee7e707c94..0000000000 --- a/tests/tap_hold_configurations/permissive_hold_ignore_mod_tap_interrupt/test_tap_hold.cpp +++ /dev/null @@ -1,133 +0,0 @@ - -/* Copyright 2021 Stefan Kerkmann - * - * 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/>. - */ - -#include "keyboard_report_util.hpp" -#include "keycode.h" -#include "test_common.hpp" -#include "action_tapping.h" -#include "test_fixture.hpp" -#include "test_keymap_key.hpp" - -using testing::_; -using testing::InSequence; - -class PermissiveHold_IgnoreModTapInterrupt : public TestFixture {}; - -TEST_F(PermissiveHold_IgnoreModTapInterrupt, tap_regular_key_while_mod_tap_key_is_held) { - TestDriver driver; - InSequence s; - auto mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); - auto regular_key = KeymapKey(0, 2, 0, KC_A); - - set_keymap({mod_tap_hold_key, regular_key}); - - /* Press mod-tap-hold key */ - EXPECT_NO_REPORT(driver); - mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press regular key */ - EXPECT_NO_REPORT(driver); - regular_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release regular key */ - EXPECT_REPORT(driver, (KC_LSFT)); - EXPECT_REPORT(driver, (KC_LSFT, KC_A)); - EXPECT_REPORT(driver, (KC_LSFT)); - regular_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release mod-tap-hold key */ - EXPECT_EMPTY_REPORT(driver); - mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); -} - -TEST_F(PermissiveHold_IgnoreModTapInterrupt, tap_mod_tap_key_while_mod_tap_key_is_held) { - TestDriver driver; - InSequence s; - auto first_mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); - auto second_mod_tap_hold_key = KeymapKey(0, 2, 0, RSFT_T(KC_A)); - - set_keymap({first_mod_tap_hold_key, second_mod_tap_hold_key}); - - /* Press first mod-tap-hold key */ - EXPECT_NO_REPORT(driver); - first_mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press second tap-hold key */ - EXPECT_NO_REPORT(driver); - second_mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release second tap-hold key */ - EXPECT_REPORT(driver, (KC_LSFT)); - EXPECT_REPORT(driver, (KC_LSFT, KC_A)); - EXPECT_REPORT(driver, (KC_LSFT)); - second_mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release first mod-tap-hold key */ - EXPECT_EMPTY_REPORT(driver); - first_mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); -} - -TEST_F(PermissiveHold_IgnoreModTapInterrupt, tap_regular_key_while_layer_tap_key_is_held) { - TestDriver driver; - InSequence s; - auto layer_tap_hold_key = KeymapKey(0, 1, 0, LT(1, KC_P)); - auto regular_key = KeymapKey(0, 2, 0, KC_A); - auto layer_key = KeymapKey(1, 2, 0, KC_B); - - set_keymap({layer_tap_hold_key, regular_key, layer_key}); - - /* Press layer-tap-hold key */ - EXPECT_NO_REPORT(driver); - layer_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press regular key */ - EXPECT_NO_REPORT(driver); - regular_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release regular key */ - EXPECT_REPORT(driver, (KC_B)); - EXPECT_EMPTY_REPORT(driver); - regular_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release layer-tap-hold key */ - EXPECT_NO_REPORT(driver); - layer_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); -} diff --git a/tests/tap_hold_configurations/tapping_force_hold/config.h b/tests/tap_hold_configurations/quick_tap/config.h index 3b4646338a..cd82d3b5a5 100644 --- a/tests/tap_hold_configurations/tapping_force_hold/config.h +++ b/tests/tap_hold_configurations/quick_tap/config.h @@ -18,4 +18,4 @@ #include "test_common.h" -#define TAPPING_FORCE_HOLD
\ No newline at end of file +#define QUICK_TAP_TERM 100 diff --git a/tests/tap_hold_configurations/ignore_mod_tap_interrupt/test.mk b/tests/tap_hold_configurations/quick_tap/test.mk index efecca2c22..efecca2c22 100644 --- a/tests/tap_hold_configurations/ignore_mod_tap_interrupt/test.mk +++ b/tests/tap_hold_configurations/quick_tap/test.mk diff --git a/tests/tap_hold_configurations/tapping_force_hold/test_action_layer.cpp b/tests/tap_hold_configurations/quick_tap/test_action_layer.cpp index 965c702d7a..44dd14c033 100644 --- a/tests/tap_hold_configurations/tapping_force_hold/test_action_layer.cpp +++ b/tests/tap_hold_configurations/quick_tap/test_action_layer.cpp @@ -40,6 +40,8 @@ TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) { run_one_scan_loop(); expect_layer_state(0); + idle_for(QUICK_TAP_TERM + 10); + layer_key.press(); run_one_scan_loop(); layer_key.release(); @@ -64,17 +66,17 @@ TEST_F(ActionLayer, LayerTapToggleWithToggleWithKeypress) { run_one_scan_loop(); expect_layer_state(0); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_REPORT(driver, (KC_A)).Times(1); regular_key.press(); run_one_scan_loop(); expect_layer_state(0); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_EMPTY_REPORT(driver).Times(1); regular_key.release(); run_one_scan_loop(); expect_layer_state(0); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/tap_hold_configurations/quick_tap/test_quick_tap.cpp b/tests/tap_hold_configurations/quick_tap/test_quick_tap.cpp new file mode 100644 index 0000000000..8ec6ea62a3 --- /dev/null +++ b/tests/tap_hold_configurations/quick_tap/test_quick_tap.cpp @@ -0,0 +1,290 @@ +/* Copyright 2021 Stefan Kerkmann + * + * 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/>. + */ + +#include "config.h" +#include "keyboard_report_util.hpp" +#include "keycode.h" +#include "test_common.hpp" +#include "action_tapping.h" +#include "test_fixture.hpp" +#include "test_keymap_key.hpp" + +using testing::_; +using testing::InSequence; + +class QuickTap : public TestFixture {}; + +TEST_F(QuickTap, tap_regular_key_while_mod_tap_key_is_held) { + TestDriver driver; + InSequence s; + auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); + auto regular_key = KeymapKey(0, 2, 0, KC_A); + + set_keymap({mod_tap_key, regular_key}); + + /* Press mod-tap key. */ + EXPECT_NO_REPORT(driver); + mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Press regular key. */ + EXPECT_NO_REPORT(driver); + regular_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release regular key. */ + EXPECT_NO_REPORT(driver); + regular_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release mod-tap key. */ + EXPECT_REPORT(driver, (KC_LSFT)); + mod_tap_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Idle for tapping term of mod tap hold key. */ + EXPECT_REPORT(driver, (KC_LSFT, KC_A)); + EXPECT_REPORT(driver, (KC_LSFT)); + EXPECT_EMPTY_REPORT(driver); + idle_for(TAPPING_TERM - 3); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(QuickTap, tap_mod_tap_key_while_mod_tap_key_is_held) { + TestDriver driver; + InSequence s; + auto first_mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); + auto second_mod_tap_key = KeymapKey(0, 2, 0, RSFT_T(KC_A)); + + set_keymap({first_mod_tap_key, second_mod_tap_key}); + + /* Press first mod-tap key */ + EXPECT_NO_REPORT(driver); + first_mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Press second mod-tap key */ + EXPECT_NO_REPORT(driver); + second_mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release second tap-hold key */ + EXPECT_NO_REPORT(driver); + second_mod_tap_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release first mod-tap key */ + EXPECT_REPORT(driver, (KC_LSFT)); + first_mod_tap_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Idle for tapping term of first mod-tap key. */ + EXPECT_REPORT(driver, (KC_LSFT, KC_A)); + EXPECT_REPORT(driver, (KC_LSFT)); + EXPECT_EMPTY_REPORT(driver); + idle_for(TAPPING_TERM - 3); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(QuickTap, tap_regular_key_while_layer_tap_key_is_held) { + TestDriver driver; + InSequence s; + auto layer_tap_key = KeymapKey(0, 1, 0, LT(1, KC_P)); + auto regular_key = KeymapKey(0, 2, 0, KC_A); + auto layer_key = KeymapKey(1, 2, 0, KC_B); + + set_keymap({layer_tap_key, regular_key, layer_key}); + + /* Press layer-tap key */ + EXPECT_NO_REPORT(driver); + layer_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Press regular key */ + EXPECT_NO_REPORT(driver); + regular_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release regular key */ + EXPECT_NO_REPORT(driver); + regular_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release layer-tap key */ + EXPECT_REPORT(driver, (KC_P)); + EXPECT_REPORT(driver, (KC_A, KC_P)); + EXPECT_REPORT(driver, (KC_P)); + EXPECT_EMPTY_REPORT(driver); + layer_tap_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(QuickTap, tap_key_and_tap_again_before_quick_tap_term) { + TestDriver driver; + InSequence s; + auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); + + set_keymap({mod_tap_key}); + + /* Press mod-tap key. */ + EXPECT_NO_REPORT(driver); + mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release mod-tap key. */ + EXPECT_REPORT(driver, (KC_P)); + EXPECT_EMPTY_REPORT(driver); + mod_tap_key.release(); + idle_for(QUICK_TAP_TERM - 10); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Press and tap mod-tap key again. */ + EXPECT_REPORT(driver, (KC_P)); + mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release mod-tap key. */ + EXPECT_EMPTY_REPORT(driver); + mod_tap_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(QuickTap, tap_key_and_hold_again_before_quick_tap_term) { + TestDriver driver; + InSequence s; + auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); + + set_keymap({mod_tap_key}); + + /* Press mod-tap key. */ + EXPECT_NO_REPORT(driver); + mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release mod-tap key. */ + EXPECT_REPORT(driver, (KC_P)); + EXPECT_EMPTY_REPORT(driver); + mod_tap_key.release(); + idle_for(QUICK_TAP_TERM - 10); + VERIFY_AND_CLEAR(driver); + + /* Press and hold mod-tap key again. */ + EXPECT_REPORT(driver, (KC_P)); + mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Wait until tapping term expired */ + EXPECT_NO_REPORT(driver); + idle_for(TAPPING_TERM); + VERIFY_AND_CLEAR(driver); + + /* Release mod-tap key. */ + EXPECT_EMPTY_REPORT(driver); + mod_tap_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(QuickTap, tap_key_and_tap_again_after_quick_tap_term) { + TestDriver driver; + InSequence s; + auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); + + set_keymap({mod_tap_key}); + + /* Press mod-tap key. */ + EXPECT_NO_REPORT(driver); + mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release mod-tap key. */ + EXPECT_REPORT(driver, (KC_P)); + EXPECT_EMPTY_REPORT(driver); + mod_tap_key.release(); + idle_for(QUICK_TAP_TERM + 10); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Press mod-tap key again. */ + EXPECT_NO_REPORT(driver); + mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release mod-tap key. */ + EXPECT_REPORT(driver, (KC_P)); + EXPECT_EMPTY_REPORT(driver); + mod_tap_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} + +TEST_F(QuickTap, tap_key_and_hold_again_after_quick_tap_term) { + TestDriver driver; + InSequence s; + auto mod_tap_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); + + set_keymap({mod_tap_key}); + + /* Press mod-tap key. */ + EXPECT_NO_REPORT(driver); + mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Release mod-tap key. */ + EXPECT_REPORT(driver, (KC_P)); + EXPECT_EMPTY_REPORT(driver); + mod_tap_key.release(); + idle_for(QUICK_TAP_TERM + 10); + VERIFY_AND_CLEAR(driver); + + /* Press and hold mod-tap key again. */ + EXPECT_NO_REPORT(driver); + mod_tap_key.press(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); + + /* Wait until tapping term expired */ + EXPECT_REPORT(driver, (KC_LSFT)); + idle_for(TAPPING_TERM); + VERIFY_AND_CLEAR(driver); + + /* Release mod-tap key. */ + EXPECT_EMPTY_REPORT(driver); + mod_tap_key.release(); + run_one_scan_loop(); + VERIFY_AND_CLEAR(driver); +} diff --git a/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp b/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp index e08c600dbd..2b49cddcce 100644 --- a/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp +++ b/tests/tap_hold_configurations/retro_tapping/test_tap_hold.cpp @@ -38,7 +38,7 @@ TEST_F(RetroTapping, tap_and_hold_mod_tap_hold_key) { EXPECT_NO_REPORT(driver); mod_tap_hold_key.press(); idle_for(TAPPING_TERM); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod-tap-hold key. */ /* TODO: Why is LSHIFT send at all? */ @@ -48,5 +48,5 @@ TEST_F(RetroTapping, tap_and_hold_mod_tap_hold_key) { EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp b/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp index 42139d50da..db81c39101 100644 --- a/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp +++ b/tests/tap_hold_configurations/retro_tapping/test_tapping.cpp @@ -35,18 +35,18 @@ TEST_F(Tapping, HoldA_SHFT_T_KeyReportsShift) { EXPECT_NO_REPORT(driver); mod_tap_hold_key.press(); idle_for(TAPPING_TERM); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_REPORT(driver, (KC_LSFT)); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); EXPECT_EMPTY_REPORT(driver); EXPECT_REPORT(driver, (KC_P)); EXPECT_EMPTY_REPORT(driver); mod_tap_hold_key.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) { @@ -60,45 +60,45 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) { EXPECT_NO_REPORT(driver); key_shift_hold_p_tap.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod_tap_hold key */ EXPECT_REPORT(driver, (KC_P)); EXPECT_EMPTY_REPORT(driver); key_shift_hold_p_tap.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press mod_tap_hold key again */ EXPECT_REPORT(driver, (KC_P)); key_shift_hold_p_tap.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod_tap_hold key again */ EXPECT_EMPTY_REPORT(driver); key_shift_hold_p_tap.release(); idle_for(TAPPING_TERM + 1); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press mod_tap_hold key again */ EXPECT_NO_REPORT(driver); key_shift_hold_p_tap.press(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod_tap_hold key again */ EXPECT_REPORT(driver, (KC_P)); EXPECT_EMPTY_REPORT(driver); key_shift_hold_p_tap.release(); idle_for(TAPPING_TERM + 1); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Press mod_tap_hold key again */ EXPECT_NO_REPORT(driver); key_shift_hold_p_tap.press(); idle_for(TAPPING_TERM); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Release mod_tap_hold key again */ /* TODO: Why is KC_LSFT send? */ @@ -108,5 +108,5 @@ TEST_F(Tapping, ANewTapWithinTappingTermIsBuggy) { EXPECT_EMPTY_REPORT(driver); key_shift_hold_p_tap.release(); run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); } diff --git a/tests/tap_hold_configurations/tapping_force_hold/test.mk b/tests/tap_hold_configurations/tapping_force_hold/test.mk deleted file mode 100644 index efecca2c22..0000000000 --- a/tests/tap_hold_configurations/tapping_force_hold/test.mk +++ /dev/null @@ -1,18 +0,0 @@ -# Copyright 2021 Stefan Kerkmann -# -# 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/>. - -# -------------------------------------------------------------------------------- -# Keep this file, even if it is empty, as a marker that this folder contains tests -# -------------------------------------------------------------------------------- diff --git a/tests/tap_hold_configurations/tapping_force_hold/test_tap_hold.cpp b/tests/tap_hold_configurations/tapping_force_hold/test_tap_hold.cpp deleted file mode 100644 index 604f9a4a54..0000000000 --- a/tests/tap_hold_configurations/tapping_force_hold/test_tap_hold.cpp +++ /dev/null @@ -1,213 +0,0 @@ - -/* Copyright 2021 Stefan Kerkmann - * - * 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/>. - */ - -#include "keyboard_report_util.hpp" -#include "keycode.h" -#include "test_common.hpp" -#include "action_tapping.h" -#include "test_fixture.hpp" -#include "test_keymap_key.hpp" - -using testing::_; -using testing::InSequence; - -class TappingForceHold : public TestFixture {}; - -TEST_F(TappingForceHold, tap_regular_key_while_mod_tap_key_is_held) { - TestDriver driver; - InSequence s; - auto mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); - auto regular_key = KeymapKey(0, 2, 0, KC_A); - - set_keymap({mod_tap_hold_key, regular_key}); - - /* Press mod-tap-hold key. */ - EXPECT_NO_REPORT(driver); - mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press regular key. */ - EXPECT_NO_REPORT(driver); - regular_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release regular key. */ - EXPECT_NO_REPORT(driver); - regular_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release mod-tap-hold key. */ - EXPECT_REPORT(driver, (KC_LSFT)); - mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Idle for tapping term of mod tap hold key. */ - EXPECT_REPORT(driver, (KC_LSFT, KC_A)); - EXPECT_REPORT(driver, (KC_LSFT)); - EXPECT_EMPTY_REPORT(driver); - idle_for(TAPPING_TERM - 3); - testing::Mock::VerifyAndClearExpectations(&driver); -} - -TEST_F(TappingForceHold, tap_mod_tap_key_while_mod_tap_key_is_held) { - TestDriver driver; - InSequence s; - auto first_mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); - auto second_mod_tap_hold_key = KeymapKey(0, 2, 0, RSFT_T(KC_A)); - - set_keymap({first_mod_tap_hold_key, second_mod_tap_hold_key}); - - /* Press first mod-tap-hold key */ - EXPECT_NO_REPORT(driver); - first_mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press second tap-hold key */ - EXPECT_NO_REPORT(driver); - second_mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release second tap-hold key */ - EXPECT_NO_REPORT(driver); - second_mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release first mod-tap-hold key */ - EXPECT_REPORT(driver, (KC_LSFT)); - first_mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Idle for tapping term of first mod tap hold key. */ - EXPECT_REPORT(driver, (KC_LSFT, KC_A)); - EXPECT_REPORT(driver, (KC_LSFT)); - EXPECT_EMPTY_REPORT(driver); - idle_for(TAPPING_TERM - 3); - testing::Mock::VerifyAndClearExpectations(&driver); -} - -TEST_F(TappingForceHold, tap_regular_key_while_layer_tap_key_is_held) { - TestDriver driver; - InSequence s; - auto layer_tap_hold_key = KeymapKey(0, 1, 0, LT(1, KC_P)); - auto regular_key = KeymapKey(0, 2, 0, KC_A); - auto layer_key = KeymapKey(1, 2, 0, KC_B); - - set_keymap({layer_tap_hold_key, regular_key, layer_key}); - - /* Press layer-tap-hold key */ - EXPECT_NO_REPORT(driver); - layer_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press regular key */ - EXPECT_NO_REPORT(driver); - regular_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release regular key */ - EXPECT_NO_REPORT(driver); - regular_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release layer-tap-hold key */ - EXPECT_REPORT(driver, (KC_P)); - EXPECT_REPORT(driver, (KC_A, KC_P)); - EXPECT_REPORT(driver, (KC_P)); - EXPECT_EMPTY_REPORT(driver); - layer_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); -} - -TEST_F(TappingForceHold, tap_mod_tap_hold_key_two_times) { - TestDriver driver; - InSequence s; - auto mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); - - set_keymap({mod_tap_hold_key}); - - /* Press mod-tap-hold key. */ - EXPECT_NO_REPORT(driver); - mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release mod-tap-hold key. */ - EXPECT_REPORT(driver, (KC_P)); - EXPECT_EMPTY_REPORT(driver); - mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press mod-tap-hold key again. */ - EXPECT_NO_REPORT(driver); - mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release mod-tap-hold key. */ - EXPECT_REPORT(driver, (KC_P)); - EXPECT_EMPTY_REPORT(driver); - mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); -} - -TEST_F(TappingForceHold, tap_mod_tap_hold_key_twice_and_hold_on_second_time) { - TestDriver driver; - InSequence s; - auto mod_tap_hold_key = KeymapKey(0, 1, 0, SFT_T(KC_P)); - - set_keymap({mod_tap_hold_key}); - - /* Press mod-tap-hold key. */ - EXPECT_NO_REPORT(driver); - mod_tap_hold_key.press(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release mod-tap-hold key. */ - EXPECT_REPORT(driver, (KC_P)); - EXPECT_EMPTY_REPORT(driver); - mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Press mod-tap-hold key again. */ - EXPECT_NO_REPORT(driver); - mod_tap_hold_key.press(); - idle_for(TAPPING_TERM); - testing::Mock::VerifyAndClearExpectations(&driver); - - /* Release mod-tap-hold key. */ - EXPECT_REPORT(driver, (KC_LEFT_SHIFT)); - EXPECT_EMPTY_REPORT(driver); - mod_tap_hold_key.release(); - run_one_scan_loop(); - testing::Mock::VerifyAndClearExpectations(&driver); -} diff --git a/tests/test_common/keyboard_report_util.cpp b/tests/test_common/keyboard_report_util.cpp index 7908e64f7f..2de1af2301 100644 --- a/tests/test_common/keyboard_report_util.cpp +++ b/tests/test_common/keyboard_report_util.cpp @@ -15,11 +15,16 @@ */ #include "keyboard_report_util.hpp" +#include <cstdint> #include <vector> #include <algorithm> + using namespace testing; +extern std::map<uint16_t, std::string> KEYCODE_ID_TABLE; + namespace { + std::vector<uint8_t> get_keys(const report_keyboard_t& report) { std::vector<uint8_t> result; #if defined(NKRO_ENABLE) @@ -36,6 +41,19 @@ std::vector<uint8_t> get_keys(const report_keyboard_t& report) { std::sort(result.begin(), result.end()); return result; } + +std::vector<uint8_t> get_mods(const report_keyboard_t& report) { + std::vector<uint8_t> result; + for (size_t i = 0; i < 8; i++) { + if (report.mods & (1 << i)) { + uint8_t code = KC_LEFT_CTRL + i; + result.emplace_back(code); + } + } + std::sort(result.begin(), result.end()); + return result; +} + } // namespace bool operator==(const report_keyboard_t& lhs, const report_keyboard_t& rhs) { @@ -44,21 +62,36 @@ bool operator==(const report_keyboard_t& lhs, const report_keyboard_t& rhs) { return lhs.mods == rhs.mods && lhskeys == rhskeys; } -std::ostream& operator<<(std::ostream& stream, const report_keyboard_t& report) { +std::ostream& operator<<(std::ostream& os, const report_keyboard_t& report) { auto keys = get_keys(report); + auto mods = get_mods(report); - // TODO: This should probably print friendly names for the keys - stream << "Keyboard Report: Mods (" << (uint32_t)report.mods << ") Keys ("; + os << std::setw(10) << std::left << "report: "; + + if (!keys.size() && !mods.size()) { + return os << "empty" << std::endl; + } + os << "("; for (auto key = keys.cbegin(); key != keys.cend();) { - stream << +(*key); + os << KEYCODE_ID_TABLE.at(*key); key++; if (key != keys.cend()) { - stream << ","; + os << ", "; + } + } + + os << ") ["; + + for (auto mod = mods.cbegin(); mod != mods.cend();) { + os << KEYCODE_ID_TABLE.at(*mod); + mod++; + if (mod != mods.cend()) { + os << ", "; } } - return stream << ")" << std::endl; + return os << "]" << std::endl; } KeyboardReportMatcher::KeyboardReportMatcher(const std::vector<uint8_t>& keys) { diff --git a/tests/test_common/keycode_table.cpp b/tests/test_common/keycode_table.cpp new file mode 100644 index 0000000000..63350c272d --- /dev/null +++ b/tests/test_common/keycode_table.cpp @@ -0,0 +1,663 @@ +// Copyright 2022 QMK +// SPDX-License-Identifier: GPL-2.0-or-later + +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ + +// clang-format off +extern "C" { +#include <keycode.h> +} +#include <map> +#include <string> +#include <cstdint> + +std::map<uint16_t, std::string> KEYCODE_ID_TABLE = { + {KC_NO, "KC_NO"}, + {KC_TRANSPARENT, "KC_TRANSPARENT"}, + {KC_A, "KC_A"}, + {KC_B, "KC_B"}, + {KC_C, "KC_C"}, + {KC_D, "KC_D"}, + {KC_E, "KC_E"}, + {KC_F, "KC_F"}, + {KC_G, "KC_G"}, + {KC_H, "KC_H"}, + {KC_I, "KC_I"}, + {KC_J, "KC_J"}, + {KC_K, "KC_K"}, + {KC_L, "KC_L"}, + {KC_M, "KC_M"}, + {KC_N, "KC_N"}, + {KC_O, "KC_O"}, + {KC_P, "KC_P"}, + {KC_Q, "KC_Q"}, + {KC_R, "KC_R"}, + {KC_S, "KC_S"}, + {KC_T, "KC_T"}, + {KC_U, "KC_U"}, + {KC_V, "KC_V"}, + {KC_W, "KC_W"}, + {KC_X, "KC_X"}, + {KC_Y, "KC_Y"}, + {KC_Z, "KC_Z"}, + {KC_1, "KC_1"}, + {KC_2, "KC_2"}, + {KC_3, "KC_3"}, + {KC_4, "KC_4"}, + {KC_5, "KC_5"}, + {KC_6, "KC_6"}, + {KC_7, "KC_7"}, + {KC_8, "KC_8"}, + {KC_9, "KC_9"}, + {KC_0, "KC_0"}, + {KC_ENTER, "KC_ENTER"}, + {KC_ESCAPE, "KC_ESCAPE"}, + {KC_BACKSPACE, "KC_BACKSPACE"}, + {KC_TAB, "KC_TAB"}, + {KC_SPACE, "KC_SPACE"}, + {KC_MINUS, "KC_MINUS"}, + {KC_EQUAL, "KC_EQUAL"}, + {KC_LEFT_BRACKET, "KC_LEFT_BRACKET"}, + {KC_RIGHT_BRACKET, "KC_RIGHT_BRACKET"}, + {KC_BACKSLASH, "KC_BACKSLASH"}, + {KC_NONUS_HASH, "KC_NONUS_HASH"}, + {KC_SEMICOLON, "KC_SEMICOLON"}, + {KC_QUOTE, "KC_QUOTE"}, + {KC_GRAVE, "KC_GRAVE"}, + {KC_COMMA, "KC_COMMA"}, + {KC_DOT, "KC_DOT"}, + {KC_SLASH, "KC_SLASH"}, + {KC_CAPS_LOCK, "KC_CAPS_LOCK"}, + {KC_F1, "KC_F1"}, + {KC_F2, "KC_F2"}, + {KC_F3, "KC_F3"}, + {KC_F4, "KC_F4"}, + {KC_F5, "KC_F5"}, + {KC_F6, "KC_F6"}, + {KC_F7, "KC_F7"}, + {KC_F8, "KC_F8"}, + {KC_F9, "KC_F9"}, + {KC_F10, "KC_F10"}, + {KC_F11, "KC_F11"}, + {KC_F12, "KC_F12"}, + {KC_PRINT_SCREEN, "KC_PRINT_SCREEN"}, + {KC_SCROLL_LOCK, "KC_SCROLL_LOCK"}, + {KC_PAUSE, "KC_PAUSE"}, + {KC_INSERT, "KC_INSERT"}, + {KC_HOME, "KC_HOME"}, + {KC_PAGE_UP, "KC_PAGE_UP"}, + {KC_DELETE, "KC_DELETE"}, + {KC_END, "KC_END"}, + {KC_PAGE_DOWN, "KC_PAGE_DOWN"}, + {KC_RIGHT, "KC_RIGHT"}, + {KC_LEFT, "KC_LEFT"}, + {KC_DOWN, "KC_DOWN"}, + {KC_UP, "KC_UP"}, + {KC_NUM_LOCK, "KC_NUM_LOCK"}, + {KC_KP_SLASH, "KC_KP_SLASH"}, + {KC_KP_ASTERISK, "KC_KP_ASTERISK"}, + {KC_KP_MINUS, "KC_KP_MINUS"}, + {KC_KP_PLUS, "KC_KP_PLUS"}, + {KC_KP_ENTER, "KC_KP_ENTER"}, + {KC_KP_1, "KC_KP_1"}, + {KC_KP_2, "KC_KP_2"}, + {KC_KP_3, "KC_KP_3"}, + {KC_KP_4, "KC_KP_4"}, + {KC_KP_5, "KC_KP_5"}, + {KC_KP_6, "KC_KP_6"}, + {KC_KP_7, "KC_KP_7"}, + {KC_KP_8, "KC_KP_8"}, + {KC_KP_9, "KC_KP_9"}, + {KC_KP_0, "KC_KP_0"}, + {KC_KP_DOT, "KC_KP_DOT"}, + {KC_NONUS_BACKSLASH, "KC_NONUS_BACKSLASH"}, + {KC_APPLICATION, "KC_APPLICATION"}, + {KC_KB_POWER, "KC_KB_POWER"}, + {KC_KP_EQUAL, "KC_KP_EQUAL"}, + {KC_F13, "KC_F13"}, + {KC_F14, "KC_F14"}, + {KC_F15, "KC_F15"}, + {KC_F16, "KC_F16"}, + {KC_F17, "KC_F17"}, + {KC_F18, "KC_F18"}, + {KC_F19, "KC_F19"}, + {KC_F20, "KC_F20"}, + {KC_F21, "KC_F21"}, + {KC_F22, "KC_F22"}, + {KC_F23, "KC_F23"}, + {KC_F24, "KC_F24"}, + {KC_EXECUTE, "KC_EXECUTE"}, + {KC_HELP, "KC_HELP"}, + {KC_MENU, "KC_MENU"}, + {KC_SELECT, "KC_SELECT"}, + {KC_STOP, "KC_STOP"}, + {KC_AGAIN, "KC_AGAIN"}, + {KC_UNDO, "KC_UNDO"}, + {KC_CUT, "KC_CUT"}, + {KC_COPY, "KC_COPY"}, + {KC_PASTE, "KC_PASTE"}, + {KC_FIND, "KC_FIND"}, + {KC_KB_MUTE, "KC_KB_MUTE"}, + {KC_KB_VOLUME_UP, "KC_KB_VOLUME_UP"}, + {KC_KB_VOLUME_DOWN, "KC_KB_VOLUME_DOWN"}, + {KC_LOCKING_CAPS_LOCK, "KC_LOCKING_CAPS_LOCK"}, + {KC_LOCKING_NUM_LOCK, "KC_LOCKING_NUM_LOCK"}, + {KC_LOCKING_SCROLL_LOCK, "KC_LOCKING_SCROLL_LOCK"}, + {KC_KP_COMMA, "KC_KP_COMMA"}, + {KC_KP_EQUAL_AS400, "KC_KP_EQUAL_AS400"}, + {KC_INTERNATIONAL_1, "KC_INTERNATIONAL_1"}, + {KC_INTERNATIONAL_2, "KC_INTERNATIONAL_2"}, + {KC_INTERNATIONAL_3, "KC_INTERNATIONAL_3"}, + {KC_INTERNATIONAL_4, "KC_INTERNATIONAL_4"}, + {KC_INTERNATIONAL_5, "KC_INTERNATIONAL_5"}, + {KC_INTERNATIONAL_6, "KC_INTERNATIONAL_6"}, + {KC_INTERNATIONAL_7, "KC_INTERNATIONAL_7"}, + {KC_INTERNATIONAL_8, "KC_INTERNATIONAL_8"}, + {KC_INTERNATIONAL_9, "KC_INTERNATIONAL_9"}, + {KC_LANGUAGE_1, "KC_LANGUAGE_1"}, + {KC_LANGUAGE_2, "KC_LANGUAGE_2"}, + {KC_LANGUAGE_3, "KC_LANGUAGE_3"}, + {KC_LANGUAGE_4, "KC_LANGUAGE_4"}, + {KC_LANGUAGE_5, "KC_LANGUAGE_5"}, + {KC_LANGUAGE_6, "KC_LANGUAGE_6"}, + {KC_LANGUAGE_7, "KC_LANGUAGE_7"}, + {KC_LANGUAGE_8, "KC_LANGUAGE_8"}, + {KC_LANGUAGE_9, "KC_LANGUAGE_9"}, + {KC_ALTERNATE_ERASE, "KC_ALTERNATE_ERASE"}, + {KC_SYSTEM_REQUEST, "KC_SYSTEM_REQUEST"}, + {KC_CANCEL, "KC_CANCEL"}, + {KC_CLEAR, "KC_CLEAR"}, + {KC_PRIOR, "KC_PRIOR"}, + {KC_RETURN, "KC_RETURN"}, + {KC_SEPARATOR, "KC_SEPARATOR"}, + {KC_OUT, "KC_OUT"}, + {KC_OPER, "KC_OPER"}, + {KC_CLEAR_AGAIN, "KC_CLEAR_AGAIN"}, + {KC_CRSEL, "KC_CRSEL"}, + {KC_EXSEL, "KC_EXSEL"}, + {KC_SYSTEM_POWER, "KC_SYSTEM_POWER"}, + {KC_SYSTEM_SLEEP, "KC_SYSTEM_SLEEP"}, + {KC_SYSTEM_WAKE, "KC_SYSTEM_WAKE"}, + {KC_AUDIO_MUTE, "KC_AUDIO_MUTE"}, + {KC_AUDIO_VOL_UP, "KC_AUDIO_VOL_UP"}, + {KC_AUDIO_VOL_DOWN, "KC_AUDIO_VOL_DOWN"}, + {KC_MEDIA_NEXT_TRACK, "KC_MEDIA_NEXT_TRACK"}, + {KC_MEDIA_PREV_TRACK, "KC_MEDIA_PREV_TRACK"}, + {KC_MEDIA_STOP, "KC_MEDIA_STOP"}, + {KC_MEDIA_PLAY_PAUSE, "KC_MEDIA_PLAY_PAUSE"}, + {KC_MEDIA_SELECT, "KC_MEDIA_SELECT"}, + {KC_MEDIA_EJECT, "KC_MEDIA_EJECT"}, + {KC_MAIL, "KC_MAIL"}, + {KC_CALCULATOR, "KC_CALCULATOR"}, + {KC_MY_COMPUTER, "KC_MY_COMPUTER"}, + {KC_WWW_SEARCH, "KC_WWW_SEARCH"}, + {KC_WWW_HOME, "KC_WWW_HOME"}, + {KC_WWW_BACK, "KC_WWW_BACK"}, + {KC_WWW_FORWARD, "KC_WWW_FORWARD"}, + {KC_WWW_STOP, "KC_WWW_STOP"}, + {KC_WWW_REFRESH, "KC_WWW_REFRESH"}, + {KC_WWW_FAVORITES, "KC_WWW_FAVORITES"}, + {KC_MEDIA_FAST_FORWARD, "KC_MEDIA_FAST_FORWARD"}, + {KC_MEDIA_REWIND, "KC_MEDIA_REWIND"}, + {KC_BRIGHTNESS_UP, "KC_BRIGHTNESS_UP"}, + {KC_BRIGHTNESS_DOWN, "KC_BRIGHTNESS_DOWN"}, + {KC_CONTROL_PANEL, "KC_CONTROL_PANEL"}, + {KC_ASSISTANT, "KC_ASSISTANT"}, + {KC_MS_UP, "KC_MS_UP"}, + {KC_MS_DOWN, "KC_MS_DOWN"}, + {KC_MS_LEFT, "KC_MS_LEFT"}, + {KC_MS_RIGHT, "KC_MS_RIGHT"}, + {KC_MS_BTN1, "KC_MS_BTN1"}, + {KC_MS_BTN2, "KC_MS_BTN2"}, + {KC_MS_BTN3, "KC_MS_BTN3"}, + {KC_MS_BTN4, "KC_MS_BTN4"}, + {KC_MS_BTN5, "KC_MS_BTN5"}, + {KC_MS_BTN6, "KC_MS_BTN6"}, + {KC_MS_BTN7, "KC_MS_BTN7"}, + {KC_MS_BTN8, "KC_MS_BTN8"}, + {KC_MS_WH_UP, "KC_MS_WH_UP"}, + {KC_MS_WH_DOWN, "KC_MS_WH_DOWN"}, + {KC_MS_WH_LEFT, "KC_MS_WH_LEFT"}, + {KC_MS_WH_RIGHT, "KC_MS_WH_RIGHT"}, + {KC_MS_ACCEL0, "KC_MS_ACCEL0"}, + {KC_MS_ACCEL1, "KC_MS_ACCEL1"}, + {KC_MS_ACCEL2, "KC_MS_ACCEL2"}, + {KC_LEFT_CTRL, "KC_LEFT_CTRL"}, + {KC_LEFT_SHIFT, "KC_LEFT_SHIFT"}, + {KC_LEFT_ALT, "KC_LEFT_ALT"}, + {KC_LEFT_GUI, "KC_LEFT_GUI"}, + {KC_RIGHT_CTRL, "KC_RIGHT_CTRL"}, + {KC_RIGHT_SHIFT, "KC_RIGHT_SHIFT"}, + {KC_RIGHT_ALT, "KC_RIGHT_ALT"}, + {KC_RIGHT_GUI, "KC_RIGHT_GUI"}, + {SH_TG, "SH_TG"}, + {SH_TT, "SH_TT"}, + {SH_MON, "SH_MON"}, + {SH_MOFF, "SH_MOFF"}, + {SH_OFF, "SH_OFF"}, + {SH_ON, "SH_ON"}, + {SH_OS, "SH_OS"}, + {MAGIC_SWAP_CONTROL_CAPSLOCK, "MAGIC_SWAP_CONTROL_CAPSLOCK"}, + {MAGIC_UNSWAP_CONTROL_CAPSLOCK, "MAGIC_UNSWAP_CONTROL_CAPSLOCK"}, + {MAGIC_TOGGLE_CONTROL_CAPSLOCK, "MAGIC_TOGGLE_CONTROL_CAPSLOCK"}, + {MAGIC_UNCAPSLOCK_TO_CONTROL, "MAGIC_UNCAPSLOCK_TO_CONTROL"}, + {MAGIC_CAPSLOCK_TO_CONTROL, "MAGIC_CAPSLOCK_TO_CONTROL"}, + {MAGIC_SWAP_LALT_LGUI, "MAGIC_SWAP_LALT_LGUI"}, + {MAGIC_UNSWAP_LALT_LGUI, "MAGIC_UNSWAP_LALT_LGUI"}, + {MAGIC_SWAP_RALT_RGUI, "MAGIC_SWAP_RALT_RGUI"}, + {MAGIC_UNSWAP_RALT_RGUI, "MAGIC_UNSWAP_RALT_RGUI"}, + {MAGIC_UNNO_GUI, "MAGIC_UNNO_GUI"}, + {MAGIC_NO_GUI, "MAGIC_NO_GUI"}, + {MAGIC_TOGGLE_GUI, "MAGIC_TOGGLE_GUI"}, + {MAGIC_SWAP_GRAVE_ESC, "MAGIC_SWAP_GRAVE_ESC"}, + {MAGIC_UNSWAP_GRAVE_ESC, "MAGIC_UNSWAP_GRAVE_ESC"}, + {MAGIC_SWAP_BACKSLASH_BACKSPACE, "MAGIC_SWAP_BACKSLASH_BACKSPACE"}, + {MAGIC_UNSWAP_BACKSLASH_BACKSPACE, "MAGIC_UNSWAP_BACKSLASH_BACKSPACE"}, + {MAGIC_TOGGLE_BACKSLASH_BACKSPACE, "MAGIC_TOGGLE_BACKSLASH_BACKSPACE"}, + {MAGIC_HOST_NKRO, "MAGIC_HOST_NKRO"}, + {MAGIC_UNHOST_NKRO, "MAGIC_UNHOST_NKRO"}, + {MAGIC_TOGGLE_NKRO, "MAGIC_TOGGLE_NKRO"}, + {MAGIC_SWAP_ALT_GUI, "MAGIC_SWAP_ALT_GUI"}, + {MAGIC_UNSWAP_ALT_GUI, "MAGIC_UNSWAP_ALT_GUI"}, + {MAGIC_TOGGLE_ALT_GUI, "MAGIC_TOGGLE_ALT_GUI"}, + {MAGIC_SWAP_LCTL_LGUI, "MAGIC_SWAP_LCTL_LGUI"}, + {MAGIC_UNSWAP_LCTL_LGUI, "MAGIC_UNSWAP_LCTL_LGUI"}, + {MAGIC_SWAP_RCTL_RGUI, "MAGIC_SWAP_RCTL_RGUI"}, + {MAGIC_UNSWAP_RCTL_RGUI, "MAGIC_UNSWAP_RCTL_RGUI"}, + {MAGIC_SWAP_CTL_GUI, "MAGIC_SWAP_CTL_GUI"}, + {MAGIC_UNSWAP_CTL_GUI, "MAGIC_UNSWAP_CTL_GUI"}, + {MAGIC_TOGGLE_CTL_GUI, "MAGIC_TOGGLE_CTL_GUI"}, + {MAGIC_EE_HANDS_LEFT, "MAGIC_EE_HANDS_LEFT"}, + {MAGIC_EE_HANDS_RIGHT, "MAGIC_EE_HANDS_RIGHT"}, + {MAGIC_SWAP_ESCAPE_CAPSLOCK, "MAGIC_SWAP_ESCAPE_CAPSLOCK"}, + {MAGIC_UNSWAP_ESCAPE_CAPSLOCK, "MAGIC_UNSWAP_ESCAPE_CAPSLOCK"}, + {MAGIC_TOGGLE_ESCAPE_CAPSLOCK, "MAGIC_TOGGLE_ESCAPE_CAPSLOCK"}, + {QK_MIDI_ON, "QK_MIDI_ON"}, + {QK_MIDI_OFF, "QK_MIDI_OFF"}, + {QK_MIDI_TOGGLE, "QK_MIDI_TOGGLE"}, + {QK_MIDI_NOTE_C_0, "QK_MIDI_NOTE_C_0"}, + {QK_MIDI_NOTE_C_SHARP_0, "QK_MIDI_NOTE_C_SHARP_0"}, + {QK_MIDI_NOTE_D_0, "QK_MIDI_NOTE_D_0"}, + {QK_MIDI_NOTE_D_SHARP_0, "QK_MIDI_NOTE_D_SHARP_0"}, + {QK_MIDI_NOTE_E_0, "QK_MIDI_NOTE_E_0"}, + {QK_MIDI_NOTE_F_0, "QK_MIDI_NOTE_F_0"}, + {QK_MIDI_NOTE_F_SHARP_0, "QK_MIDI_NOTE_F_SHARP_0"}, + {QK_MIDI_NOTE_G_0, "QK_MIDI_NOTE_G_0"}, + {QK_MIDI_NOTE_G_SHARP_0, "QK_MIDI_NOTE_G_SHARP_0"}, + {QK_MIDI_NOTE_A_0, "QK_MIDI_NOTE_A_0"}, + {QK_MIDI_NOTE_A_SHARP_0, "QK_MIDI_NOTE_A_SHARP_0"}, + {QK_MIDI_NOTE_B_0, "QK_MIDI_NOTE_B_0"}, + {QK_MIDI_NOTE_C_1, "QK_MIDI_NOTE_C_1"}, + {QK_MIDI_NOTE_C_SHARP_1, "QK_MIDI_NOTE_C_SHARP_1"}, + {QK_MIDI_NOTE_D_1, "QK_MIDI_NOTE_D_1"}, + {QK_MIDI_NOTE_D_SHARP_1, "QK_MIDI_NOTE_D_SHARP_1"}, + {QK_MIDI_NOTE_E_1, "QK_MIDI_NOTE_E_1"}, + {QK_MIDI_NOTE_F_1, "QK_MIDI_NOTE_F_1"}, + {QK_MIDI_NOTE_F_SHARP_1, "QK_MIDI_NOTE_F_SHARP_1"}, + {QK_MIDI_NOTE_G_1, "QK_MIDI_NOTE_G_1"}, + {QK_MIDI_NOTE_G_SHARP_1, "QK_MIDI_NOTE_G_SHARP_1"}, + {QK_MIDI_NOTE_A_1, "QK_MIDI_NOTE_A_1"}, + {QK_MIDI_NOTE_A_SHARP_1, "QK_MIDI_NOTE_A_SHARP_1"}, + {QK_MIDI_NOTE_B_1, "QK_MIDI_NOTE_B_1"}, + {QK_MIDI_NOTE_C_2, "QK_MIDI_NOTE_C_2"}, + {QK_MIDI_NOTE_C_SHARP_2, "QK_MIDI_NOTE_C_SHARP_2"}, + {QK_MIDI_NOTE_D_2, "QK_MIDI_NOTE_D_2"}, + {QK_MIDI_NOTE_D_SHARP_2, "QK_MIDI_NOTE_D_SHARP_2"}, + {QK_MIDI_NOTE_E_2, "QK_MIDI_NOTE_E_2"}, + {QK_MIDI_NOTE_F_2, "QK_MIDI_NOTE_F_2"}, + {QK_MIDI_NOTE_F_SHARP_2, "QK_MIDI_NOTE_F_SHARP_2"}, + {QK_MIDI_NOTE_G_2, "QK_MIDI_NOTE_G_2"}, + {QK_MIDI_NOTE_G_SHARP_2, "QK_MIDI_NOTE_G_SHARP_2"}, + {QK_MIDI_NOTE_A_2, "QK_MIDI_NOTE_A_2"}, + {QK_MIDI_NOTE_A_SHARP_2, "QK_MIDI_NOTE_A_SHARP_2"}, + {QK_MIDI_NOTE_B_2, "QK_MIDI_NOTE_B_2"}, + {QK_MIDI_NOTE_C_3, "QK_MIDI_NOTE_C_3"}, + {QK_MIDI_NOTE_C_SHARP_3, "QK_MIDI_NOTE_C_SHARP_3"}, + {QK_MIDI_NOTE_D_3, "QK_MIDI_NOTE_D_3"}, + {QK_MIDI_NOTE_D_SHARP_3, "QK_MIDI_NOTE_D_SHARP_3"}, + {QK_MIDI_NOTE_E_3, "QK_MIDI_NOTE_E_3"}, + {QK_MIDI_NOTE_F_3, "QK_MIDI_NOTE_F_3"}, + {QK_MIDI_NOTE_F_SHARP_3, "QK_MIDI_NOTE_F_SHARP_3"}, + {QK_MIDI_NOTE_G_3, "QK_MIDI_NOTE_G_3"}, + {QK_MIDI_NOTE_G_SHARP_3, "QK_MIDI_NOTE_G_SHARP_3"}, + {QK_MIDI_NOTE_A_3, "QK_MIDI_NOTE_A_3"}, + {QK_MIDI_NOTE_A_SHARP_3, "QK_MIDI_NOTE_A_SHARP_3"}, + {QK_MIDI_NOTE_B_3, "QK_MIDI_NOTE_B_3"}, + {QK_MIDI_NOTE_C_4, "QK_MIDI_NOTE_C_4"}, + {QK_MIDI_NOTE_C_SHARP_4, "QK_MIDI_NOTE_C_SHARP_4"}, + {QK_MIDI_NOTE_D_4, "QK_MIDI_NOTE_D_4"}, + {QK_MIDI_NOTE_D_SHARP_4, "QK_MIDI_NOTE_D_SHARP_4"}, + {QK_MIDI_NOTE_E_4, "QK_MIDI_NOTE_E_4"}, + {QK_MIDI_NOTE_F_4, "QK_MIDI_NOTE_F_4"}, + {QK_MIDI_NOTE_F_SHARP_4, "QK_MIDI_NOTE_F_SHARP_4"}, + {QK_MIDI_NOTE_G_4, "QK_MIDI_NOTE_G_4"}, + {QK_MIDI_NOTE_G_SHARP_4, "QK_MIDI_NOTE_G_SHARP_4"}, + {QK_MIDI_NOTE_A_4, "QK_MIDI_NOTE_A_4"}, + {QK_MIDI_NOTE_A_SHARP_4, "QK_MIDI_NOTE_A_SHARP_4"}, + {QK_MIDI_NOTE_B_4, "QK_MIDI_NOTE_B_4"}, + {QK_MIDI_NOTE_C_5, "QK_MIDI_NOTE_C_5"}, + {QK_MIDI_NOTE_C_SHARP_5, "QK_MIDI_NOTE_C_SHARP_5"}, + {QK_MIDI_NOTE_D_5, "QK_MIDI_NOTE_D_5"}, + {QK_MIDI_NOTE_D_SHARP_5, "QK_MIDI_NOTE_D_SHARP_5"}, + {QK_MIDI_NOTE_E_5, "QK_MIDI_NOTE_E_5"}, + {QK_MIDI_NOTE_F_5, "QK_MIDI_NOTE_F_5"}, + {QK_MIDI_NOTE_F_SHARP_5, "QK_MIDI_NOTE_F_SHARP_5"}, + {QK_MIDI_NOTE_G_5, "QK_MIDI_NOTE_G_5"}, + {QK_MIDI_NOTE_G_SHARP_5, "QK_MIDI_NOTE_G_SHARP_5"}, + {QK_MIDI_NOTE_A_5, "QK_MIDI_NOTE_A_5"}, + {QK_MIDI_NOTE_A_SHARP_5, "QK_MIDI_NOTE_A_SHARP_5"}, + {QK_MIDI_NOTE_B_5, "QK_MIDI_NOTE_B_5"}, + {QK_MIDI_OCTAVE_N2, "QK_MIDI_OCTAVE_N2"}, + {QK_MIDI_OCTAVE_N1, "QK_MIDI_OCTAVE_N1"}, + {QK_MIDI_OCTAVE_0, "QK_MIDI_OCTAVE_0"}, + {QK_MIDI_OCTAVE_1, "QK_MIDI_OCTAVE_1"}, + {QK_MIDI_OCTAVE_2, "QK_MIDI_OCTAVE_2"}, + {QK_MIDI_OCTAVE_3, "QK_MIDI_OCTAVE_3"}, + {QK_MIDI_OCTAVE_4, "QK_MIDI_OCTAVE_4"}, + {QK_MIDI_OCTAVE_5, "QK_MIDI_OCTAVE_5"}, + {QK_MIDI_OCTAVE_6, "QK_MIDI_OCTAVE_6"}, + {QK_MIDI_OCTAVE_7, "QK_MIDI_OCTAVE_7"}, + {QK_MIDI_OCTAVE_DOWN, "QK_MIDI_OCTAVE_DOWN"}, + {QK_MIDI_OCTAVE_UP, "QK_MIDI_OCTAVE_UP"}, + {QK_MIDI_TRANSPOSE_N6, "QK_MIDI_TRANSPOSE_N6"}, + {QK_MIDI_TRANSPOSE_N5, "QK_MIDI_TRANSPOSE_N5"}, + {QK_MIDI_TRANSPOSE_N4, "QK_MIDI_TRANSPOSE_N4"}, + {QK_MIDI_TRANSPOSE_N3, "QK_MIDI_TRANSPOSE_N3"}, + {QK_MIDI_TRANSPOSE_N2, "QK_MIDI_TRANSPOSE_N2"}, + {QK_MIDI_TRANSPOSE_N1, "QK_MIDI_TRANSPOSE_N1"}, + {QK_MIDI_TRANSPOSE_0, "QK_MIDI_TRANSPOSE_0"}, + {QK_MIDI_TRANSPOSE_1, "QK_MIDI_TRANSPOSE_1"}, + {QK_MIDI_TRANSPOSE_2, "QK_MIDI_TRANSPOSE_2"}, + {QK_MIDI_TRANSPOSE_3, "QK_MIDI_TRANSPOSE_3"}, + {QK_MIDI_TRANSPOSE_4, "QK_MIDI_TRANSPOSE_4"}, + {QK_MIDI_TRANSPOSE_5, "QK_MIDI_TRANSPOSE_5"}, + {QK_MIDI_TRANSPOSE_6, "QK_MIDI_TRANSPOSE_6"}, + {QK_MIDI_TRANSPOSE_DOWN, "QK_MIDI_TRANSPOSE_DOWN"}, + {QK_MIDI_TRANSPOSE_UP, "QK_MIDI_TRANSPOSE_UP"}, + {QK_MIDI_VELOCITY_0, "QK_MIDI_VELOCITY_0"}, + {QK_MIDI_VELOCITY_1, "QK_MIDI_VELOCITY_1"}, + {QK_MIDI_VELOCITY_2, "QK_MIDI_VELOCITY_2"}, + {QK_MIDI_VELOCITY_3, "QK_MIDI_VELOCITY_3"}, + {QK_MIDI_VELOCITY_4, "QK_MIDI_VELOCITY_4"}, + {QK_MIDI_VELOCITY_5, "QK_MIDI_VELOCITY_5"}, + {QK_MIDI_VELOCITY_6, "QK_MIDI_VELOCITY_6"}, + {QK_MIDI_VELOCITY_7, "QK_MIDI_VELOCITY_7"}, + {QK_MIDI_VELOCITY_8, "QK_MIDI_VELOCITY_8"}, + {QK_MIDI_VELOCITY_9, "QK_MIDI_VELOCITY_9"}, + {QK_MIDI_VELOCITY_10, "QK_MIDI_VELOCITY_10"}, + {QK_MIDI_VELOCITY_DOWN, "QK_MIDI_VELOCITY_DOWN"}, + {QK_MIDI_VELOCITY_UP, "QK_MIDI_VELOCITY_UP"}, + {QK_MIDI_CHANNEL_1, "QK_MIDI_CHANNEL_1"}, + {QK_MIDI_CHANNEL_2, "QK_MIDI_CHANNEL_2"}, + {QK_MIDI_CHANNEL_3, "QK_MIDI_CHANNEL_3"}, + {QK_MIDI_CHANNEL_4, "QK_MIDI_CHANNEL_4"}, + {QK_MIDI_CHANNEL_5, "QK_MIDI_CHANNEL_5"}, + {QK_MIDI_CHANNEL_6, "QK_MIDI_CHANNEL_6"}, + {QK_MIDI_CHANNEL_7, "QK_MIDI_CHANNEL_7"}, + {QK_MIDI_CHANNEL_8, "QK_MIDI_CHANNEL_8"}, + {QK_MIDI_CHANNEL_9, "QK_MIDI_CHANNEL_9"}, + {QK_MIDI_CHANNEL_10, "QK_MIDI_CHANNEL_10"}, + {QK_MIDI_CHANNEL_11, "QK_MIDI_CHANNEL_11"}, + {QK_MIDI_CHANNEL_12, "QK_MIDI_CHANNEL_12"}, + {QK_MIDI_CHANNEL_13, "QK_MIDI_CHANNEL_13"}, + {QK_MIDI_CHANNEL_14, "QK_MIDI_CHANNEL_14"}, + {QK_MIDI_CHANNEL_15, "QK_MIDI_CHANNEL_15"}, + {QK_MIDI_CHANNEL_16, "QK_MIDI_CHANNEL_16"}, + {QK_MIDI_CHANNEL_DOWN, "QK_MIDI_CHANNEL_DOWN"}, + {QK_MIDI_CHANNEL_UP, "QK_MIDI_CHANNEL_UP"}, + {QK_MIDI_ALL_NOTES_OFF, "QK_MIDI_ALL_NOTES_OFF"}, + {QK_MIDI_SUSTAIN, "QK_MIDI_SUSTAIN"}, + {QK_MIDI_PORTAMENTO, "QK_MIDI_PORTAMENTO"}, + {QK_MIDI_SOSTENUTO, "QK_MIDI_SOSTENUTO"}, + {QK_MIDI_SOFT, "QK_MIDI_SOFT"}, + {QK_MIDI_LEGATO, "QK_MIDI_LEGATO"}, + {QK_MIDI_MODULATION, "QK_MIDI_MODULATION"}, + {QK_MIDI_MODULATION_SPEED_DOWN, "QK_MIDI_MODULATION_SPEED_DOWN"}, + {QK_MIDI_MODULATION_SPEED_UP, "QK_MIDI_MODULATION_SPEED_UP"}, + {QK_MIDI_PITCH_BEND_DOWN, "QK_MIDI_PITCH_BEND_DOWN"}, + {QK_MIDI_PITCH_BEND_UP, "QK_MIDI_PITCH_BEND_UP"}, + {SQ_ON, "SQ_ON"}, + {SQ_OFF, "SQ_OFF"}, + {SQ_TOG, "SQ_TOG"}, + {SQ_TMPD, "SQ_TMPD"}, + {SQ_TMPU, "SQ_TMPU"}, + {SQ_RESD, "SQ_RESD"}, + {SQ_RESU, "SQ_RESU"}, + {SQ_SALL, "SQ_SALL"}, + {SQ_SCLR, "SQ_SCLR"}, + {QK_JOYSTICK_BUTTON_0, "QK_JOYSTICK_BUTTON_0"}, + {QK_JOYSTICK_BUTTON_1, "QK_JOYSTICK_BUTTON_1"}, + {QK_JOYSTICK_BUTTON_2, "QK_JOYSTICK_BUTTON_2"}, + {QK_JOYSTICK_BUTTON_3, "QK_JOYSTICK_BUTTON_3"}, + {QK_JOYSTICK_BUTTON_4, "QK_JOYSTICK_BUTTON_4"}, + {QK_JOYSTICK_BUTTON_5, "QK_JOYSTICK_BUTTON_5"}, + {QK_JOYSTICK_BUTTON_6, "QK_JOYSTICK_BUTTON_6"}, + {QK_JOYSTICK_BUTTON_7, "QK_JOYSTICK_BUTTON_7"}, + {QK_JOYSTICK_BUTTON_8, "QK_JOYSTICK_BUTTON_8"}, + {QK_JOYSTICK_BUTTON_9, "QK_JOYSTICK_BUTTON_9"}, + {QK_JOYSTICK_BUTTON_10, "QK_JOYSTICK_BUTTON_10"}, + {QK_JOYSTICK_BUTTON_11, "QK_JOYSTICK_BUTTON_11"}, + {QK_JOYSTICK_BUTTON_12, "QK_JOYSTICK_BUTTON_12"}, + {QK_JOYSTICK_BUTTON_13, "QK_JOYSTICK_BUTTON_13"}, + {QK_JOYSTICK_BUTTON_14, "QK_JOYSTICK_BUTTON_14"}, + {QK_JOYSTICK_BUTTON_15, "QK_JOYSTICK_BUTTON_15"}, + {QK_JOYSTICK_BUTTON_16, "QK_JOYSTICK_BUTTON_16"}, + {QK_JOYSTICK_BUTTON_17, "QK_JOYSTICK_BUTTON_17"}, + {QK_JOYSTICK_BUTTON_18, "QK_JOYSTICK_BUTTON_18"}, + {QK_JOYSTICK_BUTTON_19, "QK_JOYSTICK_BUTTON_19"}, + {QK_JOYSTICK_BUTTON_20, "QK_JOYSTICK_BUTTON_20"}, + {QK_JOYSTICK_BUTTON_21, "QK_JOYSTICK_BUTTON_21"}, + {QK_JOYSTICK_BUTTON_22, "QK_JOYSTICK_BUTTON_22"}, + {QK_JOYSTICK_BUTTON_23, "QK_JOYSTICK_BUTTON_23"}, + {QK_JOYSTICK_BUTTON_24, "QK_JOYSTICK_BUTTON_24"}, + {QK_JOYSTICK_BUTTON_25, "QK_JOYSTICK_BUTTON_25"}, + {QK_JOYSTICK_BUTTON_26, "QK_JOYSTICK_BUTTON_26"}, + {QK_JOYSTICK_BUTTON_27, "QK_JOYSTICK_BUTTON_27"}, + {QK_JOYSTICK_BUTTON_28, "QK_JOYSTICK_BUTTON_28"}, + {QK_JOYSTICK_BUTTON_29, "QK_JOYSTICK_BUTTON_29"}, + {QK_JOYSTICK_BUTTON_30, "QK_JOYSTICK_BUTTON_30"}, + {QK_JOYSTICK_BUTTON_31, "QK_JOYSTICK_BUTTON_31"}, + {QK_PROGRAMMABLE_BUTTON_1, "QK_PROGRAMMABLE_BUTTON_1"}, + {QK_PROGRAMMABLE_BUTTON_2, "QK_PROGRAMMABLE_BUTTON_2"}, + {QK_PROGRAMMABLE_BUTTON_3, "QK_PROGRAMMABLE_BUTTON_3"}, + {QK_PROGRAMMABLE_BUTTON_4, "QK_PROGRAMMABLE_BUTTON_4"}, + {QK_PROGRAMMABLE_BUTTON_5, "QK_PROGRAMMABLE_BUTTON_5"}, + {QK_PROGRAMMABLE_BUTTON_6, "QK_PROGRAMMABLE_BUTTON_6"}, + {QK_PROGRAMMABLE_BUTTON_7, "QK_PROGRAMMABLE_BUTTON_7"}, + {QK_PROGRAMMABLE_BUTTON_8, "QK_PROGRAMMABLE_BUTTON_8"}, + {QK_PROGRAMMABLE_BUTTON_9, "QK_PROGRAMMABLE_BUTTON_9"}, + {QK_PROGRAMMABLE_BUTTON_10, "QK_PROGRAMMABLE_BUTTON_10"}, + {QK_PROGRAMMABLE_BUTTON_11, "QK_PROGRAMMABLE_BUTTON_11"}, + {QK_PROGRAMMABLE_BUTTON_12, "QK_PROGRAMMABLE_BUTTON_12"}, + {QK_PROGRAMMABLE_BUTTON_13, "QK_PROGRAMMABLE_BUTTON_13"}, + {QK_PROGRAMMABLE_BUTTON_14, "QK_PROGRAMMABLE_BUTTON_14"}, + {QK_PROGRAMMABLE_BUTTON_15, "QK_PROGRAMMABLE_BUTTON_15"}, + {QK_PROGRAMMABLE_BUTTON_16, "QK_PROGRAMMABLE_BUTTON_16"}, + {QK_PROGRAMMABLE_BUTTON_17, "QK_PROGRAMMABLE_BUTTON_17"}, + {QK_PROGRAMMABLE_BUTTON_18, "QK_PROGRAMMABLE_BUTTON_18"}, + {QK_PROGRAMMABLE_BUTTON_19, "QK_PROGRAMMABLE_BUTTON_19"}, + {QK_PROGRAMMABLE_BUTTON_20, "QK_PROGRAMMABLE_BUTTON_20"}, + {QK_PROGRAMMABLE_BUTTON_21, "QK_PROGRAMMABLE_BUTTON_21"}, + {QK_PROGRAMMABLE_BUTTON_22, "QK_PROGRAMMABLE_BUTTON_22"}, + {QK_PROGRAMMABLE_BUTTON_23, "QK_PROGRAMMABLE_BUTTON_23"}, + {QK_PROGRAMMABLE_BUTTON_24, "QK_PROGRAMMABLE_BUTTON_24"}, + {QK_PROGRAMMABLE_BUTTON_25, "QK_PROGRAMMABLE_BUTTON_25"}, + {QK_PROGRAMMABLE_BUTTON_26, "QK_PROGRAMMABLE_BUTTON_26"}, + {QK_PROGRAMMABLE_BUTTON_27, "QK_PROGRAMMABLE_BUTTON_27"}, + {QK_PROGRAMMABLE_BUTTON_28, "QK_PROGRAMMABLE_BUTTON_28"}, + {QK_PROGRAMMABLE_BUTTON_29, "QK_PROGRAMMABLE_BUTTON_29"}, + {QK_PROGRAMMABLE_BUTTON_30, "QK_PROGRAMMABLE_BUTTON_30"}, + {QK_PROGRAMMABLE_BUTTON_31, "QK_PROGRAMMABLE_BUTTON_31"}, + {QK_PROGRAMMABLE_BUTTON_32, "QK_PROGRAMMABLE_BUTTON_32"}, + {QK_AUDIO_ON, "QK_AUDIO_ON"}, + {QK_AUDIO_OFF, "QK_AUDIO_OFF"}, + {QK_AUDIO_TOGGLE, "QK_AUDIO_TOGGLE"}, + {QK_AUDIO_CLICKY_TOGGLE, "QK_AUDIO_CLICKY_TOGGLE"}, + {QK_AUDIO_CLICKY_ON, "QK_AUDIO_CLICKY_ON"}, + {QK_AUDIO_CLICKY_OFF, "QK_AUDIO_CLICKY_OFF"}, + {QK_AUDIO_CLICKY_UP, "QK_AUDIO_CLICKY_UP"}, + {QK_AUDIO_CLICKY_DOWN, "QK_AUDIO_CLICKY_DOWN"}, + {QK_AUDIO_CLICKY_RESET, "QK_AUDIO_CLICKY_RESET"}, + {QK_MUSIC_ON, "QK_MUSIC_ON"}, + {QK_MUSIC_OFF, "QK_MUSIC_OFF"}, + {QK_MUSIC_TOGGLE, "QK_MUSIC_TOGGLE"}, + {QK_MUSIC_MODE_NEXT, "QK_MUSIC_MODE_NEXT"}, + {QK_AUDIO_VOICE_NEXT, "QK_AUDIO_VOICE_NEXT"}, + {QK_AUDIO_VOICE_PREVIOUS, "QK_AUDIO_VOICE_PREVIOUS"}, + {QK_STENO_BOLT, "QK_STENO_BOLT"}, + {QK_STENO_GEMINI, "QK_STENO_GEMINI"}, + {QK_STENO_COMB, "QK_STENO_COMB"}, + {QK_STENO_COMB_MAX, "QK_STENO_COMB_MAX"}, + {QK_MACRO_0, "QK_MACRO_0"}, + {QK_MACRO_1, "QK_MACRO_1"}, + {QK_MACRO_2, "QK_MACRO_2"}, + {QK_MACRO_3, "QK_MACRO_3"}, + {QK_MACRO_4, "QK_MACRO_4"}, + {QK_MACRO_5, "QK_MACRO_5"}, + {QK_MACRO_6, "QK_MACRO_6"}, + {QK_MACRO_7, "QK_MACRO_7"}, + {QK_MACRO_8, "QK_MACRO_8"}, + {QK_MACRO_9, "QK_MACRO_9"}, + {QK_MACRO_10, "QK_MACRO_10"}, + {QK_MACRO_11, "QK_MACRO_11"}, + {QK_MACRO_12, "QK_MACRO_12"}, + {QK_MACRO_13, "QK_MACRO_13"}, + {QK_MACRO_14, "QK_MACRO_14"}, + {QK_MACRO_15, "QK_MACRO_15"}, + {QK_MACRO_16, "QK_MACRO_16"}, + {QK_MACRO_17, "QK_MACRO_17"}, + {QK_MACRO_18, "QK_MACRO_18"}, + {QK_MACRO_19, "QK_MACRO_19"}, + {QK_MACRO_20, "QK_MACRO_20"}, + {QK_MACRO_21, "QK_MACRO_21"}, + {QK_MACRO_22, "QK_MACRO_22"}, + {QK_MACRO_23, "QK_MACRO_23"}, + {QK_MACRO_24, "QK_MACRO_24"}, + {QK_MACRO_25, "QK_MACRO_25"}, + {QK_MACRO_26, "QK_MACRO_26"}, + {QK_MACRO_27, "QK_MACRO_27"}, + {QK_MACRO_28, "QK_MACRO_28"}, + {QK_MACRO_29, "QK_MACRO_29"}, + {QK_MACRO_30, "QK_MACRO_30"}, + {QK_MACRO_31, "QK_MACRO_31"}, + {QK_BACKLIGHT_ON, "QK_BACKLIGHT_ON"}, + {QK_BACKLIGHT_OFF, "QK_BACKLIGHT_OFF"}, + {QK_BACKLIGHT_TOGGLE, "QK_BACKLIGHT_TOGGLE"}, + {QK_BACKLIGHT_DOWN, "QK_BACKLIGHT_DOWN"}, + {QK_BACKLIGHT_UP, "QK_BACKLIGHT_UP"}, + {QK_BACKLIGHT_STEP, "QK_BACKLIGHT_STEP"}, + {QK_BACKLIGHT_TOGGLE_BREATHING, "QK_BACKLIGHT_TOGGLE_BREATHING"}, + {RGB_TOG, "RGB_TOG"}, + {RGB_MODE_FORWARD, "RGB_MODE_FORWARD"}, + {RGB_MODE_REVERSE, "RGB_MODE_REVERSE"}, + {RGB_HUI, "RGB_HUI"}, + {RGB_HUD, "RGB_HUD"}, + {RGB_SAI, "RGB_SAI"}, + {RGB_SAD, "RGB_SAD"}, + {RGB_VAI, "RGB_VAI"}, + {RGB_VAD, "RGB_VAD"}, + {RGB_SPI, "RGB_SPI"}, + {RGB_SPD, "RGB_SPD"}, + {RGB_MODE_PLAIN, "RGB_MODE_PLAIN"}, + {RGB_MODE_BREATHE, "RGB_MODE_BREATHE"}, + {RGB_MODE_RAINBOW, "RGB_MODE_RAINBOW"}, + {RGB_MODE_SWIRL, "RGB_MODE_SWIRL"}, + {RGB_MODE_SNAKE, "RGB_MODE_SNAKE"}, + {RGB_MODE_KNIGHT, "RGB_MODE_KNIGHT"}, + {RGB_MODE_XMAS, "RGB_MODE_XMAS"}, + {RGB_MODE_GRADIENT, "RGB_MODE_GRADIENT"}, + {RGB_MODE_RGBTEST, "RGB_MODE_RGBTEST"}, + {RGB_MODE_TWINKLE, "RGB_MODE_TWINKLE"}, + {QK_BOOTLOADER, "QK_BOOTLOADER"}, + {QK_REBOOT, "QK_REBOOT"}, + {QK_DEBUG_TOGGLE, "QK_DEBUG_TOGGLE"}, + {QK_CLEAR_EEPROM, "QK_CLEAR_EEPROM"}, + {QK_MAKE, "QK_MAKE"}, + {QK_AUTO_SHIFT_DOWN, "QK_AUTO_SHIFT_DOWN"}, + {QK_AUTO_SHIFT_UP, "QK_AUTO_SHIFT_UP"}, + {QK_AUTO_SHIFT_REPORT, "QK_AUTO_SHIFT_REPORT"}, + {QK_AUTO_SHIFT_ON, "QK_AUTO_SHIFT_ON"}, + {QK_AUTO_SHIFT_OFF, "QK_AUTO_SHIFT_OFF"}, + {QK_AUTO_SHIFT_TOGGLE, "QK_AUTO_SHIFT_TOGGLE"}, + {QK_GRAVE_ESCAPE, "QK_GRAVE_ESCAPE"}, + {QK_VELOCIKEY_TOGGLE, "QK_VELOCIKEY_TOGGLE"}, + {QK_SPACE_CADET_LEFT_CTRL_PARENTHESIS_OPEN, "QK_SPACE_CADET_LEFT_CTRL_PARENTHESIS_OPEN"}, + {QK_SPACE_CADET_RIGHT_CTRL_PARENTHESIS_CLOSE, "QK_SPACE_CADET_RIGHT_CTRL_PARENTHESIS_CLOSE"}, + {QK_SPACE_CADET_LEFT_SHIFT_PARENTHESIS_OPEN, "QK_SPACE_CADET_LEFT_SHIFT_PARENTHESIS_OPEN"}, + {QK_SPACE_CADET_RIGHT_SHIFT_PARENTHESIS_CLOSE, "QK_SPACE_CADET_RIGHT_SHIFT_PARENTHESIS_CLOSE"}, + {QK_SPACE_CADET_LEFT_ALT_PARENTHESIS_OPEN, "QK_SPACE_CADET_LEFT_ALT_PARENTHESIS_OPEN"}, + {QK_SPACE_CADET_RIGHT_ALT_PARENTHESIS_CLOSE, "QK_SPACE_CADET_RIGHT_ALT_PARENTHESIS_CLOSE"}, + {QK_SPACE_CADET_RIGHT_SHIFT_ENTER, "QK_SPACE_CADET_RIGHT_SHIFT_ENTER"}, + {QK_OUTPUT_AUTO, "QK_OUTPUT_AUTO"}, + {QK_OUTPUT_USB, "QK_OUTPUT_USB"}, + {QK_OUTPUT_BLUETOOTH, "QK_OUTPUT_BLUETOOTH"}, + {QK_UNICODE_MODE_NEXT, "QK_UNICODE_MODE_NEXT"}, + {QK_UNICODE_MODE_PREVIOUS, "QK_UNICODE_MODE_PREVIOUS"}, + {QK_UNICODE_MODE_MACOS, "QK_UNICODE_MODE_MACOS"}, + {QK_UNICODE_MODE_LINUX, "QK_UNICODE_MODE_LINUX"}, + {QK_UNICODE_MODE_WINDOWS, "QK_UNICODE_MODE_WINDOWS"}, + {QK_UNICODE_MODE_BSD, "QK_UNICODE_MODE_BSD"}, + {QK_UNICODE_MODE_WINCOMPOSE, "QK_UNICODE_MODE_WINCOMPOSE"}, + {QK_UNICODE_MODE_EMACS, "QK_UNICODE_MODE_EMACS"}, + {QK_HAPTIC_ON, "QK_HAPTIC_ON"}, + {QK_HAPTIC_OFF, "QK_HAPTIC_OFF"}, + {QK_HAPTIC_TOGGLE, "QK_HAPTIC_TOGGLE"}, + {QK_HAPTIC_RESET, "QK_HAPTIC_RESET"}, + {QK_HAPTIC_FEEDBACK_TOGGLE, "QK_HAPTIC_FEEDBACK_TOGGLE"}, + {QK_HAPTIC_BUZZ_TOGGLE, "QK_HAPTIC_BUZZ_TOGGLE"}, + {QK_HAPTIC_MODE_NEXT, "QK_HAPTIC_MODE_NEXT"}, + {QK_HAPTIC_MODE_PREVIOUS, "QK_HAPTIC_MODE_PREVIOUS"}, + {QK_HAPTIC_CONTINUOUS_TOGGLE, "QK_HAPTIC_CONTINUOUS_TOGGLE"}, + {QK_HAPTIC_CONTINUOUS_UP, "QK_HAPTIC_CONTINUOUS_UP"}, + {QK_HAPTIC_CONTINUOUS_DOWN, "QK_HAPTIC_CONTINUOUS_DOWN"}, + {QK_HAPTIC_DWELL_UP, "QK_HAPTIC_DWELL_UP"}, + {QK_HAPTIC_DWELL_DOWN, "QK_HAPTIC_DWELL_DOWN"}, + {QK_COMBO_ON, "QK_COMBO_ON"}, + {QK_COMBO_OFF, "QK_COMBO_OFF"}, + {QK_COMBO_TOGGLE, "QK_COMBO_TOGGLE"}, + {QK_DYNAMIC_MACRO_RECORD_START_1, "QK_DYNAMIC_MACRO_RECORD_START_1"}, + {QK_DYNAMIC_MACRO_RECORD_START_2, "QK_DYNAMIC_MACRO_RECORD_START_2"}, + {QK_DYNAMIC_MACRO_RECORD_STOP, "QK_DYNAMIC_MACRO_RECORD_STOP"}, + {QK_DYNAMIC_MACRO_PLAY_1, "QK_DYNAMIC_MACRO_PLAY_1"}, + {QK_DYNAMIC_MACRO_PLAY_2, "QK_DYNAMIC_MACRO_PLAY_2"}, + {QK_LEADER, "QK_LEADER"}, + {QK_LOCK, "QK_LOCK"}, + {QK_ONE_SHOT_ON, "QK_ONE_SHOT_ON"}, + {QK_ONE_SHOT_OFF, "QK_ONE_SHOT_OFF"}, + {QK_ONE_SHOT_TOGGLE, "QK_ONE_SHOT_TOGGLE"}, + {QK_KEY_OVERRIDE_TOGGLE, "QK_KEY_OVERRIDE_TOGGLE"}, + {QK_KEY_OVERRIDE_ON, "QK_KEY_OVERRIDE_ON"}, + {QK_KEY_OVERRIDE_OFF, "QK_KEY_OVERRIDE_OFF"}, + {QK_SECURE_LOCK, "QK_SECURE_LOCK"}, + {QK_SECURE_UNLOCK, "QK_SECURE_UNLOCK"}, + {QK_SECURE_TOGGLE, "QK_SECURE_TOGGLE"}, + {QK_SECURE_REQUEST, "QK_SECURE_REQUEST"}, + {QK_DYNAMIC_TAPPING_TERM_PRINT, "QK_DYNAMIC_TAPPING_TERM_PRINT"}, + {QK_DYNAMIC_TAPPING_TERM_UP, "QK_DYNAMIC_TAPPING_TERM_UP"}, + {QK_DYNAMIC_TAPPING_TERM_DOWN, "QK_DYNAMIC_TAPPING_TERM_DOWN"}, + {QK_CAPS_WORD_TOGGLE, "QK_CAPS_WORD_TOGGLE"}, + {QK_AUTOCORRECT_ON, "QK_AUTOCORRECT_ON"}, + {QK_AUTOCORRECT_OFF, "QK_AUTOCORRECT_OFF"}, + {QK_AUTOCORRECT_TOGGLE, "QK_AUTOCORRECT_TOGGLE"}, + {SAFE_RANGE, "SAFE_RANGE"}, +}; diff --git a/tests/test_common/keycode_util.cpp b/tests/test_common/keycode_util.cpp new file mode 100644 index 0000000000..9f88d40ec7 --- /dev/null +++ b/tests/test_common/keycode_util.cpp @@ -0,0 +1,128 @@ +#include "keycode_util.hpp" +#include <cstdint> +extern "C" { +#include "action_code.h" +#include "keycode.h" +#include "quantum_keycodes.h" +#include "util.h" +} +#include <string> +#include <iomanip> +#include <map> + +extern std::map<uint16_t, std::string> KEYCODE_ID_TABLE; + +std::string get_mods(uint8_t mods) { + std::stringstream s; + if ((mods & MOD_RCTL) == MOD_RCTL) { + s << XSTR(MOD_RCTL) << " | "; + } else if ((mods & MOD_LCTL) == MOD_LCTL) { + s << XSTR(MOD_LCTL) << " | "; + } + + if ((mods & MOD_RSFT) == MOD_RSFT) { + s << XSTR(MOD_RSFT) << " | "; + } else if ((mods & MOD_LSFT) == MOD_LSFT) { + s << XSTR(MOD_LSFT) << " | "; + } + + if ((mods & MOD_RALT) == MOD_RALT) { + s << XSTR(MOD_RALT) << " | "; + } else if ((mods & MOD_LALT) == MOD_LALT) { + s << XSTR(MOD_LALT) << " | "; + } + + if ((mods & MOD_RGUI) == MOD_RGUI) { + s << XSTR(MOD_RGUI) << " | "; + } else if ((mods & MOD_LGUI) == MOD_LGUI) { + s << XSTR(MOD_LGUI) << " | "; + } + + auto _mods = s.str(); + + if (_mods.size()) { + _mods.resize(_mods.size() - 3); + } + + return std::string(_mods); +} + +std::string get_qk_mods(uint16_t keycode) { + std::stringstream s; + if ((keycode & QK_RCTL) == QK_RCTL) { + s << XSTR(QK_RCTL) << " | "; + } else if ((keycode & QK_LCTL) == QK_LCTL) { + s << XSTR(QK_LCTL) << " | "; + } + + if ((keycode & QK_RSFT) == QK_RSFT) { + s << XSTR(QK_RSFT) << " | "; + } else if ((keycode & QK_LSFT) == QK_LSFT) { + s << XSTR(QK_LSFT) << " | "; + } + + if ((keycode & QK_RALT) == QK_RALT) { + s << XSTR(QK_RALT) << " | "; + } else if ((keycode & QK_LALT) == QK_LALT) { + s << XSTR(QK_LALT) << " | "; + } + + if ((keycode & QK_RGUI) == QK_RGUI) { + s << XSTR(QK_RGUI) << " | "; + } else if ((keycode & QK_LGUI) == QK_LGUI) { + s << XSTR(QK_LGUI) << " | "; + } + + auto _mods = s.str(); + + if (_mods.size()) { + _mods.resize(_mods.size() - 3); + } + + return std::string(_mods); +} + +std::string generate_identifier(uint16_t kc) { + std::stringstream s; + if (IS_QK_MOD_TAP(kc)) { + s << "MT(" << get_mods(QK_MOD_TAP_GET_MODS(kc)) << ", " << KEYCODE_ID_TABLE.at(kc & 0xFF) << ")"; + } else if (IS_QK_LAYER_TAP(kc)) { + s << "LT(" << +QK_LAYER_TAP_GET_LAYER(kc) << ", " << KEYCODE_ID_TABLE.at(kc & 0xFF) << ")"; + } else if (IS_QK_TO(kc)) { + s << "TO(" << +QK_TO_GET_LAYER(kc) << ")"; + } else if (IS_QK_MOMENTARY(kc)) { + s << "MO(" << +QK_MOMENTARY_GET_LAYER(kc) << ")"; + } else if (IS_QK_DEF_LAYER(kc)) { + s << "DF(" << +QK_DEF_LAYER_GET_LAYER(kc) << ")"; + } else if (IS_QK_TOGGLE_LAYER(kc)) { + s << "TG(" << +QK_TOGGLE_LAYER_GET_LAYER(kc) << ")"; + } else if (IS_QK_LAYER_TAP_TOGGLE(kc)) { + s << "TT(" << +QK_LAYER_TAP_TOGGLE_GET_LAYER(kc) << ")"; + } else if (IS_QK_ONE_SHOT_LAYER(kc)) { + s << "OSL(" << +QK_ONE_SHOT_LAYER_GET_LAYER(kc) << ")"; + } else if (IS_QK_LAYER_MOD(kc)) { + s << "LM(" << +QK_LAYER_MOD_GET_LAYER(kc) << ", " << get_mods(QK_LAYER_MOD_GET_MODS(kc)) << ")"; + } else if (IS_QK_ONE_SHOT_MOD(kc)) { + s << "OSM(" << get_mods(QK_ONE_SHOT_MOD_GET_MODS(kc)) << ")"; + } else if (IS_QK_MODS(kc)) { + s << "QK_MODS(" << KEYCODE_ID_TABLE.at(QK_MODS_GET_BASIC_KEYCODE(kc)) << ", " << get_qk_mods(kc) << ")"; + } else if (IS_QK_TAP_DANCE(kc)) { + s << "TD(" << +(kc & 0xFF) << ")"; + } else { + // Fallback - we didn't found any matching keycode, generate the hex representation. + s << "unknown keycode: 0x" << std::hex << kc << ". Add conversion to " << XSTR(generate_identifier); + } + + return std::string(s.str()); +} + +std::string get_keycode_identifier_or_default(uint16_t keycode) { + auto identifier = KEYCODE_ID_TABLE.find(keycode); + if (identifier != KEYCODE_ID_TABLE.end()) { + return identifier->second; + } + + KEYCODE_ID_TABLE[keycode] = generate_identifier(keycode); + + return KEYCODE_ID_TABLE[keycode]; +} diff --git a/tests/test_common/keycode_util.hpp b/tests/test_common/keycode_util.hpp new file mode 100644 index 0000000000..d5a520d4b2 --- /dev/null +++ b/tests/test_common/keycode_util.hpp @@ -0,0 +1,5 @@ +#pragma once + +#include <string> + +std::string get_keycode_identifier_or_default(uint16_t keycode); diff --git a/tests/test_common/matrix.c b/tests/test_common/matrix.c index 7b24d560e3..45e76d32c5 100644 --- a/tests/test_common/matrix.c +++ b/tests/test_common/matrix.c @@ -41,11 +41,15 @@ void matrix_init_kb(void) {} void matrix_scan_kb(void) {} void press_key(uint8_t col, uint8_t row) { - matrix[row] |= 1 << col; + matrix[row] |= (matrix_row_t)1 << col; } void release_key(uint8_t col, uint8_t row) { - matrix[row] &= ~(1 << col); + matrix[row] &= ~((matrix_row_t)1 << col); +} + +bool matrix_is_on(uint8_t row, uint8_t col) { + return (matrix[row] & ((matrix_row_t)1 << col)); } void clear_all_keys(void) { diff --git a/tests/test_common/test_common.hpp b/tests/test_common/test_common.hpp index a88fa8d7b8..295a6083cd 100644 --- a/tests/test_common/test_common.hpp +++ b/tests/test_common/test_common.hpp @@ -22,5 +22,6 @@ extern "C" { } #include "test_driver.hpp" #include "test_matrix.h" +#include "test_keymap_key.hpp" #include "keyboard_report_util.hpp" #include "test_fixture.hpp" diff --git a/tests/test_common/test_driver.hpp b/tests/test_common/test_driver.hpp index 982aec6c83..8d09e44840 100644 --- a/tests/test_common/test_driver.hpp +++ b/tests/test_common/test_driver.hpp @@ -98,6 +98,12 @@ class TestDriver { */ #define EXPECT_NO_REPORT(driver) EXPECT_ANY_REPORT(driver).Times(0) +/** + * @brief Verify and clear all gmock expectations that have been setup until + * this point. + */ +#define VERIFY_AND_CLEAR(driver) testing::Mock::VerifyAndClearExpectations(&driver) + namespace internal { void expect_unicode_code_point(TestDriver& driver, uint32_t code_point); } // namespace internal diff --git a/tests/test_common/test_fixture.cpp b/tests/test_common/test_fixture.cpp index 44694cd390..76daa625ad 100644 --- a/tests/test_common/test_fixture.cpp +++ b/tests/test_common/test_fixture.cpp @@ -12,6 +12,7 @@ #include "test_logger.hpp" #include "test_matrix.h" #include "test_keymap_key.hpp" +#include "timer.h" extern "C" { #include "action.h" @@ -41,7 +42,7 @@ extern "C" uint16_t keymap_key_to_keycode(uint8_t layer, keypos_t position) { } void TestFixture::SetUpTestCase() { - test_logger.info() << "TestFixture setup-up start." << std::endl; + test_logger.info() << "test fixture setup-up start." << std::endl; // The following is enough to bootstrap the values set in main eeconfig_init_quantum(); @@ -50,17 +51,19 @@ void TestFixture::SetUpTestCase() { TestDriver driver; keyboard_init(); - test_logger.info() << "TestFixture setup-up end." << std::endl; + test_logger.info() << "test fixture setup-up end." << std::endl; } void TestFixture::TearDownTestCase() {} TestFixture::TestFixture() { m_this = this; + timer_clear(); + test_logger.info() << "tapping term is " << +GET_TAPPING_TERM(KC_TRANSPARENT, &(keyrecord_t){}) << "ms" << std::endl; } TestFixture::~TestFixture() { - test_logger.info() << "TestFixture clean-up start." << std::endl; + test_logger.info() << "test fixture clean-up start." << std::endl; TestDriver driver; /* Reset keyboard state. */ @@ -79,23 +82,21 @@ TestFixture::~TestFixture() { #endif idle_for(TAPPING_TERM * 10); - testing::Mock::VerifyAndClearExpectations(&driver); + VERIFY_AND_CLEAR(driver); /* Verify that the matrix really is cleared */ EXPECT_NO_REPORT(driver); idle_for(TAPPING_TERM * 10); - testing::Mock::VerifyAndClearExpectations(&driver); - + VERIFY_AND_CLEAR(driver); m_this = nullptr; - test_logger.info() << "TestFixture clean-up end." << std::endl; - + test_logger.info() << "test fixture clean-up end." << std::endl; print_test_log(); } void TestFixture::add_key(KeymapKey key) { if (this->find_key(key.layer, key.position)) { - FAIL() << "Key is already mapped for layer " << +key.layer << " and (column,row) (" << +key.position.col << "," << +key.position.row << ")"; + FAIL() << "key is already mapped for layer " << +key.layer << " and (column,row) (" << +key.position.col << "," << +key.position.row << ")"; } this->keymap.push_back(key); @@ -149,7 +150,7 @@ void TestFixture::get_keycode(const layer_t layer, const keypos_t position, uint /* See if this is done in hardware as well, because this is 100% out of bounds reads on all QMK keebs out there. */ auto msg = [&]() { std::stringstream msg; - msg << "Keycode for position (" << +position.col << "," << +position.row << ") requested! This is out of bounds." << std::endl; + msg << "keycode for position (" << +position.col << "," << +position.row << ") requested! This is out of bounds." << std::endl; return msg.str(); }(); @@ -164,17 +165,18 @@ void TestFixture::get_keycode(const layer_t layer, const keypos_t position, uint return; } - FAIL() << "No key is mapped for layer " << +layer << " and (column,row) " << +position.col << "," << +position.row << ")"; + FAIL() << "no key is mapped for layer " << +layer << " and (column,row) " << +position.col << "," << +position.row << ")"; } void TestFixture::run_one_scan_loop() { - keyboard_task(); - advance_time(1); + this->idle_for(1); } void TestFixture::idle_for(unsigned time) { + test_logger.trace() << +time << " keyboard task " << (time > 1 ? "loops" : "loop") << std::endl; for (unsigned i = 0; i < time; i++) { - run_one_scan_loop(); + keyboard_task(); + advance_time(1); } } @@ -182,12 +184,13 @@ void TestFixture::print_test_log() const { const ::testing::TestInfo* const test_info = ::testing::UnitTest::GetInstance()->current_test_info(); if (HasFailure()) { std::cerr << test_info->test_case_name() << "." << test_info->name() << " failed!" << std::endl; + test_logger.print_header(); test_logger.print_log(); } test_logger.reset(); } void TestFixture::expect_layer_state(layer_t layer_state) const { - test_logger.trace() << "Layer state: (" << +layer_state << ") Highest layer bit: (" << +get_highest_layer(layer_state) << ")" << std::endl; + test_logger.trace() << "layer state: (" << +layer_state << ") highest layer bit: (" << +get_highest_layer(layer_state) << ")" << std::endl; EXPECT_TRUE(layer_state_is(layer_state)); } diff --git a/tests/test_common/test_keymap_key.cpp b/tests/test_common/test_keymap_key.cpp index 878ae097bf..63ae29975b 100644 --- a/tests/test_common/test_keymap_key.cpp +++ b/tests/test_common/test_keymap_key.cpp @@ -15,16 +15,26 @@ */ #include "test_keymap_key.hpp" +#include <cstdint> +#include <ios> +#include "matrix.h" #include "test_logger.hpp" #include "gtest/gtest-message.h" #include "gtest/gtest.h" +#include "timer.h" void KeymapKey::press() { - test_logger.trace() << "Key pressed: (" << +this->position.col << "," << +this->position.row << ")" << std::endl; + EXPECT_FALSE(matrix_is_on(position.row, position.col)) << "tried to press key " << this->name << " that was already pressed! Check the test code." << std::endl; + press_key(this->position.col, this->position.row); + this->timestamp_pressed = timer_read32(); + test_logger.trace() << std::setw(10) << std::left << "pressed: " << this->name << std::endl; } void KeymapKey::release() { - test_logger.trace() << "Key released: (" << +this->position.col << "," << +this->position.row << ")" << std::endl; + EXPECT_TRUE(matrix_is_on(this->position.row, this->position.col)) << "tried to release key " << this->name << " that wasn't pressed before! Check the test code." << std::endl; + release_key(this->position.col, this->position.row); -}
\ No newline at end of file + uint32_t now = timer_read32(); + test_logger.trace() << std::setw(10) << std::left << "released: " << this->name << " was pressed for " << now - this->timestamp_pressed << "ms" << std::endl; +} diff --git a/tests/test_common/test_keymap_key.hpp b/tests/test_common/test_keymap_key.hpp index 7861cb4a32..37b4c827e4 100644 --- a/tests/test_common/test_keymap_key.hpp +++ b/tests/test_common/test_keymap_key.hpp @@ -16,6 +16,9 @@ #pragma once +#include <cstddef> +#include <string> +#include "keycode_util.hpp" extern "C" { #include "keyboard.h" #include "test_matrix.h" @@ -26,8 +29,13 @@ extern "C" { typedef uint8_t layer_t; struct KeymapKey { - KeymapKey(layer_t layer, uint8_t col, uint8_t row, uint16_t keycode) : layer(layer), position({.col = col, .row = row}), code(keycode), report_code(keycode) { validate(); } - KeymapKey(layer_t layer, uint8_t col, uint8_t row, uint16_t keycode, uint16_t report_code) : layer(layer), position({.col = col, .row = row}), code(keycode), report_code(report_code) { validate(); } + KeymapKey(layer_t layer, uint8_t col, uint8_t row, uint16_t keycode) : layer(layer), position({.col = col, .row = row}), code(keycode), report_code(keycode), name(get_keycode_identifier_or_default(keycode)) { + validate(); + } + + KeymapKey(layer_t layer, uint8_t col, uint8_t row, uint16_t keycode, uint16_t report_code) : layer(layer), position({.col = col, .row = row}), code(keycode), report_code(report_code), name{get_keycode_identifier_or_default(keycode)} { + validate(); + } void press(); void release(); @@ -35,6 +43,7 @@ struct KeymapKey { const layer_t layer; const keypos_t position; const uint16_t code; + std::string name; /* Sometimes the keycode does not match the code that is send in the usb report, so we provide it here. */ const uint16_t report_code; @@ -43,4 +52,5 @@ struct KeymapKey { assert(position.col <= MATRIX_COLS); assert(position.row <= MATRIX_ROWS); } -};
\ No newline at end of file + uint32_t timestamp_pressed; +}; diff --git a/tests/test_common/test_logger.cpp b/tests/test_common/test_logger.cpp index efc7719d13..0ff4e686ee 100644 --- a/tests/test_common/test_logger.cpp +++ b/tests/test_common/test_logger.cpp @@ -14,30 +14,40 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. */ +#include <iomanip> #include <iostream> #include "test_logger.hpp" +#include "timer.h" TestLogger test_logger; TestLogger& TestLogger::info() { *this << "[ INFO ] "; - return *this; + return this->timestamp(); } TestLogger& TestLogger::trace() { *this << "[ TRACE ] "; - return *this; + return this->timestamp(); } TestLogger& TestLogger::error() { *this << "[ ERROR ] "; - return *this; + return this->timestamp(); } +TestLogger& TestLogger::timestamp() { + *this << std::setw(6) << timer_read32() << " "; + return *this; +} void TestLogger::reset() { this->m_log.str(""); }; +void TestLogger::print_header() { + std::cerr << "[ LEVEL ] [TIME] [EVENT]" << std::endl; +} + void TestLogger::print_log() { std::cerr << this->m_log.str(); } diff --git a/tests/test_common/test_logger.hpp b/tests/test_common/test_logger.hpp index 348af7fab8..4964583ded 100644 --- a/tests/test_common/test_logger.hpp +++ b/tests/test_common/test_logger.hpp @@ -25,11 +25,13 @@ class TestLogger : public std::ostream { TestLogger& info(); TestLogger& trace(); TestLogger& error(); - void print_log(); - void reset(); + void print_log(); + void print_header(); + void reset(); private: + TestLogger& timestamp(); std::stringbuf m_log; }; -extern TestLogger test_logger;
\ No newline at end of file +extern TestLogger test_logger; diff --git a/tmk_core/protocol/chibios/usb_main.c b/tmk_core/protocol/chibios/usb_main.c index 62a11faff7..47edd7cb8c 100644 --- a/tmk_core/protocol/chibios/usb_main.c +++ b/tmk_core/protocol/chibios/usb_main.c @@ -76,12 +76,24 @@ static void keyboard_idle_timer_cb(void *arg); #endif report_keyboard_t keyboard_report_sent = {{0}}; -#ifdef MOUSE_ENABLE -report_mouse_t mouse_report_blank = {0}; -#endif /* MOUSE_ENABLE */ +report_mouse_t mouse_report_sent = {0}; + +union { + uint8_t report_id; + report_keyboard_t keyboard; #ifdef EXTRAKEY_ENABLE -uint8_t extra_report_blank[3] = {0}; -#endif /* EXTRAKEY_ENABLE */ + report_extra_t extra; +#endif +#ifdef MOUSE_ENABLE + report_mouse_t mouse; +#endif +#ifdef DIGITIZER_ENABLE + report_digitizer_t digitizer; +#endif +#ifdef JOYSTICK_ENABLE + joystick_report_t joystick; +#endif +} universal_report_blank = {0}; /* --------------------------------------------------------- * Descriptors and USB driver objects @@ -111,9 +123,10 @@ uint8_t extra_report_blank[3] = {0}; static const USBDescriptor *usb_get_descriptor_cb(USBDriver *usbp, uint8_t dtype, uint8_t dindex, uint16_t wIndex) { (void)usbp; static USBDescriptor desc; - uint16_t wValue = ((uint16_t)dtype << 8) | dindex; - desc.ud_string = NULL; - desc.ud_size = get_usb_descriptor(wValue, wIndex, (const void **const) & desc.ud_string); + uint16_t wValue = ((uint16_t)dtype << 8) | dindex; + uint16_t wLength = ((uint16_t)usbp->setup[7] << 8) | usbp->setup[6]; + desc.ud_string = NULL; + desc.ud_size = get_usb_descriptor(wValue, wIndex, wLength, (const void **const) & desc.ud_string); if (desc.ud_string == NULL) return NULL; else @@ -585,7 +598,8 @@ static uint16_t get_hword(uint8_t *p) { */ static uint8_t set_report_buf[2] __attribute__((aligned(4))); -static void set_led_transfer_cb(USBDriver *usbp) { + +static void set_led_transfer_cb(USBDriver *usbp) { if (usbp->setup[6] == 2) { /* LSB(wLength) */ uint8_t report_id = set_report_buf[0]; if ((report_id == REPORT_ID_KEYBOARD) || (report_id == REPORT_ID_NKRO)) { @@ -614,20 +628,38 @@ static bool usb_request_hook_cb(USBDriver *usbp) { switch (usbp->setup[1]) { /* bRequest */ case HID_GET_REPORT: switch (usbp->setup[4]) { /* LSB(wIndex) (check MSB==0?) */ +#ifndef KEYBOARD_SHARED_EP case KEYBOARD_INTERFACE: - usbSetupTransfer(usbp, (uint8_t *)&keyboard_report_sent, sizeof(keyboard_report_sent), NULL); + usbSetupTransfer(usbp, (uint8_t *)&keyboard_report_sent, KEYBOARD_REPORT_SIZE, NULL); return TRUE; break; - +#endif #if defined(MOUSE_ENABLE) && !defined(MOUSE_SHARED_EP) case MOUSE_INTERFACE: - usbSetupTransfer(usbp, (uint8_t *)&mouse_report_blank, sizeof(mouse_report_blank), NULL); + usbSetupTransfer(usbp, (uint8_t *)&mouse_report_sent, sizeof(mouse_report_sent), NULL); return TRUE; break; #endif - +#ifdef SHARED_EP_ENABLE + case SHARED_INTERFACE: +# ifdef KEYBOARD_SHARED_EP + if (usbp->setup[2] == REPORT_ID_KEYBOARD) { + usbSetupTransfer(usbp, (uint8_t *)&keyboard_report_sent, KEYBOARD_REPORT_SIZE, NULL); + return TRUE; + break; + } +# endif +# ifdef MOUSE_SHARED_EP + if (usbp->setup[2] == REPORT_ID_MOUSE) { + usbSetupTransfer(usbp, (uint8_t *)&mouse_report_sent, sizeof(mouse_report_sent), NULL); + return TRUE; + break; + } +# endif +#endif /* SHARED_EP_ENABLE */ default: - usbSetupTransfer(usbp, NULL, 0, NULL); + universal_report_blank.report_id = usbp->setup[2]; + usbSetupTransfer(usbp, (uint8_t *)&universal_report_blank, usbp->setup[6], NULL); return TRUE; break; } @@ -665,8 +697,7 @@ static bool usb_request_hook_cb(USBDriver *usbp) { if ((usbp->setup[4] == KEYBOARD_INTERFACE) && (usbp->setup[5] == 0)) { /* wIndex */ keyboard_protocol = ((usbp->setup[2]) != 0x00); /* LSB(wValue) */ #ifdef NKRO_ENABLE - keymap_config.nkro = !!keyboard_protocol; - if (!keymap_config.nkro && keyboard_idle) { + if (!keyboard_protocol && keyboard_idle) { #else /* NKRO_ENABLE */ if (keyboard_idle) { #endif /* NKRO_ENABLE */ @@ -921,6 +952,7 @@ void send_mouse(report_mouse_t *report) { } } usbStartTransmitI(&USB_DRIVER, MOUSE_IN_EPNUM, (uint8_t *)report, sizeof(report_mouse_t)); + mouse_report_sent = *report; osalSysUnlock(); } diff --git a/tmk_core/protocol/lufa/lufa.c b/tmk_core/protocol/lufa/lufa.c index 8f36e02b9a..99f7d31287 100644 --- a/tmk_core/protocol/lufa/lufa.c +++ b/tmk_core/protocol/lufa/lufa.c @@ -901,5 +901,5 @@ void protocol_post_task(void) { } uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue, const uint16_t wIndex, const void **const DescriptorAddress) { - return get_usb_descriptor(wValue, wIndex, DescriptorAddress); + return get_usb_descriptor(wValue, wIndex, USB_ControlRequest.wLength, DescriptorAddress); } diff --git a/tmk_core/protocol/usb_descriptor.c b/tmk_core/protocol/usb_descriptor.c index 99c52952a0..5ab9e3ff4f 100644 --- a/tmk_core/protocol/usb_descriptor.c +++ b/tmk_core/protocol/usb_descriptor.c @@ -45,8 +45,9 @@ # include "joystick.h" #endif -// TODO: wb32 support defines ISO macro which breaks PRODUCT stringification -#undef ISO +#ifdef OS_DETECTION_ENABLE +# include "os_detection.h" +#endif // clang-format off @@ -1095,7 +1096,7 @@ const USB_Descriptor_String_t PROGMEM SerialNumberString = { * is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the * USB host. */ -uint16_t get_usb_descriptor(const uint16_t wValue, const uint16_t wIndex, const void** const DescriptorAddress) { +uint16_t get_usb_descriptor(const uint16_t wValue, const uint16_t wIndex, const uint16_t wLength, const void** const DescriptorAddress) { const uint8_t DescriptorType = (wValue >> 8); const uint8_t DescriptorIndex = (wValue & 0xFF); const void* Address = NULL; @@ -1137,6 +1138,9 @@ uint16_t get_usb_descriptor(const uint16_t wValue, const uint16_t wIndex, const break; #endif } +#ifdef OS_DETECTION_ENABLE + process_wlength(wLength); +#endif break; case HID_DTYPE_HID: diff --git a/tmk_core/protocol/usb_descriptor.h b/tmk_core/protocol/usb_descriptor.h index bc5e84e586..ed84f4c9ab 100644 --- a/tmk_core/protocol/usb_descriptor.h +++ b/tmk_core/protocol/usb_descriptor.h @@ -308,4 +308,4 @@ enum usb_endpoints { #define JOYSTICK_EPSIZE 8 #define DIGITIZER_EPSIZE 8 -uint16_t get_usb_descriptor(const uint16_t wValue, const uint16_t wIndex, const void** const DescriptorAddress); +uint16_t get_usb_descriptor(const uint16_t wValue, const uint16_t wIndex, const uint16_t wLength, const void** const DescriptorAddress); diff --git a/tmk_core/protocol/vusb/vusb.c b/tmk_core/protocol/vusb/vusb.c index 2d17761978..b3eeff9e01 100644 --- a/tmk_core/protocol/vusb/vusb.c +++ b/tmk_core/protocol/vusb/vusb.c @@ -44,6 +44,10 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. # include "ring_buffer.h" #endif +#ifdef OS_DETECTION_ENABLE +# include "os_detection.h" +#endif + #define NEXT_INTERFACE __COUNTER__ /* @@ -1013,6 +1017,9 @@ USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq) { break; #endif } +#ifdef OS_DETECTION_ENABLE + process_wlength(rq->wLength.word); +#endif break; case USBDESCR_HID: switch (rq->wValue.bytes[0]) { diff --git a/users/333fred/333fred.c b/users/333fred/333fred.c index c035493e37..e75a862a3e 100644 --- a/users/333fred/333fred.c +++ b/users/333fred/333fred.c @@ -31,7 +31,7 @@ typedef enum { static tap_dance_state_enum tap_dance_state; static bool tap_dance_active = false; -void tap_dance_sym_vim_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_sym_vim_finished(tap_dance_state_t *state, void *user_data) { // Determine the current state if (state->count == 1) { if (state->interrupted || state->pressed == 0) tap_dance_state = SINGLE_TAP; @@ -60,7 +60,7 @@ void tap_dance_sym_vim_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void tap_dance_sym_vim_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_sym_vim_reset(tap_dance_state_t *state, void *user_data) { switch(tap_dance_state) { case SINGLE_TAP: clear_oneshot_layer_state(ONESHOT_PRESSED); @@ -74,7 +74,7 @@ void tap_dance_sym_vim_reset(qk_tap_dance_state_t *state, void *user_data) { } } -void tap_dance_copy_paste_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_copy_paste_finished(tap_dance_state_t *state, void *user_data) { bool is_paste = state->count == 2; // If either the one-shot shift is set, or if shift is being held, count as shift being held. // We'll clear the one-shot shift if it was held @@ -103,7 +103,7 @@ void tap_dance_copy_paste_finished(qk_tap_dance_state_t *state, void *user_data) } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SYM_VIM] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tap_dance_sym_vim_finished, tap_dance_sym_vim_reset), [TD_COPY_PASTE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tap_dance_copy_paste_finished, NULL) }; diff --git a/users/333fred/333fred.h b/users/333fred/333fred.h index 0532ff2df7..e8473e7ce1 100644 --- a/users/333fred/333fred.h +++ b/users/333fred/333fred.h @@ -45,7 +45,7 @@ enum custom_keys { PSCREEN_APP }; -void tap_dance_sym_vim_finished(qk_tap_dance_state_t*, void*); -void tap_dance_sym_vim_reset(qk_tap_dance_state_t*, void*); +void tap_dance_sym_vim_finished(tap_dance_state_t*, void*); +void tap_dance_sym_vim_reset(tap_dance_state_t*, void*); void tap_dance_process_keycode(uint16_t); bool try_handle_macro(uint16_t keycode, keyrecord_t *record); diff --git a/users/bcat/config.h b/users/bcat/config.h index 7bb5d71bae..b9eac74ff6 100644 --- a/users/bcat/config.h +++ b/users/bcat/config.h @@ -35,7 +35,7 @@ /* Turn off key repeat support of the tap keycode for tap-hold keys, enabling * holds to work correctly in quick succession after taps. */ -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 #if defined(OLED_ENABLE) /* The built-in OLED timeout wakes the OLED screen every time the buffer is diff --git a/users/billypython/tap_dance.c b/users/billypython/tap_dance.c index 74ae166393..c55f9e9133 100644 --- a/users/billypython/tap_dance.c +++ b/users/billypython/tap_dance.c @@ -2,11 +2,11 @@ #define ACTION_TAP_DANCE_DOUBLE_MODS(mod1, mod2) { \ .fn = { td_double_mods_each, NULL, td_double_mods_reset }, \ - .user_data = &(qk_tap_dance_pair_t){ mod1, mod2 }, \ + .user_data = &(tap_dance_pair_t){ mod1, mod2 }, \ } -void td_double_mods_each(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_pair_t *mods = (qk_tap_dance_pair_t *)user_data; +void td_double_mods_each(tap_dance_state_t *state, void *user_data) { + tap_dance_pair_t *mods = (tap_dance_pair_t *)user_data; // Single tap → mod1, double tap → mod2, triple tap etc. → mod1+mod2 if (state->count == 1 || state->count == 3) { register_code(mods->kc1); @@ -18,8 +18,8 @@ void td_double_mods_each(qk_tap_dance_state_t *state, void *user_data) { state->weak_mods &= ~(MOD_BIT(mods->kc1) | MOD_BIT(mods->kc2)); } -void td_double_mods_reset(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_pair_t *mods = (qk_tap_dance_pair_t *)user_data; +void td_double_mods_reset(tap_dance_state_t *state, void *user_data) { + tap_dance_pair_t *mods = (tap_dance_pair_t *)user_data; if (state->count == 1 || state->count >= 3) { unregister_code(mods->kc1); } @@ -28,6 +28,6 @@ void td_double_mods_reset(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_RSF_RCT] = ACTION_TAP_DANCE_DOUBLE_MODS(KC_RSFT, KC_RCTL), }; diff --git a/users/brandonschlack/tap_dances.c b/users/brandonschlack/tap_dances.c index 861b31805b..4a4a530ff2 100644 --- a/users/brandonschlack/tap_dances.c +++ b/users/brandonschlack/tap_dances.c @@ -16,7 +16,7 @@ #include "tap_dances.h" #include "process_keycode/process_tap_dance.h" -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return SINGLE_TAP; else return SINGLE_HOLD; @@ -35,8 +35,8 @@ int cur_dance (qk_tap_dance_state_t *state) { __attribute__ ((weak)) void process_tap_dance_keycode (bool reset, uint8_t toggle_layer) { }; -void td_trigger_layer_finished (qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_trigger_layer_t *data = (qk_tap_dance_trigger_layer_t *)user_data; +void td_trigger_layer_finished (tap_dance_state_t *state, void *user_data) { + tap_dance_trigger_layer_t *data = (tap_dance_trigger_layer_t *)user_data; data->state = cur_dance(state); if (data->state == data->trigger) { @@ -46,8 +46,8 @@ void td_trigger_layer_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void td_trigger_layer_reset (qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_trigger_layer_t *data = (qk_tap_dance_trigger_layer_t *)user_data; +void td_trigger_layer_reset (tap_dance_state_t *state, void *user_data) { + tap_dance_trigger_layer_t *data = (tap_dance_trigger_layer_t *)user_data; if (data->state == data->trigger) { switch (data->trigger) { case SINGLE_HOLD: @@ -63,8 +63,8 @@ void td_trigger_layer_reset (qk_tap_dance_state_t *state, void *user_data) { } /* Tap Dance: Layer Mod. Toggles Layer when tapped, Mod when held. */ -void td_layer_mod_each(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_dual_role_t *data = (qk_tap_dance_dual_role_t *)user_data; +void td_layer_mod_each(tap_dance_state_t *state, void *user_data) { + tap_dance_dual_role_t *data = (tap_dance_dual_role_t *)user_data; // Single tap → toggle layer, Single hold → mod if (state->pressed) { @@ -74,16 +74,16 @@ void td_layer_mod_each(qk_tap_dance_state_t *state, void *user_data) { } } -void td_layer_mod_finished(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_dual_role_t *data = (qk_tap_dance_dual_role_t *)user_data; +void td_layer_mod_finished(tap_dance_state_t *state, void *user_data) { + tap_dance_dual_role_t *data = (tap_dance_dual_role_t *)user_data; if (state->count == 1 && !state->pressed) { layer_invert(data->layer); } } -void td_layer_mod_reset(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_dual_role_t *data = (qk_tap_dance_dual_role_t *)user_data; +void td_layer_mod_reset(tap_dance_state_t *state, void *user_data) { + tap_dance_dual_role_t *data = (tap_dance_dual_role_t *)user_data; if (state->count == 1) { unregister_code(data->kc); diff --git a/users/brandonschlack/tap_dances.h b/users/brandonschlack/tap_dances.h index 3747619a5e..62c585631e 100644 --- a/users/brandonschlack/tap_dances.h +++ b/users/brandonschlack/tap_dances.h @@ -29,7 +29,7 @@ enum tap_dance_states { TRIPLE_HOLD = 7 }; -int cur_dance (qk_tap_dance_state_t *state); +int cur_dance (tap_dance_state_t *state); void process_tap_dance_keycode (bool reset, uint8_t toggle_layer); /* Tap Dance: Trigger Layer @@ -41,12 +41,12 @@ typedef struct { uint8_t trigger; uint8_t layer; uint8_t state; -} qk_tap_dance_trigger_layer_t; +} tap_dance_trigger_layer_t; #define ACTION_TAP_DANCE_TRIGGER_LAYER(trigger, layer) { \ .fn = { NULL, td_trigger_layer_finished, td_trigger_layer_reset }, \ - .user_data = (void *)&((qk_tap_dance_trigger_layer_t) { trigger, layer, 0 }), \ + .user_data = (void *)&((tap_dance_trigger_layer_t) { trigger, layer, 0 }), \ } -void td_trigger_layer_finished (qk_tap_dance_state_t *state, void *user_data); -void td_trigger_layer_reset (qk_tap_dance_state_t *state, void *user_data); +void td_trigger_layer_finished (tap_dance_state_t *state, void *user_data); +void td_trigger_layer_reset (tap_dance_state_t *state, void *user_data); diff --git a/users/curry/tap_dances.c b/users/curry/tap_dances.c index 166ea2c686..86a8f679d2 100644 --- a/users/curry/tap_dances.c +++ b/users/curry/tap_dances.c @@ -1,4 +1,4 @@ #include "tap_dances.h" #include "curry.h" -qk_tap_dance_action_t tap_dance_actions[] = {}; +tap_dance_action_t tap_dance_actions[] = {}; diff --git a/users/cwebster2/config.h b/users/cwebster2/config.h index 78733687cc..313e6d533f 100644 --- a/users/cwebster2/config.h +++ b/users/cwebster2/config.h @@ -18,7 +18,7 @@ #define TAPPING_TOGGLE 1 #define TAPPING_TERM 200 #define TAPPING_TERM_PER_KEY -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 #undef PERMISSIVE_HOLD #define IGNORE_MOD_TAP_INTERRUPT #define NO_ACTION_ONESHOT diff --git a/users/d4mation/tap-dance.c b/users/d4mation/tap-dance.c index 77d09962d6..928a932611 100644 --- a/users/d4mation/tap-dance.c +++ b/users/d4mation/tap-dance.c @@ -1,6 +1,6 @@ #include "tap-dance.h" -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { /* Tap once/hold for Shift, tap twice for Caps Lock */ [SHIFT_CAPS] = ACTION_TAP_DANCE_DOUBLE( KC_LSFT, KC_CAPS ) };
\ No newline at end of file diff --git a/users/danielo515/danielo515.c b/users/danielo515/danielo515.c index 9b09aed9d7..ea91ec55bf 100644 --- a/users/danielo515/danielo515.c +++ b/users/danielo515/danielo515.c @@ -7,9 +7,9 @@ bool onMac = true; LEADER_EXTERNS(); # ifdef RGBLIGHT_ENABLE -void leader_start() { rgblight_setrgb_range(5, 100, 199, 10, 15); }; +void leader_start_user() { rgblight_setrgb_range(5, 100, 199, 10, 15); }; -void leader_end() { rgblight_setrgb_range(200, 200, 255, 10, 15); }; +void leader_end_user() { rgblight_setrgb_range(200, 200, 255, 10, 15); }; # endif void matrix_scan_user(void) { diff --git a/users/danielo515/tap_dance.c b/users/danielo515/tap_dance.c index a07b4c792f..b69ee715d4 100644 --- a/users/danielo515/tap_dance.c +++ b/users/danielo515/tap_dance.c @@ -1,7 +1,7 @@ #include "tap_dance.h" //**************** Definitions needed for quad function to work *********************// #ifdef QUAD_DANCE -int cur_dance(qk_tap_dance_state_t *state) +int cur_dance(tap_dance_state_t *state) { if (state->count == 1) { @@ -30,8 +30,8 @@ int cur_dance(qk_tap_dance_state_t *state) # endif // Slightly better tap dance double: interruption sends double single and any number over double sends the single that number of times -void qk_tap_dance_pair_finished_safe(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data; +void tap_dance_pair_finished_safe(tap_dance_state_t *state, void *user_data) { + tap_dance_pair_t *pair = (tap_dance_pair_t *)user_data; int count = state->count; if (state->count == 2) { if (state->interrupted){ @@ -47,8 +47,8 @@ void qk_tap_dance_pair_finished_safe(qk_tap_dance_state_t *state, void *user_dat } } -void qk_tap_dance_pair_reset_safe(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_pair_t *pair = (qk_tap_dance_pair_t *)user_data; +void tap_dance_pair_reset_safe(tap_dance_state_t *state, void *user_data) { + tap_dance_pair_t *pair = (tap_dance_pair_t *)user_data; if (state->count == 2) { unregister_code16 (pair->kc2); return; @@ -58,7 +58,7 @@ void qk_tap_dance_pair_reset_safe(qk_tap_dance_state_t *state, void *user_data) //**************** Tap dance functions *********************// -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [COPY_CUT] = ACTION_TAP_DANCE_FN(td_copy_cut), [PASTE_DANCE] = ACTION_TAP_DANCE_FN(td_paste), [_TD_F1] = ACTION_TAP_DANCE_DOUBLE(KC_1, KC_F1), @@ -86,7 +86,7 @@ qk_tap_dance_action_t tap_dance_actions[] = { [_TD_PASTE] = ACTION_TAP_DANCE_FN(dance_paste) }; -void td_copy_cut(qk_tap_dance_state_t *state, void *user_data) +void td_copy_cut(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { @@ -99,7 +99,7 @@ void td_copy_cut(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); }; -void td_paste(qk_tap_dance_state_t *state, void *user_data) +void td_paste(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { @@ -113,7 +113,7 @@ void td_paste(qk_tap_dance_state_t *state, void *user_data) }; //===== The awesome tap dance for CUT, COPY and PASTE letters -void dance_copy (qk_tap_dance_state_t *state, void *user_data) { +void dance_copy (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(KC_C); } else if (state->interrupted) { tap_code16(KC_C);tap_code16(KC_C);} @@ -122,13 +122,13 @@ void dance_copy (qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance (state); } -void dance_cut (qk_tap_dance_state_t *state, void *user_data) { +void dance_cut (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(KC_X); } else { CMD(KC_X); } reset_tap_dance (state); } -void dance_paste (qk_tap_dance_state_t *state, void *user_data) { +void dance_paste (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code16(KC_V); } diff --git a/users/danielo515/tap_dance.h b/users/danielo515/tap_dance.h index 880ad525ee..aaf3864841 100644 --- a/users/danielo515/tap_dance.h +++ b/users/danielo515/tap_dance.h @@ -4,8 +4,8 @@ extern bool onMac; #define ACTION_TAP_DANCE_DOUBLE_SAFE(kc1, kc2) { \ - .fn = { NULL, qk_tap_dance_pair_finished_safe, qk_tap_dance_pair_reset_safe }, \ - .user_data = (void *)&((qk_tap_dance_pair_t) { kc1, kc2 }), \ + .fn = { NULL, tap_dance_pair_finished_safe, tap_dance_pair_reset_safe }, \ + .user_data = (void *)&((tap_dance_pair_t) { kc1, kc2 }), \ } #ifdef QUAD_DANCE @@ -18,7 +18,7 @@ enum { DOUBLE_SINGLE_TAP = 5 //send SINGLE_TAP twice - NOT DOUBLE_TAP // Add more enums here if you want for triple, quadruple, etc. }; -int cur_dance (qk_tap_dance_state_t *state); +int cur_dance (tap_dance_state_t *state); # endif enum tap_dance { @@ -48,14 +48,14 @@ enum tap_dance { _TD_CUT, _TD_PASTE, }; -void qk_tap_dance_pair_finished_safe(qk_tap_dance_state_t *state, void *user_data); -void qk_tap_dance_pair_reset_safe(qk_tap_dance_state_t *state, void *user_data); -void td_copy_cut (qk_tap_dance_state_t *state, void *user_data); -void td_paste(qk_tap_dance_state_t *state, void *user_data); -int cur_dance (qk_tap_dance_state_t *state); -void dance_cut (qk_tap_dance_state_t *state, void *user_data); -void dance_copy (qk_tap_dance_state_t *state, void *user_data); -void dance_paste (qk_tap_dance_state_t *state, void *user_data); +void tap_dance_pair_finished_safe(tap_dance_state_t *state, void *user_data); +void tap_dance_pair_reset_safe(tap_dance_state_t *state, void *user_data); +void td_copy_cut (tap_dance_state_t *state, void *user_data); +void td_paste(tap_dance_state_t *state, void *user_data); +int cur_dance (tap_dance_state_t *state); +void dance_cut (tap_dance_state_t *state, void *user_data); +void dance_copy (tap_dance_state_t *state, void *user_data); +void dance_paste (tap_dance_state_t *state, void *user_data); // Ready to use Tap dance definitions, just put them on your layout #define TD_COPY TD(_TD_COPY) diff --git a/users/draevin/draevin.c b/users/draevin/draevin.c index 95570bf377..70b465a33d 100644 --- a/users/draevin/draevin.c +++ b/users/draevin/draevin.c @@ -54,6 +54,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS) // shift/caps TD }; diff --git a/users/drashna/config.h b/users/drashna/config.h index 5c5c131e36..9edbfff56b 100644 --- a/users/drashna/config.h +++ b/users/drashna/config.h @@ -81,9 +81,8 @@ #endif // !ONESHOT_TIMEOUT #if defined(PER_KEY_TAPPING) -# define IGNORE_MOD_TAP_INTERRUPT_PER_KEY # define PERMISSIVE_HOLD_PER_KEY -# define TAPPING_FORCE_HOLD_PER_KEY +# define QUICK_TAP_TERM_PER_KEY # define HOLD_ON_OTHER_KEY # define RETRO_TAPPING_PER_KEY # define HOLD_ON_OTHER_KEY_PRESS_PER_KEY diff --git a/users/drashna/keyrecords/tap_dance.md b/users/drashna/keyrecords/tap_dance.md index fef1435918..9dff96640f 100644 --- a/users/drashna/keyrecords/tap_dance.md +++ b/users/drashna/keyrecords/tap_dance.md @@ -30,7 +30,7 @@ These are the custom defined dances that I'm using. It sets up everything for l ```c //Tap Dance Definitions, sets the index and the keycode. -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // tap once to disable, and more to enable timed micros [TD_D3_1] = ACTION_TAP_DANCE_DIABLO(0, KC_1), [TD_D3_2] = ACTION_TAP_DANCE_DIABLO(1, KC_2), @@ -82,7 +82,7 @@ The first part of the magic here is the `diablo_tapdance_master` function. The ```c // Cycle through the times for the macro, starting at 0, for disabled. -void diablo_tapdance_master(qk_tap_dance_state_t *state, void *user_data) { +void diablo_tapdance_master(tap_dance_state_t *state, void *user_data) { diable_keys_t *diablo_keys = (diable_keys_t *)user_data; // Sets the keycode based on the index diablo_timer[diablo_keys->index].keycode = diablo_keys->keycode; diff --git a/users/drashna/keyrecords/tap_dances.c b/users/drashna/keyrecords/tap_dances.c index 7bdea3cae3..87739c2a18 100644 --- a/users/drashna/keyrecords/tap_dances.c +++ b/users/drashna/keyrecords/tap_dances.c @@ -17,7 +17,7 @@ uint8_t diablo_times[] = {0, 1, 3, 5, 10, 30}; * @param state Main data struction contining information about events * @param user_data Local data for the dance. Allows customization to be passed on to function */ -void diablo_tapdance_master(qk_tap_dance_state_t *state, void *user_data) { +void diablo_tapdance_master(tap_dance_state_t *state, void *user_data) { diable_keys_t *diablo_keys = (diable_keys_t *)user_data; // Sets the keycode based on the index diablo_timer[diablo_keys->index].keycode = diablo_keys->keycode; @@ -40,7 +40,7 @@ void diablo_tapdance_master(qk_tap_dance_state_t *state, void *user_data) { // clang-format on // Tap Dance Definitions, sets the index and the keycode. -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // tap once to disable, and more to enable timed micros [TD_D3_1] = ACTION_TAP_DANCE_DIABLO(0, KC_1), [TD_D3_2] = ACTION_TAP_DANCE_DIABLO(1, KC_2), diff --git a/users/drashna/keyrecords/tapping.c b/users/drashna/keyrecords/tapping.c index 7496610c2f..6a26a02aca 100644 --- a/users/drashna/keyrecords/tapping.c +++ b/users/drashna/keyrecords/tapping.c @@ -42,29 +42,14 @@ __attribute__((weak)) bool get_hold_on_other_key_press(uint16_t keycode, keyreco } #endif // HOLD_ON_OTHER_KEY_PRESS_PER_KEY -#ifdef IGNORE_MOD_TAP_INTERRUPT_PER_KEY -__attribute__((weak)) bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) { - // Do not force the mod-tap key press to be handled as a modifier - // if any other key was pressed while the mod-tap key is held down. - // return true; - // Force the mod-tap key press to be handled as a modifier if any - // other key was pressed while the mod-tap key is held down. - // return false; - switch (keycode) { - default: - return true; - } -} -#endif // IGNORE_MOD_TAP_INTERRUPT_PER_KEY - -#ifdef TAPPING_FORCE_HOLD_PER_KEY -__attribute__((weak)) bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { +#ifdef QUICK_TAP_TERM_PER_KEY +__attribute__((weak)) uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { switch (keycode) { default: - return false; + return QUICK_TAP_TERM; } } -#endif // TAPPING_FORCE_HOLD_PER_KEY +#endif // QUICK_TAP_TERM_PER_KEY #ifdef RETRO_TAPPING_PER_KEY __attribute__((weak)) bool get_retro_tapping(uint16_t keycode, keyrecord_t *record) { diff --git a/users/dshields/config.h b/users/dshields/config.h index 1420a9178f..279bcf217b 100644 --- a/users/dshields/config.h +++ b/users/dshields/config.h @@ -6,7 +6,7 @@ #define ONESHOT_TIMEOUT 3000 #define IGNORE_MOD_TAP_INTERRUPT #define PERMISSIVE_HOLD_PER_KEY -#define TAPPING_FORCE_HOLD_PER_KEY +#define QUICK_TAP_TERM_PER_KEY #define TAPPING_TERM 200 #define BACKLIGHT_BREATHING #define DYNAMIC_MACRO_NO_NESTING diff --git a/users/dshields/dshields.c b/users/dshields/dshields.c index 46f0b33cd3..a8e1333104 100644 --- a/users/dshields/dshields.c +++ b/users/dshields/dshields.c @@ -29,7 +29,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { return true; } -bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { switch (keycode) { case MT_A: case MT_S: @@ -39,9 +39,9 @@ bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { case MT_K: case MT_L: case MT_SCLN: - return true; + return 0; default: - return false; + return QUICK_TAP_TERM; } } @@ -55,4 +55,3 @@ bool get_permissive_hold(uint16_t keycode, keyrecord_t *record) { return false; } } - diff --git a/users/dvorak_42_key/dvorak_42_key.c b/users/dvorak_42_key/dvorak_42_key.c index f4ec3cd06e..99cfd8cb7d 100644 --- a/users/dvorak_42_key/dvorak_42_key.c +++ b/users/dvorak_42_key/dvorak_42_key.c @@ -5,7 +5,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { // tap dance processing - qk_tap_dance_action_t *action; + tap_dance_action_t *action; switch (keycode) { case TD(TD_DEL_WORD_DEL): // list all tap dance keycodes with tap-hold configurations action = &tap_dance_actions[TD_INDEX(keycode)]; @@ -167,7 +167,7 @@ bool caps_word_press_user(uint16_t keycode) { } -void tap_dance_tap_hold_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_tap_hold_finished(tap_dance_state_t *state, void *user_data) { tap_dance_tap_hold_t *tap_hold = (tap_dance_tap_hold_t *)user_data; if (state->pressed) { @@ -185,7 +185,7 @@ void tap_dance_tap_hold_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void tap_dance_tap_hold_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_tap_hold_reset(tap_dance_state_t *state, void *user_data) { tap_dance_tap_hold_t *tap_hold = (tap_dance_tap_hold_t *)user_data; if (tap_hold->held) { @@ -196,7 +196,7 @@ void tap_dance_tap_hold_reset(qk_tap_dance_state_t *state, void *user_data) { // Tap Dance definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Tap once for Escape, twice for Caps Lock // [TD_BSPC_CTL_BSPC] = ACTION_TAP_DANCE_DOUBLE(KC_BSPC, RCTL(KC_BSPC)), // [TD_BSPC_CTL_BSPC_IOS] = ACTION_TAP_DANCE_DOUBLE(KC_BSPC, LALT(KC_BSPC)), diff --git a/users/edvorakjp/edvorakjp_tap_dance.c b/users/edvorakjp/edvorakjp_tap_dance.c index 69fcbac1ca..d2c9f2b0e9 100644 --- a/users/edvorakjp/edvorakjp_tap_dance.c +++ b/users/edvorakjp/edvorakjp_tap_dance.c @@ -14,7 +14,7 @@ typedef struct { } td_status_t; static td_status_t td_status = {NONE, NONE}; -uint8_t cur_dance(qk_tap_dance_state_t *state) { +uint8_t cur_dance(tap_dance_state_t *state) { if (state->interrupted || !state->pressed) { return state->count == 1 ? SINGLE_TAP : DOUBLE_TAP; } else { @@ -22,7 +22,7 @@ uint8_t cur_dance(qk_tap_dance_state_t *state) { } } -void td_lower_finished(qk_tap_dance_state_t *state, void *user_data) { +void td_lower_finished(tap_dance_state_t *state, void *user_data) { td_status.lower = cur_dance(state); switch (td_status.lower) { case SINGLE_TAP: @@ -36,7 +36,7 @@ void td_lower_finished(qk_tap_dance_state_t *state, void *user_data) { layer_on(L_EDVORAKJP_LOWER); } -void td_lower_reset(qk_tap_dance_state_t *state, void *user_data) { +void td_lower_reset(tap_dance_state_t *state, void *user_data) { switch (td_status.lower) { case DOUBLE_TAP: unregister_code(KC_ESC); @@ -46,7 +46,7 @@ void td_lower_reset(qk_tap_dance_state_t *state, void *user_data) { td_status.lower = NONE; } -void td_raise_finished(qk_tap_dance_state_t *state, void *user_data) { +void td_raise_finished(tap_dance_state_t *state, void *user_data) { td_status.raise = cur_dance(state); switch (td_status.raise) { case DOUBLE_TAP: @@ -58,12 +58,12 @@ void td_raise_finished(qk_tap_dance_state_t *state, void *user_data) { layer_on(L_EDVORAKJP_RAISE); } -void td_raise_reset(qk_tap_dance_state_t *state, void *user_data) { +void td_raise_reset(tap_dance_state_t *state, void *user_data) { layer_off(L_EDVORAKJP_RAISE); td_status.raise = NONE; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_EDVORAKJP_LOWER] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_lower_finished, td_lower_reset), [TD_EDVORAKJP_RAISE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, td_raise_finished, td_raise_reset), }; diff --git a/users/ericgebhart/extensions/keycodes.h b/users/ericgebhart/extensions/keycodes.h index a3c5d72a09..eafdfbad43 100755 --- a/users/ericgebhart/extensions/keycodes.h +++ b/users/ericgebhart/extensions/keycodes.h @@ -515,9 +515,9 @@ enum { int on_qwerty(void); #ifdef TAP_DANCES_ENABLE -int cur_dance (qk_tap_dance_state_t *state); +int cur_dance (tap_dance_state_t *state); //for the x tap dance. Put it here so it can be used in any keymap -void x_finished (qk_tap_dance_state_t *state, void *user_data); -void x_reset (qk_tap_dance_state_t *state, void *user_data); +void x_finished (tap_dance_state_t *state, void *user_data); +void x_reset (tap_dance_state_t *state, void *user_data); #endif diff --git a/users/ericgebhart/extensions/tap_dances.c b/users/ericgebhart/extensions/tap_dances.c index b292dab678..8b1fea15e8 100755 --- a/users/ericgebhart/extensions/tap_dances.c +++ b/users/ericgebhart/extensions/tap_dances.c @@ -22,7 +22,7 @@ #include "action_layer.h" #include "process_keycode/process_tap_dance.h" -void tap_dance_mouse_btns (qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_mouse_btns (tap_dance_state_t *state, void *user_data) { switch(state->count){ case 1: register_code(KC_BTN1); @@ -72,7 +72,7 @@ static void switch_default_layer(uint8_t layer) { } */ -void tap_dance_df_bepo_layers_switch (qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_df_bepo_layers_switch (tap_dance_state_t *state, void *user_data) { switch(state->count){ case 1: switch_default_layer(_DVORAK_BP); @@ -89,7 +89,7 @@ void tap_dance_df_bepo_layers_switch (qk_tap_dance_state_t *state, void *user_da reset_tap_dance(state); } -void tap_dance_layer_switch (qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_layer_switch (tap_dance_state_t *state, void *user_data) { switch(state->count){ case 1: if(on_qwerty()) @@ -115,7 +115,7 @@ void tap_dance_layer_switch (qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void tap_dance_default_layer_switch (qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_default_layer_switch (tap_dance_state_t *state, void *user_data) { switch(state->count){ case 1: switch_default_layer(_DVORAK); @@ -178,7 +178,7 @@ void switch_default_layer_on_bepo(int count) { // a qwerty software keyboard and a bepo software keyboard. // if shifted, choose layers based on the other software keyboard, otherwise choose only // layers that work on the current software keyboard. -void tap_dance_default_os_layer_switch (qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_default_os_layer_switch (tap_dance_state_t *state, void *user_data) { //uint8_t shifted = (get_mods() & MOD_BIT(KC_LSFT|KC_RSFT)); bool shifted = ( keyboard_report->mods & (MOD_BIT(KC_LSFT)|MOD_BIT(KC_RSFT)) ); int qwerty = on_qwerty(); @@ -230,7 +230,7 @@ void tap_dance_default_os_layer_switch (qk_tap_dance_state_t *state, void *user_ * For the third point, there does exist the 'DOUBLE_SINGLE_TAP', however this is not fully tested * */ -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return SINGLE_TAP; //key has not been interrupted, but they key is still held. Means you want to send a 'HOLD'. @@ -257,7 +257,7 @@ int cur_dance (qk_tap_dance_state_t *state) { } //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Esc, twice for Caps Lock [TD_ESC_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS), [TD_TAB_BKTAB] = ACTION_TAP_DANCE_DOUBLE(KC_TAB, LSFT(KC_TAB)), diff --git a/users/greatwizard/tap_dances.c b/users/greatwizard/tap_dances.c index c6be995c45..ca2c33824f 100644 --- a/users/greatwizard/tap_dances.c +++ b/users/greatwizard/tap_dances.c @@ -15,7 +15,7 @@ */ #include "tap_dances.h" -uint8_t cur_dance(qk_tap_dance_state_t *state) { +uint8_t cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return SINGLE_TAP; else return SINGLE_HOLD; @@ -36,7 +36,7 @@ static tap tap_state = { }; #ifdef TAP_DANCE_LALT_GIT -void lalt_finished(qk_tap_dance_state_t *state, void *user_data) { +void lalt_finished(tap_dance_state_t *state, void *user_data) { tap_state.state = cur_dance(state); switch (tap_state.state) { case SINGLE_HOLD: @@ -49,7 +49,7 @@ void lalt_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void lalt_reset(qk_tap_dance_state_t *state, void *user_data) { +void lalt_reset(tap_dance_state_t *state, void *user_data) { switch (tap_state.state) { case SINGLE_HOLD: unregister_mods(MOD_BIT(KC_LALT)); @@ -65,7 +65,7 @@ void lalt_reset(qk_tap_dance_state_t *state, void *user_data) { #ifdef TAP_DANCE_LSFT_CAPS # ifdef LAYERS_PROGRAMMER -void pg_lsft_finished(qk_tap_dance_state_t *state, void *user_data) { +void pg_lsft_finished(tap_dance_state_t *state, void *user_data) { tap_state.state = cur_dance(state); switch (tap_state.state) { case SINGLE_HOLD: @@ -80,7 +80,7 @@ void pg_lsft_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void pg_lsft_reset(qk_tap_dance_state_t *state, void *user_data) { +void pg_lsft_reset(tap_dance_state_t *state, void *user_data) { switch (tap_state.state) { case SINGLE_HOLD: unregister_mods(MOD_BIT(KC_LSFT)); @@ -92,7 +92,7 @@ void pg_lsft_reset(qk_tap_dance_state_t *state, void *user_data) { # endif #endif -qk_tap_dance_action_t tap_dance_actions[] = { +dance_action_t tap_dance_actions[] = { #ifdef TAP_DANCE_LALT_GIT [TD_LALT_GIT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, lalt_finished, lalt_reset), #endif diff --git a/users/greatwizard/tap_dances.h b/users/greatwizard/tap_dances.h index 944ae45553..19819125b5 100644 --- a/users/greatwizard/tap_dances.h +++ b/users/greatwizard/tap_dances.h @@ -45,18 +45,18 @@ enum { #endif }; -uint8_t cur_dance(qk_tap_dance_state_t *state); +uint8_t cur_dance(tap_dance_state_t *state); #ifdef TAP_DANCE_LALT_GIT -void lalt_finished(qk_tap_dance_state_t *state, void *user_data); -void lalt_reset(qk_tap_dance_state_t *state, void *user_data); +void lalt_finished(tap_dance_state_t *state, void *user_data); +void lalt_reset(tap_dance_state_t *state, void *user_data); # define TD_LALT TD(TD_LALT_GIT) #endif #ifdef TAP_DANCE_LSFT_CAPS # ifdef LAYERS_PROGRAMMER -void pg_lsft_finished(qk_tap_dance_state_t *state, void *user_data); -void pg_lsft_reset(qk_tap_dance_state_t *state, void *user_data); +void pg_lsft_finished(tap_dance_state_t *state, void *user_data); +void pg_lsft_reset(tap_dance_state_t *state, void *user_data); # endif #endif diff --git a/users/hvp/tap_dances.c b/users/hvp/tap_dances.c index 1269d5f272..51e227737a 100644 --- a/users/hvp/tap_dances.c +++ b/users/hvp/tap_dances.c @@ -2,7 +2,7 @@ // Tap dance function for enable swedish characters on first layer. Unregister to not let tap bleed over to next keypress. // Tap dance 1 -void dance_1_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_1_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code(KC_SCLN); } else { @@ -10,7 +10,7 @@ void dance_1_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_1_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_1_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code(KC_SCLN); } else { @@ -19,7 +19,7 @@ void dance_1_reset(qk_tap_dance_state_t *state, void *user_data) { } // Tap dance 2 -void dance_2_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_2_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code(KC_QUOT); } else { @@ -27,7 +27,7 @@ void dance_2_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_2_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_2_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code(KC_QUOT); } else { @@ -36,7 +36,7 @@ void dance_2_reset(qk_tap_dance_state_t *state, void *user_data) { } // Tap dance 3 -void dance_3_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_3_finished(tap_dance_state_t *state, void *user_data) { // if (state->count == 2) if (state->count == 2) { tap_code(KC_SLSH); @@ -45,7 +45,7 @@ void dance_3_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_3_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_3_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code(KC_SLSH); } else { @@ -54,7 +54,7 @@ void dance_3_reset(qk_tap_dance_state_t *state, void *user_data) { } // Tap dance 4 -void dance_4_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_4_finished(tap_dance_state_t *state, void *user_data) { // if (state->count == 2) if (state->count == 2) { tap_code(KC_DOT); @@ -63,7 +63,7 @@ void dance_4_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_4_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_4_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code(KC_DOT); } else { @@ -72,7 +72,7 @@ void dance_4_reset(qk_tap_dance_state_t *state, void *user_data) { } // Tap dance 5 -void dance_5_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_5_finished(tap_dance_state_t *state, void *user_data) { // if (state->count == 2) if (state->count == 2) { tap_code(KC_DOT); @@ -81,7 +81,7 @@ void dance_5_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_5_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_5_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code(KC_DOT); } else { @@ -90,7 +90,7 @@ void dance_5_reset(qk_tap_dance_state_t *state, void *user_data) { } // Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // simple tap dance [TD1] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_1_finished, dance_1_reset), diff --git a/users/imchipwood/imchipwood.c b/users/imchipwood/imchipwood.c index b019012a71..9d111c015b 100644 --- a/users/imchipwood/imchipwood.c +++ b/users/imchipwood/imchipwood.c @@ -18,7 +18,7 @@ static td_state_t td_state[3]; // determine the tapdance state to return -int cur_dance(qk_tap_dance_state_t *state) { +int cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) { return SINGLE_TAP; @@ -33,7 +33,7 @@ int cur_dance(qk_tap_dance_state_t *state) { } // any number higher than the maximum state value you return above } -void altf2_finished(qk_tap_dance_state_t *state, void *user_data) { +void altf2_finished(tap_dance_state_t *state, void *user_data) { td_state[0] = cur_dance(state); switch (td_state[0]) { case SINGLE_TAP: @@ -49,7 +49,7 @@ void altf2_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void altf2_reset(qk_tap_dance_state_t *state, void *user_data) { +void altf2_reset(tap_dance_state_t *state, void *user_data) { switch (td_state[0]) { case SINGLE_TAP: unregister_code(KC_F2); @@ -65,7 +65,7 @@ void altf2_reset(qk_tap_dance_state_t *state, void *user_data) { } -void ctlf5_finished(qk_tap_dance_state_t *state, void *user_data) { +void ctlf5_finished(tap_dance_state_t *state, void *user_data) { td_state[1] = cur_dance(state); switch (td_state[1]) { case SINGLE_TAP: @@ -81,7 +81,7 @@ void ctlf5_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void ctlf5_reset(qk_tap_dance_state_t *state, void *user_data) { +void ctlf5_reset(tap_dance_state_t *state, void *user_data) { switch (td_state[1]) { case SINGLE_TAP: unregister_code(KC_F5); @@ -96,7 +96,7 @@ void ctlf5_reset(qk_tap_dance_state_t *state, void *user_data) { } } -void altf7_finished(qk_tap_dance_state_t *state, void *user_data) { +void altf7_finished(tap_dance_state_t *state, void *user_data) { td_state[2] = cur_dance(state); switch (td_state[2]) { case SINGLE_TAP: @@ -112,7 +112,7 @@ void altf7_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void altf7_reset(qk_tap_dance_state_t *state, void *user_data) { +void altf7_reset(tap_dance_state_t *state, void *user_data) { switch (td_state[2]) { case SINGLE_TAP: unregister_code(KC_F7); @@ -127,7 +127,7 @@ void altf7_reset(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [ALT_F2] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altf2_finished, altf2_reset), [CTL_F5] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ctlf5_finished, ctlf5_reset), [ALT_F7] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altf7_finished, altf7_reset), diff --git a/users/imchipwood/imchipwood.h b/users/imchipwood/imchipwood.h index 64726a862b..1e4bc3f744 100644 --- a/users/imchipwood/imchipwood.h +++ b/users/imchipwood/imchipwood.h @@ -41,11 +41,11 @@ enum td_keycodes { typedef enum { SINGLE_TAP, SINGLE_HOLD, DOUBLE_TAP } td_state_t; -int cur_dance(qk_tap_dance_state_t *state); - -void altf2_finished(qk_tap_dance_state_t *state, void *user_data); -void altf2_reset(qk_tap_dance_state_t *state, void *user_data); -void ctlf5_finished(qk_tap_dance_state_t *state, void *user_data); -void ctlf5_reset(qk_tap_dance_state_t *state, void *user_data); -void altf7_finished(qk_tap_dance_state_t *state, void *user_data); -void altf7_reset(qk_tap_dance_state_t *state, void *user_data); +int cur_dance(tap_dance_state_t *state); + +void altf2_finished(tap_dance_state_t *state, void *user_data); +void altf2_reset(tap_dance_state_t *state, void *user_data); +void ctlf5_finished(tap_dance_state_t *state, void *user_data); +void ctlf5_reset(tap_dance_state_t *state, void *user_data); +void altf7_finished(tap_dance_state_t *state, void *user_data); +void altf7_reset(tap_dance_state_t *state, void *user_data); diff --git a/users/jdelkins/jdelkins.c b/users/jdelkins/jdelkins.c index e7bef607c9..4f59e8901b 100644 --- a/users/jdelkins/jdelkins.c +++ b/users/jdelkins/jdelkins.c @@ -45,7 +45,7 @@ void send_secret_string(uint8_t n) { // To activate SINGLE_HOLD, you will need to hold for 200ms first. // This tap dance favors keys that are used frequently in typing like 'f' -int cur_dance(qk_tap_dance_state_t *state) { +int cur_dance(tap_dance_state_t *state) { if (state->count == 1) { // If count = 1, and it has been interrupted - it doesn't matter if it // is pressed or not: Send SINGLE_TAP @@ -84,7 +84,7 @@ int cur_dance(qk_tap_dance_state_t *state) { // This works well if you want this key to work as a "fast modifier". It favors // being held over being tapped. -int hold_cur_dance(qk_tap_dance_state_t *state) { +int hold_cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted) { if (!state->pressed) diff --git a/users/jdelkins/jdelkins.h b/users/jdelkins/jdelkins.h index ddec8dc4ae..7c9f2d021c 100644 --- a/users/jdelkins/jdelkins.h +++ b/users/jdelkins/jdelkins.h @@ -128,7 +128,7 @@ enum { TRIPLE_HOLD = 7 }; -int cur_dance(qk_tap_dance_state_t *state); // prefer tap -int hold_cur_dance(qk_tap_dance_state_t *state); // prefer hold +int cur_dance(tap_dance_state_t *state); // prefer tap +int hold_cur_dance(tap_dance_state_t *state); // prefer hold #endif // TAP_DANCE_ENABLE diff --git a/users/jonavin/jonavin.c b/users/jonavin/jonavin.c index f203bd77df..94173ac20e 100644 --- a/users/jonavin/jonavin.c +++ b/users/jonavin/jonavin.c @@ -22,7 +22,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #ifdef TD_LSFT_CAPSLOCK_ENABLE // Tap once for shift, twice for Caps Lock but only if Win Key in not disabled - void dance_LSFT_finished(qk_tap_dance_state_t *state, void *user_data) { + void dance_LSFT_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 1 || keymap_config.no_gui) { register_code16(KC_LSFT); } else { @@ -30,7 +30,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. } } - void dance_LSFT_reset(qk_tap_dance_state_t *state, void *user_data) { + void dance_LSFT_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 1 || keymap_config.no_gui) { unregister_code16(KC_LSFT); } else { @@ -38,7 +38,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. } } - qk_tap_dance_action_t tap_dance_actions[] = { + tap_dance_action_t tap_dance_actions[] = { // Tap once for shift, twice for Caps Lock [TD_LSFT_CAPSLOCK] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), [TD_LSFT_CAPS_WIN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_LSFT_finished, dance_LSFT_reset), diff --git a/users/klackygears/tap_dances.c b/users/klackygears/tap_dances.c index 9f706d2b7f..3749e0ed4e 100644 --- a/users/klackygears/tap_dances.c +++ b/users/klackygears/tap_dances.c @@ -1,7 +1,7 @@ #include "tap_dances.h" /* -void macroTogKey(qk_tap_dance_state_t *state, void *user_data) { +void macroTogKey(tap_dance_state_t *state, void *user_data) { keyrecord_t kr; if (state->count == 1) @@ -21,7 +21,7 @@ void macroTogKey(qk_tap_dance_state_t *state, void *user_data) { } } -void macroTogKey2(qk_tap_dance_state_t *state, void *user_data) { +void macroTogKey2(tap_dance_state_t *state, void *user_data) { keyrecord_t kr; if (state->count == 1) @@ -42,7 +42,7 @@ void macroTogKey2(qk_tap_dance_state_t *state, void *user_data) { } */ -void pstinsrt(qk_tap_dance_state_t *state, void *user_data) { +void pstinsrt(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { register_code(KC_LALT); tap_code(KC_I); @@ -54,7 +54,7 @@ void pstinsrt(qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void ccopy(qk_tap_dance_state_t *state, void *user_data) { +void ccopy(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_code16(C(KC_X)); @@ -65,7 +65,7 @@ void ccopy(qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void pstspecial(qk_tap_dance_state_t *state, void *user_data) { +void pstspecial(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { register_code(KC_LALT); tap_code(KC_E); @@ -82,7 +82,7 @@ void pstspecial(qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void deldel(qk_tap_dance_state_t *state, void *user_data) { +void deldel(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { register_code(KC_LALT); tap_code(KC_E); @@ -94,7 +94,7 @@ void deldel(qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void findreplace(qk_tap_dance_state_t *state, void *user_data) { +void findreplace(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_code16(C(KC_H)); } else { @@ -103,7 +103,7 @@ void findreplace(qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void cyclawin(qk_tap_dance_state_t *state, void *user_data) { +void cyclawin(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_code16(C(S(KC_F6))); } else { @@ -112,7 +112,7 @@ void cyclawin(qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void SCRNSNP(qk_tap_dance_state_t *state, void *user_data) { +void SCRNSNP(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_code16(A(KC_PSCR)); } else { @@ -124,7 +124,7 @@ void SCRNSNP(qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void mcccpy(qk_tap_dance_state_t *state, void *user_data) { +void mcccpy(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_code16(G(KC_X)); } else { @@ -133,7 +133,7 @@ void mcccpy(qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void mcpstin(qk_tap_dance_state_t *state, void *user_data) { +void mcpstin(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_code16(G(KC_I)); } else { @@ -142,7 +142,7 @@ void mcpstin(qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void enttab(qk_tap_dance_state_t *state, void *user_data) { +void enttab(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_code(KC_ENT); } else { @@ -151,7 +151,7 @@ void enttab(qk_tap_dance_state_t *state, void *user_data) { reset_tap_dance(state); } -void rgb_toggle(qk_tap_dance_state_t *state, void *user_data) { +void rgb_toggle(tap_dance_state_t *state, void *user_data) { #ifdef RGBLIGHT_ENABLE if (state->count == 1) { rgblight_step(); @@ -162,7 +162,7 @@ void rgb_toggle(qk_tap_dance_state_t *state, void *user_data) { } // Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_PSTI] = ACTION_TAP_DANCE_FN(pstinsrt), [TD_PTSP] = ACTION_TAP_DANCE_FN(pstspecial), [TD_FNDR] = ACTION_TAP_DANCE_FN(findreplace), diff --git a/users/konstantin/tap_dance.c b/users/konstantin/tap_dance.c index 57a29d98b8..38d00bf56c 100644 --- a/users/konstantin/tap_dance.c +++ b/users/konstantin/tap_dance.c @@ -19,11 +19,11 @@ #define ACTION_TAP_DANCE_DOUBLE_MOD(mod1, mod2) { \ .fn = { td_double_mod_each, NULL, td_double_mod_reset }, \ - .user_data = &(qk_tap_dance_pair_t){ mod1, mod2 }, \ + .user_data = &(tap_dance_pair_t){ mod1, mod2 }, \ } -void td_double_mod_each(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_pair_t *data = (qk_tap_dance_pair_t *)user_data; +void td_double_mod_each(tap_dance_state_t *state, void *user_data) { + tap_dance_pair_t *data = (tap_dance_pair_t *)user_data; // Single tap → mod1, double tap → mod2, triple tap etc. → mod1+mod2 if (state->count == 1 || state->count == 3) { @@ -36,8 +36,8 @@ void td_double_mod_each(qk_tap_dance_state_t *state, void *user_data) { state->weak_mods &= ~(MOD_BIT(data->kc1) | MOD_BIT(data->kc2)); } -void td_double_mod_reset(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_pair_t *data = (qk_tap_dance_pair_t *)user_data; +void td_double_mod_reset(tap_dance_state_t *state, void *user_data) { + tap_dance_pair_t *data = (tap_dance_pair_t *)user_data; if (state->count == 1 || state->count >= 3) { unregister_code(data->kc1); @@ -49,11 +49,11 @@ void td_double_mod_reset(qk_tap_dance_state_t *state, void *user_data) { #define ACTION_TAP_DANCE_MOD_LAYER(mod, layer) { \ .fn = { td_mod_layer_each, NULL, td_mod_layer_reset }, \ - .user_data = &(qk_tap_dance_dual_role_t){ mod, layer }, \ + .user_data = &(tap_dance_dual_role_t){ mod, layer }, \ } -void td_mod_layer_each(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_dual_role_t *data = (qk_tap_dance_dual_role_t *)user_data; +void td_mod_layer_each(tap_dance_state_t *state, void *user_data) { + tap_dance_dual_role_t *data = (tap_dance_dual_role_t *)user_data; // Single tap → mod, double tap → layer, triple tap etc. → mod+layer if (state->count == 1 || state->count == 3) { @@ -66,8 +66,8 @@ void td_mod_layer_each(qk_tap_dance_state_t *state, void *user_data) { } } -void td_mod_layer_reset(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_dual_role_t *data = (qk_tap_dance_dual_role_t *)user_data; +void td_mod_layer_reset(tap_dance_state_t *state, void *user_data) { + tap_dance_dual_role_t *data = (tap_dance_dual_role_t *)user_data; if (state->count == 1 || state->count >= 3) { unregister_code(data->kc); @@ -79,7 +79,7 @@ void td_mod_layer_reset(qk_tap_dance_state_t *state, void *user_data) { #define ACTION_TAP_DANCE_LAYER_MOD(layer, mod) { \ .fn = { td_layer_mod_each, NULL, td_layer_mod_reset }, \ - .user_data = &(qk_tap_dance_layer_mod_t){ layer, mod, 0, 0 }, \ + .user_data = &(tap_dance_layer_mod_t){ layer, mod, 0, 0 }, \ } typedef struct { @@ -87,10 +87,10 @@ typedef struct { uint16_t kc; bool layer_on; // Layer state when tap dance started bool started; -} qk_tap_dance_layer_mod_t; +} tap_dance_layer_mod_t; -void td_layer_mod_each(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_layer_mod_t *data = (qk_tap_dance_layer_mod_t *)user_data; +void td_layer_mod_each(tap_dance_state_t *state, void *user_data) { + tap_dance_layer_mod_t *data = (tap_dance_layer_mod_t *)user_data; if (!data->started) { data->layer_on = IS_LAYER_ON(data->layer); data->started = true; @@ -107,8 +107,8 @@ void td_layer_mod_each(qk_tap_dance_state_t *state, void *user_data) { } } -void td_layer_mod_reset(qk_tap_dance_state_t *state, void *user_data) { - qk_tap_dance_layer_mod_t *data = (qk_tap_dance_layer_mod_t *)user_data; +void td_layer_mod_reset(tap_dance_state_t *state, void *user_data) { + tap_dance_layer_mod_t *data = (tap_dance_layer_mod_t *)user_data; if ((state->count == 1 || state->count >= 3) && !data->layer_on) { layer_off(data->layer); @@ -120,7 +120,7 @@ void td_layer_mod_reset(qk_tap_dance_state_t *state, void *user_data) { data->started = false; } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_DST_A_R] = ACTION_TAP_DANCE_DOUBLE(DST_ADD, DST_REM), [TD_RAL_RGU] = ACTION_TAP_DANCE_DOUBLE_MOD(KC_RALT, KC_RGUI), diff --git a/users/kuatsure/kuatsure.c b/users/kuatsure/kuatsure.c index 84afcc9623..bfdbdd4035 100644 --- a/users/kuatsure/kuatsure.c +++ b/users/kuatsure/kuatsure.c @@ -1,7 +1,7 @@ #include "kuatsure.h" #include "version.h" -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LBRC] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_LT), [TD_RBRC] = ACTION_TAP_DANCE_DOUBLE(KC_RBRC, KC_GT), [TD_SLSH] = ACTION_TAP_DANCE_DOUBLE(KC_SLSH, KC_BSLS), diff --git a/users/kuchosauronad0/config.h b/users/kuchosauronad0/config.h index 9315f879ae..bc0fe67df8 100644 --- a/users/kuchosauronad0/config.h +++ b/users/kuchosauronad0/config.h @@ -70,7 +70,7 @@ // actually sends Ctrl-x. That's bad.) #define IGNORE_MOD_TAP_INTERRUPT #undef PERMISSIVE_HOLD -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 //#define RETRO_TAPPING #ifndef TAPPING_TOGGLE diff --git a/users/kuchosauronad0/leader.c b/users/kuchosauronad0/leader.c index ac2a6599a1..e8935ec401 100644 --- a/users/kuchosauronad0/leader.c +++ b/users/kuchosauronad0/leader.c @@ -93,7 +93,7 @@ void matrix_scan_user(void) { // matrix_scan_keymap(); } -void leader_start(void) { +void leader_start_user(void) { #ifdef RGBLIGHT_ENABLE rgblight_savebase(); rgblight_mode_noeeprom(1); @@ -101,7 +101,7 @@ void leader_start(void) { #endif } -void leader_end(void) { +void leader_end_user(void) { // pick color depending of success /fail // fade leader_start from 100 to 0 // fade new color from 0 to 100 to 0 diff --git a/users/kuchosauronad0/tap_dances.c b/users/kuchosauronad0/tap_dances.c index 7bdd3d3375..40d1c245e3 100644 --- a/users/kuchosauronad0/tap_dances.c +++ b/users/kuchosauronad0/tap_dances.c @@ -1,5 +1,5 @@ #include "tap_dances.h" -void td_parenthesis (qk_tap_dance_state_t *state, void *user_data) { +void td_parenthesis (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { // SEND_STRING ("\("); tap_code(KC_QUOT); @@ -23,7 +23,7 @@ void td_parenthesis (qk_tap_dance_state_t *state, void *user_data) { } } -void safe_reset(qk_tap_dance_state_t *state, void *user_data) { +void safe_reset(tap_dance_state_t *state, void *user_data) { if (state->count >= 3) { // Reset the keyboard if you tap the key more than three times reset_keyboard(); @@ -31,7 +31,7 @@ void safe_reset(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_RESET] = ACTION_TAP_DANCE_FN(safe_reset), [TD_NUM1] = ACTION_TAP_DANCE_DOUBLE(KC_1, KC_4), [TD_NUM2] = ACTION_TAP_DANCE_DOUBLE(KC_2, KC_5), diff --git a/users/kuchosauronad0/tap_dances.h b/users/kuchosauronad0/tap_dances.h index 19da8d69dc..818bbd7b93 100644 --- a/users/kuchosauronad0/tap_dances.h +++ b/users/kuchosauronad0/tap_dances.h @@ -23,4 +23,4 @@ enum { TD_ABR // single double angle brackets }; #endif // TAP_DANCE_ENABLE -void td_parenthesis (qk_tap_dance_state_t *state, void *user_data); +void td_parenthesis (tap_dance_state_t *state, void *user_data); diff --git a/users/losinggeneration/losinggeneration-keymap.h b/users/losinggeneration/losinggeneration-keymap.h index bb1c6cf697..14e25adecc 100644 --- a/users/losinggeneration/losinggeneration-keymap.h +++ b/users/losinggeneration/losinggeneration-keymap.h @@ -17,7 +17,7 @@ enum tap_dance_keycodes { Used to indicate a CTRL should be pressed on one press, or CTRL+ALT on a double tap */ -void dance_ctl_ctlalt_each(qk_tap_dance_state_t *state, void *user_data) { +void dance_ctl_ctlalt_each(tap_dance_state_t *state, void *user_data) { register_code(KC_LCTL); if(state->count > 1) { register_code(KC_LALT); @@ -25,7 +25,7 @@ void dance_ctl_ctlalt_each(qk_tap_dance_state_t *state, void *user_data) { } /* Used to release CTRL or the double tapped variant CTRL+ALT */ -void dance_ctl_ctlalt_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_ctl_ctlalt_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); if(state->count > 1) { unregister_code(KC_LALT); @@ -37,7 +37,7 @@ void dance_ctl_ctlalt_reset(qk_tap_dance_state_t *state, void *user_data) { Each is used to make sure ADJUST activates as soon as it's pressed the first time. */ -void dance_adj_each(qk_tap_dance_state_t *state, void *user_data) { +void dance_adj_each(tap_dance_state_t *state, void *user_data) { if(state->count == 1) { layer_on(_ADJUST); } else { @@ -46,7 +46,7 @@ void dance_adj_each(qk_tap_dance_state_t *state, void *user_data) { } /* Set NUMPAD layer on second tap and MOUSE layer on 3rd */ -void dance_adj_finish(qk_tap_dance_state_t *state, void *user_data) { +void dance_adj_finish(tap_dance_state_t *state, void *user_data) { switch(state->count) { case 1: break; case 2: @@ -62,7 +62,7 @@ void dance_adj_finish(qk_tap_dance_state_t *state, void *user_data) { } /* Turn off any layer that may have been tapped on */ -void dance_adj_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_adj_reset(tap_dance_state_t *state, void *user_data) { switch(state->count) { case 1: layer_off(_ADJUST); @@ -76,7 +76,7 @@ void dance_adj_reset(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_CTL_CTLALT] = ACTION_TAP_DANCE_FN_ADVANCED(dance_ctl_ctlalt_each, NULL, dance_ctl_ctlalt_reset), [TD_LGUI_RGUI] = ACTION_TAP_DANCE_DOUBLE(KC_LGUI, KC_RGUI), [TD_LALT_RALT] = ACTION_TAP_DANCE_DOUBLE(KC_LALT, KC_RALT), diff --git a/users/manna-harbour_miryoku/config.h b/users/manna-harbour_miryoku/config.h index 920003598e..429e08493d 100644 --- a/users/manna-harbour_miryoku/config.h +++ b/users/manna-harbour_miryoku/config.h @@ -15,7 +15,7 @@ #define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -#define TAPPING_FORCE_HOLD +#define QUICK_TAP_TERM 0 // Auto Shift #define NO_AUTO_SHIFT_ALPHA @@ -40,4 +40,3 @@ #define COMBO_TERM 200 #define EXTRA_SHORT_COMBOS #endif - diff --git a/users/manna-harbour_miryoku/manna-harbour_miryoku.c b/users/manna-harbour_miryoku/manna-harbour_miryoku.c index 5de5d9b129..4662bd8f42 100644 --- a/users/manna-harbour_miryoku/manna-harbour_miryoku.c +++ b/users/manna-harbour_miryoku/manna-harbour_miryoku.c @@ -17,14 +17,14 @@ MIRYOKU_LAYER_LIST #undef MIRYOKU_X }; -void u_td_fn_boot(qk_tap_dance_state_t *state, void *user_data) { \ +void u_td_fn_boot(tap_dance_state_t *state, void *user_data) { \ if (state->count == 2) { reset_keyboard(); } } #define MIRYOKU_X(LAYER, STRING) \ -void u_td_fn_U_##LAYER(qk_tap_dance_state_t *state, void *user_data) { \ +void u_td_fn_U_##LAYER(tap_dance_state_t *state, void *user_data) { \ if (state->count == 2) { \ default_layer_set((layer_state_t)1 << U_##LAYER); \ } \ @@ -32,7 +32,7 @@ void u_td_fn_U_##LAYER(qk_tap_dance_state_t *state, void *user_data) { \ MIRYOKU_LAYER_LIST #undef MIRYOKU_X -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [U_TD_BOOT] = ACTION_TAP_DANCE_FN(u_td_fn_boot), #define MIRYOKU_X(LAYER, STRING) [U_TD_U_##LAYER] = ACTION_TAP_DANCE_FN(u_td_fn_U_##LAYER), MIRYOKU_LAYER_LIST diff --git a/users/mnil/mnil.c b/users/mnil/mnil.c index 00da6086ef..eb3b4a1c9d 100644 --- a/users/mnil/mnil.c +++ b/users/mnil/mnil.c @@ -54,7 +54,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { // Tap Dance // Determine the current tap dance state -int cur_dance(qk_tap_dance_state_t *state) { +int cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return SINGLE_TAP; @@ -79,7 +79,7 @@ int cur_dance(qk_tap_dance_state_t *state) { static tap ae_tap_state = {.is_press_action = true, .state = 0}; -void ae_finished(qk_tap_dance_state_t *state, void *user_data) { +void ae_finished(tap_dance_state_t *state, void *user_data) { ae_tap_state.state = cur_dance(state); switch (ae_tap_state.state) { case SINGLE_TAP: @@ -95,7 +95,7 @@ void ae_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void ae_reset(qk_tap_dance_state_t *state, void *user_data) { +void ae_reset(tap_dance_state_t *state, void *user_data) { switch (ae_tap_state.state) { case SINGLE_TAP: unregister_code(KC_A); @@ -109,7 +109,7 @@ void ae_reset(qk_tap_dance_state_t *state, void *user_data) { static tap aa_tap_state = {.is_press_action = true, .state = 0}; -void aa_finished(qk_tap_dance_state_t *state, void *user_data) { +void aa_finished(tap_dance_state_t *state, void *user_data) { aa_tap_state.state = cur_dance(state); switch (aa_tap_state.state) { case SINGLE_TAP: @@ -126,7 +126,7 @@ void aa_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void aa_reset(qk_tap_dance_state_t *state, void *user_data) { +void aa_reset(tap_dance_state_t *state, void *user_data) { switch (aa_tap_state.state) { case SINGLE_TAP: unregister_code(SE_ODIA); @@ -139,7 +139,7 @@ void aa_reset(qk_tap_dance_state_t *state, void *user_data) { } // clang-format off -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [AAE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ae_finished, ae_reset), [OAA] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, aa_finished, aa_reset) }; diff --git a/users/muppetjones/config.h b/users/muppetjones/config.h index 3dd4d1b1b6..583567d4f3 100644 --- a/users/muppetjones/config.h +++ b/users/muppetjones/config.h @@ -34,7 +34,7 @@ # define IGNORE_MOD_TAP_INTERRUPT // Enable rapid switch from tap to hold, disables double tap hold auto-repeat. -# define TAPPING_FORCE_HOLD +# define QUICK_TAP_TERM 0 #endif diff --git a/users/muppetjones/features/dancelayers.c b/users/muppetjones/features/dancelayers.c index e7e5f2a6f2..3744950a4f 100644 --- a/users/muppetjones/features/dancelayers.c +++ b/users/muppetjones/features/dancelayers.c @@ -27,7 +27,7 @@ static td_tap_t lyr_tap_state = {.is_press_action = true, .state = TD_NONE}; * @param A tap dance state struct. * @return A struct. */ -td_state_t cur_dance(qk_tap_dance_state_t *state) { +td_state_t cur_dance(tap_dance_state_t *state) { switch (state->count) { case 1: if (!state->pressed) @@ -49,7 +49,7 @@ td_state_t cur_dance(qk_tap_dance_state_t *state) { } // Functions that control what our tap dance key does -__attribute__((weak)) void td_layer_finished(qk_tap_dance_state_t *state, void *user_data) { +__attribute__((weak)) void td_layer_finished(tap_dance_state_t *state, void *user_data) { lyr_tap_state.state = cur_dance(state); switch (lyr_tap_state.state) { case TD_1X_TAP: @@ -87,7 +87,7 @@ __attribute__((weak)) void td_layer_finished(qk_tap_dance_state_t *state, void * } } -__attribute__((weak)) void td_layer_reset(qk_tap_dance_state_t *state, void *user_data) { +__attribute__((weak)) void td_layer_reset(tap_dance_state_t *state, void *user_data) { // If the key was held down and now is released then switch off the layer if (lyr_tap_state.state == TD_1X_HOLD) { layer_off(_ADJUST); diff --git a/users/muppetjones/features/dancelayers.h b/users/muppetjones/features/dancelayers.h index 23defcca92..5f7440f48b 100644 --- a/users/muppetjones/features/dancelayers.h +++ b/users/muppetjones/features/dancelayers.h @@ -51,7 +51,7 @@ typedef struct { * @param A tap dance state struct. * @return A struct. */ -td_state_t cur_dance(qk_tap_dance_state_t *state); +td_state_t cur_dance(tap_dance_state_t *state); // Functions associated with individual tap dances @@ -63,7 +63,7 @@ td_state_t cur_dance(qk_tap_dance_state_t *state); * @param user_data Pointer to user data. * @return None. */ -void td_layer_finished(qk_tap_dance_state_t *state, void *user_data); +void td_layer_finished(tap_dance_state_t *state, void *user_data); /* @brief Reset tap dance actions. * @@ -73,10 +73,10 @@ void td_layer_finished(qk_tap_dance_state_t *state, void *user_data); * @param user_data Pointer to user data. * @return None. */ -void td_layer_reset(qk_tap_dance_state_t *state, void *user_data); +void td_layer_reset(tap_dance_state_t *state, void *user_data); /* Define tap dance actions. */ __attribute__((weak)) -qk_tap_dance_action_t tap_dance_actions[1] = {[TD_LAYERS] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, td_layer_finished, td_layer_reset, 275)}; +tap_dance_action_t tap_dance_actions[1] = {[TD_LAYERS] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, td_layer_finished, td_layer_reset, 275)}; #endif diff --git a/users/ninjonas/tap_dances.c b/users/ninjonas/tap_dances.c index 3e4cec9133..c03433e2d6 100644 --- a/users/ninjonas/tap_dances.c +++ b/users/ninjonas/tap_dances.c @@ -1,7 +1,7 @@ #include "ninjonas.h" //// BEGIN: Advanced Tap Dances -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) return SINGLE_TAP; //key has not been interrupted, but they key is still held. Means you want to send a 'HOLD'. @@ -34,7 +34,7 @@ static tap copy_paste_app_tap_state = { .state = 0 }; -void copy_paste_app_finished (qk_tap_dance_state_t *state, void *user_data) { +void copy_paste_app_finished (tap_dance_state_t *state, void *user_data) { copy_paste_app_tap_state.state = cur_dance(state); switch (copy_paste_app_tap_state.state) { case SINGLE_TAP: @@ -56,7 +56,7 @@ void copy_paste_app_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void copy_paste_app_reset (qk_tap_dance_state_t *state, void *user_data) { +void copy_paste_app_reset (tap_dance_state_t *state, void *user_data) { copy_paste_app_tap_state.state = 0; } // END: Copy, Paste, Apps @@ -67,7 +67,7 @@ static tap y_numpad_tap_state = { .state = 0 }; -void y_numpad_finished (qk_tap_dance_state_t *state, void *user_data) { +void y_numpad_finished (tap_dance_state_t *state, void *user_data) { y_numpad_tap_state.state = cur_dance(state); switch (y_numpad_tap_state.state) { case SINGLE_TAP: @@ -86,7 +86,7 @@ void y_numpad_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void y_numpad_reset (qk_tap_dance_state_t *state, void *user_data) { +void y_numpad_reset (tap_dance_state_t *state, void *user_data) { switch (y_numpad_tap_state.state) { case SINGLE_HOLD: unregister_code16(KC_Y); @@ -98,7 +98,7 @@ void y_numpad_reset (qk_tap_dance_state_t *state, void *user_data) { //// END: Advanced Tap Dances -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_ESC_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS), [TD_LBRC_BACK] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, LGUI(KC_LBRC)), [TD_RBRC_FWD] = ACTION_TAP_DANCE_DOUBLE(KC_RBRC, LGUI(KC_RBRC)), diff --git a/users/nstickney/nstickney.c b/users/nstickney/nstickney.c index 94453ec340..b056e1cbaf 100644 --- a/users/nstickney/nstickney.c +++ b/users/nstickney/nstickney.c @@ -16,7 +16,7 @@ #include "nstickney.h" // Tap Dancing -void dance_layer(qk_tap_dance_state_t *state, void *user_data) { +void dance_layer(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: tap_code(KC_APP); @@ -32,7 +32,7 @@ void dance_layer(qk_tap_dance_state_t *state, void *user_data) { } }; -void dance_lock_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_lock_finished(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: register_code(KC_LGUI); @@ -51,7 +51,7 @@ void dance_lock_finished(qk_tap_dance_state_t *state, void *user_data) { } }; -void dance_lock_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_lock_reset(tap_dance_state_t *state, void *user_data) { switch (state->count) { case 1: unregister_code(KC_LGUI); @@ -70,7 +70,7 @@ void dance_lock_reset(qk_tap_dance_state_t *state, void *user_data) { } }; -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [LOCKS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_lock_finished, dance_lock_reset), [LAYERS] = ACTION_TAP_DANCE_FN(dance_layer) }; diff --git a/users/pvinis/pvinis.c b/users/pvinis/pvinis.c index 96b01bb461..f3263f9bd5 100644 --- a/users/pvinis/pvinis.c +++ b/users/pvinis/pvinis.c @@ -75,7 +75,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { } #ifdef TAP_DANCE_ENABLE -qk_tap_dance_action_t tap_dance_actions[] = {}; +tap_dance_action_t tap_dance_actions[] = {}; #endif void keyboard_post_init_rgb_light(void) { diff --git a/users/replicaJunction/features/.gitignore b/users/replicaJunction/features/.gitignore deleted file mode 100644 index 9b590ee802..0000000000 --- a/users/replicaJunction/features/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -# Do not include the secrets definitions -secret_definitions.h diff --git a/users/replicaJunction/features/caps_word.c b/users/replicaJunction/features/caps_word.c deleted file mode 100644 index 536da81ec7..0000000000 --- a/users/replicaJunction/features/caps_word.c +++ /dev/null @@ -1,105 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include "caps_word.h" - -static bool is_caps_word_on = false; - -bool is_caps_word_enabled(void) { - return is_caps_word_on; -} - -void enable_caps_word(void) { - if (is_caps_word_on) return; - is_caps_word_on = true; - tap_code(KC_CAPS); -} - -void disable_caps_word(void) { - if (!is_caps_word_on) return; - is_caps_word_on = false; - tap_code(KC_CAPS); -} - -void toggle_caps_word(void) { - if (is_caps_word_on) { - disable_caps_word(); - } - else { - enable_caps_word(); - } -} - -bool should_terminate_caps_word(uint16_t keycode, const keyrecord_t *record) { - switch (keycode) { - // Keycodes which should not disable caps word mode - case KC_A ... KC_Z: - case KC_1 ... KC_0: - case KC_MINS: - case KC_UNDS: - case KC_BSPC: - return false; - - default: - if (record->event.pressed) { - return true; - } - return false; - } - - // Should be unreachable - return false; -} - - -bool process_record_caps_word(uint16_t keycode, const keyrecord_t *record) { - // Nothing in this function acts on key release - if (!record->event.pressed) { - return true; - } - - // Handle the custom keycodes that go with this feature - if (keycode == CAPWORD) { - enable_caps_word(); - return false; - } - - // If the behavior isn't enabled and the keypress isn't a keycode to - // toggle the behavior, allow QMK to handle the keypress as usual - if (!is_caps_word_on) { - return true; - } - - // Get the base keycode of a mod or layer tap key - switch (keycode) { - case QK_MOD_TAP ... QK_MOD_TAP_MAX: - case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: - case QK_TAP_DANCE ... QK_TAP_DANCE_MAX: - // Earlier return if this has not been considered tapped yet - if (record->tap.count == 0) - return true; - keycode = keycode & 0xFF; - break; - default: - break; - } - - if (should_terminate_caps_word(keycode, record)) { - disable_caps_word(); - } - - return true; -} diff --git a/users/replicaJunction/features/caps_word.h b/users/replicaJunction/features/caps_word.h deleted file mode 100644 index 4182ce5829..0000000000 --- a/users/replicaJunction/features/caps_word.h +++ /dev/null @@ -1,26 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once -#include QMK_KEYBOARD_H -#include "rj_keycodes.h" - -bool is_caps_word_enabled(void); -void enable_caps_word(void); -void disable_caps_word(void); -void toggle_caps_word(void); - -bool process_record_caps_word(uint16_t keycode, const keyrecord_t *record); diff --git a/users/replicaJunction/features/mouse_jiggle.c b/users/replicaJunction/features/mouse_jiggle.c deleted file mode 100644 index b2c451d33e..0000000000 --- a/users/replicaJunction/features/mouse_jiggle.c +++ /dev/null @@ -1,46 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include "mouse_jiggle.h" - -bool is_mouse_jiggle_active = false; - -void matrix_scan_mouse_jiggle(void) { - if (is_mouse_jiggle_active) { - tap_code(KC_MS_UP); - tap_code(KC_MS_DOWN); - } -} - -bool process_record_mouse_jiggle(uint16_t keycode, const keyrecord_t *record) { - if (!record->event.pressed) { - return true; - } - - if (is_mouse_jiggle_active) { - // If active, quit whenever another key is pressed - is_mouse_jiggle_active = false; - return true; - } - - if (keycode != MS_JIGL) { - return true; - } - - is_mouse_jiggle_active = true; - SEND_STRING("Mouse jiggler enabled"); - return false; -} diff --git a/users/replicaJunction/features/mouse_jiggle.h b/users/replicaJunction/features/mouse_jiggle.h deleted file mode 100644 index ba2c6e7570..0000000000 --- a/users/replicaJunction/features/mouse_jiggle.h +++ /dev/null @@ -1,23 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once -#include QMK_KEYBOARD_H -#include "rj_keycodes.h" - -void matrix_scan_mouse_jiggle(void); - -bool process_record_mouse_jiggle(uint16_t keycode, const keyrecord_t *record); diff --git a/users/replicaJunction/features/num_word.c b/users/replicaJunction/features/num_word.c deleted file mode 100644 index 4cca5c19ae..0000000000 --- a/users/replicaJunction/features/num_word.c +++ /dev/null @@ -1,129 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include "num_word.h" - -static uint16_t num_word_timer = 0; -static bool is_num_word_on = false; - -bool is_num_word_enabled(void) { - return is_num_word_on; -} - -void enable_num_word(void) { - if (is_num_word_on) return; - is_num_word_on = true; - layer_on(L_NUMBERS); -} - -void disable_num_word(void) { - if (!is_num_word_on) return; - is_num_word_on = false; - layer_off(L_NUMBERS); -} - -void toggle_num_word(void) { - if (is_num_word_on) { - disable_num_word(); - } - else { - enable_num_word(); - } -} - -bool should_terminate_num_word(uint16_t keycode, const keyrecord_t *record) { - switch (keycode) { - // Keycodes which should not disable num word mode. - // We could probably be more brief with these definitions by using - // a couple more ranges, but I believe "explicit is better than - // implicit" - case KC_1 ... KC_0: - case KC_EQL: - case KC_SCLN: - case KC_MINS: - case KC_DOT: - - // Numpad keycodes - case KC_P1 ... KC_P0: - case KC_PSLS ... KC_PPLS: - case KC_PDOT: - - // Misc - case KC_UNDS: - case KC_BSPC: - return false; - - default: - if (record->event.pressed) { - return true; - } - return false; - } - - // Should be unreachable - return false; -} - - -bool process_record_num_word(uint16_t keycode, const keyrecord_t *record) { - // Handle the custom keycodes that go with this feature - if (keycode == NUMWORD) { - if (record->event.pressed) { - enable_num_word(); - num_word_timer = timer_read(); - return false; - } - else { - if (timer_elapsed(num_word_timer) > TAPPING_TERM) { - // If the user held the key longer than TAPPING_TERM, - // consider it a hold, and disable the behavior on - // key release. - disable_num_word(); - return false; - } - } - } - - // Other than the custom keycodes, nothing else in this feature will - // activate if the behavior is not on, so allow QMK to handle the - // event as usual - if (!is_num_word_on) return true; - - // Nothing else acts on key release, either - if (!record->event.pressed) { - return true; - } - - // Get the base keycode of a mod or layer tap key - switch (keycode) { - case QK_MOD_TAP ... QK_MOD_TAP_MAX: - case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: - case QK_TAP_DANCE ... QK_TAP_DANCE_MAX: - // Earlier return if this has not been considered tapped yet - if (record->tap.count == 0) - return true; - keycode = keycode & 0xFF; - break; - default: - break; - } - - if (should_terminate_num_word(keycode, record)) { - disable_num_word(); - } - - return true; -} diff --git a/users/replicaJunction/features/num_word.h b/users/replicaJunction/features/num_word.h deleted file mode 100644 index 194c4e2e0d..0000000000 --- a/users/replicaJunction/features/num_word.h +++ /dev/null @@ -1,27 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once -#include QMK_KEYBOARD_H -#include "rj_keycodes.h" -#include "rj_layers.h" - -bool is_num_word_enabled(void); -void enable_num_word(void); -void disable_num_word(void); -void toggle_num_word(void); - -bool process_record_num_word(uint16_t keycode, const keyrecord_t *record); diff --git a/users/replicaJunction/features/secrets.c b/users/replicaJunction/features/secrets.c deleted file mode 100644 index 3e1ea283dc..0000000000 --- a/users/replicaJunction/features/secrets.c +++ /dev/null @@ -1,51 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -// Before you can compile with this feature, you'll need to manually -// create a file in this directory called "secret_definitions.h" -// containing the data to be added. -// -// Example implementation: -// -// #pragma once -// static const char * const secrets[] = { -// "secret1", -// "secret2", -// "secret3", -// "secret4" -// } - -#include QMK_KEYBOARD_H -#include "replicaJunction.h" -#include "secrets.h" -#include "secret_definitions.h" - -#ifndef MACRO_TIMER -# define MACRO_TIMER 5 -#endif - -bool process_record_secrets(uint16_t keycode, const keyrecord_t *record) { - switch (keycode) { - case K_SECR1 ... K_SECR4: // Secrets! Externally defined strings, not stored in repo - if (!record->event.pressed) { - clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED); - send_string_with_delay(secrets[keycode - K_SECR1], MACRO_TIMER); - } - return false; - } - - return true; -} diff --git a/users/replicaJunction/features/secrets.h b/users/replicaJunction/features/secrets.h deleted file mode 100644 index ef43962272..0000000000 --- a/users/replicaJunction/features/secrets.h +++ /dev/null @@ -1,30 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once -#include QMK_KEYBOARD_H - -// NOTE: In some implementations of the "secrets" functionality, the -// secrets.h file is the file that actually contains secret text. -// -// This is not the case in my implementation. That file is called -// "secret_definitions.h", and it's in a local .gitignore file so it -// does not get committed. -// -// The inclusion of this file is not an error, and there is no sensitive -// text here. - -bool process_record_secrets(uint16_t keycode, const keyrecord_t *record); diff --git a/users/replicaJunction/features/super_alt_tab.c b/users/replicaJunction/features/super_alt_tab.c deleted file mode 100644 index 9759898c87..0000000000 --- a/users/replicaJunction/features/super_alt_tab.c +++ /dev/null @@ -1,52 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include "super_alt_tab.h" - -// https://docs.qmk.fm/#/feature_macros?id=super-alt%E2%86%AFtab - -bool is_alt_tab_active = false; -uint16_t alt_tab_timer = 0; - -void matrix_scan_super_alt_tab(void) { - if (is_alt_tab_active) { - if (timer_elapsed(alt_tab_timer) > USER_SUPER_ALT_TAB_TIMEOUT) { - unregister_code(KC_LALT); - is_alt_tab_active = false; - } - } -} - - -bool process_record_super_alt_tab(uint16_t keycode, const keyrecord_t *record) { - if (keycode != SALTTAB) { - return true; - } - - if (record->event.pressed) { - if (!is_alt_tab_active) { - is_alt_tab_active = true; - register_code(KC_LALT); - } - alt_tab_timer = timer_read(); - register_code(KC_TAB); - } - else { - unregister_code(KC_TAB); - } - - return false; -} diff --git a/users/replicaJunction/features/super_alt_tab.h b/users/replicaJunction/features/super_alt_tab.h deleted file mode 100644 index 8bdf2bc22e..0000000000 --- a/users/replicaJunction/features/super_alt_tab.h +++ /dev/null @@ -1,27 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once -#include QMK_KEYBOARD_H -#include "rj_keycodes.h" - -#ifndef USER_SUPER_ALT_TAB_TIMEOUT -# define USER_SUPER_ALT_TAB_TIMEOUT 500 -#endif - -void matrix_scan_super_alt_tab(void); - -bool process_record_super_alt_tab(uint16_t keycode, const keyrecord_t *record); diff --git a/users/replicaJunction/keycode_aliases.h b/users/replicaJunction/keycode_aliases.h deleted file mode 100644 index b1006a863c..0000000000 --- a/users/replicaJunction/keycode_aliases.h +++ /dev/null @@ -1,85 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once - -#include QMK_KEYBOARD_H - -// Transparent, but indicates that this key must be blocked (for example, a layer shift key) -#define ooooooo KC_TRNS - - -#define SFT_TAB LSFT(KC_TAB) -#define WIN_TAB LGUI(KC_TAB) -#define WIN_L LGUI(KC_L) -#define WIN_V LGUI(KC_V) -#define ALT_F4 LALT(KC_F4) -#define CTL_DEL LCTL_T(KC_DEL) -#define CTL_ESC CTL_T(KC_ESC) -#define ALT_ENT ALT_T(KC_ENT) -#define ALT_TAB ALT_T(KC_TAB) - -#define OSM_LSF OSM(MOD_LSFT) -#define OSM_RSF OSM(MOD_RSFT) - -// OS shortcuts (Windows) -#define OS_COPY LCTL(KC_C) -#define OS_PAST LCTL(KC_V) -#define OS_CUT LCTL(KC_X) -#define OS_UNDO LCTL(KC_Z) -#define OS_SALL LCTL(KC_A) -#define OS_FIND LCTL(KC_F) - - -// Home row modifiers -#define GUI_A LGUI_T(KC_A) -#define ALT_R LALT_T(KC_R) -#define SFT_S LSFT_T(KC_S) -#define CRT_T LCTL_T(KC_T) // we can't call this CTL_T because that name is taken! - -#define CRT_N RCTL_T(KC_N) -#define SFT_E RSFT_T(KC_E) -#define ALT_I RALT_T(KC_I) -#define GUI_O RGUI_T(KC_O) - - -// Mouse keys -#define M_UP KC_MS_UP -#define M_DOWN KC_MS_DOWN -#define M_LEFT KC_MS_LEFT -#define M_RIGHT KC_MS_RIGHT -#define M_LCLIK KC_MS_BTN1 -#define M_RCLIK KC_MS_BTN2 -#define M_MCLIK KC_MS_BTN3 -#define M_WHLUP KC_WH_U -#define M_WHLDN KC_WH_D - - -// Windows 10 shortcuts: change desktop to the left/right -#define DESKLFT LCTL(LGUI(KC_LEFT)) -#define DESKRGT LCTL(LGUI(KC_RGHT)) - - -// Application-specific shortcuts - -// Search: defined in Everything Search Engine as the keypress to show/hide the window -#define SEARCH HYPR(KC_S) - -// Microsoft PowerToys hotkeys -// https://github.com/microsoft/PowerToys -#define PTYRUN LALT(KC_SPC) // PowerToys Run -#define PTYZONE LGUI(KC_GRV) // PowerToys FancyZones -#define PTYCOLR LGUI(LSFT(KC_C)) // PowerToys ColorPicker diff --git a/users/replicaJunction/matrix_scan.c b/users/replicaJunction/matrix_scan.c deleted file mode 100644 index 969799550a..0000000000 --- a/users/replicaJunction/matrix_scan.c +++ /dev/null @@ -1,35 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include QMK_KEYBOARD_H -#include "replicaJunction.h" - -__attribute__ ((weak)) -void matrix_scan_user_kb(void) { } - -// Runs on every matrix scan. Be careful what goes here - you can really impact the -// responsiveness of your keyboard if you add too much in this function. -void matrix_scan_user(void) { -#ifdef USER_MOUSE_JIGGLE_ENABLE - matrix_scan_mouse_jiggle(); -#endif - -#ifdef USER_SUPER_ALT_TAB_ENABLE - matrix_scan_super_alt_tab(); -#endif - - matrix_scan_user_kb(); -} diff --git a/users/replicaJunction/process_records.c b/users/replicaJunction/process_records.c deleted file mode 100644 index abce215261..0000000000 --- a/users/replicaJunction/process_records.c +++ /dev/null @@ -1,149 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include QMK_KEYBOARD_H -#include "process_records.h" - -uint8_t mod_state; - - -__attribute__ ((weak)) -bool process_record_user_kb(uint16_t keycode, keyrecord_t *record) { - return true; -} - -// Runs for each key down or up event. -bool process_record_user(uint16_t keycode, keyrecord_t *record) { - // Returning true here will cause QMK to continue handling the key normally. - // Returning false indicates that we've handled everything the keycode should do, and QMK - // should not continue handling the keypress. - // - // NOTE: There is also a process_record_kb function that can be defined in the keyboard- - // specific code. This allows the keyboard to have its own process_record function. - // This is supposed to be "higher" than the user function, meaning the kb function - // is shared for all keymaps for the keyboard. - // - // For this reason, I add my own function, called process_record_user_kb, and at the end - // of this function, I defer to that one if it exists. - // return process_record_user(keycode, record); - - - // Custom keycode / function handling, based on the core function - // process_record_quantum - // https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c - - if (!( -#ifdef USER_CAPS_WORD_ENABLE - process_record_caps_word(keycode, record) && -#endif -#ifdef USER_MOUSE_JIGGLE_ENABLE - process_record_mouse_jiggle(keycode, record) && -#endif -#ifdef USER_NUM_WORD_ENABLE - process_record_num_word(keycode, record) && -#endif -#ifdef USER_SECRETS_ENABLE - process_record_secrets(keycode, record) && -#endif -#ifdef USER_SUPER_ALT_TAB_ENABLE - process_record_super_alt_tab(keycode, record) && -#endif - true)) { - return false; - } - - - // Miscellaneous keycode handling - mod_state = get_mods(); - - switch(keycode) - { - case QK_MAKE: { - if (record->event.pressed) - SEND_STRING("qmk compile --keyboard " QMK_KEYBOARD " --keymap " QMK_KEYMAP); - return false; - } - case QK_FLSH: { - if (record->event.pressed) { - SEND_STRING("qmk flash --keyboard " QMK_KEYBOARD " --keymap " QMK_KEYMAP); - } - return false; - } - case QK_VERS: { - if (record->event.pressed) { - SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION ", Built on: " QMK_BUILDDATE); - } - return false; - } - case PRG_EQ: { - if (record->event.pressed) { - SEND_STRING("=="); - } - return false; - } - case PRG_NE: { - if (record->event.pressed) { - SEND_STRING("!="); - } - return false; - } - case PRG_GEQ: { - if (record->event.pressed) { - SEND_STRING(">="); - } - return false; - } - case PRG_LEQ: { - if (record->event.pressed) { - SEND_STRING("<="); - } - return false; - } - case PRG_ARR: { - if (record->event.pressed) { - SEND_STRING("=>"); - } - return false; - } - - case PS_ITEM: { - if (record->event.pressed) { - SEND_STRING("$_"); - } - return false; - } - case FS_PIPE: { - if (record->event.pressed) { - SEND_STRING("|>"); - } - return false; - } - case FS_ARR: { - if (record->event.pressed) { - SEND_STRING("->"); - } - return false; - } - case SHEBANG: { - if (record->event.pressed) { - SEND_STRING("#!"); - } - return false; - } - } - - return process_record_user_kb(keycode, record); -} diff --git a/users/replicaJunction/process_records.h b/users/replicaJunction/process_records.h deleted file mode 100644 index 224bc6f4ff..0000000000 --- a/users/replicaJunction/process_records.h +++ /dev/null @@ -1,21 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once -#include QMK_KEYBOARD_H -#include "replicaJunction.h" - -bool process_record_user_kb(uint16_t keycode, keyrecord_t *record); diff --git a/users/replicaJunction/readme.md b/users/replicaJunction/readme.md deleted file mode 100644 index 9d728f9029..0000000000 --- a/users/replicaJunction/readme.md +++ /dev/null @@ -1,93 +0,0 @@ -replicaJunction QMK Userspace -============================= - -# Overview -I alternate between a few keyboards, one of which is the 44-key Keyboardio Atreus. Small keyboards require a liberal use of layers. Even though larger keyboards don't rely on layers as heavily, my muscle memory adapted to my Atreus layout, so I've ended up building several of those features in my keymaps for larger boards as well. - -The result, I believe, is a good compromise between ergonomics and ease of use. - -The code in this userspace is designed to be very modular. I use a few different keyboards, and I'm constantly tweaking one or another, so I want the ability to add and remove features from the firmware at compile-time. While my endgame goal is to get all the layouts to be compatible, in practice, it's been years and I'm still not to that point... - -Modular code also means that it should be easy to identify and adapt specific pieces to your own firmware. - -## Keyboards and Keymaps - -The following keyboards use the files in this userspace: - -* [Atreus](../../keyboards/atreus/keymaps/replicaJunction/readme.md) (42-key) -* [Ergodox](../../layouts/community/ergodox/replicaJunction/readme.md) -* [Keyboardio Atreus](../../keyboards/keyboardio/atreus/keymaps/replicaJunction/readme.md) (44-key) -* [XD75](../../keyboards/xd75/keymaps/replicaJunction/readme.md) - -# Features - -* **Secrets**, as [explained by Drashna](https://github.com/qmk/qmk_firmware/blob/master/users/drashna/readme_secrets.md) -* **CAPSWORD** and **NUMWORD** -* Mouse jiggler -* Super alt-tab - -## Secrets -My implementation of the "secrets" concept is very similar to Drashna's, but I've chosen to allow most of the supporting code to be committed to the repo. The only thing missing is a file called `secret_definitions.h`, which contains the actual text contained in those macros. - -To use my implementation, create a file of that name in the same directory. Make sure you've got a `.gitignore` file in place, and add these contents to the definitions file: - -```c -#pragma once -static const char * const secrets[] = { - "secret1", - "secret2", - "secret3", - "secret4" -} -``` - -Change the quoted text to the text you'd like and you're golden. If you need more (or fewer) items, you'll probably need to adjust the code in `secrets.c` as well, since it looks for up to four items in a switch case. - -## CAPSWORD and NUMWORD -The concept here is simple: more often than you'd think, you need to type a single word in ALL CAPS. An easy example for me, as a programmer, is a constant value; in most programming languages, constants are typed in all caps by convention. - -You typically have a few choices, but each one comes with a drawback. Here are the options I'm aware of: - -* Use proper typing technique and alternate which hand holds Shift for each keypress - * This can often end up requiring you to switch / re-press Shift again and again, making this a tedious process -* Hold a single Shift key down - * This can lead to uncomfortable finger gymnastics -* Hit the Caps Lock key, then hit it again when you're done - * Requires you to remember to hit it again, meaning a higher cognitive load - * In some layouts for smaller keyboards, Caps Lock is not easily accessible (sometimes not mapped at all) - -The solution to this problem is CAPSWORD. When enabled, it activates Caps Lock and begins running an additional callback on each keypress. If the keypress is an alphanumeric key or one of a specific few symbols (such as the underscore), nothing happens. Otherwise, before processing the keypress, Caps Lock is disabled again. - -NUMWORD is a similar concept, but has a slightly more elaborate implementation. There's a bit of extra logic in the NUMWORD code that allows the keycode to act as a tap/hold key as well. Tapping enables NUMWORD while number keys are in use, while holding the key enables a number layer for the duration of the key hold and disables it again afterwards. - -**Note:** The implementation of NUMWORD requires that the keyboard's layer definitions be accessible in a header file. In my case, since I use a fairly standard set of layers, I've declared it in my userspace. - -## Mouse Jiggler -This adds a keycode that will move the mouse cursor on each matrix scan. Used to prevent the screen from locking if you're temporarily doing something else (working on a different machine, reading / writing, etc.). - -When you press the keycode, the keyboard will write the text "Mouse jiggler enabled" to signify that the behavior is active. I suggest opening a Notepad window before pressing the key. - -Pressing any key will automatically disable the feature again. This is because it causes a huge hit to the reliability and performance of the keyboard while it's active (adding stuff to every matrix scan will do that). I kept forgetting to turn it off before trying to use the keyboard again, so I decided to make it automatically disable itself. - -Enable this by setting `USER_MOUSE_JIGGLE_ENABLE = yes` in your `rules.mk` file. The feature also depends on the Mouse Keys feature, so ensure you don't disable `MOUSEKEY_ENABLE`. - -## Super Alt-Tab -Taken [straight out of the QMK documentation](https://docs.qmk.fm/#/feature_macros?id=super-alt%E2%86%AFtab), this is an easy way to shift between a couple different windows. I use it with a very low interval when I'm alternating back and forth between two known windows with no real need for the visual feedback and thought. If you want to be able to browse the open windows before the function releases Alt, I'd suggest raising `USER_SUPER_ALT_TAB_TIMEOUT` to a higher value. - -# Credits -I'm absolutely sure I've missed a few sources here. If you see something in my code that you think is yours and isn't credited here, I sincerely apologize. - -[bpruitt-goddard](https://github.com/qmk/qmk_firmware/blob/master/keyboards/ergodox_ez/keymaps/bpruitt-goddard/readme.md) -* Dynamic macro tap-dance (no longer used, but I did use this for a while) - -[Drashna](https://github.com/qmk/qmk_firmware/blob/master/users/drashna/readme.md) -* Secrets concept and basic implementation -* "Wrappers" concept (no longer used, but I did use this for a while) - -[Treeman](https://github.com/treeman/qmk_firmware/blob/master/keyboards/kyria/keymaps/treeman) -* CAPSWORD and NUMBERWORD concept - * I re-implented some of the code based on my own prefences, but I did use some implementation code from here - * [Treeman's blog post](https://www.jonashietala.se/blog/2021/06/03/the-t-34-keyboard-layout/) provides more context on these features, and is a great read - -[QMK issue #452](https://github.com/qmk/qmk_firmware/issues/452) -* Helped clarify a good organizational structure for the individual features in this userspace diff --git a/users/replicaJunction/replicaJunction.c b/users/replicaJunction/replicaJunction.c deleted file mode 100644 index 55d8b77166..0000000000 --- a/users/replicaJunction/replicaJunction.c +++ /dev/null @@ -1,25 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#include QMK_KEYBOARD_H -#include "replicaJunction.h" - -__attribute__ ((weak)) -void keyboard_post_init_user_kb(void) { } - -void keyboard_post_init_user(void) { - keyboard_post_init_user_kb(); -} diff --git a/users/replicaJunction/replicaJunction.h b/users/replicaJunction/replicaJunction.h deleted file mode 100644 index f3b7bcea0a..0000000000 --- a/users/replicaJunction/replicaJunction.h +++ /dev/null @@ -1,42 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once -#include QMK_KEYBOARD_H -#include "rj_keycodes.h" -#include "rj_layers.h" -#include "keycode_aliases.h" -#include "version.h" - -#ifdef USER_CAPS_WORD_ENABLE -# include "features/caps_word.h" -#endif - -#ifdef USER_MOUSE_JIGGLE_ENABLE -# include "features/mouse_jiggle.h" -#endif - -#ifdef USER_NUM_WORD_ENABLE -# include "features/num_word.h" -#endif - -#ifdef USER_SECRETS_ENABLE -# include "features/secrets.h" -#endif - -#ifdef USER_SUPER_ALT_TAB_ENABLE -# include "features/super_alt_tab.h" -#endif diff --git a/users/replicaJunction/rj_keycodes.h b/users/replicaJunction/rj_keycodes.h deleted file mode 100644 index fde2698dfe..0000000000 --- a/users/replicaJunction/rj_keycodes.h +++ /dev/null @@ -1,63 +0,0 @@ -/* Copyright 2021 Joshua T. - * - * 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/>. - */ - -#pragma once -#include QMK_KEYBOARD_H - -// Custom keycodes and macros -enum userspace_custom_keycodes { - QK_MAKE = SAFE_RANGE, // QMK make command - QK_FLSH, // QMK flash command - QK_VERS, // QMK version - - // Programming macros - PRG_EQ, // == - PRG_NE, // != - PRG_GEQ, // >= - PRG_LEQ, // <= - PRG_ARR, // => - PS_ITEM, // $_ (PowerShell - $PSItem variable) - FS_PIPE, // |> (F# pipe operator) - FS_ARR, // -> (F# lambda / pattern matching) - SHEBANG, // #! - - // USER_CAPS_WORD_ENABLE - CAPWORD, - -#ifdef USER_NUM_WORD_ENABLE - NUMWORD, -#endif - - // USER_ENABLE_CUSTOM_SHIFT_CODES - // Custom characters that send different symbols than usual when shifted - KCC_COM, // , or ! - KCC_DOT, // . or @ - KCC_QUO, // ' or ~ - - // USER_MOUSE_JIGGLE_ENABLE - MS_JIGL, - - // USER_ENABLE_SUPER_ALT_TAB - SALTTAB, - - // USER_ENABLE_SECRETS - K_SECR1, - K_SECR2, - K_SECR3, - K_SECR4, - - DYNAMIC_MACRO_RANGE -}; diff --git a/users/replicaJunction/rules.mk b/users/replicaJunction/rules.mk deleted file mode 100644 index addaa04d97..0000000000 --- a/users/replicaJunction/rules.mk +++ /dev/null @@ -1,33 +0,0 @@ -SRC += replicaJunction.c - -# Only load these source files if the features are enabled. Keyboards can -# enable or disable these features in their own rules.mk files. - -ifeq ($(strip $(USER_CAPS_WORD_ENABLE)), yes) - SRC += features/caps_word.c - OPT_DEFS += -DUSER_CAPS_WORD_ENABLE -endif - -ifeq ($(strip $(USER_MOUSE_JIGGLE_ENABLE)), yes) - SRC += features/mouse_jiggle.c - OPT_DEFS += -DUSER_MOUSE_JIGGLE_ENABLE -endif - -ifeq ($(strip $(USER_NUM_WORD_ENABLE)), yes) - SRC += features/num_word.c - OPT_DEFS += -DUSER_NUM_WORD_ENABLE -endif - -ifeq ($(strip $(USER_SECRETS_ENABLE)), yes) - SRC += features/secrets.c - OPT_DEFS += -DUSER_SECRETS_ENABLE -endif - -ifeq ($(strip $(USER_SUPER_ALT_TAB_ENABLE)), yes) - SRC += features/super_alt_tab.c - OPT_DEFS += -DUSER_SUPER_ALT_TAB_ENABLE -endif - -# Define these last so any other logic can set up some defines first -SRC += matrix_scan.c \ - process_records.c diff --git a/users/riblee/riblee.c b/users/riblee/riblee.c index 937e603b7a..4be43ba82c 100644 --- a/users/riblee/riblee.c +++ b/users/riblee/riblee.c @@ -18,7 +18,7 @@ #include <string.h> // Tap Dance functions -void dance_key_a (qk_tap_dance_state_t *state, void *user_data) { +void dance_key_a (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { SEND_STRING("a"); reset_tap_dance(state); @@ -33,7 +33,7 @@ void dance_key_a (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_key_e (qk_tap_dance_state_t *state, void *user_data) { +void dance_key_e (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { SEND_STRING("e"); reset_tap_dance(state); @@ -48,7 +48,7 @@ void dance_key_e (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_key_i (qk_tap_dance_state_t *state, void *user_data) { +void dance_key_i (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { SEND_STRING("i"); reset_tap_dance(state); @@ -63,7 +63,7 @@ void dance_key_i (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_key_o (qk_tap_dance_state_t *state, void *user_data) { +void dance_key_o (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { SEND_STRING("o"); reset_tap_dance(state); @@ -94,7 +94,7 @@ void dance_key_o (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_key_u (qk_tap_dance_state_t *state, void *user_data) { +void dance_key_u (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { SEND_STRING("u"); reset_tap_dance(state); diff --git a/users/riblee/riblee.h b/users/riblee/riblee.h index 786e4c31ab..910c57db69 100644 --- a/users/riblee/riblee.h +++ b/users/riblee/riblee.h @@ -49,11 +49,11 @@ enum { TD_U, }; -void dance_key_a (qk_tap_dance_state_t *, void *); -void dance_key_e (qk_tap_dance_state_t *, void *); -void dance_key_i (qk_tap_dance_state_t *, void *); -void dance_key_o (qk_tap_dance_state_t *, void *); -void dance_key_u (qk_tap_dance_state_t *, void *); +void dance_key_a (tap_dance_state_t *, void *); +void dance_key_e (tap_dance_state_t *, void *); +void dance_key_i (tap_dance_state_t *, void *); +void dance_key_o (tap_dance_state_t *, void *); +void dance_key_u (tap_dance_state_t *, void *); layer_state_t layer_state_set_user(layer_state_t); bool process_record_user(uint16_t keycode, keyrecord_t *record);
\ No newline at end of file diff --git a/users/ridingqwerty/config.h b/users/ridingqwerty/config.h index 6501efe62f..291c4877e1 100644 --- a/users/ridingqwerty/config.h +++ b/users/ridingqwerty/config.h @@ -5,7 +5,7 @@ #define TAPPING_TERM 175 #define MACRO_TIMER 5 -#define TAPPING_FORCE_HOLD_PER_KEY +#define QUICK_TAP_TERM_PER_KEY // testing #define TAPPING_TERM_PER_KEY //#define IGNORE_MOD_TAP_INTERRUPT // rolling R3 "zxcv", etc... diff --git a/users/ridingqwerty/ridingqwerty.c b/users/ridingqwerty/ridingqwerty.c index 8934b9365b..639bb8d2b3 100644 --- a/users/ridingqwerty/ridingqwerty.c +++ b/users/ridingqwerty/ridingqwerty.c @@ -55,11 +55,11 @@ uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) { } }; -bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) { - switch (keycode) { - case NM(SCLN): - return true; - default: - return false; - } +uint16_t get_quick_tap_term(uint16_t keycode, keyrecord_t *record) { + switch (keycode) { + case NM(SCLN): + return 0; + default: + return QUICK_TAP_TERM; + } } diff --git a/users/ridingqwerty/tapdances.c b/users/ridingqwerty/tapdances.c index 644166cb45..0fdd941637 100644 --- a/users/ridingqwerty/tapdances.c +++ b/users/ridingqwerty/tapdances.c @@ -1,13 +1,13 @@ #include "ridingqwerty.h" #include "tapdances.h" -void braces_finished (qk_tap_dance_state_t *state, void *user_data) { +void braces_finished (tap_dance_state_t *state, void *user_data) { if ((state->count == 1) || (state->count == 3)) { register_code(KC_LSFT); } } -void braces_reset (qk_tap_dance_state_t *state, void *user_data) { +void braces_reset (tap_dance_state_t *state, void *user_data) { // two or three taps for "[]"/"{}" if ((state->count == 2) || (state->count == 3)) { tap_code(KC_LBRC); @@ -28,6 +28,6 @@ void braces_reset (qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_BRACES] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, braces_finished, braces_reset) }; diff --git a/users/rmeli/keyrecords/tap_dances.c b/users/rmeli/keyrecords/tap_dances.c index 3b38bf4a33..4e7ac31962 100644 --- a/users/rmeli/keyrecords/tap_dances.c +++ b/users/rmeli/keyrecords/tap_dances.c @@ -23,7 +23,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. // Tap dances definitions // Need to needs to be defined in a .c file to avoid a linker error (multiple definitions) -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_LSPO_CAPS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, LSPO_CAPS_finished, LSPO_CAPS_reset), [TD_RSPC_CAPS] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, RSPC_CAPS_finished, RSPC_CAPS_reset), [TD_ESC_DEL] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_DEL), @@ -34,7 +34,7 @@ qk_tap_dance_action_t tap_dance_actions[] = { // + ------ + // https://github.com/qmk/qmk_firmware/blob/9294258c02d3e025e01935a06c4d9f1997535bda/users/gordon/gordon.c#L112-L135 -td_state_t hold_cur_dance(qk_tap_dance_state_t *state) { +td_state_t hold_cur_dance(tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted) { if (!state->pressed) @@ -63,7 +63,7 @@ td_state_t hold_cur_dance(qk_tap_dance_state_t *state) { // Create an instance of 'td_tap_t' for the 'LSPO_CAPS' tap dance. static td_tap_t LSPO_CAPS_state = {.is_press_action = true, .state = TD_NONE}; -void LSPO_CAPS_finished(qk_tap_dance_state_t *state, void *user_data) { +void LSPO_CAPS_finished(tap_dance_state_t *state, void *user_data) { LSPO_CAPS_state.state = hold_cur_dance(state); switch (LSPO_CAPS_state.state) { case TD_SINGLE_TAP: @@ -80,7 +80,7 @@ void LSPO_CAPS_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void LSPO_CAPS_reset(qk_tap_dance_state_t *state, void *user_data) { +void LSPO_CAPS_reset(tap_dance_state_t *state, void *user_data) { switch (LSPO_CAPS_state.state) { case TD_SINGLE_TAP: unregister_code16(KC_LPRN); @@ -104,7 +104,7 @@ void LSPO_CAPS_reset(qk_tap_dance_state_t *state, void *user_data) { // Create an instance of 'td_tap_t' for the 'RSPC_CAPS' tap dance. static td_tap_t RSPC_CAPS_state = {.is_press_action = true, .state = TD_NONE}; -void RSPC_CAPS_finished(qk_tap_dance_state_t *state, void *user_data) { +void RSPC_CAPS_finished(tap_dance_state_t *state, void *user_data) { RSPC_CAPS_state.state = hold_cur_dance(state); switch (RSPC_CAPS_state.state) { case TD_SINGLE_TAP: @@ -121,7 +121,7 @@ void RSPC_CAPS_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void RSPC_CAPS_reset(qk_tap_dance_state_t *state, void *user_data) { +void RSPC_CAPS_reset(tap_dance_state_t *state, void *user_data) { switch (RSPC_CAPS_state.state) { case TD_SINGLE_TAP: unregister_code16(KC_RPRN); diff --git a/users/rmeli/keyrecords/tap_dances.h b/users/rmeli/keyrecords/tap_dances.h index 1d3018441e..40866fe17f 100644 --- a/users/rmeli/keyrecords/tap_dances.h +++ b/users/rmeli/keyrecords/tap_dances.h @@ -60,12 +60,12 @@ typedef struct { // + --------- + // Tap dance for fast modifiers; favors being held over being tapped. -td_state_t hold_cur_dance(qk_tap_dance_state_t *state); +td_state_t hold_cur_dance(tap_dance_state_t *state); // Left Shift Parenthesis Open (LSPO) and Caps Lock (CAPS) on DOUBLE_TAP -void LSPO_CAPS_finished(qk_tap_dance_state_t *state, void *user_data); -void LSPO_CAPS_reset(qk_tap_dance_state_t *state, void *user_data); +void LSPO_CAPS_finished(tap_dance_state_t *state, void *user_data); +void LSPO_CAPS_reset(tap_dance_state_t *state, void *user_data); // Right Shift Parenthesis Close (RSPC) and Caps Lock (CAPS) on DOUBLE_TAP -void RSPC_CAPS_finished(qk_tap_dance_state_t *state, void *user_data); -void RSPC_CAPS_reset(qk_tap_dance_state_t *state, void *user_data); +void RSPC_CAPS_finished(tap_dance_state_t *state, void *user_data); +void RSPC_CAPS_reset(tap_dance_state_t *state, void *user_data); diff --git a/users/rmw/tapdances.c b/users/rmw/tapdances.c index 1b44a87253..792bd83e55 100644 --- a/users/rmw/tapdances.c +++ b/users/rmw/tapdances.c @@ -2,7 +2,7 @@ #include "tapdances.h" -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [SHCAP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, caps, shift_reset) ,[TDGUI] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, shiftgui, gui_reset) ,[TDGUI2] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, guictl, ubermod_reset) @@ -22,13 +22,13 @@ qk_tap_dance_action_t tap_dance_actions[] = { ,[FRBK] = ACTION_TAP_DANCE_DOUBLE(KC_WWW_BACK,KC_WWW_FORWARD) }; -void caps(qk_tap_dance_state_t *state, void *user_data) // Shift, Caps +void caps(tap_dance_state_t *state, void *user_data) // Shift, Caps { if (state->count >= 2) {register_code(KC_CAPS); unregister_code(KC_CAPS);} else if (state->pressed) {register_mods(MOD_LSFT);} else {set_oneshot_mods(MOD_LSFT);} reset_tap_dance(state); } -void forward_back_mac(qk_tap_dance_state_t *state, void *user_data) // G<-, then G-> +void forward_back_mac(tap_dance_state_t *state, void *user_data) // G<-, then G-> { if (state->count > 1) { tap_code16(G(KC_RGHT)); @@ -39,7 +39,7 @@ void forward_back_mac(qk_tap_dance_state_t *state, void *user_data) // G<-, then reset_tap_dance(state); } -void shiftgui(qk_tap_dance_state_t *state, void *user_data) // G->SG +void shiftgui(tap_dance_state_t *state, void *user_data) // G->SG { if (state->count > 1) { if (state->pressed) { @@ -58,7 +58,7 @@ void shiftgui(qk_tap_dance_state_t *state, void *user_data) // G->SG reset_tap_dance(state); } -void guictl(qk_tap_dance_state_t *state, void *user_data) // G->GC +void guictl(tap_dance_state_t *state, void *user_data) // G->GC { if (state->count > 1) { if (state->pressed) { @@ -77,7 +77,7 @@ void guictl(qk_tap_dance_state_t *state, void *user_data) // G->GC reset_tap_dance(state); } -void deleter(qk_tap_dance_state_t *state, void *user_data) // bkspc -> delwrd -> delline +void deleter(tap_dance_state_t *state, void *user_data) // bkspc -> delwrd -> delline { if (state->count > 3) { tap_code16(G(KC_BSPC)); @@ -91,7 +91,7 @@ void deleter(qk_tap_dance_state_t *state, void *user_data) // bkspc -> delwrd -> reset_tap_dance(state); } -void ubermod(qk_tap_dance_state_t *state, void *user_data) // CTL->ALT->GUI +void ubermod(tap_dance_state_t *state, void *user_data) // CTL->ALT->GUI { if (state->count > 2) { if (state->pressed) { @@ -118,7 +118,7 @@ void ubermod(qk_tap_dance_state_t *state, void *user_data) // CTL->ALT->GUI reset_tap_dance(state); } -void ubermod_mac(qk_tap_dance_state_t *state, void *user_data) // GUI->CTL->ALT +void ubermod_mac(tap_dance_state_t *state, void *user_data) // GUI->CTL->ALT { if (state->count > 2) { if (state->pressed) { @@ -145,7 +145,7 @@ void ubermod_mac(qk_tap_dance_state_t *state, void *user_data) // GUI->CTL->ALT reset_tap_dance(state); } -void ubermod2(qk_tap_dance_state_t *state, void *user_data) // ALT->CTL->GUI +void ubermod2(tap_dance_state_t *state, void *user_data) // ALT->CTL->GUI { if (state->count > 2) { if (state->pressed) { @@ -172,7 +172,7 @@ void ubermod2(qk_tap_dance_state_t *state, void *user_data) // ALT->CTL->GUI reset_tap_dance(state); } -void ubermod2_mac(qk_tap_dance_state_t *state, void *user_data) // ALT->GUI->CTL +void ubermod2_mac(tap_dance_state_t *state, void *user_data) // ALT->GUI->CTL { if (state->count > 2) { if (state->pressed) { @@ -199,30 +199,30 @@ void ubermod2_mac(qk_tap_dance_state_t *state, void *user_data) // ALT->GUI->CTL reset_tap_dance(state); } -void shift_reset(qk_tap_dance_state_t *state, void *user_data) +void shift_reset(tap_dance_state_t *state, void *user_data) { unregister_mods(MOD_LSFT); // clear_oneshot_mods(); } -void gui_reset(qk_tap_dance_state_t *state, void *user_data) +void gui_reset(tap_dance_state_t *state, void *user_data) { unregister_mods(MOD_LSFT | MOD_LGUI); } -void CAS_reset(qk_tap_dance_state_t *state, void *user_data) +void CAS_reset(tap_dance_state_t *state, void *user_data) { unregister_mods(MOD_LCTL | MOD_LSFT | MOD_LALT); } -void CASG_reset(qk_tap_dance_state_t *state, void *user_data) +void CASG_reset(tap_dance_state_t *state, void *user_data) { unregister_mods(MOD_LCTL | MOD_LSFT | MOD_LALT | MOD_LGUI); // clear_oneshot_mods(); } -void ubermod_reset(qk_tap_dance_state_t *state, void *user_data) // AKA CAG_reset +void ubermod_reset(tap_dance_state_t *state, void *user_data) // AKA CAG_reset { unregister_mods(MOD_LCTL | MOD_LALT | MOD_LGUI); } -void shiftenter(qk_tap_dance_state_t *state, void *user_data) +void shiftenter(tap_dance_state_t *state, void *user_data) { if (state->count > 1) { tap_code(KC_ENT); @@ -236,7 +236,7 @@ void shiftenter(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void shiftentercaps(qk_tap_dance_state_t *state, void *user_data) +void shiftentercaps(tap_dance_state_t *state, void *user_data) { if (state->count > 2) { tap_code(KC_CAPS); @@ -253,7 +253,7 @@ void shiftentercaps(qk_tap_dance_state_t *state, void *user_data) reset_tap_dance(state); } -void ctrl_all_mac(qk_tap_dance_state_t *state, void *user_data) // C->CG->CAG +void ctrl_all_mac(tap_dance_state_t *state, void *user_data) // C->CG->CAG { if (state->count > 2) { if (state->pressed) { @@ -280,7 +280,7 @@ void ctrl_all_mac(qk_tap_dance_state_t *state, void *user_data) // C->CG->CAG reset_tap_dance(state); } -void ctrl_all(qk_tap_dance_state_t *state, void *user_data) // C->CA->SC +void ctrl_all(tap_dance_state_t *state, void *user_data) // C->CA->SC { if (state->count > 2) { if (state->pressed) { @@ -307,7 +307,7 @@ void ctrl_all(qk_tap_dance_state_t *state, void *user_data) // C->CA->SC reset_tap_dance(state); } -void alt_all(qk_tap_dance_state_t *state, void *user_data) // A->SA->AC +void alt_all(tap_dance_state_t *state, void *user_data) // A->SA->AC { if (state->count > 2) { if (state->pressed) { @@ -334,7 +334,7 @@ void alt_all(qk_tap_dance_state_t *state, void *user_data) // A->SA->AC reset_tap_dance(state); } -void shift_and(qk_tap_dance_state_t *state, void *user_data) // SC->SA->SG +void shift_and(tap_dance_state_t *state, void *user_data) // SC->SA->SG { if (state->count > 2) { if (state->pressed) { @@ -361,7 +361,7 @@ void shift_and(qk_tap_dance_state_t *state, void *user_data) // SC->SA->SG reset_tap_dance(state); } -void shift_and_mac(qk_tap_dance_state_t *state, void *user_data) // SG->SC->SA +void shift_and_mac(tap_dance_state_t *state, void *user_data) // SG->SC->SA { if (state->count > 1) { if (state->pressed) { diff --git a/users/rmw/tapdances.h b/users/rmw/tapdances.h index 11425011c5..f358358cb6 100644 --- a/users/rmw/tapdances.h +++ b/users/rmw/tapdances.h @@ -3,27 +3,27 @@ #include "process_tap_dance.h" #include "action.h" -void caps(qk_tap_dance_state_t *state, void *user_data); // Shift, Caps -void forward_back_mac(qk_tap_dance_state_t *state, void *user_data); // G<-, then G-> -void shiftgui(qk_tap_dance_state_t *state, void *user_data); // G->SG -void guictl(qk_tap_dance_state_t *state, void *user_data); // G->GC -void deleter(qk_tap_dance_state_t *state, void *user_data); // bkspc -> delwrd -> delline -void ubermod(qk_tap_dance_state_t *state, void *user_data); // CTL->ALT->GUI -void ubermod_mac(qk_tap_dance_state_t *state, void *user_data); // GUI->CTL->ALT -void ubermod2(qk_tap_dance_state_t *state, void *user_data); // ALT->CTL->GUI -void ubermod2_mac(qk_tap_dance_state_t *state, void *user_data); // ALT->GUI->CTL -void shift_reset(qk_tap_dance_state_t *state, void *user_data); -void gui_reset(qk_tap_dance_state_t *state, void *user_data); -void CAS_reset(qk_tap_dance_state_t *state, void *user_data); -void CASG_reset(qk_tap_dance_state_t *state, void *user_data); -void ubermod_reset(qk_tap_dance_state_t *state, void *user_data); // AKA CAG_reset -void shiftenter(qk_tap_dance_state_t *state, void *user_data); -void shiftentercaps(qk_tap_dance_state_t *state, void *user_data); -void ctrl_all_mac(qk_tap_dance_state_t *state, void *user_data); // C->CG->CAG -void ctrl_all(qk_tap_dance_state_t *state, void *user_data); // C->CA->SC -void alt_all(qk_tap_dance_state_t *state, void *user_data); // A->SA->AC -void shift_and(qk_tap_dance_state_t *state, void *user_data); // SC->SA->SG -void shift_and_mac(qk_tap_dance_state_t *state, void *user_data); // SG->SC->SA +void caps(tap_dance_state_t *state, void *user_data); // Shift, Caps +void forward_back_mac(tap_dance_state_t *state, void *user_data); // G<-, then G-> +void shiftgui(tap_dance_state_t *state, void *user_data); // G->SG +void guictl(tap_dance_state_t *state, void *user_data); // G->GC +void deleter(tap_dance_state_t *state, void *user_data); // bkspc -> delwrd -> delline +void ubermod(tap_dance_state_t *state, void *user_data); // CTL->ALT->GUI +void ubermod_mac(tap_dance_state_t *state, void *user_data); // GUI->CTL->ALT +void ubermod2(tap_dance_state_t *state, void *user_data); // ALT->CTL->GUI +void ubermod2_mac(tap_dance_state_t *state, void *user_data); // ALT->GUI->CTL +void shift_reset(tap_dance_state_t *state, void *user_data); +void gui_reset(tap_dance_state_t *state, void *user_data); +void CAS_reset(tap_dance_state_t *state, void *user_data); +void CASG_reset(tap_dance_state_t *state, void *user_data); +void ubermod_reset(tap_dance_state_t *state, void *user_data); // AKA CAG_reset +void shiftenter(tap_dance_state_t *state, void *user_data); +void shiftentercaps(tap_dance_state_t *state, void *user_data); +void ctrl_all_mac(tap_dance_state_t *state, void *user_data); // C->CG->CAG +void ctrl_all(tap_dance_state_t *state, void *user_data); // C->CA->SC +void alt_all(tap_dance_state_t *state, void *user_data); // A->SA->AC +void shift_and(tap_dance_state_t *state, void *user_data); // SC->SA->SG +void shift_and_mac(tap_dance_state_t *state, void *user_data); // SG->SC->SA enum { SHCAP = 0 diff --git a/users/romus/romus.c b/users/romus/romus.c index 7b2e330228..19d17a63a9 100644 --- a/users/romus/romus.c +++ b/users/romus/romus.c @@ -42,7 +42,7 @@ float tone_windows[][2] = SONG(UNICODE_WINDOWS); |*-----TAP-DANCE-----*| \*-------------------*/ #ifdef TAP_DANCE_ENABLE -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { // Shift on double tap of semicolon [SCL] = ACTION_TAP_DANCE_DOUBLE( KC_SCLN, KC_COLN ) }; diff --git a/users/sethBarberee/config.h b/users/sethBarberee/config.h index 7e9fd7d2f1..f323b27368 100644 --- a/users/sethBarberee/config.h +++ b/users/sethBarberee/config.h @@ -28,9 +28,6 @@ # endif // Trim animations I don't use/like -# ifdef RGBLIGHT_ANIMATIONS -# undef RGBLIGHT_ANIMATIONS -# endif # ifndef RGBLIGHT_EFFECT_BREATHING # define RGBLIGHT_EFFECT_BREATHING # endif diff --git a/users/sethBarberee/tap_dance.c b/users/sethBarberee/tap_dance.c index 9461e5ad60..924b3141fe 100644 --- a/users/sethBarberee/tap_dance.c +++ b/users/sethBarberee/tap_dance.c @@ -16,7 +16,7 @@ #include "tap_dance.h" // Shamelessly stolen from QMK Docs -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) { return SINGLE_TAP; @@ -44,7 +44,7 @@ tap caps_status = { }; -void dance_ecap_finished (qk_tap_dance_state_t *state, void *user_data){ +void dance_ecap_finished (tap_dance_state_t *state, void *user_data){ caps_status.state = cur_dance(state); switch(caps_status.state){ case SINGLE_TAP: @@ -74,7 +74,7 @@ void dance_ecap_finished (qk_tap_dance_state_t *state, void *user_data){ } } -void dance_ecap_reset (qk_tap_dance_state_t *state, void *user_data){ +void dance_ecap_reset (tap_dance_state_t *state, void *user_data){ if(caps_status.state == SINGLE_HOLD){ unregister_code(KC_LCTL); } @@ -82,7 +82,7 @@ void dance_ecap_reset (qk_tap_dance_state_t *state, void *user_data){ } //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { //Tap once for Esc, twice for Caps Lock [TD_ECAP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_ecap_finished, dance_ecap_reset), // Other declarations would go here, separated by commas, if you have them diff --git a/users/stanrc85/stanrc85.c b/users/stanrc85/stanrc85.c index 5f74612848..6dd5db0e33 100644 --- a/users/stanrc85/stanrc85.c +++ b/users/stanrc85/stanrc85.c @@ -8,7 +8,7 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { } // determine the tapdance state to return -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted || !state->pressed) { return SINGLE_TAP; } else { return SINGLE_HOLD; } @@ -18,7 +18,7 @@ int cur_dance (qk_tap_dance_state_t *state) { } // handle the possible states for each tapdance keycode you define: -void ctl_copy_finished (qk_tap_dance_state_t *state, void *user_data) { +void ctl_copy_finished (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: @@ -32,7 +32,7 @@ void ctl_copy_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void ctl_copy_reset (qk_tap_dance_state_t *state, void *user_data) { +void ctl_copy_reset (tap_dance_state_t *state, void *user_data) { switch (td_state) { case SINGLE_TAP: break; @@ -61,7 +61,7 @@ void ctl_copy_reset (qk_tap_dance_state_t *state, void *user_data) { static uint8_t led_user = 0; #endif -void lock_unlock (qk_tap_dance_state_t *state, void *user_data) { +void lock_unlock (tap_dance_state_t *state, void *user_data) { td_state = cur_dance(state); switch (td_state) { case SINGLE_TAP: // Ctl + Alt + Del to unlock workstation @@ -97,7 +97,7 @@ void lock_unlock (qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_WIN] = ACTION_TAP_DANCE_FN(lock_unlock), [TD_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_GRV), [TD_RCTL] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, ctl_copy_finished, ctl_copy_reset) diff --git a/users/stanrc85/stanrc85.h b/users/stanrc85/stanrc85.h index 0007e0898c..a6550ca72c 100644 --- a/users/stanrc85/stanrc85.h +++ b/users/stanrc85/stanrc85.h @@ -48,8 +48,8 @@ typedef enum { } td_state_t; // function to determine the current tapdance state -int cur_dance (qk_tap_dance_state_t *state); +int cur_dance (tap_dance_state_t *state); // `finished` and `reset` functions for each tapdance keycode -void ctl_copy_finished (qk_tap_dance_state_t *state, void *user_data); -void ctl_copy_reset (qk_tap_dance_state_t *state, void *user_data); +void ctl_copy_finished (tap_dance_state_t *state, void *user_data); +void ctl_copy_reset (tap_dance_state_t *state, void *user_data); diff --git a/users/talljoe/tapdance/actions/td.function.c b/users/talljoe/tapdance/actions/td.function.c index fffbf283dd..577f2be3d4 100644 --- a/users/talljoe/tapdance/actions/td.function.c +++ b/users/talljoe/tapdance/actions/td.function.c @@ -19,14 +19,14 @@ static struct { } function_state = {0}; // Send semi-colon + enter on two taps -void tap_dance_function_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_function_finished(tap_dance_state_t *state, void *user_data) { function_state.state = hold_cur_dance(state); switch (function_state.state) { case SINGLE_HOLD: layer_on(_ADJUST); break; } } -void tap_dance_function_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_function_reset(tap_dance_state_t *state, void *user_data) { switch (function_state.state) { case SPECIAL: reset_keyboard(); break; case SINGLE_HOLD: layer_off(_ADJUST); break; diff --git a/users/talljoe/tapdance/actions/td.grave.c b/users/talljoe/tapdance/actions/td.grave.c index 509b66dc35..f58f00f8c0 100644 --- a/users/talljoe/tapdance/actions/td.grave.c +++ b/users/talljoe/tapdance/actions/td.grave.c @@ -15,7 +15,7 @@ */ // Send `. ~. ``` -void tap_dance_grave_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_grave_finished(tap_dance_state_t *state, void *user_data) { switch(state->count) { case 1: SEND_STRING("`"); @@ -26,7 +26,7 @@ void tap_dance_grave_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void tap_dance_grave_each(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_grave_each(tap_dance_state_t *state, void *user_data) { if(state->count == 3) { SEND_STRING("```"); } else if (state->count > 3) { diff --git a/users/talljoe/tapdance/actions/td.lock.c b/users/talljoe/tapdance/actions/td.lock.c index 4422d9e252..bdca0bb11b 100644 --- a/users/talljoe/tapdance/actions/td.lock.c +++ b/users/talljoe/tapdance/actions/td.lock.c @@ -19,7 +19,7 @@ static struct { } lock_state = {0}; // Send semi-colon + enter on two taps -void tap_dance_lock_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_lock_finished(tap_dance_state_t *state, void *user_data) { lock_state.state = cur_dance(state); switch (lock_state.state) { case SINGLE_TAP: register_code(KC_ESC); break; @@ -27,7 +27,7 @@ void tap_dance_lock_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void tap_dance_lock_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_lock_reset(tap_dance_state_t *state, void *user_data) { switch (lock_state.state) { case SINGLE_TAP: unregister_code(KC_ESC); break; } diff --git a/users/talljoe/tapdance/actions/td.semicolon.c b/users/talljoe/tapdance/actions/td.semicolon.c index 45776492a4..c2fc500c48 100644 --- a/users/talljoe/tapdance/actions/td.semicolon.c +++ b/users/talljoe/tapdance/actions/td.semicolon.c @@ -19,12 +19,12 @@ static struct { bool mods; } tap_state = {0}; -void tap_dance_semicolon_each(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_semicolon_each(tap_dance_state_t *state, void *user_data) { tap_state.mods |= get_mods(); } // Send semi-colon + enter on two taps -void tap_dance_semicolon_finished(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_semicolon_finished(tap_dance_state_t *state, void *user_data) { tap_state.semicolon = hold_cur_dance(state); switch (tap_state.semicolon) { case SINGLE_TAP: case DOUBLE_HOLD: register_code(KC_SCLN); break; @@ -32,7 +32,7 @@ void tap_dance_semicolon_finished(qk_tap_dance_state_t *state, void *user_data) } } -void tap_dance_semicolon_reset(qk_tap_dance_state_t *state, void *user_data) { +void tap_dance_semicolon_reset(tap_dance_state_t *state, void *user_data) { switch (tap_state.semicolon) { case SINGLE_TAP: case DOUBLE_HOLD: unregister_code(KC_SCLN); break; case DOUBLE_TAP: { diff --git a/users/talljoe/tapdance/tapdance_actions.c b/users/talljoe/tapdance/tapdance_actions.c index 59a34b7b9e..b574586171 100644 --- a/users/talljoe/tapdance/tapdance_actions.c +++ b/users/talljoe/tapdance/tapdance_actions.c @@ -20,7 +20,7 @@ #include "actions/td.semicolon.c" #include "actions/td.function.c" -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SEMICOLON] = ACTION_TAP_DANCE_FN_ADVANCED(tap_dance_semicolon_each, tap_dance_semicolon_finished, tap_dance_semicolon_reset), [TD_LOCK] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, tap_dance_lock_finished, tap_dance_lock_reset), [TD_GRAVE] = ACTION_TAP_DANCE_FN_ADVANCED(tap_dance_grave_each, tap_dance_grave_finished, NULL), diff --git a/users/talljoe/tapdance/td_setup.c b/users/talljoe/tapdance/td_setup.c index d8464144ac..0742763266 100644 --- a/users/talljoe/tapdance/td_setup.c +++ b/users/talljoe/tapdance/td_setup.c @@ -16,7 +16,7 @@ #include "tapdance.h" -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP if (state->interrupted) { @@ -45,7 +45,7 @@ int cur_dance (qk_tap_dance_state_t *state) { else return SPECIAL; } -int hold_cur_dance (qk_tap_dance_state_t *state) { +int hold_cur_dance (tap_dance_state_t *state) { if (state->count == 1) { if (state->interrupted) { if (!state->pressed) return SINGLE_TAP; diff --git a/users/talljoe/tapdance/td_setup.h b/users/talljoe/tapdance/td_setup.h index 85d45d944f..e9685c83b2 100644 --- a/users/talljoe/tapdance/td_setup.h +++ b/users/talljoe/tapdance/td_setup.h @@ -25,5 +25,5 @@ enum { SPECIAL = 8 }; -int cur_dance (qk_tap_dance_state_t *state); -int hold_cur_dance (qk_tap_dance_state_t *state); +int cur_dance (tap_dance_state_t *state); +int hold_cur_dance (tap_dance_state_t *state); diff --git a/users/tominabox1/tominabox1.c b/users/tominabox1/tominabox1.c index 999222fa67..4344e06a1f 100644 --- a/users/tominabox1/tominabox1.c +++ b/users/tominabox1/tominabox1.c @@ -79,7 +79,7 @@ void rgb_matrix_layer_helper(uint8_t hue, uint8_t sat, uint8_t val, uint8_t mode } #endif //RGB_MATRIX_ENABLE -void dance_cln_finished (qk_tap_dance_state_t *state, void *user_data) { +void dance_cln_finished (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { register_code16(S(KC_2)); } else { @@ -87,14 +87,14 @@ void dance_cln_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void dance_cln_reset (qk_tap_dance_state_t *state, void *user_data) { +void dance_cln_reset (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { unregister_code16(S(KC_2)); } else { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [KC_EMAIL] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset), [TD_SFT_CPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS), }; diff --git a/users/uqs/config.h b/users/uqs/config.h index 4bb793532b..455aae9da8 100644 --- a/users/uqs/config.h +++ b/users/uqs/config.h @@ -15,7 +15,7 @@ #define TAPPING_TOGGLE 2 // number of taps for a toggle-on-tap #define TAPPING_TERM 170 // ms to trigger tap // https://precondition.github.io/home-row-mods -#define TAPPING_FORCE_HOLD // make tap-then-hold _not_ do key auto repeat +#define QUICK_TAP_TERM 0 // make tap-then-hold _not_ do key auto repeat #define IGNORE_MOD_TAP_INTERRUPT #define PERMISSIVE_HOLD // I don't think this works for me, hence I rolled my own implementation. diff --git a/users/uqs/uqs.c b/users/uqs/uqs.c index 82cf70c439..bccab617ac 100644 --- a/users/uqs/uqs.c +++ b/users/uqs/uqs.c @@ -543,7 +543,7 @@ void matrix_scan_user(void) { #ifdef UCIS_ENABLE SEQ_ONE_KEY(KC_U) { - qk_ucis_start(); + ucis_start(); } #endif SEQ_ONE_KEY(KC_H) { @@ -576,7 +576,7 @@ void matrix_scan_user(void) { #ifdef UCIS_ENABLE // 3 codepoints at most, otherwise increase UCIS_MAX_CODE_POINTS -const qk_ucis_symbol_t ucis_symbol_table[] = UCIS_TABLE( +const ucis_symbol_t ucis_symbol_table[] = UCIS_TABLE( UCIS_SYM("poop", 0x1F4A9), // 💩 UCIS_SYM("rofl", 0x1F923), // 🤣 UCIS_SYM("look", 0x0CA0, 0x005F, 0x0CA0) // ಠ_ಠdiff --git a/users/vosechu/config.h b/users/vosechu/config.h index 837cc60ff7..81d9305d50 100644 --- a/users/vosechu/config.h +++ b/users/vosechu/config.h @@ -6,7 +6,7 @@ // actually sends Ctrl-x. That's bad.) #define IGNORE_MOD_TAP_INTERRUPT #undef PERMISSIVE_HOLD -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 //#define RETRO_TAPPING #ifndef TAPPING_TOGGLE diff --git a/users/wanleg/tapdances.c b/users/wanleg/tapdances.c index cfd84a2644..5d820df3b8 100644 --- a/users/wanleg/tapdances.c +++ b/users/wanleg/tapdances.c @@ -27,7 +27,7 @@ typedef struct { int state; } tap; -int cur_dance (qk_tap_dance_state_t *state) { +int cur_dance (tap_dance_state_t *state) { if (state->count == 1) { //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP if (state->interrupted || !state->pressed) return SINGLE_TAP; @@ -59,7 +59,7 @@ static tap CADtap_state = { .state = 0 }; -void CAD_finished (qk_tap_dance_state_t *state, void *user_data) { +void CAD_finished (tap_dance_state_t *state, void *user_data) { CADtap_state.state = cur_dance(state); switch (CADtap_state.state) { case SINGLE_TAP: @@ -102,7 +102,7 @@ void CAD_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void CAD_reset (qk_tap_dance_state_t *state, void *user_data) { +void CAD_reset (tap_dance_state_t *state, void *user_data) { switch (CADtap_state.state) { //nothing to do } @@ -115,7 +115,7 @@ static tap RSTtap_state = { .state = 0 }; -void RST_finished (qk_tap_dance_state_t *state, void *user_data) { +void RST_finished (tap_dance_state_t *state, void *user_data) { RSTtap_state.state = cur_dance(state); switch (RSTtap_state.state) { case SINGLE_TAP: register_code(KC_LCTL); break; @@ -125,7 +125,7 @@ void RST_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void RST_reset (qk_tap_dance_state_t *state, void *user_data) { +void RST_reset (tap_dance_state_t *state, void *user_data) { switch (RSTtap_state.state) { case SINGLE_TAP: unregister_code(KC_LCTL); break; case SINGLE_HOLD: unregister_code(KC_LCTL); break; @@ -140,7 +140,7 @@ static tap LYRtap_state = { .state = 0 }; -void LYR_finished (qk_tap_dance_state_t *state, void *user_data) { +void LYR_finished (tap_dance_state_t *state, void *user_data) { LYRtap_state.state = cur_dance(state); switch (LYRtap_state.state) { case SINGLE_TAP: register_code(KC_PSLS); break; @@ -149,7 +149,7 @@ void LYR_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void LYR_reset (qk_tap_dance_state_t *state, void *user_data) { +void LYR_reset (tap_dance_state_t *state, void *user_data) { switch (LYRtap_state.state) { case SINGLE_TAP: unregister_code(KC_PSLS); break; case DOUBLE_TAP: set_single_persistent_default_layer(_GK); break; @@ -164,7 +164,7 @@ static tap LYR75tap_state = { .state = 0 }; -void LYR75_finished (qk_tap_dance_state_t *state, void *user_data) { +void LYR75_finished (tap_dance_state_t *state, void *user_data) { LYR75tap_state.state = cur_dance(state); switch (LYR75tap_state.state) { case SINGLE_TAP: register_code(KC_PSLS); break; @@ -173,7 +173,7 @@ void LYR75_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void LYR75_reset (qk_tap_dance_state_t *state, void *user_data) { +void LYR75_reset (tap_dance_state_t *state, void *user_data) { switch (LYR75tap_state.state) { case SINGLE_TAP: unregister_code(KC_PSLS); break; case DOUBLE_TAP: set_single_persistent_default_layer(_GK); break; @@ -188,7 +188,7 @@ static tap LYR50tap_state = { .state = 0 }; -void LYR50_finished (qk_tap_dance_state_t *state, void *user_data) { +void LYR50_finished (tap_dance_state_t *state, void *user_data) { LYR50tap_state.state = cur_dance(state); switch (LYR75tap_state.state) { case SINGLE_TAP: register_code(KC_PSLS); break; @@ -197,7 +197,7 @@ void LYR50_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void LYR50_reset (qk_tap_dance_state_t *state, void *user_data) { +void LYR50_reset (tap_dance_state_t *state, void *user_data) { switch (LYR50tap_state.state) { case SINGLE_TAP: unregister_code(KC_PSLS); break; case DOUBLE_TAP: set_single_persistent_default_layer(GK50); break; @@ -212,7 +212,7 @@ static tap BSWtap_state = { .state = 0 }; -void BSW_finished (qk_tap_dance_state_t *state, void *user_data) { +void BSW_finished (tap_dance_state_t *state, void *user_data) { BSWtap_state.state = cur_dance(state); switch (BSWtap_state.state) { case SINGLE_TAP: register_code(KC_ENTER); break; @@ -233,7 +233,7 @@ void BSW_finished (qk_tap_dance_state_t *state, void *user_data) { } } -void BSW_reset (qk_tap_dance_state_t *state, void *user_data) { +void BSW_reset (tap_dance_state_t *state, void *user_data) { switch (BSWtap_state.state) { case SINGLE_TAP: unregister_code(KC_ENTER); break; case DOUBLE_TAP: @@ -248,7 +248,7 @@ void BSW_reset (qk_tap_dance_state_t *state, void *user_data) { //Tap Dance Definitions //THIS SECTION HAS TO BE AT THE END OF THE TAP DANCE SECTION -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_SFT_CAPS] = ACTION_TAP_DANCE_DOUBLE(KC_LSFT, KC_CAPS) // Other declarations would go here, separated by commas, if you have them ,[TD_Q_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_Q, KC_ESC) diff --git a/users/xulkal/config.h b/users/xulkal/config.h index 7f7782807e..bc175dda98 100644 --- a/users/xulkal/config.h +++ b/users/xulkal/config.h @@ -1,10 +1,11 @@ #pragma once -#undef TAPPING_FORCE_HOLD - #undef TAPPING_TERM #define TAPPING_TERM 175 +#undef QUICK_TAP_TERM +#define QUICK_TAP_TERM TAPPING_TERM + #define SPACE_CADET_MODIFIER_CARRYOVER #define LSPO_KEYS KC_LSFT, KC_TRNS, KC_LBRC #define RSPC_KEYS KC_RSFT, KC_TRNS, KC_RBRC diff --git a/users/xulkal/custom_tap_dance.c b/users/xulkal/custom_tap_dance.c index bcbfb577bb..c2f9efe44b 100644 --- a/users/xulkal/custom_tap_dance.c +++ b/users/xulkal/custom_tap_dance.c @@ -4,7 +4,7 @@ #ifdef TAP_DANCE_ENABLE //Tap Dance Definitions -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [COMM_QUOT] = ACTION_TAP_DANCE_DOUBLE(KC_COMM, KC_QUOT), [BACKSPACE] = ACTION_TAP_DANCE_DOUBLE (KC_BACKSPACE, LCTL(KC_BACKSPACE)), [DELETE] = ACTION_TAP_DANCE_DOUBLE (KC_DELETE, LCTL(KC_DELETE)) diff --git a/users/yet-another-developer/config.h b/users/yet-another-developer/config.h index 6d1bf83f0b..030872d3dd 100644 --- a/users/yet-another-developer/config.h +++ b/users/yet-another-developer/config.h @@ -31,7 +31,7 @@ // actually sends Ctrl-x. That's bad.) #define IGNORE_MOD_TAP_INTERRUPT #undef PERMISSIVE_HOLD -//#define TAPPING_FORCE_HOLD +//#define QUICK_TAP_TERM 0 //#define RETRO_TAPPING #ifndef TAPPING_TOGGLE diff --git a/users/yet-another-developer/tap_dances.c b/users/yet-another-developer/tap_dances.c index 66dcc60fa5..cde0cb832e 100644 --- a/users/yet-another-developer/tap_dances.c +++ b/users/yet-another-developer/tap_dances.c @@ -1,6 +1,6 @@ #include "tap_dances.h" -void td_parenthesis (qk_tap_dance_state_t *state, void *user_data) { +void td_parenthesis (tap_dance_state_t *state, void *user_data) { if (state->count == 1) { // SEND_STRING ("\("); tap_code(KC_QUOT); @@ -24,7 +24,7 @@ void td_parenthesis (qk_tap_dance_state_t *state, void *user_data) { } } -void safe_reset(qk_tap_dance_state_t *state, void *user_data) { +void safe_reset(tap_dance_state_t *state, void *user_data) { if (state->count >= 3) { // Reset the keyboard if you tap the key more than three times reset_keyboard(); @@ -32,7 +32,7 @@ void safe_reset(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [TD_RESET] = ACTION_TAP_DANCE_FN(safe_reset), [TD_NUM1] = ACTION_TAP_DANCE_DOUBLE(KC_1, KC_4), [TD_NUM2] = ACTION_TAP_DANCE_DOUBLE(KC_2, KC_5), diff --git a/users/yet-another-developer/tap_dances.h b/users/yet-another-developer/tap_dances.h index 8afda817cb..ca925e71bd 100644 --- a/users/yet-another-developer/tap_dances.h +++ b/users/yet-another-developer/tap_dances.h @@ -23,4 +23,4 @@ enum { TD_ABR // single double angle brackets }; #endif // TAP_DANCE_ENABLE -void td_parenthesis (qk_tap_dance_state_t *state, void *user_data); +void td_parenthesis (tap_dance_state_t *state, void *user_data); diff --git a/users/zer09/tap_dance.c b/users/zer09/tap_dance.c index 4c7d182d8a..dc87f31eb5 100644 --- a/users/zer09/tap_dance.c +++ b/users/zer09/tap_dance.c @@ -1,7 +1,7 @@ #include "tap_dance.h" #include "lights.h" -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [DA_LCTL] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_lctl_finished, dance_lctl_reset), [DA_LSPR] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_lspr_finished, @@ -40,7 +40,7 @@ void layer_switcher_tap(uint8_t new_layer) { } } -int cur_dance(qk_tap_dance_state_t *state) { +int cur_dance(tap_dance_state_t *state) { switch (state->count) { case 1: return state->pressed == 0 ? SINGLE_TAP : SINGLE_HOLD; @@ -53,17 +53,17 @@ int cur_dance(qk_tap_dance_state_t *state) { } } -void dance_lctl_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_lctl_finished(tap_dance_state_t *state, void *user_data) { rbw_led_keys[RBW_LCTL].status = ENABLED; register_code(KC_LCTL); }; -void dance_lctl_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_lctl_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_LCTL); rbw_led_keys[RBW_LCTL].status = DISABLED; }; -void dance_lspr_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_lspr_finished(tap_dance_state_t *state, void *user_data) { lsprtap_state.state = cur_dance(state); switch (lsprtap_state.state) { @@ -77,7 +77,7 @@ void dance_lspr_finished(qk_tap_dance_state_t *state, void *user_data) { } }; -void dance_lspr_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_lspr_reset(tap_dance_state_t *state, void *user_data) { switch (lsprtap_state.state) { case DOUBLE_HOLD: unregister_code(KC_LALT); @@ -89,17 +89,17 @@ void dance_lspr_reset(qk_tap_dance_state_t *state, void *user_data) { } }; -void dance_rctl_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_rctl_finished(tap_dance_state_t *state, void *user_data) { rbw_led_keys[RBW_RCTL].status = ENABLED; register_code(KC_RCTL); }; -void dance_rctl_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_rctl_reset(tap_dance_state_t *state, void *user_data) { unregister_code(KC_RCTL); rbw_led_keys[RBW_RCTL].status = DISABLED; }; -void dance_ralt_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_ralt_finished(tap_dance_state_t *state, void *user_data) { ralttap_state.state = cur_dance(state); switch (ralttap_state.state) { @@ -113,7 +113,7 @@ void dance_ralt_finished(qk_tap_dance_state_t *state, void *user_data) { } }; -void dance_ralt_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_ralt_reset(tap_dance_state_t *state, void *user_data) { switch (ralttap_state.state) { case DOUBLE_HOLD: unregister_code(KC_RGUI); @@ -125,7 +125,7 @@ void dance_ralt_reset(qk_tap_dance_state_t *state, void *user_data) { } }; -void dance_uply_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_uply_finished(tap_dance_state_t *state, void *user_data) { upltap_state.state = cur_dance(state); switch (upltap_state.state) { @@ -145,7 +145,7 @@ void dance_uply_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_uply_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_uply_reset(tap_dance_state_t *state, void *user_data) { switch (upltap_state.state) { case SINGLE_TAP: break; @@ -157,7 +157,7 @@ void dance_uply_reset(qk_tap_dance_state_t *state, void *user_data) { upltap_state.state = 0; } -void dance_dwly_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_dwly_finished(tap_dance_state_t *state, void *user_data) { dwltap_state.state = cur_dance(state); switch (dwltap_state.state) { @@ -188,7 +188,7 @@ void dance_dwly_finished(qk_tap_dance_state_t *state, void *user_data) { } } -void dance_dwly_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_dwly_reset(tap_dance_state_t *state, void *user_data) { switch (dwltap_state.state) { case SINGLE_TAP: break; diff --git a/users/zer09/tap_dance.h b/users/zer09/tap_dance.h index 555c159248..293b5eedc5 100644 --- a/users/zer09/tap_dance.h +++ b/users/zer09/tap_dance.h @@ -32,24 +32,24 @@ enum { extern volatile uint8_t active_layer; void layer_switcher_tap(uint8_t); -int cur_dance(qk_tap_dance_state_t *); +int cur_dance(tap_dance_state_t *); -void dance_lctl_finished(qk_tap_dance_state_t *, void *); -void dance_lctl_reset(qk_tap_dance_state_t *, void *); +void dance_lctl_finished(tap_dance_state_t *, void *); +void dance_lctl_reset(tap_dance_state_t *, void *); -void dance_lspr_finished(qk_tap_dance_state_t *, void *); -void dance_lspr_reset(qk_tap_dance_state_t *, void *); +void dance_lspr_finished(tap_dance_state_t *, void *); +void dance_lspr_reset(tap_dance_state_t *, void *); -void dance_rctl_finished(qk_tap_dance_state_t *, void *); -void dance_rctl_reset(qk_tap_dance_state_t *, void *); +void dance_rctl_finished(tap_dance_state_t *, void *); +void dance_rctl_reset(tap_dance_state_t *, void *); -void dance_ralt_finished(qk_tap_dance_state_t *, void *); -void dance_ralt_reset(qk_tap_dance_state_t *, void *); +void dance_ralt_finished(tap_dance_state_t *, void *); +void dance_ralt_reset(tap_dance_state_t *, void *); -void dance_uply_finished(qk_tap_dance_state_t *, void *); -void dance_uply_reset(qk_tap_dance_state_t *, void *); +void dance_uply_finished(tap_dance_state_t *, void *); +void dance_uply_reset(tap_dance_state_t *, void *); -void dance_dwly_finished(qk_tap_dance_state_t *, void *); -void dance_dwly_reset(qk_tap_dance_state_t *, void *); +void dance_dwly_finished(tap_dance_state_t *, void *); +void dance_dwly_reset(tap_dance_state_t *, void *); #endif diff --git a/users/zigotica/tapdances.c b/users/zigotica/tapdances.c index 06015fc64d..69390d244c 100644 --- a/users/zigotica/tapdances.c +++ b/users/zigotica/tapdances.c @@ -13,7 +13,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. #include "tapdances.h" -void ios_media(qk_tap_dance_state_t *state, void *user_data) { +void ios_media(tap_dance_state_t *state, void *user_data) { if (state->count == 1) { tap_code(KC_MPLY); } else if (state->count == 2) { @@ -25,7 +25,7 @@ void ios_media(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [0] = ACTION_TAP_DANCE_FN(ios_media), [1] = ACTION_TAP_DANCE_DOUBLE(KC_COMM, KC_SCLN), [2] = ACTION_TAP_DANCE_DOUBLE(KC_DOT, KC_COLON), diff --git a/users/zyber/zyber.c b/users/zyber/zyber.c index 63915ddbd4..72852d091a 100644 --- a/users/zyber/zyber.c +++ b/users/zyber/zyber.c @@ -65,14 +65,14 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { } /* Screenshoot */ -void dance_SSHT_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_SSHT_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code16(C(S(G(KC_4)))); } else { tap_code(KC_4); } } -void dance_SSHT_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_SSHT_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code16(C(S(G(KC_4)))); } else { @@ -81,14 +81,14 @@ void dance_SSHT_reset(qk_tap_dance_state_t *state, void *user_data) { } /* Å */ -void dance_LBRC_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_LBRC_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code16(A(KC_LBRC)); } else { tap_code(KC_LBRC); } } -void dance_LBRC_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_LBRC_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code16(A(KC_LBRC)); } else { @@ -97,14 +97,14 @@ void dance_LBRC_reset(qk_tap_dance_state_t *state, void *user_data) { } /* Ö */ -void dance_SCLN_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_SCLN_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code16(A(KC_SCLN)); } else { tap_code(KC_SCLN); } } -void dance_SCLN_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_SCLN_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code16(A(KC_SCLN)); } else { @@ -113,14 +113,14 @@ void dance_SCLN_reset(qk_tap_dance_state_t *state, void *user_data) { } /* Ä */ -void dance_QUOT_finished(qk_tap_dance_state_t *state, void *user_data) { +void dance_QUOT_finished(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { tap_code16(A(KC_QUOT)); } else { tap_code(KC_QUOT); } } -void dance_QUOT_reset(qk_tap_dance_state_t *state, void *user_data) { +void dance_QUOT_reset(tap_dance_state_t *state, void *user_data) { if (state->count == 2) { unregister_code16(A(KC_QUOT)); } else { @@ -128,7 +128,7 @@ void dance_QUOT_reset(qk_tap_dance_state_t *state, void *user_data) { } } -qk_tap_dance_action_t tap_dance_actions[] = { +tap_dance_action_t tap_dance_actions[] = { [SSHT] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_SSHT_finished, dance_SSHT_reset), [LBRC] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_LBRC_finished, dance_LBRC_reset), [SCLN] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, dance_SCLN_finished, dance_SCLN_reset), diff --git a/users/zyber/zyber.h b/users/zyber/zyber.h index d5f114e852..018d0f5e85 100644 --- a/users/zyber/zyber.h +++ b/users/zyber/zyber.h @@ -23,11 +23,11 @@ enum tap_dances { bool process_record_user(uint16_t keycode, keyrecord_t *record); -void dance_SSHT_finished(qk_tap_dance_state_t *state, void *user_data); -void dance_SSHT_reset(qk_tap_dance_state_t *state, void *user_data); -void dance_LBRC_finished(qk_tap_dance_state_t *state, void *user_data); -void dance_LBRC_reset(qk_tap_dance_state_t *state, void *user_data); -void dance_SCLN_finished(qk_tap_dance_state_t *state, void *user_data); -void dance_SCLN_reset(qk_tap_dance_state_t *state, void *user_data); -void dance_QUOT_finished(qk_tap_dance_state_t *state, void *user_data); -void dance_QUOT_reset(qk_tap_dance_state_t *state, void *user_data); +void dance_SSHT_finished(tap_dance_state_t *state, void *user_data); +void dance_SSHT_reset(tap_dance_state_t *state, void *user_data); +void dance_LBRC_finished(tap_dance_state_t *state, void *user_data); +void dance_LBRC_reset(tap_dance_state_t *state, void *user_data); +void dance_SCLN_finished(tap_dance_state_t *state, void *user_data); +void dance_SCLN_reset(tap_dance_state_t *state, void *user_data); +void dance_QUOT_finished(tap_dance_state_t *state, void *user_data); +void dance_QUOT_reset(tap_dance_state_t *state, void *user_data); diff --git a/util/lang_conv.py b/util/lang_conv.py new file mode 100644 index 0000000000..a0da6c392d --- /dev/null +++ b/util/lang_conv.py @@ -0,0 +1,65 @@ +from pathlib import Path + +langs = set() +files = Path('quantum/keymap_extras/').glob('keymap_*.h') +for file in files: + langs.add(file.stem.replace('keymap_', '')) + +for lang in langs: + try: + file = Path(f'quantum/keymap_extras/keymap_{lang}.h') + print(f'Reading:{file}') + collect = None + out = [] + out += ['{'] + out += [' "aliases": {'] + lines = file.read_text(encoding='utf-8').split('\n') + for line in lines: + + if line.startswith("// Row"): + # print(line) + continue + elif line.startswith("/*******************************************************************************"): + raise Exception(f'Skipping:{file}') + elif '/*' in line: + collect = [line] + elif '*/' in line: + collect += [line] + if 'copyright' in collect[0].lower(): + collect = None + continue + out += collect + collect = None + elif collect: + collect += [line] + + elif '#define' in line: + define = line.split() + while len(define) < 5: + define.append("") + + if define[4] == "(backslash)": + define[4] = '\\\\' + + define[4] = " ".join(define[4:]).strip() + define[4] = define[4].replace('"', '\\"') + + if define[4]: + out += [f' "{define[2]}": {{'] + out += [f' "key": "{define[1]}",'] + out += [f' "label": "{define[4]}",'] + out += [f' }}'] + else: + out += [f' "{define[2]}": {{'] + out += [f' "key": "{define[1]}"'] + out += [f' }}'] + + out += [' }'] + out += ['}'] + + dump = Path(f'data/constants/keycodes/extras/keycodes_{lang}_0.0.1.hjson') + print(f'Writing:{dump}') + dump.write_text("\n".join(out), encoding='utf-8') + + except Exception as e: + print(e) diff --git a/util/lang_gen.sh b/util/lang_gen.sh new file mode 100755 index 0000000000..0b062b1a09 --- /dev/null +++ b/util/lang_gen.sh @@ -0,0 +1,8 @@ +#!/bin/bash + +for lang in $(find data/constants/keycodes/extras/ -type f -printf "%f\n" | sed "s/keycodes_//g" | sed "s/_[0-9].*//"); do + data=$(qmk generate-keycode-extras --version latest --lang $lang) + if [ "$?" == "0" ]; then + echo "$data" > quantum/keymap_extras/keymap_$lang.h + fi +done diff --git a/util/size_regression.sh b/util/size_regression.sh index 6da2d360bb..96555c6519 100755 --- a/util/size_regression.sh +++ b/util/size_regression.sh @@ -64,6 +64,7 @@ fixup_submodules() { [ -e lib/ugfx ] && rm -rf lib/ugfx [ -e lib/pico-sdk ] && rm -rf lib/pico-sdk [ -e lib/chibios-contrib/ext/mcux-sdk ] && rm -rf lib/chibios-contrib/ext/mcux-sdk + [ -e lib/lvgl ] && rm -rf lib/lvgl make git-submodule } diff --git a/util/udev/50-qmk.rules b/util/udev/50-qmk.rules index 86f1dc9004..1cc19b4142 100644 --- a/util/udev/50-qmk.rules +++ b/util/udev/50-qmk.rules @@ -81,3 +81,6 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="314b", ATTRS{idProduct}=="0106", TAG+="uacc # GD32V DFU SUBSYSTEMS=="usb", ATTRS{idVendor}=="28e9", ATTRS{idProduct}=="0189", TAG+="uaccess" + +# WB32 DFU +SUBSYSTEMS=="usb", ATTRS{idVendor}=="342d", ATTRS{idProduct}=="dfa0", TAG+="uaccess" |