diff options
Diffstat (limited to 'keyboards/melody96/keymaps/zunger')
| -rw-r--r-- | keyboards/melody96/keymaps/zunger/keymap.c | 268 |
1 files changed, 245 insertions, 23 deletions
diff --git a/keyboards/melody96/keymaps/zunger/keymap.c b/keyboards/melody96/keymaps/zunger/keymap.c index d396de6839..d0d2698b7a 100644 --- a/keyboards/melody96/keymaps/zunger/keymap.c +++ b/keyboards/melody96/keymaps/zunger/keymap.c @@ -14,6 +14,83 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include QMK_KEYBOARD_H +#include <assert.h> + +// This keymap is designed to make it easy to type in a wide variety of languages, as well as +// generate mathematical symbols (à la Space Cadet). +// +// LAYER MAGIC (aka, typing in many alphabets) +// This keyboard has three "base" layers: QWERTY, GREEK, and CADET. The GREEK and CADET layers +// are actually full of Unicode points, and so which point they generate depends on things like +// whether the shift key is down. To handle this, each of those layers is actually *two* layers, one +// with and one without shift. In our main loop, we manage modifier state detection, as well as +// layer switch detection, and pick the right layer on the fly. +// Layers are selected with a combination of three keys. The "Greek" and "Cadet" keys act like +// modifiers: When held down, they transiently select the indicated base layer. The "Layer Lock" key +// locks the value of the base layer at whatever is currently held; so e.g., if you hold Greek + +// Layer Lock, you'll stay in Greek mode until you hit Layer Lock again without any of the mods +// held. +// TODO: This system of layer selection is nice for math, but it's not very nice for actually +// typing in multiple languages. It seems like a better plan will be to reserve one key for each +// base layer -- maybe fn + F(n) -- which can either be held as a modifier or tapped to switch +// layers. That will open up adding some more languages, like Yiddish, but to do this effectively +// we'll need to find a good UI with which to show the currently selected layer. Need to check what +// the melody96 has in the way of outputs (LEDs, sound, etc). +// +// ACCENT MAGIC (aka, typing conveniently in Romance languages) +// We want to support easy typing of diacritical marks. We can't rely on the host OS for this, +// because (e.g.) on MacOS, to make any of the other stuff work, we need to be using the Unicode +// input method at the OS level, which breaks all the normal accent stuff on that end. So we do it +// ourselves. Accents can actually be invoked in two different ways: one fast and very compatible, +// one very versatile but with occasional compatibility problems. +// +// THE MAIN WAY: You can hit one of the "accent request" key patterns immediately *before* typing +// a letter to be accented. It will emit the corresponding accented Unicode. For example, you can +// hit fn-e to request an acute accent, followed by i, and it will output í, U+00ED LATIN SMALL +// LETTER I WITH ACUTE. These "combined characters" are in Unicode normal form C (NFKC), which is +// important because many European websites and apps, in particular, tend to behave very badly +// (misunderstanding and/or crashing) when presented with characters in other forms! The catch is +// that this only works for the various combinations of letters and accents found in the Latin-1 +// supplement block of Unicode -- basically, things you need for Western European languages. +// +// (NB: If you make an accent request followed by a letter which can't take the corresponding +// accent, it will output the uncombined form of the accent followed by whatever you typed; so +// e.g., if you hit fn-e followed by f, it will output ´f, U+00B4 ACUTE ACCENT followed by an +// ordinary f. This is very similar to the default behavior of MacOS.) +// +// THE FLEXIBLE WAY: If you hit the accent request with a shift -- e.g., fn-shift-e -- it will +// instead immediately output the corresponding *combining* Unicode accent mark, which will modify +// the *previous* character you typed. For example, if you type i followed by fn-shift-e, it will +// generate í. But don't be fooled by visual similarity: unlike the previous example, this one is +// an ordinary i followed by U+0301 COMBINING ACUTE ACCENT. It's actually *two symbols*, and this +// is Unicode normal form D (NFKD). Unlike NFKC, there are NFKD representations of far more +// combinations of letters and accents, and it's easy to add more of these if you need. (The NFKC +// representation of such combinations is identical to their NFKD representation) +// +// Programs that try to compare Unicode strings *should* first normalize them by converting them +// all into one normal form or another, and there are functions in every programming language to +// do this -- e.g., JavaScript's string.normalize() -- but lots of programmers fail to understand +// this, and so write code that massively freaks out when it encounters the wrong form. +// +// The current accent request codes are modeled on the ones in MacOS. +// +// fn+` Grave accent (`) +// fn+e Acute accent (´) +// fn+i Circumflex (^) +// fn+u Diaresis / umlaut / trema (¨) +// fn+c Cedilla (¸) +// fn+n Tilde (˜) +// +// Together, these functions make for a nice "polyglot" keyboard: one that can easily type in a wide +// variety of languages, which is very useful for people who, well, need to type in a bunch of +// languages. +// +// The major TODOs are: +// - Update the layer selection logic (and add visible layer cues); +// - Factor the code below so that the data layers are more clearly separated from the code logic, +// so that other users of this keymap can easily add whichever alphabets they need without +// having to deeply understand the implementation. + enum custom_keycodes { // We provide special layer management keys: @@ -32,6 +109,16 @@ enum custom_keycodes { KC_GREEK = SAFE_RANGE, KC_CADET, KC_LAYER_LOCK, + + // These are the keycodes generated by the various "accent request" keystrokes. + KC_ACCENT_START, + KC_CGRV = KC_ACCENT_START, // Grave accent + KC_CAGU, // Acute accent + KC_CDIA, // Diaresis / umlaut / trema + KC_CCIR, // Circumflex + KC_CCED, // Cedilla + KC_CTIL, // Tilde + KC_ACCENT_END, }; enum layers_keymap { @@ -49,21 +136,6 @@ enum layers_keymap { #define MO_FN MO(_FUNCTION) #define KC_LLCK KC_LAYER_LOCK -// TODO: To generalize this, we want some #defines that let us specify how each key on the base -// layer should map to the four special layers, and then use that plus the base layer definition to -// autogenerate the keymaps for the other layers. -// TODO: It would also be nice to be able to put the actual code points in here, rather than -// numbers. - -// Accent marks -#define CMB_GRV H(0300) -#define CMB_AGU H(0301) -#define CMB_DIA H(0308) -#define CMB_CIR H(0302) -#define CMB_MAC H(0304) -#define CMB_CED H(0327) -#define CMB_TIL H(0303) - const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { // NB: Using GESC for escape in the QWERTY layer as a temporary hack because I messed up the @@ -164,14 +236,119 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { // Function layer is mostly for keyboard meta-control operations, but also contains the combining // accent marks. These are deliberately placed to match where the analogous controls go on Mac OS. [_FUNCTION] = LAYOUT_hotswap( - CMB_GRV, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______, RESET, - CMB_GRV, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, - _______, _______, _______, CMB_AGU, _______, _______, _______, CMB_DIA, CMB_CIR, CMB_MAC, _______, _______, _______, _______, _______, _______, _______, + KC_CGRV, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLD, KC_VOLU, _______, _______, RESET, + KC_CGRV, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, + _______, _______, _______, KC_CAGU, _______, _______, _______, KC_CDIA, KC_CCIR, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, UC_M_OS, UC_M_LN, UC_M_WI, UC_M_BS, UC_M_WC, _______, _______, _______, _______, _______, _______, _______, _______, _______, - _______, _______, _______, CMB_CED, _______, _______, CMB_TIL, _______, _______, _______, _______, _______, _______, _______, _______, _______, + _______, _______, _______, KC_CCED, _______, _______, KC_CTIL, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______), }; +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Accent implementation +// +// In the body of process_record_user, we store an "accent_request", which is the accent keycode if +// one was just selected, or zero otherwise. When the *next* key is hit, we look up whether the +// accent request plus that next keycode (plus the state of the shift key) together amount to an +// interesting combined (NFKC) character, and if so, emit it; otherwise, we emit the accent as a +// separate character and then process the next key normally. The resulting UI behavior is similar +// to that of the combining accent keys in MacOS. +// +// We store two arrays, depending on whether shift is or isn't held. Each is two-dimensional, with +// its outer key by the next keycode struck, and the inner key by the accent requested. The outer +// array has KC_Z + 1 as its upper bound, so that we can save memory by only coding alphabetic keys. +// The contents are either Unicode code points, or zero to indicate that we don't have a point for +// this combination. + +#define KC_NUM_ACCENTS (KC_ACCENT_END - KC_ACCENT_START) +#define KC_NUM_SLOTS (KC_Z + 1) + +const uint16_t PROGMEM unshifted_accents[KC_NUM_SLOTS][KC_NUM_ACCENTS] = { + // KC_CGRV, KC_CAGU, KC_CDIA, KC_CCIR, KC_CCED, KC_CTIL + [KC_A] = { 0x00e0, 0x00e1, 0x00e4, 0x00e2, 0, 0x00e3 }, + [KC_E] = { 0x00e8, 0x00e9, 0x00eb, 0x00ea, 0, 0 }, + [KC_I] = { 0x00ec, 0x00ed, 0x00ef, 0x00ee, 0, 0 }, + [KC_O] = { 0x00f2, 0x00f3, 0x00f6, 0x00f4, 0, 0x00f5 }, + [KC_U] = { 0x00f9, 0x00fa, 0x00fc, 0x00fb, 0, 0 }, + [KC_Y] = { 0, 0, 0x00ff, 0, 0, 0 }, + [KC_N] = { 0, 0, 0, 0, 0, 0x00f1 }, + [KC_C] = { 0, 0, 0, 0, 0x00e7, 0 }, +}; + +const uint16_t PROGMEM shifted_accents[KC_NUM_SLOTS][KC_NUM_ACCENTS] = { + // KC_CGRV, KC_CAGU, KC_CDIA, KC_CCIR, KC_CCED, KC_CTIL + [KC_A] = { 0x00c0, 0x00c1, 0x00c4, 0x00c2, 0, 0x00c3 }, + [KC_E] = { 0x00c8, 0x00c9, 0x00cb, 0x00ca, 0, 0 }, + [KC_I] = { 0x00cc, 0x00cd, 0x00cf, 0x00ce, 0, 0 }, + [KC_O] = { 0x00d2, 0x00d3, 0x00d6, 0x00d4, 0, 0x00d5 }, + [KC_U] = { 0x00d9, 0x00da, 0x00dc, 0x00db, 0, 0 }, + [KC_Y] = { 0, 0, 0x00df, 0, 0, 0 }, + [KC_N] = { 0, 0, 0, 0, 0, 0x00d1 }, + [KC_C] = { 0, 0, 0, 0, 0x00c7, 0 }, +}; + +// The uncombined and combined forms of the accents, for when we want to emit them as single +// characters. +const uint16_t PROGMEM uncombined_accents[KC_NUM_ACCENTS] = { + [KC_CGRV - KC_ACCENT_START] = 0x0060, + [KC_CAGU - KC_ACCENT_START] = 0x00b4, + [KC_CDIA - KC_ACCENT_START] = 0x00a8, + [KC_CCIR - KC_ACCENT_START] = 0x005e, + [KC_CCED - KC_ACCENT_START] = 0x00b8, + [KC_CTIL - KC_ACCENT_START] = 0x02dc, +}; + +const uint16_t PROGMEM combined_accents[KC_NUM_ACCENTS] = { + [KC_CGRV - KC_ACCENT_START] = 0x0300, + [KC_CAGU - KC_ACCENT_START] = 0x0301, + [KC_CDIA - KC_ACCENT_START] = 0x0308, + [KC_CCIR - KC_ACCENT_START] = 0x0302, + [KC_CCED - KC_ACCENT_START] = 0x0327, + [KC_CTIL - KC_ACCENT_START] = 0x0303, +}; + +// This function manages keypresses that happen after an accent has been selected by an earlier +// keypress. +// Args: +// accent_key: The accent key which was earlier selected. This must be in the range +// [KC_ACCENT_START, KC_ACCENT_END). +// keycode: The keycode which was just pressed. +// is_shifted: The current shift state (as set by a combination of shift and caps lock) +// force_no_accent: If true, we're in a situation where we want to force there to be no +// accent combination -- if e.g. we're in a non-QWERTY layer, or if other modifier keys +// are held. +// +// Returns true if the keycode has been completely handled by this function (and so should not be +// processed further by process_record_user) or false otherwise. +bool process_key_after_accent( + uint16_t accent_key, + uint16_t keycode, + bool is_shifted, + bool force_no_accent +) { + assert(accent_key >= KC_ACCENT_START); + assert(accent_key < KC_ACCENT_END); + const int accent_index = accent_key - KC_ACCENT_START; + + // If the keycode is outside A..Z, or force_no_accent is set, we know we shouldn't even bother + // with a table lookup. + if (keycode <= KC_Z && !force_no_accent) { + // Pick the correct array. Because this is progmem, we're going to need to do the + // two-dimensional array indexing by hand, and so we just cast it to a single-dimensional array. + const uint16_t *points = (const uint16_t*)(is_shifted ? shifted_accents : unshifted_accents); + const uint16_t code_point = pgm_read_word_near(points + KC_NUM_ACCENTS * keycode + accent_index); + if (code_point) { + register_unicode(code_point); + return true; + } + } + + // If we get here, there was no accent match. Emit the accent as its own character, and then let + // the caller figure out what to do next. + register_unicode(pgm_read_word_near(uncombined_accents + accent_index)); + return false; +} + // Layer bitfields. #define GREEK_LAYER (1UL << _GREEK) #define SHIFTGREEK_LAYER (1UL << _SHIFTGREEK) @@ -185,6 +362,8 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { // get_mods or the like, because this function is called *before* that's updated! static bool shift_held = false; static bool alt_held = false; + static bool ctrl_held = false; + static bool super_held = false; static bool greek_held = false; static bool cadet_held = false; @@ -192,18 +371,36 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { static bool shift_lock = false; static int layer_lock = _QWERTY; - // Process any modifier key presses. + // The accent request, or zero if there isn't one. + static uint16_t accent_request = 0; + + // If this is set to true, don't trigger any handling of pending accent requests. That's what we + // want to do if e.g. the user just hit the shift key or something. + bool ignore_accent_change = !record->event.pressed; + + // Step 1: Process any modifier key state changes, so we can maintain that state. if (keycode == KC_LSHIFT || keycode == KC_RSHIFT) { shift_held = record->event.pressed; + ignore_accent_change = true; } else if (keycode == KC_LALT || keycode == KC_RALT) { alt_held = record->event.pressed; + ignore_accent_change = true; + } else if (keycode == KC_LCTRL || keycode == KC_RCTRL) { + ctrl_held = record->event.pressed; + ignore_accent_change = true; + } else if (keycode == KC_LGUI || keycode == KC_RGUI) { + super_held = record->event.pressed; + ignore_accent_change = true; } else if (keycode == KC_GREEK) { greek_held = record->event.pressed; + ignore_accent_change = true; } else if (keycode == KC_CADET) { cadet_held = record->event.pressed; + ignore_accent_change = true; } - // Now let's transform these into the "cadet request" and "greek request." + // Step 2: Figure out which layer we're supposed to be in, by transforming all the prior stuff + // into layer requests. const bool greek_request = (greek_held && !alt_held); const bool cadet_request = (cadet_held || (greek_held && alt_held)); @@ -260,8 +457,33 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { layer_state_set(new_layer_state); } - // TODO: We can update LED states based on shift_lock (caps), layer_lock (layer lock), and - // base_layer (base layer). + // Step 3: Handle accents. If there's a pending accent request, process it. If what the user just + // hit creates a new accent request, update the pending state for the next keypress. + if (!ignore_accent_change && accent_request && record->event.pressed) { + // Only do the accent stuff if we're in the QWERTY layer and we aren't modifying something. + const bool force_no_accent = ( + actual_layer != _QWERTY || + ctrl_held || + super_held || + alt_held + ); + const uint16_t old_accent = accent_request; + accent_request = 0; + if (process_key_after_accent(old_accent, keycode, shifted, force_no_accent)) { + return false; + } + } + + // And if a new accent request just arrived, update accent_request. + if (keycode >= KC_ACCENT_START && keycode < KC_ACCENT_END && record->event.pressed) { + if (shifted) { + // Shift + accent request generates the combining accent key, and leaves accent_request alone. + register_unicode(pgm_read_word_near(combined_accents + keycode - KC_ACCENT_START)); + return false; + } else { + accent_request = keycode; + } + } return true; } |