@ -1,17 +1,17 @@ | |||
BOOTMAGIC_ENABLE = no # Enable Bootmagic Lite | |||
MOUSEKEY_ENABLE = no # Mouse keys(+4700) | |||
EXTRAKEY_ENABLE = yes # Audio control and System control(+450) | |||
CONSOLE_ENABLE = no # Console for debug(+400) | |||
COMMAND_ENABLE = no # Commands for debug and configuration | |||
TAP_DANCE_ENABLE = no | |||
RGBLIGHT_ENABLE = yes | |||
AUDIO_ENABLE = no | |||
NKRO_ENABLE = yes | |||
BACKLIGHT_ENABLE = no | |||
SWAP_HANDS_ENABLE = no | |||
SPACE_CADET_ENABLE = no | |||
INDICATOR_LIGHTS = no | |||
RGBLIGHT_STARTUP_ANIMATION = no | |||
BOOTMAGIC_ENABLE = no # Enable Bootmagic Lite | |||
MOUSEKEY_ENABLE = no # Mouse keys | |||
EXTRAKEY_ENABLE = yes # Audio control and System control | |||
CONSOLE_ENABLE = no # Console for debug | |||
COMMAND_ENABLE = no # Commands for debug and configuration | |||
TAP_DANCE_ENABLE = no | |||
RGBLIGHT_ENABLE = yes | |||
AUDIO_ENABLE = no | |||
NKRO_ENABLE = yes | |||
BACKLIGHT_ENABLE = no | |||
SWAP_HANDS_ENABLE = no | |||
BOOTLOADER = qmk-dfu | |||
INDICATOR_LIGHTS = no | |||
RGBLIGHT_STARTUP_ANIMATION = no | |||
CUSTOM_UNICODE_ENABLE = no | |||
CUSTOM_SPLIT_TRANSPORT_SYNC = no |
@ -0,0 +1,143 @@ | |||
// Copyright 2021 Google LLC | |||
// Copyright 2022 @filterpaper | |||
// SPDX-License-Identifier: Apache-2.0 | |||
// Original source: https://getreuer.info/posts/keyboards/autocorrection | |||
#include "autocorrection.h" | |||
#include <string.h> | |||
#if __has_include("autocorrection_data.h") | |||
# include "autocorrection_data.h" | |||
# if AUTOCORRECTION_MIN_LENGTH < 4 | |||
# error Minimum Length is too short and may cause overflows | |||
# endif | |||
bool process_autocorrection(uint16_t keycode, keyrecord_t* record) { | |||
static uint8_t typo_buffer[AUTOCORRECTION_MAX_LENGTH] = {KC_SPC}; | |||
static uint8_t typo_buffer_size = 1; | |||
if (keycode == AUTO_CTN) { | |||
if (record->event.pressed) { | |||
typo_buffer_size = 0; | |||
userspace_config.autocorrection ^= 1; | |||
eeconfig_update_user(userspace_config.raw); | |||
} | |||
return false; | |||
} | |||
if (!userspace_config.autocorrection) { | |||
typo_buffer_size = 0; | |||
return true; | |||
} | |||
switch (keycode) { | |||
case KC_LSFT: | |||
case KC_RSFT: | |||
return true; | |||
# ifndef NO_ACTION_TAPPING | |||
case QK_MOD_TAP ... QK_MOD_TAP_MAX: | |||
if (((keycode >> 8) & 0xF) == MOD_LSFT) { | |||
return true; | |||
} | |||
# ifndef NO_ACTION_LAYER | |||
case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: | |||
# endif | |||
if (record->event.pressed || !record->tap.count) { | |||
return true; | |||
} | |||
keycode &= 0xFF; | |||
break; | |||
# endif | |||
# ifndef NO_ACTION_ONESHOT | |||
case QK_ONE_SHOT_MOD ... QK_ONE_SHOT_MOD_MAX: | |||
if ((keycode & 0xF) == MOD_LSFT) { | |||
return true; | |||
} | |||
# endif | |||
default: | |||
if (!record->event.pressed) { | |||
return true; | |||
} | |||
} | |||
// Subtract buffer for Backspace key, reset for other non-alpha. | |||
if (!(KC_A <= keycode && keycode <= KC_Z)) { | |||
if (keycode == KC_BSPC) { | |||
// Remove last character from the buffer. | |||
if (typo_buffer_size > 0) { | |||
--typo_buffer_size; | |||
} | |||
return true; | |||
} else if (KC_1 <= keycode && keycode <= KC_SLSH && keycode != KC_ESC) { | |||
// Set a word boundary if space, period, digit, etc. is pressed. | |||
// Behave more conservatively for the enter key. Reset, so that enter | |||
// can't be used on a word ending. | |||
if (keycode == KC_ENT) { | |||
typo_buffer_size = 0; | |||
} | |||
keycode = KC_SPC; | |||
} else { | |||
// Clear state if some other non-alpha key is pressed. | |||
typo_buffer_size = 0; | |||
return true; | |||
} | |||
} | |||
// Rotate oldest character if buffer is full. | |||
if (typo_buffer_size >= AUTOCORRECTION_MAX_LENGTH) { | |||
memmove(typo_buffer, typo_buffer + 1, AUTOCORRECTION_MAX_LENGTH - 1); | |||
typo_buffer_size = AUTOCORRECTION_MAX_LENGTH - 1; | |||
} | |||
// Append `keycode` to buffer. | |||
typo_buffer[typo_buffer_size++] = keycode; | |||
// Return if buffer is smaller than the shortest word. | |||
if (typo_buffer_size < AUTOCORRECTION_MIN_LENGTH) { | |||
return true; | |||
} | |||
// Check for typo in buffer using a trie stored in `autocorrection_data`. | |||
uint16_t state = 0; | |||
uint8_t code = pgm_read_byte(autocorrection_data + state); | |||
for (uint8_t i = typo_buffer_size - 1; i >= 0; --i) { | |||
uint8_t const key_i = typo_buffer[i]; | |||
if (code & 64) { // Check for match in node with multiple children. | |||
code &= 63; | |||
for (; code != key_i; code = pgm_read_byte(autocorrection_data + (state += 3))) { | |||
if (!code) return true; | |||
} | |||
// Follow link to child node. | |||
state = (pgm_read_byte(autocorrection_data + state + 1) | pgm_read_byte(autocorrection_data + state + 2) << 8); | |||
// Check for match in node with single child. | |||
} else if (code != key_i) { | |||
return true; | |||
} else if (!(code = pgm_read_byte(autocorrection_data + (++state)))) { | |||
++state; | |||
} | |||
code = pgm_read_byte(autocorrection_data + state); | |||
if (code & 128) { // A typo was found! Apply autocorrection. | |||
const uint8_t backspaces = code & 63; | |||
for (uint8_t i = 0; i < backspaces; ++i) { | |||
tap_code(KC_BSPC); | |||
} | |||
send_string_P((char const*)(autocorrection_data + state + 1)); | |||
if (keycode == KC_SPC) { | |||
typo_buffer[0] = KC_SPC; | |||
typo_buffer_size = 1; | |||
return true; | |||
} else { | |||
typo_buffer_size = 0; | |||
return false; | |||
} | |||
} | |||
} | |||
return true; | |||
} | |||
#else | |||
# pragma message "Warning!!! Autocorrect is not corretly setup!" | |||
bool process_autocorrection(uint16_t keycode, keyrecord_t* record) { return true; } | |||
#endif |
@ -0,0 +1,10 @@ | |||
// Copyright 2021 Google LLC | |||
// Copyright 2022 @filterpaper | |||
// SPDX-License-Identifier: Apache-2.0 | |||
// Original source: https://getreuer.info/posts/keyboards/autocorrection | |||
#pragma once | |||
#include "drashna.h" | |||
bool process_autocorrection(uint16_t keycode, keyrecord_t* record); |
@ -0,0 +1,273 @@ | |||
# Copyright 2021 Google LLC | |||
# | |||
# Licensed under the Apache License, Version 2.0 (the "License"); | |||
# you may not use this file except in compliance with the License. | |||
# You may obtain a copy of the License at | |||
# | |||
# https://www.apache.org/licenses/LICENSE-2.0 | |||
# | |||
# Unless required by applicable law or agreed to in writing, software | |||
# distributed under the License is distributed on an "AS IS" BASIS, | |||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||
# See the License for the specific language governing permissions and | |||
# limitations under the License. | |||
"""Python program to make autocorrection_data.h. | |||
This program reads "autocorrection_dict.txt" and generates a C source file | |||
"autocorrection_data.h" with a serialized trie embedded as an array. Run this | |||
program without arguments like | |||
$ python3 make_autocorrection_data.py | |||
Or to read from a different typo dict file, pass it as the first argument like | |||
$ python3 make_autocorrection_data.py dict.txt | |||
Each line of the dict file defines one typo and its correction with the syntax | |||
"typo -> correction". Blank lines or lines starting with '#' are ignored. | |||
Example: | |||
:thier -> their | |||
fitler -> filter | |||
lenght -> length | |||
ouput -> output | |||
widht -> width | |||
See autocorrection_dict_extra.txt for a larger example. | |||
For full documentation, see | |||
https://getreuer.info/posts/keyboards/autocorrection | |||
""" | |||
import sys | |||
import textwrap | |||
from typing import Any, Dict, List, Tuple | |||
try: | |||
from english_words import english_words_lower_alpha_set as CORRECT_WORDS | |||
except ImportError: | |||
print('Autocorrection will falsely trigger when a typo is a substring of a ' | |||
'correctly spelled word. To check for this, install the english_words ' | |||
'package and rerun this script:\n\n pip install english_words\n') | |||
# Use a minimal word list as a fallback. | |||
CORRECT_WORDS = ('information', 'available', 'international', 'language', | |||
'loosest', 'reference', 'wealthier', 'entertainment', | |||
'association', 'provides', 'technology', 'statehood') | |||
KC_A = 4 | |||
KC_SPC = 0x2c | |||
def parse_file(file_name: str) -> List[Tuple[str, str]]: | |||
"""Parses autocorrections dictionary file. | |||
Each line of the file defines one typo and its correction with the syntax | |||
"typo -> correction". Blank lines or lines starting with '#' are ignored. The | |||
function validates that typos only have characters a-z and that typos are not | |||
substrings of other typos, otherwise the longer typo would never trigger. | |||
Args: | |||
file_name: String, path of the autocorrections dictionary. | |||
Returns: | |||
List of (typo, correction) tuples. | |||
""" | |||
autocorrections = [] | |||
typos = set() | |||
line_number = 0 | |||
for line in open(file_name, 'rt'): | |||
line_number += 1 | |||
line = line.strip() | |||
if line and line[0] != '#': | |||
# Parse syntax "typo -> correction", using strip to ignore indenting. | |||
tokens = [token.strip() for token in line.split('->', 1)] | |||
if len(tokens) != 2 or not tokens[0]: | |||
print(f'Error:{line_number}: Invalid syntax: "{line}"') | |||
sys.exit(1) | |||
typo, correction = tokens | |||
typo = typo.lower() # Force typos to lowercase. | |||
typo = typo.replace(' ', ':') | |||
if typo in typos: | |||
print(f'Warning:{line_number}: Ignoring duplicate typo: "{typo}"') | |||
continue | |||
# Check that `typo` is valid. | |||
if not(all([ord('a') <= ord(c) <= ord('z') or c == ':' for c in typo])): | |||
print(f'Error:{line_number}: Typo "{typo}" has ' | |||
'characters other than a-z and :.') | |||
sys.exit(1) | |||
for other_typo in typos: | |||
if typo in other_typo or other_typo in typo: | |||
print(f'Error:{line_number}: Typos may not be substrings of one ' | |||
f'another, otherwise the longer typo would never trigger: ' | |||
f'"{typo}" vs. "{other_typo}".') | |||
sys.exit(1) | |||
if len(typo) < 5: | |||
print(f'Warning:{line_number}: It is suggested that typos are at ' | |||
f'least 5 characters long to avoid false triggers: "{typo}"') | |||
if typo.startswith(':') and typo.endswith(':'): | |||
if typo[1:-1] in CORRECT_WORDS: | |||
print(f'Warning:{line_number}: Typo "{typo}" is a correctly spelled ' | |||
'dictionary word.') | |||
elif typo.startswith(':') and not typo.endswith(':'): | |||
for word in CORRECT_WORDS: | |||
if word.startswith(typo[1:]): | |||
print(f'Warning:{line_number}: Typo "{typo}" would falsely trigger ' | |||
f'on correctly spelled word "{word}".') | |||
elif not typo.startswith(':') and typo.endswith(':'): | |||
for word in CORRECT_WORDS: | |||
if word.endswith(typo[:-1]): | |||
print(f'Warning:{line_number}: Typo "{typo}" would falsely trigger ' | |||
f'on correctly spelled word "{word}".') | |||
elif not typo.startswith(':') and not typo.endswith(':'): | |||
for word in CORRECT_WORDS: | |||
if typo in word: | |||
print(f'Warning:{line_number}: Typo "{typo}" would falsely trigger ' | |||
f'on correctly spelled word "{word}".') | |||
autocorrections.append((typo, correction)) | |||
typos.add(typo) | |||
return autocorrections | |||
def make_trie(autocorrections: List[Tuple[str, str]]) -> Dict[str, Any]: | |||
"""Makes a trie from the the typos, writing in reverse. | |||
Args: | |||
autocorrections: List of (typo, correction) tuples. | |||
Returns: | |||
Dict of dict, representing the trie. | |||
""" | |||
trie = {} | |||
for typo, correction in autocorrections: | |||
node = trie | |||
for letter in typo[::-1]: | |||
node = node.setdefault(letter, {}) | |||
node['LEAF'] = (typo, correction) | |||
return trie | |||
def serialize_trie(autocorrections: List[Tuple[str, str]], | |||
trie: Dict[str, Any]) -> List[int]: | |||
"""Serializes trie and correction data in a form readable by the C code. | |||
Args: | |||
autocorrections: List of (typo, correction) tuples. | |||
trie: Dict of dicts. | |||
Returns: | |||
List of ints in the range 0-255. | |||
""" | |||
table = [] | |||
# Traverse trie in depth first order. | |||
def traverse(trie_node): | |||
if 'LEAF' in trie_node: # Handle a leaf trie node. | |||
typo, correction = trie_node['LEAF'] | |||
word_boundary_ending = typo[-1] == ':' | |||
typo = typo.strip(':') | |||
i = 0 # Make the autocorrection data for this entry and serialize it. | |||
while i < min(len(typo), len(correction)) and typo[i] == correction[i]: | |||
i += 1 | |||
backspaces = len(typo) - i - 1 + word_boundary_ending | |||
assert 0 <= backspaces <= 63 | |||
correction = correction[i:] | |||
data = [backspaces + 128] + list(bytes(correction, 'ascii')) + [0] | |||
entry = {'data': data, 'links': [], 'byte_offset': 0} | |||
table.append(entry) | |||
elif len(trie_node) == 1: # Handle trie node with a single child. | |||
c, trie_node = next(iter(trie_node.items())) | |||
entry = {'chars': c, 'byte_offset': 0} | |||
# It's common for a trie to have long chains of single-child nodes. We | |||
# find the whole chain so that we can serialize it more efficiently. | |||
while len(trie_node) == 1 and 'LEAF' not in trie_node: | |||
c, trie_node = next(iter(trie_node.items())) | |||
entry['chars'] += c | |||
table.append(entry) | |||
entry['links'] = [traverse(trie_node)] | |||
else: # Handle trie node with multiple children. | |||
entry = {'chars': ''.join(sorted(trie_node.keys())), 'byte_offset': 0} | |||
table.append(entry) | |||
entry['links'] = [traverse(trie_node[c]) for c in entry['chars']] | |||
return entry | |||
traverse(trie) | |||
def serialize(e): | |||
def kc_code(c): | |||
if ord('a') <= ord(c) <= ord('z'): | |||
return ord(c) - ord('a') + KC_A | |||
elif c == ':': | |||
return KC_SPC | |||
else: | |||
raise ValueError(f'Invalid character: {c}') | |||
encode_link = lambda link: [link['byte_offset'] & 255, | |||
link['byte_offset'] >> 8] | |||
if not e['links']: # Handle a leaf table entry. | |||
return e['data'] | |||
elif len(e['links']) == 1: # Handle a chain table entry. | |||
return list(map(kc_code, e['chars'])) + [0] #+ encode_link(e['links'][0])) | |||
else: # Handle a branch table entry. | |||
data = [] | |||
for c, link in zip(e['chars'], e['links']): | |||
data += [kc_code(c) | (0 if data else 64)] + encode_link(link) | |||
return data + [0] | |||
byte_offset = 0 | |||
for e in table: # To encode links, first compute byte offset of each entry. | |||
e['byte_offset'] = byte_offset | |||
byte_offset += len(serialize(e)) | |||
assert 0 <= byte_offset <= 0xffff | |||
return [b for e in table for b in serialize(e)] # Serialize final table. | |||
def write_generated_code(autocorrections: List[Tuple[str, str]], | |||
data: List[int], | |||
file_name: str) -> None: | |||
"""Writes autocorrection data as generated C code to `file_name`. | |||
Args: | |||
autocorrections: List of (typo, correction) tuples. | |||
data: List of ints in 0-255, the serialized trie. | |||
file_name: String, path of the output C file. | |||
""" | |||
assert all(0 <= b <= 255 for b in data) | |||
typo_len = lambda e: len(e[0]) | |||
min_typo = min(autocorrections, key=typo_len)[0] | |||
max_typo = max(autocorrections, key=typo_len)[0] | |||
generated_code = ''.join([ | |||
'// Generated code.\n\n', | |||
f'// Autocorrection dictionary ({len(autocorrections)} entries):\n', | |||
''.join(sorted(f'// {typo:<{len(max_typo)}} -> {correction}\n' | |||
for typo, correction in autocorrections)), | |||
f'\n#define AUTOCORRECTION_MIN_LENGTH {len(min_typo)} // "{min_typo}"\n', | |||
f'#define AUTOCORRECTION_MAX_LENGTH {len(max_typo)} // "{max_typo}"\n\n', | |||
textwrap.fill('static const uint8_t autocorrection_data[%d] PROGMEM = {%s};' % ( | |||
len(data), ', '.join(map(str, data))), width=80, subsequent_indent=' '), | |||
'\n\n']) | |||
with open(file_name, 'wt') as f: | |||
f.write(generated_code) | |||
def main(argv): | |||
dict_file = argv[1] if len(argv) > 1 else 'autocorrection_dict.txt' | |||
autocorrections = parse_file(dict_file) | |||
trie = make_trie(autocorrections) | |||
data = serialize_trie(autocorrections, trie) | |||
print(f'Processed %d autocorrection entries to table with %d bytes.' | |||
% (len(autocorrections), len(data))) | |||
write_generated_code(autocorrections, data, 'autocorrection_data.h') | |||
if __name__ == '__main__': | |||
main(sys.argv) |
@ -0,0 +1,69 @@ | |||
// Copyright 2021 Google LLC. | |||
// SPDX-License-Identifier: Apache-2.0 | |||
#include "caps_word.h" | |||
bool caps_word_enabled = false; | |||
bool caps_word_shifted = false; | |||
bool process_caps_word(uint16_t keycode, keyrecord_t* record) { | |||
if (!caps_word_enabled) { | |||
// Pressing both shift keys at the same time enables caps word. | |||
if (((get_mods() | get_oneshot_mods()) & MOD_MASK_SHIFT) == MOD_MASK_SHIFT) { | |||
clear_mods(); | |||
clear_oneshot_mods(); | |||
caps_word_shifted = false; | |||
caps_word_enabled = true; | |||
return false; | |||
} | |||
return true; | |||
} | |||
if (!record->event.pressed) { | |||
return true; | |||
} | |||
if (!((get_mods() | get_oneshot_mods()) & ~MOD_MASK_SHIFT)) { | |||
switch (keycode) { | |||
case QK_MOD_TAP ... QK_MOD_TAP_MAX: | |||
case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: | |||
// Earlier return if this has not been considered tapped yet. | |||
if (record->tap.count == 0) { | |||
return true; | |||
} | |||
// Get the base tapping keycode of a mod- or layer-tap key. | |||
keycode &= 0xff; | |||
} | |||
switch (keycode) { | |||
// Letter keys should be shifted. | |||
case KC_A ... KC_Z: | |||
if (!caps_word_shifted) { | |||
register_code(KC_LSFT); | |||
} | |||
caps_word_shifted = true; | |||
return true; | |||
// Keycodes that continue caps word but shouldn't get shifted. | |||
case KC_1 ... KC_0: | |||
case KC_BSPC: | |||
case KC_MINS: | |||
case KC_UNDS: | |||
if (caps_word_shifted) { | |||
unregister_code(KC_LSFT); | |||
} | |||
caps_word_shifted = false; | |||
return true; | |||
// Any other keycode disables caps word. | |||
} | |||
} | |||
// Disable caps word. | |||
caps_word_enabled = false; | |||
if (caps_word_shifted) { | |||
unregister_code(KC_LSFT); | |||
} | |||
caps_word_shifted = false; | |||
return true; | |||
} |
@ -0,0 +1,8 @@ | |||
// Copyright 2021 Google LLC. | |||
// SPDX-License-Identifier: Apache-2.0 | |||
#pragma once | |||
#include "drashna.h" | |||
bool process_caps_word(uint16_t keycode, keyrecord_t* record); |
@ -0,0 +1,136 @@ | |||
/* Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.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 "pointing.h" | |||
static uint16_t mouse_timer = 0; | |||
static uint16_t mouse_debounce_timer = 0; | |||
static uint8_t mouse_keycode_tracker = 0; | |||
bool tap_toggling = false, enable_acceleration = false; | |||
#ifdef TAPPING_TERM_PER_KEY | |||
# define TAP_CHECK get_tapping_term(KC_BTN1, NULL) | |||
#else | |||
# ifndef TAPPING_TERM | |||
# define TAPPING_TERM 200 | |||
# endif | |||
# define TAP_CHECK TAPPING_TERM | |||
#endif | |||
__attribute__((weak)) report_mouse_t pointing_device_task_keymap(report_mouse_t mouse_report) { | |||
return mouse_report; | |||
} | |||
report_mouse_t pointing_device_task_user(report_mouse_t mouse_report) { | |||
int8_t x = mouse_report.x, y = mouse_report.y; | |||
mouse_report.x = 0; | |||
mouse_report.y = 0; | |||
if (x != 0 && y != 0) { | |||
mouse_timer = timer_read(); | |||
#ifdef OLED_ENABLE | |||
oled_timer = timer_read32(); | |||
#endif | |||
if (timer_elapsed(mouse_debounce_timer) > TAP_CHECK) { | |||
if (enable_acceleration) { | |||
x = (x > 0 ? x * x / 16 + x : -x * x / 16 + x); | |||
y = (y > 0 ? y * y / 16 + y : -y * y / 16 + y); | |||
} | |||
mouse_report.x = x; | |||
mouse_report.y = y; | |||
if (!layer_state_is(_MOUSE)) { | |||
layer_on(_MOUSE); | |||
} | |||
} | |||
} | |||
return pointing_device_task_keymap(mouse_report); | |||
} | |||
void matrix_scan_pointing(void) { | |||
if (timer_elapsed(mouse_timer) > 650 && layer_state_is(_MOUSE) && !mouse_keycode_tracker && !tap_toggling) { | |||
layer_off(_MOUSE); | |||
} | |||
if (tap_toggling) { | |||
if (!layer_state_is(_MOUSE)) { | |||
layer_on(_MOUSE); | |||
} | |||
} | |||
} | |||
bool process_record_pointing(uint16_t keycode, keyrecord_t* record) { | |||
switch (keycode) { | |||
case TT(_MOUSE): | |||
if (record->event.pressed) { | |||
mouse_keycode_tracker++; | |||
} else { | |||
#if TAPPING_TOGGLE != 0 | |||
if (record->tap.count == TAPPING_TOGGLE) { | |||
tap_toggling ^= 1; | |||
# if TAPPING_TOGGLE == 1 | |||
if (!tap_toggling) mouse_keycode_tracker -= record->tap.count + 1; | |||
# else | |||
if (!tap_toggling) mouse_keycode_tracker -= record->tap.count; | |||
# endif | |||
} else { | |||
mouse_keycode_tracker--; | |||
} | |||
#endif | |||
} | |||
mouse_timer = timer_read(); | |||
break; | |||
case TG(_MOUSE): | |||
if (record->event.pressed) { | |||
tap_toggling ^= 1; | |||
} | |||
break; | |||
case MO(_MOUSE): | |||
#if defined(KEYBOARD_ploopy) || defined(KEYBOARD_handwired_tractyl_manuform) | |||
case DPI_CONFIG: | |||
#elif defined(KEYBOARD_bastardkb_charybdis) | |||
case SAFE_RANGE ... (CHARYBDIS_SAFE_RANGE-1): | |||
#endif | |||
case KC_MS_UP ... KC_MS_WH_RIGHT: | |||
record->event.pressed ? mouse_keycode_tracker++ : mouse_keycode_tracker--; | |||
mouse_timer = timer_read(); | |||
break; | |||
case KC_ACCEL: | |||
enable_acceleration = record->event.pressed; | |||
record->event.pressed ? mouse_keycode_tracker++ : mouse_keycode_tracker--; | |||
mouse_timer = timer_read(); | |||
break; | |||
default: | |||
if (IS_NOEVENT(record->event)) break; | |||
if ((keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX) && (((keycode >> 0x8) & 0xF) == _MOUSE)) { | |||
record->event.pressed ? mouse_keycode_tracker++ : mouse_keycode_tracker--; | |||
mouse_timer = timer_read(); | |||
break; | |||
} | |||
if (layer_state_is(_MOUSE) && !mouse_keycode_tracker) { | |||
layer_off(_MOUSE); | |||
} | |||
mouse_keycode_tracker = 0; | |||
mouse_debounce_timer = timer_read(); | |||
break; | |||
} | |||
return true; | |||
} | |||
layer_state_t layer_state_set_pointing(layer_state_t state) { | |||
if (layer_state_cmp(state, _GAMEPAD) || layer_state_cmp(state, _DIABLO)) { | |||
state |= ((layer_state_t)1 << _MOUSE); | |||
} | |||
return state; | |||
} |
@ -0,0 +1,23 @@ | |||
/* Copyright 2020 Christopher Courtney, aka Drashna Jael're (@drashna) <drashna@live.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 "drashna.h" | |||
report_mouse_t pointing_device_task_keymap(report_mouse_t mouse_report); | |||
void matrix_scan_pointing(void); | |||
bool process_record_pointing(uint16_t keycode, keyrecord_t* record); | |||
layer_state_t layer_state_set_pointing(layer_state_t state); | |||
extern bool tap_toggling, enable_acceleration; |