[Keymap] Unicode and Pointing Device and Autocorect for drashna keymaps (#15415)
Drashna Jaelre
3 years ago
committed by
GitHub
parent
c10bc9f91e
commit
3fa592a402
@ -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; |
||||
Loading…
Reference in new issue