2672 lines
90 KiB
C
2672 lines
90 KiB
C
/*
|
||
* License (GPL):
|
||
|
||
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/>.
|
||
|
||
* Author: © 2019, 2020 by Jos Boersema
|
||
*
|
||
*/
|
||
|
||
/* This file contains mostly the Unicode and special macros.
|
||
It contains the function: process_record_user(...)
|
||
*/
|
||
|
||
#include "./unicode_macros.h"
|
||
#include "./unicode_weurope.h"
|
||
#include "./unicode_hebrew.h"
|
||
|
||
// Definition of ƒ (Dutch currency symbol).
|
||
// Best changed in user_config.h, if you like a Euro symbol instead.
|
||
//
|
||
# ifndef UNICODE_CURRENCY // Prior optional definition in user_config.h
|
||
# define UNICODE_CURRENCY 0x0192 // Hex number. The unicode hex number for position ƒ in the default keymap.
|
||
# endif
|
||
|
||
//
|
||
// 🛠
|
||
#define CS_USER_DEFINED 0x1F6E0 // Hammer & wrench (place holder).
|
||
|
||
#define DIV10POINT TRUE // suggest to function write_number, to divide by 10 and print as a fraction: N.N
|
||
|
||
// Gives Unicode code points to the relevant QMK functions.
|
||
// Handles Dvorak 'descramble' Unicode mode, if compiled (only tested on Linux).
|
||
void unicode_hex2output (long unsigned int unshifted, long unsigned int shifted) {
|
||
|
||
long unsigned int input; // which argument to work on
|
||
|
||
# ifdef DVORAK_DESCRAMBLE // Do the letter descramble if needed.
|
||
|
||
char output[10]; // will hold the ascii for output
|
||
int index; // count backwards 'to left' in the string
|
||
long unsigned int bitmove; // move computation to next digit.
|
||
long unsigned int work; // temporary value for computation
|
||
|
||
# endif
|
||
|
||
// What to work on
|
||
if(shift_ison) input = shifted; // Trying to get everything possible here in this function, to reduce firmware size.
|
||
else input = unshifted;
|
||
|
||
# ifndef DVORAK_DESCRAMBLE // Only normal mode
|
||
|
||
register_unicode ( (uint32_t) input ) ;
|
||
|
||
# else
|
||
|
||
if(_FULL_ != alternate){
|
||
|
||
register_unicode ( (uint32_t) input ) ; // normal Unicode mode
|
||
|
||
}else{ // Special Dvorak-descramble mode: 0-9=0-9, a=a, b=n, c=i, d=h, e=d, f=y
|
||
|
||
// Take the hex value 4 bits at a time, starting with the least significant, convert to ascii, store
|
||
index = 9;
|
||
output[index] = '\0'; // terminator
|
||
bitmove = 0x1;
|
||
while ((work = (input / bitmove)) && (index >= 0)) {
|
||
index --;
|
||
work &= 0xF;
|
||
if (work < 0xA){ // numbers
|
||
output[index] = work + 0x30; // pad to ASCII
|
||
}else{ // alphas
|
||
if (0xA == work) output[index] = 'a';
|
||
if (0xB == work) output[index] = 'n';
|
||
if (0xC == work) output[index] = 'i';
|
||
if (0xD == work) output[index] = 'h';
|
||
if (0xE == work) output[index] = 'd';
|
||
if (0xF == work) output[index] = 'y';
|
||
}
|
||
bitmove *= 0x10; // next digit
|
||
}
|
||
|
||
SEND_STRING ( SS_DOWN(X_LCTRL) SS_DOWN(X_LSHIFT) "f" SS_UP(X_LSHIFT) SS_UP(X_LCTRL) ); // lead-in for Unicode on Linux, 'descramble' mode
|
||
send_string (output + index); // pointer to argument with formatted string
|
||
SEND_STRING ( " " ); // Ends the Unicode numerical input mode
|
||
}
|
||
|
||
# endif // DVORAK_DESCRAMBLE mode for that Base layer & mode setting is compiled in
|
||
|
||
}
|
||
|
||
|
||
// Wrapper for unicode keys that do have the same on shift.
|
||
void unicode_hex2output_single (long unsigned int either) {
|
||
unicode_hex2output (either, either);
|
||
}
|
||
|
||
|
||
// Required by QMK Unicode
|
||
const uint32_t PROGMEM unicode_map[] = {
|
||
|
||
};
|
||
|
||
// Macro name definitions. The Unicode layers _ACC, _DRA and _BON are defined here,
|
||
// because the Unicode map system does not have enough space (at time of this programming, year 2020).
|
||
enum custom_keycodes {
|
||
|
||
// Macro, allowing the upper left button to switch to either _DEF_BASE base layer, or the _ALT_BASE base layer.
|
||
// Alternate is set on/half/off in the _RAR layer. The word "base" is used to avoid "default," because the default
|
||
// layer system call DF() is not being used.
|
||
CTO_BASE = SAFE_RANGE, // 'C' for costum, "TO" for to, "BASE" for chosen base layer
|
||
|
||
OTHER_BASE, // cycles modes: use _DEF_BASE, _ALT_BASE. For “dvorak²” layout (descramble) compile option, there is a third mode.
|
||
|
||
# if defined(BASE_NUMPAD__ALT_BASE)
|
||
OTHER_BASE_GO, // Like OTHER_BASE, but also immediately switches to the other BASE layer.
|
||
# endif
|
||
|
||
CTO_NUMS, // activates number-symbols layer, taking into account the dual layout mode
|
||
CTO_ACCE, // accented ''
|
||
CTO_DRAW, // drawings ''
|
||
|
||
# ifndef CHOLTAP_ACCE_NOP
|
||
CHOLTAP_ACCE, // Go to accented layer, or others in combination with other keys.
|
||
# endif
|
||
|
||
// Keys can be pressed together for a separate layer (like 'adjust layer' on the Planck).
|
||
DUO_HOLD,
|
||
|
||
CHOLTAP_RSHFT, // Go to _FUN layer, or shift modifier.
|
||
CHOLTAP_LSHFT, // Go to <configurable> layer, or shift modifier.
|
||
CHOLTAP_LAYR, // Go to _RAR layer, or right arrow
|
||
|
||
// Shifts which on tap produce a key
|
||
|
||
RSFT_TILDE,
|
||
LSFT_DASH,
|
||
|
||
// Special macro to make F-keys one-shot or not.
|
||
_FUN_STAY,
|
||
|
||
// Layer toggle to be guaranteed on up-key, therefore macro definition here.
|
||
_MOV_UP,
|
||
|
||
// These macros protect the critical keys like 'Power' from accidental press, by needing Shift to be pressed.
|
||
C_KC_PWR, // Powers computer off.
|
||
C_KC_WAKE,
|
||
C_KC_SLEP, // sleep computer
|
||
C_KC_PAUS, // pauze computer
|
||
|
||
// Toggles side leds on/off.
|
||
LEDS_ON,
|
||
RGBTOG_,
|
||
|
||
// Typing speed measuring
|
||
SPEED_TOG,
|
||
SPEED_REPORT,
|
||
|
||
// Word/character counting
|
||
COUNT_TOG, // starts word counting
|
||
COUNT_REPORT, // writes to the computer as if typing, gives count report
|
||
COUNT_WORDMIN, // reduces the word count
|
||
COUNT_NULL, // resets count to zero
|
||
LT__MOV__KC_ENT, // move to layer _MOV, or <enter>
|
||
|
||
// The _ACC layer, additional Unicode.
|
||
# ifndef REMOVE_ACC // This cuts out the whole _ACC layer.
|
||
XP_ACC_AA,
|
||
XP_ACC_AB,
|
||
XP_ACC_AC,
|
||
XP_ACC_AD,
|
||
XP_ACC_AE,
|
||
XP_ACC_AF,
|
||
XP_ACC_AG,
|
||
XP_ACC_AH,
|
||
XP_ACC_AI,
|
||
XP_ACC_AJ,
|
||
XP_ACC_BA,
|
||
XP_ACC_BB,
|
||
XP_ACC_BC,
|
||
XP_ACC_BD,
|
||
XP_ACC_BE,
|
||
XP_ACC_BF,
|
||
XP_ACC_BG,
|
||
XP_ACC_BH,
|
||
XP_ACC_BI,
|
||
XP_ACC_BJ,
|
||
XP_ACC_BK,
|
||
XP_ACC_CA,
|
||
XP_ACC_CB,
|
||
XP_ACC_CC,
|
||
XP_ACC_CD,
|
||
XP_ACC_CE,
|
||
XP_ACC_CF,
|
||
XP_ACC_CG,
|
||
XP_ACC_CH,
|
||
XP_ACC_CI,
|
||
XP_ACC_CJ,
|
||
# endif // REMOVE_ACC
|
||
|
||
# ifndef REMOVE_DRA // This cuts out the whole _DRA layer
|
||
// The _DRA layer, additional Unicode.
|
||
XP_DRA_AA,
|
||
XP_DRA_AB,
|
||
XP_DRA_AC,
|
||
XP_DRA_AD,
|
||
XP_DRA_AE,
|
||
XP_DRA_AF,
|
||
XP_DRA_AG,
|
||
XP_DRA_AH,
|
||
XP_DRA_AI,
|
||
XP_DRA_AJ,
|
||
XP_DRA_BA,
|
||
XP_DRA_BB,
|
||
XP_DRA_BC,
|
||
XP_DRA_BD,
|
||
XP_DRA_BE,
|
||
XP_DRA_BF,
|
||
XP_DRA_BG,
|
||
XP_DRA_BH,
|
||
XP_DRA_BI,
|
||
XP_DRA_BJ,// XP_DRA_BK , // no 'BK' key definition on this layer
|
||
XP_DRA_CA,
|
||
XP_DRA_CB,
|
||
XP_DRA_CC,
|
||
XP_DRA_CD,
|
||
XP_DRA_CE,
|
||
XP_DRA_CF,
|
||
# endif // REMOVE_DRA
|
||
XP_DRA_CG, // Needed for ☑ on Unicode tester key in _RAR
|
||
# ifndef REMOVE_DRA // This cuts out the whole _DRA layer
|
||
XP_DRA_CH,
|
||
XP_DRA_CI,
|
||
XP_DRA_CJ,
|
||
# endif // REMOVE_DRA
|
||
|
||
// The _BON layer, additional Unicode.
|
||
# ifndef REMOVE_BON // Removes this layer entirely, if set.
|
||
XP_BON_AA,
|
||
XP_BON_AB,
|
||
XP_BON_AC,
|
||
XP_BON_AD,
|
||
XP_BON_AE,
|
||
XP_BON_AF,
|
||
XP_BON_AG,
|
||
XP_BON_AH,
|
||
XP_BON_AI,
|
||
XP_BON_AJ,
|
||
XP_BON_BA,
|
||
XP_BON_BB,
|
||
XP_BON_BC,
|
||
XP_BON_BD,
|
||
XP_BON_BE,
|
||
XP_BON_BF,
|
||
XP_BON_BG,
|
||
XP_BON_BH,
|
||
XP_BON_BI,
|
||
XP_BON_BJ,
|
||
XP_BON_BK,
|
||
XP_BON_CA,
|
||
XP_BON_CB,
|
||
XP_BON_CC,
|
||
XP_BON_CD,
|
||
XP_BON_CE,
|
||
XP_BON_CF,
|
||
XP_BON_CG,
|
||
XP_BON_CH,
|
||
XP_BON_CI,
|
||
XP_BON_CJ,
|
||
# endif // REMOVE_BON
|
||
|
||
// Hebrew
|
||
# if defined(BASE_HEBREW__DEF_BASE) || defined(BASE_HEBREW__ALT_BASE)
|
||
XP_HEB_AA,
|
||
XP_HEB_AB,
|
||
XP_HEB_AC,
|
||
XP_HEB_AD,
|
||
XP_HEB_AE,
|
||
XP_HEB_AF,
|
||
XP_HEB_AG,
|
||
XP_HEB_AH,
|
||
XP_HEB_AI,
|
||
XP_HEB_AJ,
|
||
XP_HEB_BA,
|
||
XP_HEB_BB,
|
||
XP_HEB_BC,
|
||
XP_HEB_BD,
|
||
XP_HEB_BE,
|
||
XP_HEB_BF,
|
||
XP_HEB_BG,
|
||
XP_HEB_BH,
|
||
XP_HEB_BI,
|
||
XP_HEB_BJ,
|
||
# if defined(HEBREW_ISRAEL)
|
||
XP_HEB_BK, //
|
||
# endif
|
||
XP_HEB_CA,
|
||
XP_HEB_CB,
|
||
XP_HEB_CC,
|
||
XP_HEB_CD,
|
||
XP_HEB_CE,
|
||
XP_HEB_CF,
|
||
XP_HEB_CG,
|
||
# if defined(HEBREW_ISRAEL) || defined(HEBREW_DVORAK)
|
||
XP_HEB_CH,
|
||
XP_HEB_CI,
|
||
XP_HEB_CJ,
|
||
# endif
|
||
XP_HEB_MQF, // ־
|
||
# endif //BASE_HEBREW__*
|
||
|
||
};
|
||
|
||
// Pre-existing function, called for every key up and down.
|
||
// This function is sortof the hub of the whole thing.
|
||
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
|
||
|
||
// User input for the word count menu
|
||
if (sizecount_menu) {
|
||
if (record->event.pressed) { // key down
|
||
|
||
switch (keycode) {
|
||
case KC_0: // read in how many is maximum
|
||
sizecount_max = (sizecount_max * 10);
|
||
break;
|
||
|
||
case KC_1:
|
||
sizecount_max = (sizecount_max * 10) + 1;
|
||
break;
|
||
|
||
case KC_2:
|
||
sizecount_max = (sizecount_max * 10) + 2;
|
||
break;
|
||
|
||
case KC_3:
|
||
sizecount_max = (sizecount_max * 10) + 3;
|
||
break;
|
||
|
||
case KC_4:
|
||
sizecount_max = (sizecount_max * 10) + 4;
|
||
break;
|
||
|
||
case KC_5:
|
||
sizecount_max = (sizecount_max * 10) + 5;
|
||
break;
|
||
|
||
case KC_6:
|
||
sizecount_max = (sizecount_max * 10) + 6;
|
||
break;
|
||
|
||
case KC_7:
|
||
sizecount_max = (sizecount_max * 10) + 7;
|
||
break;
|
||
|
||
case KC_8:
|
||
sizecount_max = (sizecount_max * 10) + 8;
|
||
break;
|
||
|
||
case KC_9:
|
||
sizecount_max = (sizecount_max * 10) + 9;
|
||
break;
|
||
|
||
case KC_C: // count characters
|
||
sizecount_max_type = SIZECOUNT_CHAR;
|
||
sizecount_menu = FALSE;
|
||
break;
|
||
|
||
case KC_W: // count words
|
||
sizecount_max_type = SIZECOUNT_WORD;
|
||
sizecount_menu = FALSE;
|
||
break;
|
||
|
||
// Anything else ends menu input.
|
||
case KC_DOT:
|
||
case KC_ESC:
|
||
sizecount_menu = FALSE; // break out
|
||
break;
|
||
|
||
}
|
||
if (!sizecount_menu) { // end
|
||
send_string ("->");
|
||
write_number (sizecount_max, FALSE); // just indicate something
|
||
}
|
||
}
|
||
}
|
||
|
||
// Go back to base-layer after pressing an F-key, on key-up to avoid BASE key activation
|
||
if ((_fun_stay == FALSE) && //
|
||
(((keycode >= KC_F1) && (keycode <= KC_F12))
|
||
||
|
||
((keycode >= KC_F13) && (keycode <= KC_F24)))) { // assumes keycodes 1-12 and 13-24 are consequtive, which seems likely, although using 1-24 failed (probably not consequtive)
|
||
// Go back to base layer
|
||
if (!(record->event.pressed)) { // key up
|
||
if (alternate) { //
|
||
layer_move (_ALT_BASE);
|
||
}else{
|
||
layer_move (_DEF_BASE);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Detect if Shift was pressed in isolation, by seeing if another key was pressed during the time
|
||
// the right shift key was held down.
|
||
// This system is also used by CHOLTAP_ACCE
|
||
// This helps make sure a tapped use of these keys is correctly differentiated from their use as a
|
||
// modifier/layer-hold key. The Shift and CHOLTAP_ACCE should not normally interfere with each other.
|
||
if (isolate_trigger) { // speed: hoping this statement to execute a little quicker overall, than the next
|
||
if ((keycode != CHOLTAP_RSHFT) // not right shift up
|
||
&&
|
||
(keycode != CHOLTAP_LSHFT) // not left shift up
|
||
&&
|
||
(keycode != CHOLTAP_ACCE) // _ACC layer (and others)
|
||
&&
|
||
(keycode != RSFT_TILDE) // Shift on _NSY
|
||
&&
|
||
(keycode != LSFT_DASH) // Shift on _NSY
|
||
&&
|
||
(keycode != CHOLTAP_LAYR))
|
||
{ // _RAR layer, or RAlt/Alt-Gr
|
||
isolate_trigger = FALSE; // another key was pressed
|
||
}
|
||
}
|
||
|
||
// This block contains the complex macros, which should not count in speed counting or word/character counting,
|
||
// because they aren't typed characters.
|
||
switch (keycode) {
|
||
|
||
// Typing speed measuring
|
||
case SPEED_TOG: // Toggle speed measuring on/off
|
||
if (record->event.pressed) { // key down
|
||
if (speed_measure) {
|
||
speed_measure = FALSE;
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
rgblight_sethsv_noeeprom (HSV_PURPLE); // indicates stop (_RAR color)
|
||
# endif
|
||
|
||
}else{
|
||
// initialization of measurements
|
||
speed_measure = TRUE; // activates
|
||
speed = 0; // start at 0 k/s
|
||
speed_countdown = SPEED_COUNTDOWN; // reset, speed is measured in batches of keypresses
|
||
speed_counttime = timer_read32 ();// get current time
|
||
speed_add = 0;// speed average accumulator, it keeps adding the *speed* of each batch to this total
|
||
speed_batches = 0; // divider for speed_add to get the average
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
// set middle led
|
||
rgblight_sethsv_noeeprom (HSV_WHITE); // indicates start
|
||
# endif
|
||
|
||
}
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
isolate_rgblight_set ();
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case SPEED_REPORT: // Report the current typing speed by writing it, as if typing
|
||
if (record->event.pressed) { // down
|
||
short added = 5; // This counts how many characters the report itself is adding into the current text,
|
||
// to later delete it from the character count for text-size counting.
|
||
|
||
if (speed_measure) {
|
||
|
||
# ifdef WORDS_PER_MINUTE
|
||
|
||
// The speed is recorded as an accumulation of keystrokes-per-second, times 10 for added precision.
|
||
// This will be converted into words-per-minute by dividing by 5 characters for a word including
|
||
// blank space and punctuation, and multiplied by 60 for seconds per minute. ⁶⁰/₅ = 12. Multiplied
|
||
// by 12 is the simple conversion.
|
||
send_string ("<"); // +1 character written // analogue to '<POWER>'
|
||
added += write_number ((long int)((speed*12)/10), FALSE); // writes the speed
|
||
send_string ("wpm"); // +3 character written
|
||
if (0 != speed_batches) {
|
||
long int average_times_ten;
|
||
average_times_ten =(long int) ((speed_add * 12) / speed_batches); // *12 converts k/s to wpm
|
||
|
||
send_string (";"); // +① ''
|
||
added += write_number (average_times_ten / 10, FALSE); // writes the average speed, cannot use decimal because precision is not there
|
||
send_string ("wpm"); // +③
|
||
added += write_number ((long int) speed_batches, FALSE); // amount of batches
|
||
send_string ("x"); // +①
|
||
added += 9 + write_number ((long int) SPEED_COUNTDOWN, FALSE); // amount of batches
|
||
send_string ("keys"); // +④ = ⑨
|
||
|
||
speed_led ( (int) (average_times_ten / 12));// on report, show the average
|
||
// we need to convert back to k/s now
|
||
}
|
||
|
||
# else // keystrokes per second, k/s
|
||
|
||
send_string ("<"); // +1 character written // analogue to '<POWER>'
|
||
added += write_number ((long int)(speed/10), FALSE); // writes the speed
|
||
send_string ("k/s"); // +3 character written
|
||
if (0 != speed_batches) {
|
||
long int average_times_ten;
|
||
average_times_ten =(long int) (speed_add / speed_batches);
|
||
|
||
send_string (";"); // +① ''
|
||
added += write_number (average_times_ten, DIV10POINT); // writes the average speed
|
||
send_string ("k/s"); // +③
|
||
added += write_number ((long int) speed_batches, FALSE); // amount of batches
|
||
send_string ("x"); // +①
|
||
added += 9 + write_number ((long int) SPEED_COUNTDOWN, FALSE); // amount of batches
|
||
send_string ("keys"); // +④ = ⑨
|
||
|
||
speed_led ( (int) average_times_ten );// on report, show the average. speed_led divides by 10
|
||
}
|
||
|
||
# endif
|
||
|
||
send_string (">"); // +1 = 5
|
||
if (sizecount_measure) sizecount_chars += added; // the user is expected to hit <backspace>
|
||
}else{
|
||
send_string ("<Soff>"); // indicates off
|
||
if (sizecount_measure) sizecount_chars += 5; // user: <backspace>, to take it down again
|
||
}
|
||
|
||
key_timer = timer_read ();
|
||
|
||
}else{ // key up
|
||
// This use of the key is for callibrating your colors; it is difficult otherwise to see.
|
||
// This is not part of normal usage, therefore it is kept bare bones to reduce firmware size
|
||
if (timer_elapsed (key_timer) > 999) { // held for one second
|
||
speed += 10;
|
||
write_number ((long int)(speed/10), FALSE); // writes the speed
|
||
speed_led (speed); // update led
|
||
}
|
||
}
|
||
break;
|
||
|
||
case COUNT_TOG: // Toggle start/stop text size measuring
|
||
if (record->event.pressed) { // key down
|
||
|
||
key_timer = timer_read ();
|
||
|
||
}else{ // up
|
||
if (timer_elapsed (key_timer) < 500) { // held for less than half a second (tapped)
|
||
if (sizecount_measure) {
|
||
|
||
sizecount_measure = FALSE;
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
rgblight_sethsv_noeeprom (HSV_PURPLE); // indicates stop (color of _RAR)
|
||
isolate_rgblight_set ();
|
||
# endif
|
||
|
||
}else{
|
||
|
||
sizecount_measure = TRUE; // start counting
|
||
sizecount_word = FALSE; // detect double blanks. leading blanks are not a word
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
if (0 == sizecount_max) {
|
||
rgblight_sethsv_noeeprom (HSV_BLUE); // indicates start/activated, but only without maximum set
|
||
isolate_rgblight_set (); // .. if maximum set, led goes green to red.
|
||
}else{
|
||
rgblight_sethsv_noeeprom (HSV_GREEN); // indicates start/activated, but only without maximum set
|
||
isolate_rgblight_set (); // .. if maximum set, led goes green to red.
|
||
}
|
||
# endif
|
||
|
||
}
|
||
}else{ // held longer
|
||
sizecount_menu = TRUE;
|
||
send_string ("<Nc|w>"); // Menu: N amount, c|w character|word counting. Input is a number then ‛c’ or ‛w’
|
||
sizecount_max = 0;
|
||
}
|
||
}
|
||
break;
|
||
|
||
case COUNT_NULL: // Sets the count to zero, which allows on/off to have a suspend/resume
|
||
if (record->event.pressed) { // key up
|
||
sizecount_blanks = 0; //
|
||
sizecount_chars = 0;
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
rgblight_sethsv_noeeprom (HSV_CYAN); // indicates reset
|
||
isolate_rgblight_set ();
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case COUNT_REPORT: // Report the current typing speed
|
||
if (record->event.pressed) {
|
||
// We assume the user is writing a report in its active document, and then likely deleting it.
|
||
short added = 0; // This counts how much characters the report adds into the user document.
|
||
|
||
if (sizecount_measure) {
|
||
send_string ("<"); // + 1 and ① characters (1 is one logical stream, ① another)
|
||
if (0 == sizecount_max) { // no size counting maximum, print both characters and words
|
||
|
||
added += write_number (sizecount_chars, FALSE); // returns how many characters where printed
|
||
send_string ("c;"); // + 2
|
||
added += write_number (sizecount_blanks, FALSE) + 5; // adds here
|
||
send_string ("w>"); // + 2 = 5
|
||
|
||
}else{ // Only show the one for which the maximum is set, don't throw off that mental focus
|
||
if (SIZECOUNT_WORD == sizecount_max_type ) {
|
||
|
||
added += write_number (sizecount_blanks, FALSE) + 3;
|
||
send_string ("w>"); // + ② = ③
|
||
|
||
}else{ // characters
|
||
|
||
added += write_number (sizecount_chars, FALSE) + 3; // returns how many characters where printed
|
||
send_string ("c>"); // + ② = ③
|
||
|
||
}
|
||
// add current maximum setting
|
||
send_string ("["); // + 1
|
||
added += write_number (sizecount_max, FALSE) + 3;
|
||
if (SIZECOUNT_WORD == sizecount_max_type) send_string ("w]"); // + 2
|
||
else send_string ("c]"); // + 2
|
||
}
|
||
sizecount_chars += added; // Account for the written characters in the report itself.
|
||
|
||
}else{ // no size counting, also here: keep the report terse
|
||
send_string ("<Coff>"); // indicates off (no need to add to count, since counting is off)
|
||
}
|
||
}
|
||
break;
|
||
|
||
// This allows the user to manually remove word counts, when he has deleted a word.
|
||
// This is not needed for character count, because <backspace> counts as minus.
|
||
case COUNT_WORDMIN: // Take down one word in the word-count.
|
||
if (record->event.pressed) { // down
|
||
key_timer = timer_read ();
|
||
}else{ // up
|
||
if (timer_elapsed (key_timer) < 500) { // held for less than half a second (tapped)
|
||
sizecount_blanks--;
|
||
}else{
|
||
sizecount_blanks -= 10;
|
||
}
|
||
}
|
||
break;
|
||
|
||
// Shift detection system.
|
||
// Disused because it turned out 'one shot' like Unicode input. Shift detection copied from.
|
||
// https://github.com/kyleterry/qmk_firmware/blob/master/quantum/quantum.c
|
||
//uint8_t shifted = get_mods() & (MOD_BIT(KC_LSHIFT)|MOD_BIT(KC_RSHIFT));
|
||
|
||
// Crude but self contained in this source file shift detection.
|
||
// ... right shift
|
||
case KC_RSFT:
|
||
// + ... left shift
|
||
case KC_LSFT:
|
||
if (record->event.pressed) { // key down
|
||
shift_ison = 1; // shift depressed
|
||
}else{ // key up
|
||
shift_ison = 0; // shift released
|
||
}
|
||
// There are macros on Shift who also alter this variable.
|
||
break;
|
||
|
||
case OTHER_BASE: // Switching through the default/alternate BASE modes, and Descramble for that Dvorak compile
|
||
if (record->event.pressed) {
|
||
;
|
||
}else{ // key up
|
||
|
||
// Cycles through the modes
|
||
# ifdef DVORAK_DESCRAMBLE // version Dvorak+Dvorak-descramble has 3 modes
|
||
if (_NORMAL_ == alternate) {
|
||
alternate = _FULL_;// alternate layers
|
||
default_layer_set (_ALT_BASE_MASK); // This is needed only for a rare case,
|
||
// where _DEF_BASE and _ALT_BASE their layer switching keys don't line up,
|
||
// such as with Qwerty Base Arrow
|
||
} else if (_HALF_ == alternate) {
|
||
alternate = _NORMAL_;// normal layers
|
||
default_layer_set (_DEF_BASE_MASK);
|
||
}else{ // _FULL_ == alternate
|
||
alternate = _HALF_;// alternate layers, without 'descramble' recomputing Unicode
|
||
//default_layer_set (_ALT_BASE_MASK);
|
||
// it cycles, and this comes always after it was set _FULL_
|
||
}
|
||
# else // Only switching the BASE layers between alternate and default
|
||
|
||
if (_NORMAL_ == alternate) {
|
||
alternate = _FULL_;// alternate base layers
|
||
default_layer_set (_ALT_BASE_MASK);
|
||
}else{
|
||
alternate = _NORMAL_;// default base layers
|
||
default_layer_set (_DEF_BASE_MASK);
|
||
}
|
||
# endif
|
||
|
||
indicate_base (); // activate led change
|
||
}
|
||
break;
|
||
|
||
# if defined(BASE_NUMPAD__ALT_BASE)
|
||
|
||
case OTHER_BASE_GO: // Switching through the default/alternate BASE modes, and Descramble for that Dvorak compile
|
||
if (record->event.pressed) {
|
||
;
|
||
}else{ // key up
|
||
|
||
// Cycles through the modes
|
||
# ifdef DVORAK_DESCRAMBLE // version Dvorak+Dvorak-descramble has 3 modes
|
||
if (_NORMAL_ == alternate) {
|
||
alternate = _FULL_;// alternate layers
|
||
default_layer_set (_ALT_BASE_MASK);
|
||
} else if (_HALF_ == alternate) {
|
||
alternate = _NORMAL_;// normal layers
|
||
default_layer_set (_DEF_BASE_MASK);
|
||
}else{ // _FULL_ == alternate
|
||
alternate = _HALF_;// alternate layers, without 'descramble' recomputing Unicode
|
||
//default_layer_set (_ALT_BASE_MASK);
|
||
// it cycles, and this comes always after it was set _FULL_
|
||
}
|
||
# else // Only switching the BASE layers between alternate and default
|
||
|
||
if (_NORMAL_ == alternate) {
|
||
alternate = _FULL_;// alternate base layers
|
||
default_layer_set (_ALT_BASE_MASK);
|
||
}else{
|
||
alternate = _NORMAL_;// default base layers
|
||
default_layer_set (_DEF_BASE_MASK);
|
||
}
|
||
# endif
|
||
// make the switch to the other Base layer
|
||
if (alternate) { //
|
||
layer_move (_ALT_BASE);
|
||
}else{
|
||
layer_move (_DEF_BASE);
|
||
}
|
||
}
|
||
break;
|
||
# endif
|
||
|
||
// Switching to layers:
|
||
|
||
case CTO_BASE:
|
||
// User pressed upper/left button, while not on BASE layer: ‛escape’ from a layer to BASE layer.
|
||
// On BASE itself, that key is <Escape>.
|
||
if (record->event.pressed) { // key down
|
||
;
|
||
}else{ // key up
|
||
if (alternate) { // go to the alternate version (bit of a hack maybe, but all alternate
|
||
// ... modes are non-zero)
|
||
layer_move (_ALT_BASE);
|
||
}else{
|
||
layer_move (_DEF_BASE);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case CTO_NUMS: // activates number-symbols layer
|
||
if (record->event.pressed) { // key down
|
||
;
|
||
}else{ // key up, so that upon key down the target layer isn't already activated, triggering that key on up
|
||
if (alternate) { // go to the alternate version
|
||
layer_move (_ALT_NSY);
|
||
}else{
|
||
layer_move (_DEF_NSY);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case CTO_ACCE: // Unicode layer
|
||
if (record->event.pressed) { // key down
|
||
;
|
||
}else{ // key up
|
||
|
||
# ifndef REMOVE_ACC // This cuts out the whole _ACC layer.
|
||
layer_move (_ACC); // activates normal accented layer
|
||
# else
|
||
# ifdef _ACC_KEY_ALT_LAYER
|
||
layer_move (_ACC_KEY_ALT_LAYER); // Alternative layer user configuration
|
||
# endif
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case CTO_DRAW: // Unicode layer
|
||
if (record->event.pressed) { // key down
|
||
;
|
||
}else{ // key up
|
||
|
||
# ifndef REMOVE_DRA // This cuts out the whole _DRA layer.
|
||
layer_move (_DRA); // activates normal accented layer
|
||
# else
|
||
# ifdef _DRA_KEY_ALT_LAYER
|
||
layer_move (_DRA_KEY_ALT_LAYER); // Alternative layer user configuration
|
||
# endif
|
||
# endif
|
||
}
|
||
break;
|
||
|
||
// The below are a simulated LT(layer,kc), layer-tap.
|
||
// Double-tap-hold repeater functionality: not done.
|
||
// They switch what layer to use depending on 'alternate' variable
|
||
// Basically it starts the right layer on key down, goes back to base layer on key up,
|
||
// and throws in a keypress as well if tapped.
|
||
// It also integrates with DUO_HOLD, to reach the _BON layer.
|
||
|
||
# ifndef CHOLTAP_ACCE_NOP // When this key has been eviscerated, this macro becomes useless
|
||
case CHOLTAP_ACCE: // Works with DUO_HOLD macro to activate one of several layers.
|
||
if (record->event.pressed) { // key down
|
||
key_timer = timer_read ();
|
||
isolate_trigger = TRUE; // keep track of whether another key gets pressed.
|
||
|
||
duo_press_acc_bon ++; // This signals to the two DUO_HOLD keys, whether a move to _BON is desired.
|
||
|
||
if (duo_press_nsy_dra) { // One or more of the DUO_HOLD layer keys was already pressed; move to _BON
|
||
|
||
# ifndef REMOVE_BON // Removes this layer entirely, if set.
|
||
layer_move (_BON); // Bonus Unicode layer
|
||
# else
|
||
# ifdef _BON_KEY_ALT_LAYER
|
||
layer_move (_BON_KEY_ALT_LAYER); // Alternative layer user configuration
|
||
# endif
|
||
# endif
|
||
|
||
}else{ // pressed in isolation
|
||
|
||
# ifndef REMOVE_ACC // This cuts out the whole _ACC layer.
|
||
layer_move (_ACC); // Accented layer
|
||
# else
|
||
# ifdef _ACC_KEY_ALT_LAYER
|
||
layer_move (_ACC_KEY_ALT_LAYER); // Alternative layer user configuration
|
||
# endif
|
||
# endif
|
||
|
||
}
|
||
}else{ // key up
|
||
|
||
duo_press_acc_bon --;
|
||
|
||
if (1 == duo_press_nsy_dra) { // One DUO_HOLD layer keys is still pressed; move to numbers/symbols
|
||
|
||
if (_FULL_ == alternate) {
|
||
layer_move (_ALT_NSY);
|
||
}else{
|
||
layer_move (_DEF_NSY);
|
||
}
|
||
}else if (2 == duo_press_nsy_dra) { // Two of the DUO_HOLD layer keys are still pressed: move to _DRA
|
||
|
||
# ifndef REMOVE_DRA // This cuts out the whole _DRA layer.
|
||
layer_move (_DRA); // activates normal accented layer
|
||
# else
|
||
# ifdef _DRA_KEY_ALT_LAYER
|
||
layer_move (_DRA_KEY_ALT_LAYER); // Alternative layer user configuration
|
||
# endif
|
||
# endif
|
||
|
||
}else{
|
||
if (alternate) { // No _DEF_NSY layer keys remain pressed; Go back to base layer
|
||
layer_move (_ALT_BASE);
|
||
}else{
|
||
layer_move (_DEF_BASE);
|
||
}
|
||
}
|
||
|
||
// Pressed in isolation
|
||
if (isolate_trigger)
|
||
{
|
||
if (timer_elapsed (key_timer) <= TAPPING_TERM_HOLTAP) { // tapped
|
||
SEND_STRING (SS_TAP (X_DEL));
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
# endif // CHOLTAP_ACCE_NOP
|
||
|
||
case CHOLTAP_LAYR: //to _RAR on hold, otherwise a keycode
|
||
if (record->event.pressed) { // key down
|
||
key_timer = timer_read ();
|
||
isolate_trigger = TRUE; // keep track of whether another key gets pressed.
|
||
|
||
# ifdef BASE_RIGHT_ALT
|
||
SEND_STRING (SS_DOWN (X_RALT));
|
||
# else
|
||
layer_move (_RAR); // activates descrambled drawings layer
|
||
# endif
|
||
|
||
}else{ // key up
|
||
// Go back to base layer
|
||
if (speed_measure) speed_led (speed); // The _RAR layer overwrites the middle led,
|
||
//.. for use with alternate _HALF_ led colors (middle); thus needs to be set back to speed
|
||
// led color upon leaving.
|
||
|
||
# ifdef BASE_RIGHT_ALT
|
||
SEND_STRING (SS_UP (X_RALT));
|
||
# else
|
||
if (alternate) {
|
||
layer_move (_ALT_BASE);
|
||
}else{
|
||
layer_move (_DEF_BASE);
|
||
}
|
||
# endif
|
||
|
||
// Pressed in isolation
|
||
if (isolate_trigger)
|
||
{
|
||
if (timer_elapsed (key_timer) <= TAPPING_TERM_HOLTAP) { // tapped
|
||
SEND_STRING (SS_TAP (X_RIGHT));
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
# ifndef DUO_HOLD_BASIC
|
||
// This is the normal 'big' version, dealing with switching between _DEF_NSY/_ALT_NSY, _ACC, _DRA and _BON, in
|
||
// .. conjunction with the CHOLTAP_ACCE macro.
|
||
case DUO_HOLD: // The macro around the split space-bar. Both keys come to this macro.
|
||
if (record->event.pressed) { // key down
|
||
|
||
duo_press_nsy_dra ++; // simple way to keep track of how many are pressed
|
||
|
||
if (duo_press_acc_bon){ // Preceded by holding the _ACC/_BON layer switch key: move to _BON
|
||
|
||
# ifndef REMOVE_BON // Removes this layer entirely, if set.
|
||
layer_move (_BON); // Bonus Unicode layer
|
||
# else
|
||
# ifdef _BON_KEY_ALT_LAYER
|
||
layer_move (_BON_KEY_ALT_LAYER); // Alternative layer user configuration
|
||
# endif
|
||
# endif
|
||
|
||
}else if (1 == duo_press_nsy_dra) { // This is the first press of either of the DUO_HOLD keys on BASE
|
||
|
||
if (_NORMAL_ == alternate) {
|
||
layer_move (_DEF_NSY);
|
||
}else{
|
||
layer_move (_ALT_NSY);
|
||
}
|
||
}
|
||
else if (2 == duo_press_nsy_dra) { // both are pressed
|
||
|
||
# ifndef REMOVE_DRA // This cuts out the whole _DRA layer.
|
||
layer_move (_DRA); // activates normal accented layer
|
||
# else
|
||
# ifdef _DRA_KEY_ALT_LAYER
|
||
layer_move (_DRA_KEY_ALT_LAYER); // Alternative layer user configuration
|
||
# endif
|
||
# endif
|
||
}
|
||
|
||
}else{ // key up
|
||
|
||
duo_press_nsy_dra --;
|
||
|
||
if (1 == duo_press_nsy_dra) {
|
||
if (duo_press_acc_bon){ // Still holding the _ACC/_BON layer switch key, and one DUO_HOLD keys
|
||
|
||
# ifndef REMOVE_BON // Removes this layer entirely, if set.
|
||
layer_move (_BON); // Bonus Unicode layer
|
||
# else
|
||
# ifdef _BON_KEY_ALT_LAYER
|
||
layer_move (_BON_KEY_ALT_LAYER); // Alternative layer user configuration
|
||
# endif
|
||
# endif
|
||
|
||
}else{
|
||
if (_NORMAL_ == alternate) {
|
||
layer_move (_DEF_NSY);
|
||
}else{
|
||
layer_move (_ALT_NSY);
|
||
}
|
||
}
|
||
}
|
||
else { // Has to be zero.
|
||
if (duo_press_acc_bon){ // Still holding the _ACC/_BON layer switch key, but zero DUO_HOLD layer keys
|
||
|
||
# ifndef REMOVE_ACC // This cuts out the whole _ACC layer.
|
||
layer_move (_ACC); // Accented layer
|
||
# else
|
||
# ifdef _ACC_KEY_ALT_LAYER
|
||
layer_move (_ACC_KEY_ALT_LAYER); // Alternative layer user configuration
|
||
# endif
|
||
# endif
|
||
|
||
}else{
|
||
if (alternate) { // Back to letters
|
||
layer_move (_ALT_BASE);
|
||
}else{
|
||
layer_move (_DEF_BASE);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
# else
|
||
// This is the eviscerated version, compiled when all Unicode layers _ACC, _DRA, _BON are cut, and layer key
|
||
// .. combinations have not been assigned other uses.
|
||
case DUO_HOLD: // The macro for the keys around the split space-bar. Both keys come to this macro.
|
||
if (record->event.pressed) { // key down
|
||
|
||
duo_press_nsy_dra ++; // simple way to keep track of how many are pressed
|
||
|
||
if (0 != duo_press_nsy_dra) { // One or more of the DUO_HOLD keys is pressed
|
||
if (_NORMAL_ == alternate) {
|
||
layer_move (_DEF_NSY);
|
||
}else{
|
||
layer_move (_ALT_NSY);
|
||
}
|
||
}
|
||
}else{ // key up
|
||
|
||
duo_press_nsy_dra --;
|
||
|
||
if (0 == duo_press_nsy_dra) { // None of the DUO_HOLD keys remains pressed
|
||
if (alternate) { // Back to letters
|
||
layer_move (_ALT_BASE);
|
||
}else{
|
||
layer_move (_DEF_BASE);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
# endif // DUO_HOLD_BASIC
|
||
|
||
// When held the key is shift. When tapped it is computed if the tap is short enough,
|
||
// and if no other key was pressed, in which case: right-shift-up is a toggle to the _FUN layer.
|
||
// The timing is meant to be able to undo an erroneous shift press just by holding longer,
|
||
// and the test if another key was pressed is to prevent an erroneous detection when typing
|
||
// very fast.
|
||
// The reason for this on shift is to isolate GUI, where _FUN was previously more easily
|
||
// located. No alternative tapping function with GUI because some systems do not treat GUI
|
||
// purely as a modifier it seems. Since it is a toggle anyway, _FUN can fit away from the thumb-hold row.
|
||
case CHOLTAP_RSHFT: // When tapped it toggles the _FUN layer, when held it is Shift
|
||
|
||
if (record->event.pressed) { // key down
|
||
|
||
SEND_STRING (SS_DOWN (X_RSFT));
|
||
shift_ison = 1; // shift depressed
|
||
|
||
key_timer = timer_read ();
|
||
isolate_trigger = TRUE; // keep track of whether another key gets pressed until key-up
|
||
|
||
}else{ // key up
|
||
|
||
SEND_STRING (SS_UP (X_RSFT));
|
||
shift_ison = 0; // shift released
|
||
|
||
if (isolate_trigger) { // no other key was hit since key down
|
||
|
||
|
||
// Held medium long: _PAD, long: _MOV.
|
||
// The reason to have a switch to _MOV on the left hand, is to be able to reach arrows on a toggle,
|
||
// all by the left hand, when the right hand is on the mouse.
|
||
if ((timer_elapsed (key_timer) <= 200)) { // tapped short (milliseconds)
|
||
|
||
# ifndef SWITCH_RSHIFT_FUN_RAR // user config to reverse what this key its timing toggles to
|
||
|
||
layer_move (_FUN); // activates function layer as a toggle
|
||
|
||
} else { // held for longer
|
||
|
||
layer_move (_RAR);
|
||
|
||
# else
|
||
|
||
layer_move (_RAR); // activates function layer as a toggle
|
||
|
||
} else { // held for longer
|
||
|
||
layer_move (_FUN);
|
||
|
||
# endif
|
||
|
||
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
// The left-shift version of the above keycode. User can configure something (_PAD is default)
|
||
case CHOLTAP_LSHFT: // When tapped it toggles the _MOV layer, when held it is Shift
|
||
// _RAR was the first idea, but some of its keys are too dangerous regarding accidents.
|
||
if (record->event.pressed) { // key down
|
||
|
||
SEND_STRING (SS_DOWN (X_LSFT));
|
||
shift_ison = 1; // shift depressed
|
||
|
||
# ifndef REMOVE_PAD // The _PAD layer exists, we will use a timer …
|
||
|
||
key_timer = timer_read ();
|
||
|
||
# endif
|
||
|
||
|
||
// This variable is re-used, for speed and because using both shifts is useless,
|
||
// .. thus very rare, and also not a usage problem if it occured.
|
||
isolate_trigger = TRUE; // keep track of whether another key gets pressed.
|
||
|
||
}else{ // key up
|
||
|
||
SEND_STRING (SS_UP (X_LSFT));
|
||
shift_ison = 0; // shift released
|
||
|
||
if (isolate_trigger) { // no other key was hit since key down
|
||
|
||
# ifndef REMOVE_PAD // The _PAD layer exists, differentiate meaning by timer.
|
||
|
||
// Held medium long: _PAD, long: _MOV.
|
||
// The reason to have a switch to _MOV on the left hand, is to be able to reach arrows on a toggle,
|
||
// all by the left hand, when the right hand is on the mouse.
|
||
if ((timer_elapsed (key_timer) <= 200)) { // tapped medium-long (milliseconds)
|
||
|
||
# ifndef SWITCH_LSHIFT_PAD_MOV // user config to reverse what this key its timing toggles to
|
||
|
||
layer_move (_PAD);
|
||
|
||
} else { // held for longer
|
||
|
||
layer_move (_MOV);
|
||
|
||
# else
|
||
|
||
layer_move (_MOV);
|
||
|
||
} else { // held for longer
|
||
|
||
layer_move (_PAD);
|
||
|
||
# endif
|
||
|
||
}
|
||
|
||
# else // _PAD layer was eviscerated
|
||
|
||
layer_move (_MOV);
|
||
|
||
# endif
|
||
|
||
}
|
||
}
|
||
break;
|
||
|
||
/*
|
||
case RSFT_TILDE:
|
||
|
||
if (record->event.pressed) { // key down
|
||
|
||
SEND_STRING (SS_DOWN (X_RSFT));
|
||
shift_ison = 1; // shift depressed
|
||
|
||
key_timer = timer_read ();
|
||
isolate_trigger = TRUE; // keep track of whether another key gets pressed until key-up
|
||
|
||
}else{ // key up
|
||
|
||
SEND_STRING (SS_UP (X_RSFT));
|
||
shift_ison = 0; // shift released
|
||
|
||
if (isolate_trigger) { // no other key was hit since key down
|
||
|
||
|
||
// Held medium long: _PAD, long: _MOV.
|
||
// The reason to have a switch to _MOV on the left hand, is to be able to reach arrows on a toggle,
|
||
// all by the left hand, when the right hand is on the mouse.
|
||
if ((timer_elapsed (key_timer) <= 200)) { // tapped short (milliseconds)
|
||
|
||
SEND_STRING ("~");
|
||
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
*/
|
||
|
||
case RSFT_TILDE: // firmware size optimization, saves 36 bytes
|
||
case LSFT_DASH:
|
||
|
||
if (record->event.pressed) { // key down
|
||
|
||
if (RSFT_TILDE == keycode) { // this is probably not needed, both can be left or right shift
|
||
SEND_STRING (SS_DOWN (X_RSFT));
|
||
}else{
|
||
SEND_STRING (SS_DOWN (X_LSFT));
|
||
}
|
||
shift_ison = 1; // shift depressed
|
||
|
||
key_timer = timer_read ();
|
||
isolate_trigger = TRUE; // keep track of whether another key gets pressed until key-up
|
||
|
||
}else{ // key up
|
||
|
||
if (RSFT_TILDE == keycode) {
|
||
SEND_STRING (SS_UP (X_RSFT));
|
||
}else{
|
||
SEND_STRING (SS_UP (X_LSFT));
|
||
}
|
||
|
||
shift_ison = 0; // shift released
|
||
|
||
if (isolate_trigger) { // no other key was hit since key down
|
||
|
||
|
||
// Held medium long: _PAD, long: _MOV.
|
||
// The reason to have a switch to _MOV on the left hand, is to be able to reach arrows on a toggle,
|
||
// all by the left hand, when the right hand is on the mouse.
|
||
if ((timer_elapsed (key_timer) <= 200)) { // tapped short (milliseconds)
|
||
|
||
if (RSFT_TILDE == keycode) {
|
||
SEND_STRING ("~");
|
||
}else{
|
||
SEND_STRING ("-");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case _FUN_STAY: // toggles if the f-keys return _FUN layer to BASE after one press
|
||
if (record->event.pressed) { // key down
|
||
|
||
if (_fun_stay == FALSE) {
|
||
_fun_stay = TRUE;
|
||
}else{
|
||
_fun_stay = FALSE;
|
||
}
|
||
indicate_fun_stay (); // leds
|
||
}
|
||
break;
|
||
|
||
# ifdef MOREKEY2_ARROW_CLUSTER
|
||
|
||
case _MOV_UP: // To be sure it activates on up key, and not already has triggered the _MOV layer during up-key.
|
||
if (record->event.pressed) { // key down
|
||
;
|
||
}else{ // key up
|
||
layer_move (_MOV);
|
||
}
|
||
break;
|
||
# endif
|
||
|
||
// These keys are so disruptive on an erroneous key press, that they are behind a shift lock.
|
||
// When used unshifted, they print a memory aid string: their name.
|
||
case C_KC_PWR:
|
||
if (record->event.pressed) { // key down
|
||
if (shift_ison) {
|
||
SEND_STRING (SS_TAP (X_PWR));
|
||
}else{
|
||
SEND_STRING ("<POWER>"); // Memory aid
|
||
}
|
||
}
|
||
break;
|
||
|
||
case C_KC_WAKE:
|
||
if (record->event.pressed) { // key down
|
||
if (shift_ison) {
|
||
SEND_STRING (SS_TAP (X_WAKE));
|
||
}else{
|
||
SEND_STRING ("<WAKE>"); // Memory aid
|
||
}
|
||
}
|
||
break;
|
||
|
||
case C_KC_SLEP:
|
||
if (record->event.pressed) { // key down
|
||
if (shift_ison) {
|
||
SEND_STRING (SS_TAP (X_SLEP));
|
||
}else{
|
||
SEND_STRING ("<SLEEP>"); // Memory aid
|
||
}
|
||
}
|
||
break;
|
||
|
||
case C_KC_PAUS:
|
||
if (record->event.pressed) { // key down
|
||
if (shift_ison) {
|
||
SEND_STRING (SS_TAP (X_PAUS));
|
||
}else{
|
||
SEND_STRING ("<PAUSE>"); // Memory aid
|
||
}
|
||
}
|
||
break;
|
||
|
||
case LEDS_ON: // Toggles left/right leds on or off
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
if (leds_on == FALSE) {
|
||
leds_on = TRUE;
|
||
}else{
|
||
leds_on = FALSE;
|
||
}
|
||
set_led_colors_ (state_recall); // Update leds
|
||
}
|
||
# endif
|
||
|
||
break;
|
||
|
||
# ifdef LEDS_OFF_BASE_DEF // This messes with led effect on/off, so we need to track the state of this setting now.
|
||
case RGBTOG_: // Toggles middle led on or off
|
||
if (record->event.pressed) { // key down
|
||
if (led_middle_on == FALSE) {
|
||
led_middle_on = TRUE;
|
||
rgblight_enable_noeeprom ();
|
||
}else{
|
||
led_middle_on = FALSE;
|
||
rgblight_disable_noeeprom ();
|
||
}
|
||
}
|
||
break;
|
||
# endif
|
||
|
||
// Some keycodes treated specially for the two counting systems (speed, text size)
|
||
// Deletions:
|
||
case KC_BSPC: // non-counting speed
|
||
case KC_DEL: // non-counting speed
|
||
if (record->event.pressed) { // key down
|
||
if (sizecount_measure) sizecount_chars--; // minus count for text size (removed a character)
|
||
}
|
||
break;
|
||
|
||
// White space for counting words
|
||
case LT__MOV__KC_ENT: // We want to count the <enter> for word-counts, sadly this looses the key repetition of LT(…)
|
||
if (record->event.pressed) { // key down
|
||
|
||
key_timer = timer_read ();
|
||
layer_move (_MOV);
|
||
|
||
}else{ // key up
|
||
if (alternate) { // Back to letters
|
||
layer_move (_ALT_BASE);
|
||
}else{
|
||
layer_move (_DEF_BASE);
|
||
}
|
||
if (timer_elapsed (key_timer) <= TAPPING_TERM_HOLTAP) { // tapped
|
||
send_string ("\n");
|
||
if (sizecount_measure) {
|
||
sizecount_chars++;
|
||
|
||
if (sizecount_word) sizecount_blanks++; // count a word
|
||
sizecount_word = FALSE; // don't count immediately next blank as a word
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
// Word counting
|
||
case KC_SPC:
|
||
if (record->event.pressed) { // key down
|
||
if (sizecount_measure) {
|
||
sizecount_chars++;
|
||
|
||
if (sizecount_word) sizecount_blanks++; // count a word
|
||
sizecount_word = FALSE; // don't count immediately next blank as a word
|
||
}
|
||
}
|
||
break;
|
||
|
||
// These are excluded from counting for text size/speed, they prevent the “default“ in the case statement to execute.
|
||
|
||
case KC_LEFT:
|
||
case KC_UP:
|
||
case KC_DOWN:
|
||
case KC_RIGHT:
|
||
case KC_PGUP:
|
||
case KC_PGDN:
|
||
case KC_HOME:
|
||
case KC_END:
|
||
case LALT_T ( KC_LEFT ):
|
||
if (speed_measure) speed_countdown++; // Navigation could be integral to someone typing and correcting mistakes,
|
||
// but those keys don't add any text.
|
||
// Mouse movement is discounted in both speed and text size
|
||
case KC_WH_L:
|
||
case KC_WH_D:
|
||
case KC_WH_U:
|
||
case KC_WH_R:
|
||
case KC_MS_L:
|
||
case KC_MS_D:
|
||
case KC_MS_U:
|
||
case KC_MS_R:
|
||
case KC_BTN1:
|
||
case KC_BTN5:
|
||
case KC_BTN4:
|
||
case KC_BTN3:
|
||
case KC_BTN2:
|
||
break;
|
||
|
||
|
||
default: // If something else, it is a speed- and text measurement counting key
|
||
if (record->event.pressed) { // key down
|
||
if (speed_measure) speed_countdown--;
|
||
if (sizecount_measure) sizecount_chars++;
|
||
}
|
||
}
|
||
|
||
// If speed measuring is on, count keypresses
|
||
// The idea is to more/less follow common standard with typing speed counting: shift is not counted,
|
||
// layer-switching or its equivalent is neither. Arrows are not counted.
|
||
if (speed_measure) {
|
||
if (record->event.pressed) { // key down
|
||
|
||
if (0 >= speed_countdown) {
|
||
|
||
// key presses per second, but times ten for added precision of one digit
|
||
// This calculation quickly looses precision if not calculated with high enough numbers, but low enough to fit.
|
||
speed = (int) ( (SPEED_COUNTDOWN * 1000 ) / ((timer_read32 () - speed_counttime)/10) ); // counts time in ms
|
||
speed_led (speed); // updates led
|
||
|
||
// record for average
|
||
if (0 < (speed/10)) { // ignore 0 k/s batches, we assume the typer took a break
|
||
speed_batches++;
|
||
speed_add += speed;
|
||
}
|
||
|
||
// reset for next batch
|
||
speed_countdown = SPEED_COUNTDOWN; // reset
|
||
speed_counttime = timer_read32 ();
|
||
}
|
||
}
|
||
}
|
||
|
||
// For word-counting, ignore double blanks
|
||
if (sizecount_measure) {
|
||
if (record->event.pressed) {
|
||
bool within = TRUE; // When text size is maximized, this indicates we are not yet at that maximum.
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
unsigned short size_fraction = 0; // Used to compute led color as a fraction of a set maximum which is already typed.
|
||
# endif
|
||
|
||
// ignoring blanks wordcount
|
||
if ((keycode != KC_SPC)
|
||
&&
|
||
(keycode != KC_TAB) // This is ok, but a tab on BASE layer combo with Control, is not caught by this XXX (problem ignored, I never write Tab in a text worth counting)
|
||
&&
|
||
(keycode != LT__MOV__KC_ENT)
|
||
&&
|
||
(keycode != LT__MOV__KC_ENT)) {
|
||
|
||
sizecount_word = TRUE; // current key is not a blank, so we set this trigger for next key press
|
||
}
|
||
|
||
// computing maximum count effects: leds
|
||
if (0 != sizecount_max) {
|
||
|
||
if (SIZECOUNT_WORD == sizecount_max_type) {
|
||
if (sizecount_blanks > sizecount_max) within = FALSE;
|
||
}else{ // count chars
|
||
if (sizecount_chars > sizecount_max) within = FALSE;
|
||
}
|
||
|
||
// led colors
|
||
if (within) { // green to red middle led
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
if (SIZECOUNT_WORD == sizecount_max_type) {
|
||
size_fraction = (90 * sizecount_blanks) / sizecount_max;
|
||
}else{
|
||
size_fraction = (90 * sizecount_chars) / sizecount_max;
|
||
}
|
||
|
||
rgblight_sethsv_noeeprom (90 - size_fraction , 255, 255); // green to red, full saturation, full lit
|
||
# endif
|
||
|
||
}else{ // when at or over the limit: blink led red/white
|
||
if ((KC_BSPC != keycode)
|
||
&& (KC_DEL != keycode) // User already deleting, doubling is confusing
|
||
&& (CHOLTAP_LAYR != keycode)) { // This brings up the _RAR layer, to access the Count settings.
|
||
|
||
SEND_STRING (SS_TAP(X_BSPC)); // refuses to type further, the user is stopped from typing to make it obvious
|
||
|
||
}
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
if (sizecount_chars & 0x1) { // flip by every keypress
|
||
rgblight_sethsv_noeeprom (HSV_RED);
|
||
}else{
|
||
rgblight_sethsv_noeeprom (HSV_WHITE);
|
||
}
|
||
# endif
|
||
|
||
}
|
||
|
||
# ifdef RGBLIGHT_ENABLE
|
||
rgblight_set (); // only center led is altered, no need to go through isolate_rgblight_set()
|
||
# endif
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
// Simple macros, printing a character.
|
||
switch (keycode) {
|
||
|
||
/* _ACC layer definitions. */
|
||
|
||
// ------------------------- row 4
|
||
|
||
# ifndef REMOVE_ACC // This cuts out the whole _ACC layer.
|
||
case XP_ACC_AA: // because a
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CAL_ACU, CAU_ACU);// á Á
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_AB: // because o (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (COL_ACU, COU_ACU);// ó Ó
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_AC: // because e (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CEL_ACU, CEU_ACU);// é É
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_AD: // because u (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CUL_ACU, CUU_ACU);// ú Ú
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_AE: // because i (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CIL_ACU, CIU_ACU);// í Í
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_AF: // Because near Y
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CYL_ACU, CYU_ACU);// ý Ý
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_AG: // because near Y
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CIJL_BI, CIJU_BI);// ij IJ
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_AH: // because c (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CCL_CDL, CCU_CDL);// ç Ç
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_AI: // because ring-finger left is o (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (COL_STK, COU_STK);// ø Ø
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_AJ: // because pinky finger left is a
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CAL_RNG, CAU_RNG);// å Å
|
||
}
|
||
break;
|
||
|
||
// ------------------------- row 3
|
||
case XP_ACC_BA: // because a
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CAL_DIA, CAU_DIA);// ä Ä
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_BB: // because o (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (COL_DIA, COU_DIA);// ö Ö
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_BC: // because e (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CEL_DIA, CEU_DIA);// ë Ë
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_BD: // because u (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CUL_DIA, CUU_DIA);// ü Ü
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_BE: // because i
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CIL_DIA, CIU_DIA);// ï Ï
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_BF: // because near y
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CYL_DIA, CYU_DIA);// ÿ Ÿ
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_BG: // because vague logic about other hand having ae near on similar fingers
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (COEL_BI, COEU_BI);// œ Œ
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_BH: // because near œ, toward the side of a (pinky)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CAEL_BI, CAEU_BI);// æ Æ
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_BI: // because n
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CNL_TLD, CNU_TLD);// ñ Ñ
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_BJ: // because s
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (CSL_SHP);// ß ß
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_BK: // because roughly the location on French keyboard
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (C_MU_L);// μ
|
||
}
|
||
break;
|
||
|
||
// ------------------------- row 2
|
||
case XP_ACC_CA: // because a
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CAL_GRA, CAU_GRA);//à À
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_CB: // because o (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (COL_GRA, COU_GRA);// ò Ò
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_CC: // because e (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CEL_GRA, CEU_GRA);// è È
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_CD: // because u (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CUL_GRA, CUU_GRA);// ù Ù
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_CE: // because i (Dvorak)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CIL_GRA, CIU_GRA);// ì Ì
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_CF: // because other hand same finger i
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CIL_CAR, CIU_CAR);// î Î
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_CG: // because other hand same finger u
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CUL_CAR, CUU_CAR);// û Û
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_CH: // because other hand same finger e
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CEL_CAR, CEU_CAR);// ê Ê
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_CI: // because other hand same finger o
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (COL_CAR, COU_CAR);// ô Ô
|
||
}
|
||
break;
|
||
|
||
case XP_ACC_CJ: // because other hand same finger a
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CAL_CAR, CAU_CAR);// â Â
|
||
}
|
||
break;
|
||
|
||
# endif // REMOVE_ACC // This cuts out the whole _ACC layer.
|
||
|
||
|
||
/* _DRA layer definitions. */
|
||
|
||
|
||
# ifndef REMOVE_DRA // This cuts out the whole _DRA layer
|
||
// ------------------------- row 4
|
||
case XP_DRA_AA: // because '", the opening „“ at the ‛open’ of the keyboard (left/up)
|
||
if (record->event.pressed) { // key down
|
||
|
||
unicode_hex2output (CS_DQUHR, CS_DQUL);// “ „
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_AB: // because to the right of opening “, ≤ on <
|
||
if (record->event.pressed) { // key down
|
||
|
||
unicode_hex2output (CS_DQUH, CS_ELTHAN);// ” ≤
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_AC: // because this is where the £ is on an English keyboard, on 'any' money symbols ¤; ≥ on >
|
||
if (record->event.pressed) { // key down
|
||
|
||
unicode_hex2output (CS_POUND, CS_EGTHAN);// £ ≥
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_AD: // because ∅ looks like ¢, and ¢ (cent) is on $ (money) ?
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_4THROW
|
||
unicode_hex2output (CS_NONE, CS_CENT);// ∅ ¢
|
||
# else
|
||
unicode_hex2output_single (CS_NONE);// ∅ ¢
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_AE: // because percentages %‰‱ and money ƒ are numerical ?
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_4THROW
|
||
unicode_hex2output (CS_PLMI, CS_LGULDEN);// ± ƒ
|
||
# else
|
||
unicode_hex2output_single (CS_PLMI);// ±
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_AF: // Because left of 🙂, on top of ★
|
||
if (record->event.pressed) { // key down
|
||
|
||
unicode_hex2output (CS_FLEUR, CS_HEART);// ❦ ♥
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_AG: // because 😊 ⍨
|
||
if (record->event.pressed) { // key down
|
||
|
||
unicode_hex2output (CS_SMIL, CS_SAD_);// 🙂 🙁
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_AH: // because «no reason», next to 😊 (emoticons)
|
||
if (record->event.pressed) { // key down
|
||
|
||
unicode_hex2output (CS_THUP, CS_THDN);// 👍 👎
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_AI: // because (
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_4THROW
|
||
unicode_hex2output (CS_OPSUP, CS_OPSUB);// ⁽ ₍
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_AJ: // because )
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_4THROW
|
||
unicode_hex2output (CS_CPSUP, CS_CPSUB);// ⁾ ₎
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
// ------------------------- row 3
|
||
case XP_DRA_BA: // because 1
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef SUB_SCRIPT_NUMS
|
||
unicode_hex2output (CN_1SUP, CN_1SUB);// ¹ ₁
|
||
# else
|
||
unicode_hex2output_single (CN_1SUP);// ¹
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_BB: // because 2
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef SUB_SCRIPT_NUMS
|
||
unicode_hex2output (CN_2SUP, CN_2SUB);// ² ₂
|
||
# else
|
||
unicode_hex2output_single (CN_2SUP);// ²
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_BC: // because 3
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef SUB_SCRIPT_NUMS
|
||
unicode_hex2output (CN_3SUP, CN_3SUB);// ³ ₃
|
||
# else
|
||
unicode_hex2output_single (CN_3SUP);// ³
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_BD: // because 4
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef SUB_SCRIPT_NUMS
|
||
unicode_hex2output (CN_4SUP, CN_4SUB);// ⁴ ₄
|
||
# else
|
||
unicode_hex2output_single (CN_4SUP);// ⁴
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_BE: // because 5
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef SUB_SCRIPT_NUMS
|
||
unicode_hex2output (CN_5SUP, CN_5SUB);// ⁵ ₅
|
||
# else
|
||
unicode_hex2output_single (CN_5SUP);// ⁵
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_BF: // because 6
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef SUB_SCRIPT_NUMS
|
||
unicode_hex2output (CN_6SUP, CN_6SUB);// ⁶ ₆
|
||
# else
|
||
unicode_hex2output_single (CN_6SUP);// ⁶
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_BG: // because 7
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef SUB_SCRIPT_NUMS
|
||
unicode_hex2output (CN_7SUP, CN_7SUB);// ⁷ ₇
|
||
# else
|
||
unicode_hex2output_single (CN_7SUP);// ⁷
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_BH: // because 8
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef SUB_SCRIPT_NUMS
|
||
unicode_hex2output (CN_8SUP, CN_8SUB);// ⁸ ₈
|
||
# else
|
||
unicode_hex2output_single (CN_8SUP);// ⁸
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_BI: // because 9
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef SUB_SCRIPT_NUMS
|
||
unicode_hex2output (CN_9SUP, CN_9SUB);// ⁹ ₉
|
||
# else
|
||
unicode_hex2output_single (CN_9SUP);// ⁹
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_BJ: // because 0
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef SUB_SCRIPT_NUMS
|
||
unicode_hex2output (CN_0SUP, CN_0SUB);// ⁰ ₀
|
||
# else
|
||
unicode_hex2output_single (CN_0SUP);// ⁰
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
// ------------------------- row 2
|
||
case XP_DRA_CA: // because [
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_2NDROW
|
||
unicode_hex2output (CS_OCBRA, CB_HHORI);// 「 ━
|
||
# else
|
||
unicode_hex2output_single (CB_HHORI);// ━
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_CB: // because ]
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_2NDROW
|
||
unicode_hex2output (CS_CCBRA, CB_LHORI);// 」 ─
|
||
# else
|
||
unicode_hex2output_single (CB_LHORI);// ─
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_CC: // because «no reason»
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_2NDROW
|
||
unicode_hex2output (CS_DEGREE, CS_CIRCLE);// ° 〇
|
||
# else
|
||
unicode_hex2output_single (CS_DEGREE);// °
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_CD: // because «no reason»
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_2NDROW
|
||
unicode_hex2output (CS_BULLET, CS_PARA);// • §
|
||
# else
|
||
unicode_hex2output_single (CS_BULLET);// •
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_CE: // because «no reason»
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_2NDROW
|
||
unicode_hex2output (CS_ELLIPS, CS_MIDDOT);// … ·
|
||
# else
|
||
unicode_hex2output_single (CS_ELLIPS);// …
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_CF: // because «no reason» (+ resembles ‛☒’ ?), ✗
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CS_CHECK_B, CS_CHECK_N);// ☐ ☒
|
||
}
|
||
break;
|
||
# endif
|
||
|
||
// This one must be included for _RAR layer
|
||
case XP_DRA_CG: // because next to ✗ ☐ ☒
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_2NDROW
|
||
unicode_hex2output (CS_CHECK_Y, CS_CHECK_H);// ☑ 🗹
|
||
# else
|
||
unicode_hex2output_single (CS_CHECK_Y);// ☑
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
# ifndef REMOVE_DRA // This cuts out the whole _DRA layer
|
||
case XP_DRA_CH: // because ?
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CQU_INV, CEX_INV);// ¿ ¡
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_CI: // because {, ┄ «no reason» (opposite side from ━)
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_2NDROW
|
||
unicode_hex2output (CS_ODABRA, CB_LHORID);// 《 ┄
|
||
# else
|
||
unicode_hex2output_single (CB_LHORID);// ┄
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_DRA_CJ: // because }, ┅ «no reason» (opposite side from ─)
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_DRA_2NDROW
|
||
unicode_hex2output (CS_CDABRA, CB_HHORID);// 》 ┅
|
||
# else
|
||
unicode_hex2output_single (CB_HHORID);// ┅
|
||
# endif
|
||
}
|
||
break;
|
||
# endif // REMOVE_DRA
|
||
|
||
|
||
/* _BON layer definitions. Due to running out of X(…), XP(…) space.*/
|
||
|
||
// ------------------------- row 4
|
||
# ifndef REMOVE_BON // Removes this layer entirely, if set.
|
||
case XP_BON_AA: // because of ' "
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_BON_4THROW
|
||
unicode_hex2output (CS_HQUOSB, CS_USER_DEFINED);// ‛ 🛠
|
||
# else
|
||
unicode_hex2output_single (CS_HQUOSB);// ‛
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_AB: // because of <, because "WASD" on _MOV
|
||
// 0x2019, single quotation mark: ’
|
||
// 0x2B06 arrow up: ⬆
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CS_HQUOSE, CS_ARR_UP);// ’ ⬆
|
||
}
|
||
break;
|
||
|
||
case XP_BON_AC: // because of >
|
||
// 0x00A4 any currency symbol: ¤
|
||
// 0x1F12F Copyleft: 🄯 (means free to copy, see also © for not free to copy.)
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_BON_4THROW
|
||
unicode_hex2output (CS_CURREN, CS_COPYL);// ¤ 🄯
|
||
# else
|
||
unicode_hex2output_single (CS_CURREN);// ¤
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_AD: // because $ and ¢ can be about money, and money is often added together
|
||
// because … no reason, left over space.
|
||
// 0x2211, summation: ∑
|
||
// 0xA9, copyright: ©
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_BON_4THROW
|
||
unicode_hex2output (CS_CUMMU, CS_COPY);// ∑ ©
|
||
# else
|
||
unicode_hex2output_single (CS_CUMMU);// ∑
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_AE: // because % for percent
|
||
// 0x2030,// promille: ‰
|
||
// 0x2031,// pro ten thousandth: ‱
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_BON_4THROW
|
||
unicode_hex2output (CS_PROM, CS_PROTT);// ‰ ‱
|
||
# else
|
||
unicode_hex2output_single (CS_PROM);// ‰
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_AF: // Because ♥ is a star, ❦ and stars can be used as bullet points
|
||
// 0x2605, star: ★
|
||
// 0x066D, star small: ٭
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_BON_4THROW
|
||
unicode_hex2output (CS_STARB, CS_STARL);// ★ ٭
|
||
# else
|
||
unicode_hex2output_single (CS_STARB);// ★
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_AG: // because of 🙂 🙁
|
||
// 0x1f60A,// <smile> ^^ 😊
|
||
// 0x2368,// "Squiggly" face <sad> ⍨
|
||
|
||
# ifdef FULL_BON_4THROW
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CS_SMILP, CS_SQUIG);// 😊 ⍨
|
||
}
|
||
# endif
|
||
|
||
break;
|
||
|
||
case XP_BON_AH: // because * also for multiply, because asterisk *
|
||
// 0x00D7,// multiply: ×
|
||
// 0x20F0 high asterisk: ⃰(this thing seems to behave a bit weird in vim(1) or terminal)
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_BON_4THROW
|
||
unicode_hex2output (CS_MULT, CS_ASTL);// × ⃰
|
||
# else
|
||
unicode_hex2output_single (CS_MULT);// ×
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_AI: // because ø sort of seems to divide something, and √ also does that, and close to ⁻⁺ (exponential)
|
||
// 0x221A,// square root: √
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef FULL_BON_4THROW
|
||
unicode_hex2output_single (CS_SQRT);// √
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_AJ: // because å points in the circle where this exponential minus goes, and it is right/"up" on the board
|
||
// because ⁻⁺ belong together
|
||
// 0x207B,// exponential minus sign: ⁻
|
||
// 0x207A,// exponential plus: ⁺
|
||
|
||
# ifdef FULL_BON_4THROW
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CS_EXPMIN, CS_EXPPLS);// ⁻ ⁺
|
||
}
|
||
# endif
|
||
|
||
break;
|
||
|
||
// ------------------------- row 3
|
||
case XP_BON_BA: // because 1, because "WASD" on _MOV (depending on setup)
|
||
// 0x2460, "1" : ①
|
||
// 0x2B05, arrow left: ⬅
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CN_1CIRC, CS_ARR_LE);// ① ⬅
|
||
}
|
||
break;
|
||
|
||
case XP_BON_BB: // because 2, because "WASD" on _MOV (depending)
|
||
// 0x2461, "2" : ②
|
||
// 0x2B07, arrow down: ⬇
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CN_2CIRC, CS_ARR_DN);// ② ⬇
|
||
}
|
||
break;
|
||
|
||
case XP_BON_BC: // because 3, because "WASD" on _MOV (depending)
|
||
// 0x2462, "3" : ③
|
||
// 0x27A1, arrow right: ➡
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CN_3CIRC, CS_ARR_RI);// ③ ➡
|
||
}
|
||
break;
|
||
|
||
case XP_BON_BD: // because 4, because ┏ forms a box with the other box drawings to the right/down
|
||
// 0x2463, "4" : ④
|
||
// 0x250F, box drawing heavy: ┏
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef BOX_DRAWINGS
|
||
unicode_hex2output (CN_4CIRC, CB_C_RIDN);// ④ ┏
|
||
# else
|
||
unicode_hex2output_single (CN_4CIRC);// ④
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_BE: // because 5, because ┓ forms a box
|
||
// 0x2513,box drawing heavy: ┓
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef BOX_DRAWINGS
|
||
unicode_hex2output (CN_5CIRC, CB_C_LEDN);// ⑤ ┓
|
||
# else
|
||
unicode_hex2output_single (CN_5CIRC);// ⑤
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_BF: // because 6, because ┃ continues box block
|
||
// 0x2465, "6" : ⑥
|
||
// 0x2503, box drawing heavy: ┃
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef BOX_DRAWINGS
|
||
unicode_hex2output (CN_6CIRC, CB_VE);// ⑥ ┃
|
||
# else
|
||
unicode_hex2output_single (CN_6CIRC);// ⑥
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_BG: // because 7, because ┇ continues box block
|
||
// 0x2466, "7" : ⑦
|
||
// 0x2507, dotted line verticle (heavy): ┇
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef BOX_DRAWINGS
|
||
unicode_hex2output (CN_7CIRC, CB_VE_DOT);// ⑦ ┇
|
||
# else
|
||
unicode_hex2output_single (CN_7CIRC);// ⑦
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_BH: // because 8, ╋ because 8 also has a crossing line in it
|
||
// 0x254B, crossing lines: ╋
|
||
// 0x2467, "8" : ⑨
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef BOX_DRAWINGS
|
||
unicode_hex2output (CN_8CIRC, CB_VE_BI);// ⑧ ╋
|
||
# else
|
||
unicode_hex2output_single (CN_8CIRC);// ⑧
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_BI: // because 9
|
||
// 0x2468, "9" : ⑨
|
||
// 0x2513,box drawing heavy: ┓
|
||
if (record->event.pressed) { // key down
|
||
|
||
unicode_hex2output_single (CN_9CIRC);// ⑨
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_BJ: // because 0, because a "0" can also be a symbol for infinity, round & round
|
||
// 0x24EA, "0" : ⓪
|
||
// 0x221E,// infinity:∞
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CN_0CIRC, CS_INFIN);// ⓪ ∞
|
||
}
|
||
break;
|
||
|
||
case XP_BON_BK: // because -, because ~
|
||
// 0x2014,// dash: — (might not render differently than a hyphen - in some applications. Dash is longer).
|
||
// 0x2248,// about equal to: ≈
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (CS_DASH, CS_ABOUT);// — ≈
|
||
}
|
||
break;
|
||
|
||
// ------------------------- row 2
|
||
case XP_BON_CA: // because 1 above, because 「[
|
||
// 0x2039, opening single corner quotation: ‹
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (CS_GUILSLE);// ‹
|
||
}
|
||
break;
|
||
|
||
case XP_BON_CB: // because 2 above, because 」]
|
||
// 0x203A, closing sinle corner quotation: ›
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (CS_GUILSRI);// ›
|
||
}
|
||
break;
|
||
|
||
case XP_BON_CC: // because 3 above, because / (division)
|
||
// 0x00F7,// division: ÷
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (CS_DIVI);// ÷
|
||
}
|
||
break;
|
||
|
||
case XP_BON_CD: // because 4 above, ┗ because forms box
|
||
// 0x261E, hand bullet point: ☞
|
||
// 0x2517, box drawing heavy: ┗
|
||
if (record->event.pressed) { // key down
|
||
# ifdef BOX_DRAWINGS
|
||
unicode_hex2output (CS_FINGER, CB_C_RIUP);// ☞ ┗
|
||
# else
|
||
unicode_hex2output_single (CS_FINGER);// ☞
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_CE: // because 5 above, because =, ┛ because forms box
|
||
// 0x2260,// inequal: ≠
|
||
// 0x251B, box drawing heavy: ┛
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef BOX_DRAWINGS
|
||
unicode_hex2output (CS_UNEQL, CB_C_LEUP);// ≠ ┛
|
||
# else
|
||
unicode_hex2output_single (CS_UNEQL);// ≠
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_CF: // because ☒ , ┣ box drawings block, some place
|
||
// 0x2717, cross mark: ✗ (complements ✓)
|
||
// 0x2523, box drawing: ┣
|
||
if (record->event.pressed) { // key down
|
||
|
||
# ifdef BOX_DRAWINGS
|
||
unicode_hex2output (CS_BOTCH, CB_VE_RI);// ✗ ┣
|
||
# else
|
||
unicode_hex2output_single (CS_BOTCH);// ✗
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_CG: // because 7 above, because ☑ 🗹 , ┫ complements with key to its left
|
||
// 0x2713, checkmark: ✓
|
||
// 0x252B, box drawing: ┫
|
||
|
||
if (record->event.pressed) { // key down
|
||
# ifdef BOX_DRAWINGS
|
||
unicode_hex2output (CS_CHECK, CB_VE_LE);// ✓ ┫
|
||
# else
|
||
unicode_hex2output_single (CS_CHECK);// ✓
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_BON_CH: // because 8 above, because ¡ (inverted exclamation mark)
|
||
// 0x26A0,// alert: ⚠
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (CS_ALERT);// ⚠
|
||
}
|
||
break;
|
||
|
||
case XP_BON_CI: // because 9 above, because 《
|
||
// 0xAB, French quotation opening: «
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (CS_GUILLE);// «
|
||
}
|
||
break;
|
||
|
||
case XP_BON_CJ: // because 0 above, because 》
|
||
// 0xBB, French quotation closing: »
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (CS_GUILRI);// »
|
||
}
|
||
break;
|
||
|
||
# endif // REMOVE_BON
|
||
|
||
// Hebrew
|
||
# if defined(BASE_HEBREW__DEF_BASE) || defined(BASE_HEBREW__ALT_BASE)
|
||
// The layout follows a standard hebrew keyboard, with the exception
|
||
// of ק, which is displaced by “.>” copied from the Dvorak layout.
|
||
|
||
// HEBREW_DVORAK
|
||
// These letters on the upper left follow Dvorak layout.
|
||
// The reason is space on the device: these are not macros.
|
||
// Also: typing compatibility between Dvorak and Hebrew
|
||
// for these similar/same symbols: ,<.>. Idealy these symbols
|
||
// should be the hebrew variation, if space allows it.
|
||
|
||
# if defined(HEBREW_ISRAEL)
|
||
|
||
case XP_HEB_AA: //
|
||
if (record->event.pressed) { // key down
|
||
// These shifts-up seem to work on GNU/Debian/Linux, otherwise it prints ':'
|
||
if (shift_ison) send_string ( SS_UP(X_RSFT) SS_UP(X_LSFT) ";" ); // moved here from <esc> on standard hebrew
|
||
else send_string ("/");//
|
||
} break;
|
||
|
||
case XP_HEB_AB: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_GERSH);// ׳
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_AC: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_QOF);// ק
|
||
}
|
||
break;
|
||
|
||
# elif defined(HEBREW_QWERTY)
|
||
|
||
case XP_HEB_AA: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_TAV);// ת
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_AB: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_TSDIS);// ץ
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_AC: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_QOF);// ק
|
||
}
|
||
break;
|
||
|
||
# endif // #HEBREW_*
|
||
|
||
case XP_HEB_AD: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_RESH);// ר
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_AE: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_ALEF);// א
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_AF: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_TET);// ט
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_AG: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_VAV);// ו
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_AH: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_NUNS);// ן
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_AI:
|
||
if (record->event.pressed) { // key down
|
||
|
||
# if defined(HEBREW_ISRAEL)
|
||
// The logic is that it mirrors '", “„, ”≤, ‛’ in Dvorak Base and other layers.
|
||
// Therefore the little and ring fingers are used. Mirroring ━─ and ┄┅ on DRA_
|
||
// layer, the outside on the keyboard is “big/fat”, the inside is “small/thin”,
|
||
// like something protected in a shell. Hence: ……׳״
|
||
unicode_hex2output_single (HB_MEMS);// ם // ׳ is located elsewhere
|
||
# elif defined(HEBREW_QWERTY) || defined(HEBREW_DVORAK)
|
||
unicode_hex2output (HB_MEMS, HB_GERSH);// ם׳
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_AJ: //
|
||
if (record->event.pressed) { // key down
|
||
|
||
# if defined(HEBREW_ISRAEL)
|
||
unicode_hex2output_single (HB_PE);// פ // ״ is located elsewhere
|
||
# elif defined(HEBREW_QWERTY) || defined(HEBREW_DVORAK)
|
||
unicode_hex2output (HB_PE, HB_GRSHM);// פ״
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
// ------------------------- row 3
|
||
case XP_HEB_BA: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_SHIN);// ש
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_BB: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_DALET);// ד
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_BC: //Right-left-mark to the first free strong homerow finger on the left (middle)
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (HB_GIMEL, HB_RLM);// ג {RLM}
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_BD: // The logic is that כ is the same key as 4 on another layer, which connects
|
||
// with $, and other currencies in the same region (ģ).
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (HB_KAF, HB_SHEKL);// כ₪
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_BE: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_AYIN);// ע
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_BF: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_YOD);// י
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_BG: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_GET);// ח
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_BH: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output (HB_LAMED, HB_LRM);// ל {LRM}
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_BI: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_KAFS);// ך
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_BJ: //
|
||
if (record->event.pressed) { // key down
|
||
|
||
# if defined(HEBREW_ISRAEL) || defined(HEBREW_QWERTY)
|
||
if (shift_ison) send_string (":"); // : (the hebrew eqquivalent is apparently almost never used, and this saves space)
|
||
else unicode_hex2output_single (HB_PES);// ף
|
||
# elif defined(HEBREW_DVORAK)
|
||
unicode_hex2output_single (HB_PES);// ף
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
# if defined(HEBREW_ISRAEL)
|
||
case XP_HEB_BK: //
|
||
if (record->event.pressed) { // key down
|
||
if (shift_ison) unicode_hex2output_single (HB_GRSHM);// ״
|
||
else send_string (","); // comma
|
||
}
|
||
break;
|
||
# endif
|
||
|
||
case XP_HEB_MQF: // ־ Maqaf
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_MAQAF);// ־
|
||
}
|
||
break;
|
||
|
||
// ------------------------- row 2
|
||
case XP_HEB_CA: //
|
||
if (record->event.pressed) { // key down
|
||
// Hebrew harmonization + ':'
|
||
# if defined(HEBREW_ISRAEL) || defined(HEBREW_QWERTY)
|
||
unicode_hex2output_single (HB_ZAYIN);// ז
|
||
# elif defined(HEBREW_DVORAK)
|
||
if (shift_ison) send_string (":"); //
|
||
else unicode_hex2output_single (HB_ZAYIN);// ז
|
||
# endif
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_CB: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_SAMEG);// ס
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_CC: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_BET);// ב
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_CD: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_HE);// ה
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_CE: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_NUN);// נ
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_CF: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_MEM);// מ
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_CG: //
|
||
if (record->event.pressed) { // key down
|
||
unicode_hex2output_single (HB_TSADI);// צ
|
||
}
|
||
break;
|
||
|
||
# if defined(HEBREW_ISRAEL) || defined(HEBREW_DVORAK)
|
||
case XP_HEB_CH: //
|
||
if (record->event.pressed) { // key down
|
||
|
||
# if defined(HEBREW_ISRAEL)
|
||
if (shift_ison) send_string ("<"); //
|
||
else unicode_hex2output_single (HB_TAV);// ת
|
||
# else // HEBREW_DVORAK
|
||
unicode_hex2output_single (HB_TAV);// ת
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_CI: //
|
||
if (record->event.pressed) { // key down
|
||
|
||
# if defined(HEBREW_ISRAEL)
|
||
if (shift_ison) send_string (">"); //
|
||
else unicode_hex2output_single (HB_TSDIS);// ץ
|
||
# else // HEBREW_DVORAK
|
||
unicode_hex2output_single (HB_TSDIS);// ץ
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
|
||
case XP_HEB_CJ: // anomaly
|
||
if (record->event.pressed) { // key down
|
||
|
||
# if defined(HEBREW_ISRAEL)
|
||
if (shift_ison) send_string ("?"); //
|
||
else send_string ("."); //
|
||
# else // HEBREW_DVORAK
|
||
unicode_hex2output_single (HB_QOF);// ק
|
||
# endif
|
||
|
||
}
|
||
break;
|
||
# endif // HEBREW_*
|
||
|
||
// HB_D_VAV,
|
||
// HB_VAVYD,
|
||
// HB_D_YOD,
|
||
# endif // Hebrew Base layer
|
||
}
|
||
|
||
return true;
|
||
};
|