gitbot/qmk_firmware
0
0
Fork 0
mirror of https://github.com/qmk/qmk_firmware.git synced 2025-04-10 15:56:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/develop' into xap

Browse Source
This commit is contained in:
QMK Bot 2022-08-14 19:25:34 +00:00
commit 346e044572
6 changed files with 225 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
docs/feature_unicode.md
View File

@ -127,7 +127,7 @@ The following input modes are available:
By default, this mode uses Ctrl+Shift+U (`LCTL(LSFT(KC_U))`) to start Unicode input, but this can be changed by defining [`UNICODE_KEY_LNX`](#input-key-configuration) with a different keycode. This might be required for IBus versions ≥1.5.15, where Ctrl+Shift+U behavior is consolidated into Ctrl+Shift+E.
Users who wish support in non-GTK apps without IBus may need to resort to a more indirect method, such as creating a custom keyboard layout ([more on this method](#custom-linux-layout)).
* **`UC_WIN`**: _(not recommended)_ Windows built-in hex numpad Unicode input. Supports code points up to `0xFFFF`.
To enable, create a registry key under `HKEY_CURRENT_USER\Control Panel\Input Method` of type `REG_SZ` called `EnableHexNumpad` and set its value to `1`. This can be done from the Command Prompt by running `reg add "HKCU\Control Panel\Input Method" -v EnableHexNumpad -t REG_SZ -d 1` with administrator privileges. Reboot afterwards.
@ -172,6 +172,7 @@ You can switch the input mode at any time by using the following keycodes. Addin
|`UNICODE_MODE_WIN` |`UC_M_WI`|`UC_WIN` |Switch to Windows input |
|`UNICODE_MODE_BSD` |`UC_M_BS`|`UC_BSD` |Switch to BSD input _(not implemented)_ |
|`UNICODE_MODE_WINC` |`UC_M_WC`|`UC_WINC` |Switch to Windows input using WinCompose |
|`UNICODE_MODE_EMACS` |`UC_M_EM`|`UC_EMACS` |Switch to emacs (`C-x-8 RET`) |
You can also switch the input mode by calling `set_unicode_input_mode(x)` in your code, where _x_ is one of the above input mode constants (e.g. `UC_LNX`).

32
quantum/process_keycode/process_caps_word.c
View File

@ -101,14 +101,34 @@ bool process_caps_word(uint16_t keycode, keyrecord_t* record) {
return true;
#ifndef NO_ACTION_TAPPING
// Corresponding to mod keys above, a held mod-tap is handled as:
// * For shift mods, pass KC_LSFT or KC_RSFT to
// caps_word_press_user() to determine whether to continue.
// * For Shift + AltGr (MOD_RSFT | MOD_RALT), pass RSFT(KC_RALT).
// * AltGr (MOD_RALT) is ignored.
// * Otherwise stop Caps Word.
case QK_MOD_TAP ... QK_MOD_TAP_MAX:
if (record->tap.count == 0) {
// Deactivate if a mod becomes active through holding
// a mod-tap key.
caps_word_off();
return true;
if (record->tap.count == 0) { // Mod-tap key is held.
const uint8_t mods = (keycode >> 8) & 0x1f;
switch (mods) {
case MOD_LSFT:
keycode = KC_LSFT;
break;
case MOD_RSFT:
keycode = KC_RSFT;
break;
case MOD_RSFT | MOD_RALT:
keycode = RSFT(KC_RALT);
break;
case MOD_RALT:
return true;
default:
caps_word_off();
return true;
}
} else {
keycode &= 0xff;
}
keycode &= 0xff;
break;
# ifndef NO_ACTION_LAYER

40
quantum/process_keycode/process_unicode_common.c
View File

@ -117,6 +117,12 @@ __attribute__((weak)) void unicode_input_start(void) {
tap_code(UNICODE_KEY_WINC);
tap_code(KC_U);
break;
case UC_EMACS:
// The usual way to type unicode in emacs is C-x-8 <RET> then the unicode number in hex
tap_code16(LCTL(KC_X));
tap_code16(KC_8);
tap_code16(KC_ENTER);
break;
}
wait_ms(UNICODE_TYPE_DELAY);
@ -142,6 +148,9 @@ __attribute__((weak)) void unicode_input_finish(void) {
case UC_WINC:
tap_code(KC_ENTER);
break;
case UC_EMACS:
tap_code16(KC_ENTER);
break;
}
set_mods(unicode_saved_mods); // Reregister previously set mods
@ -167,6 +176,9 @@ __attribute__((weak)) void unicode_input_cancel(void) {
tap_code(KC_NUM_LOCK);
}
break;
case UC_EMACS:
tap_code16(LCTL(KC_G)); // C-g cancels
break;
}
set_mods(unicode_saved_mods); // Reregister previously set mods
@ -299,14 +311,30 @@ bool process_unicode_common(uint16_t keycode, keyrecord_t *record) {
cycle_unicode_input_mode(shifted ? +1 : -1);
audio_helper();
break;
case UNICODE_MODE_MAC ... UNICODE_MODE_WINC: {
// Keycodes and input modes follow the same ordering
uint8_t delta = keycode - UNICODE_MODE_MAC;
set_unicode_input_mode(UC_MAC + delta);
case UNICODE_MODE_MAC:
set_unicode_input_mode(UC_MAC);
audio_helper();
break;
case UNICODE_MODE_LNX:
set_unicode_input_mode(UC_LNX);
audio_helper();
break;
case UNICODE_MODE_WIN:
set_unicode_input_mode(UC_WIN);
audio_helper();
break;
case UNICODE_MODE_BSD:
set_unicode_input_mode(UC_BSD);
audio_helper();
break;
case UNICODE_MODE_WINC:
set_unicode_input_mode(UC_WINC);
audio_helper();
break;
case UNICODE_MODE_EMACS:
set_unicode_input_mode(UC_EMACS);
audio_helper();
break;
}
}
}

1
quantum/process_keycode/process_unicode_common.h
View File

@ -64,6 +64,7 @@ enum unicode_input_modes {
UC_WIN, // Windows using EnableHexNumpad
UC_BSD, // BSD (not implemented)
UC_WINC, // Windows using WinCompose (https://github.com/samhocevar/wincompose)
UC_EMACS, // Emacs is an operating system in search of a good text editor
UC__COUNT // Number of available input modes (always leave at the end)
};

3
quantum/quantum_keycodes.h
View File

@ -609,6 +609,8 @@ enum quantum_keycodes {
MAGIC_UNSWAP_ESCAPE_CAPSLOCK,
MAGIC_TOGGLE_ESCAPE_CAPSLOCK,
UNICODE_MODE_EMACS,
// Start of custom keycode range for keyboards and keymaps - always leave at the end
SAFE_RANGE
};
@ -894,6 +896,7 @@ enum quantum_keycodes {
#define UC_M_WI UNICODE_MODE_WIN
#define UC_M_BS UNICODE_MODE_BSD
#define UC_M_WC UNICODE_MODE_WINC
#define UC_M_EM UNICODE_MODE_EMACS
// Swap Hands
#define SH_T(kc) (QK_SWAP_HANDS | (kc))

159
tests/caps_word/test_caps_word.cpp
View File

@ -25,10 +25,47 @@ using ::testing::AnyOf;
using ::testing::InSequence;
using ::testing::TestParamInfo;
namespace {
bool press_user_default(uint16_t keycode) {
switch (keycode) {
// Keycodes that continue Caps Word, with shift applied.
case KC_A ... KC_Z:
case KC_MINS:
add_weak_mods(MOD_BIT(KC_LSFT)); // Apply shift to next key.
return true;
// Keycodes that continue Caps Word, without shifting.
case KC_1 ... KC_0:
case KC_BSPC:
case KC_DEL:
case KC_UNDS:
return true;
default:
return false; // Deactivate Caps Word.
}
}
uint16_t passed_keycode;
bool press_user_save_passed_keycode(uint16_t keycode) {
passed_keycode = keycode;
return true;
}
bool (*press_user_fun)(uint16_t) = press_user_default;
extern "C" {
bool caps_word_press_user(uint16_t keycode) {
return press_user_fun(keycode);
}
} // extern "C"
class CapsWord : public TestFixture {
public:
void SetUp() override {
caps_word_off();
press_user_fun = press_user_default;
}
};
@ -226,6 +263,126 @@ TEST_F(CapsWord, ShiftsAltGrSymbols) {
testing::Mock::VerifyAndClearExpectations(&driver);
}
// Tests typing "AltGr + A" using a mod-tap key.
TEST_F(CapsWord, ShiftsModTapAltGrSymbols) {
TestDriver driver;
KeymapKey key_a(0, 0, 0, KC_A);
KeymapKey key_altgr_t(0, 1, 0, RALT_T(KC_B));
set_keymap({key_a, key_altgr_t});
// Allow any number of reports with no keys or only modifiers.
// clang-format off
EXPECT_CALL(driver, send_keyboard_mock(AnyOf(
KeyboardReport(),
KeyboardReport(KC_RALT),
KeyboardReport(KC_LSFT, KC_RALT))))
.Times(AnyNumber());
// Expect "Shift + AltGr + A".
EXPECT_REPORT(driver, (KC_LSFT, KC_RALT, KC_A));
// clang-format on
// Turn on Caps Word and type "AltGr + A".
caps_word_on();
key_altgr_t.press();
idle_for(TAPPING_TERM + 1);
tap_key(key_a);
run_one_scan_loop();
key_altgr_t.release();
EXPECT_TRUE(is_caps_word_on());
testing::Mock::VerifyAndClearExpectations(&driver);
}
struct CapsWordPressUserParams {
std::string name;
uint16_t keycode;
uint16_t delay_ms;
uint16_t expected_passed_keycode;
bool continues_caps_word;
static const std::string& GetName(const TestParamInfo<CapsWordPressUserParams>& info) {
return info.param.name;
}
};
class CapsWordPressUser : public ::testing::WithParamInterface<CapsWordPressUserParams>, public CapsWord {
void SetUp() override {
caps_word_on();
passed_keycode = KC_NO;
press_user_fun = press_user_save_passed_keycode;
}
};
// Tests keycodes passed to caps_word_press_user() function for various keys.
TEST_P(CapsWordPressUser, KeyCode) {
TestDriver driver;
KeymapKey key(0, 0, 0, GetParam().keycode);
set_keymap({key});
EXPECT_ANY_REPORT(driver).Times(AnyNumber());
tap_key(key, GetParam().delay_ms);
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);
}
const uint16_t LT_1_KC_A = LT(1, KC_A);
// clang-format off
INSTANTIATE_TEST_CASE_P(
PressUser,
CapsWordPressUser,
::testing::Values(
CapsWordPressUserParams{
"KC_A", KC_A, 1, KC_A, true},
CapsWordPressUserParams{
"KC_HASH", KC_HASH, 1, KC_HASH, true},
CapsWordPressUserParams{
"KC_LSFT", KC_LSFT, 1, KC_LSFT, true},
CapsWordPressUserParams{
"KC_RSFT", KC_RSFT, 1, KC_RSFT, true},
CapsWordPressUserParams{
"LSFT_T_tapped", LSFT_T(KC_A), 1, KC_A, true},
CapsWordPressUserParams{
"LSFT_T_held", LSFT_T(KC_A), TAPPING_TERM + 1, KC_LSFT, true},
CapsWordPressUserParams{
"RSFT_T_held", RSFT_T(KC_A), TAPPING_TERM + 1, KC_RSFT, true},
CapsWordPressUserParams{
"RSA_T_held", RSA_T(KC_A), TAPPING_TERM + 1, RSFT(KC_RALT), true},
// Holding a mod-tap other than Shift or AltGr stops Caps Word.
CapsWordPressUserParams{
"LCTL_T_held", LCTL_T(KC_A), TAPPING_TERM + 1, KC_NO, false},
CapsWordPressUserParams{
"LALT_T_held", LALT_T(KC_A), TAPPING_TERM + 1, KC_NO, false},
CapsWordPressUserParams{
"LGUI_T_held", LGUI_T(KC_A), TAPPING_TERM + 1, KC_NO, false},
// Layer keys are ignored and continue Caps Word.
CapsWordPressUserParams{
"MO", MO(1), 1, KC_NO, true},
CapsWordPressUserParams{
"TO", TO(1), 1, KC_NO, true},
CapsWordPressUserParams{
"TG", TG(1), 1, KC_NO, true},
CapsWordPressUserParams{
"TT", TT(1), 1, KC_NO, true},
CapsWordPressUserParams{
"OSL", OSL(1), 1, KC_NO, true},
CapsWordPressUserParams{
"LT_held", LT_1_KC_A, TAPPING_TERM + 1, KC_NO, true},
// AltGr keys are ignored and continue Caps Word.
CapsWordPressUserParams{
"KC_RALT", KC_RALT, 1, KC_NO, true},
CapsWordPressUserParams{
"OSM_MOD_RALT", OSM(MOD_RALT), 1, KC_NO, true},
CapsWordPressUserParams{
"RALT_T_held", RALT_T(KC_A), TAPPING_TERM + 1, KC_NO, true}
),
CapsWordPressUserParams::GetName
);
// clang-format on
struct CapsWordBothShiftsParams {
std::string name;
uint16_t left_shift_keycode;
@ -435,3 +592,5 @@ INSTANTIATE_TEST_CASE_P(
CapsWordDoubleTapShiftParams::GetName
);
// clang-format on
} // namespace