[jackhill/qmk/firmware.git] / keyboards / georgi / sten.h

// 2019, g Heavy Industries

#include QMK_KEYBOARD_H
#include "mousekey.h"
#include "keymap.h"
#include "keymap_steno.h"

// Bitfield representing the current chord
uint32_t cChord = 0;

// See if a given chord is pressed. 
// P will return 
// PJ will continue processing, removing the found chord 
#define P(chord, act)  if (cChord == (chord)) { act; return true; }
#define PJ(chord, act) if ((cChord & (chord)) == (chord)) { cChord ^= chord; act; }

// All Steno Codes
// Shift to internal representation
#define STN(n) (1L<<n)

//i.e) S(teno)R(ight)F
enum ORDER { 
		SFN = 0, SPWR, SST1, SST2, SST3, SST4, SNUM,
		SLSU, SLSD, SLT, SLK, SLP, SLW, SLH, SLR, SLA, SLO, 
		SRE, SRU, SRF, SRR, SRP, SRB, SRL, SRG, SRT, SRS, SRD, SRZ
};

// Break it all out
#define FN	STN(SFN)
#define PWR	STN(SPWR)
#define ST1 STN(SST1)
#define ST2 STN(SST2)
#define ST3 STN(SST3)
#define ST4 STN(SST4)
#define NUM STN(SNUM) // No distinction between left and right

#define LSU STN(SLSU)
#define LSD STN(SLSD)
#define LFT STN(SLT)  // (L)e(F)t (T), preprocessor conflict
#define LK  STN(SLK)
#define LP  STN(SLP)
#define LW  STN(SLW)
#define LH  STN(SLH)
#define LR  STN(SLR)
#define LA  STN(SLA)
#define LO  STN(SLO)

#define RE  STN(SRE)
#define RU  STN(SRU)
#define RF  STN(SRF)
#define RR  STN(SRR)
#define RP  STN(SRP)
#define RB  STN(SRB)
#define RL  STN(SRL)
#define RG  STN(SRG)
#define RT  STN(SRT)
#define RS  STN(SRS)
#define RD  STN(SRD)
#define RZ  STN(SRZ)

bool 		processQwerty(void);
bool 		processFakeSteno(void);
void 		clickMouse(uint8_t kc);
void 		SEND(uint8_t kc);
extern int 	getKeymapCount(void);

// Mode state
enum MODE { STENO = 0, QWERTY, COMMAND };
enum MODE cMode = STENO;
enum MODE pMode;
bool QWERSTENO = false;

// Command State
#define MAX_CMD_BUF 20
uint8_t CMDBUF[MAX_CMD_BUF];
uint8_t CMDLEN = 0;

// Key Repeat state
bool     inChord  = false;
uint16_t repTimer = 0;
#define  REP_DELAY 300

// Mousekeys state
bool	inMouse = false;
int8_t	mousePress;

// All processing done at chordUp goes through here
bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]) { 
	// Check for mousekeys, this is release
#ifdef MOUSEKEY_ENABLE
	if (inMouse) {
		inMouse = false;
		mousekey_off(mousePress);
		mousekey_send();
	}
#endif

	// Toggle Serial/QWERTY steno
	if (cChord == (PWR | FN | ST1 | ST2)) {
		uprintf("Fallback Toggle\n");
		QWERSTENO = !QWERSTENO;
		
		goto out;
	}

	// handle command mode
	if (cChord == (PWR | FN | RD | RZ)) {
		uprintf("COMMAND Toggle\n");
		if (cMode != COMMAND) {   // Entering Command Mode
			CMDLEN = 0;
			pMode = cMode;
			cMode = COMMAND;
		} else {                  // Exiting Command Mode
			cMode = pMode;

			// Press all and release all
			for (int i = 0; i < CMDLEN; i++) {
				register_code(CMDBUF[i]);
			}
			clear_keyboard();
		}

		goto out;
	}

	// Handle Gaming Toggle,
	if (cChord == (PWR | FN | ST2 | ST3) && getKeymapCount() > 1) {
		uprintf("Switching to QMK\n");
		layer_on(1);
		goto out;
	}

	// Lone FN press, toggle QWERTY
	if (cChord == FN) {
		(cMode == STENO) ? (cMode = QWERTY) : (cMode = STENO);
		goto out;
	}

	// Check for Plover momentary
	if (cMode == QWERTY && (cChord & FN)) {
		cChord ^= FN;
		goto steno;
	}

	// Do QWERTY and Momentary QWERTY
	if (cMode == QWERTY || (cMode == COMMAND) || (cChord & (FN | PWR))) {
		if (cChord & FN)  cChord ^= FN;
		processQwerty();
		goto out;
	}

	// Fallback NKRO Steno
	if (cMode == STENO && QWERSTENO) {
		processFakeSteno();
		goto out;
	}

steno:
	// Hey that's a steno chord!
	inChord = false;
	cChord = 0;
	return true; 

out:
	inChord = false;
	clear_keyboard();
	cChord = 0;
	return false;
}

// Update Chord State 
bool process_steno_user(uint16_t keycode, keyrecord_t *record) { 
	// Everything happens in here when steno keys come in.
	// Bail on keyup
	if (!record->event.pressed) return true;

	// Update key repeat timers
	repTimer = timer_read();
	inChord  = true;

	// Switch on the press adding to chord
	bool pr = record->event.pressed;
	switch (keycode) {
			// Mods and stuff
			case STN_ST1:			pr ? (cChord |= (ST1)): (cChord &= ~(ST1)); break;
			case STN_ST2:			pr ? (cChord |= (ST2)): (cChord &= ~(ST2)); break;
			case STN_ST3:			pr ? (cChord |= (ST3)): (cChord &= ~(ST3)); break;
			case STN_ST4:			pr ? (cChord |= (ST4)): (cChord &= ~(ST4)); break;
			case STN_FN:			pr ? (cChord |= (FN)) : (cChord &= ~(FN)); break;
			case STN_PWR:			pr ? (cChord |= (PWR)): (cChord &= ~(PWR)); break;
			case STN_N1...STN_N6: 
			case STN_N7...STN_NC:	pr ? (cChord |= (NUM)): (cChord &= ~(NUM)); break;

			// All the letter keys
			case STN_S1:			pr ? (cChord |= (LSU)) : (cChord &= ~(LSU));  break;
			case STN_S2:			pr ? (cChord |= (LSD)) : (cChord &= ~(LSD));  break;
			case STN_TL:			pr ? (cChord |= (LFT)) : (cChord &= ~(LFT)); break;
			case STN_KL:			pr ? (cChord |= (LK)) : (cChord &= ~(LK)); break;
			case STN_PL:			pr ? (cChord |= (LP)) : (cChord &= ~(LP)); break;
			case STN_WL:			pr ? (cChord |= (LW)) : (cChord &= ~(LW)); break;
			case STN_HL:			pr ? (cChord |= (LH)) : (cChord &= ~(LH)); break;
			case STN_RL:			pr ? (cChord |= (LR)) : (cChord &= ~(LR)); break;
			case STN_A:				pr ? (cChord |= (LA)) : (cChord &= ~(LA)); break;
			case STN_O:				pr ? (cChord |= (LO)) : (cChord &= ~(LO)); break;
			case STN_E:				pr ? (cChord |= (RE)) : (cChord &= ~(RE)); break;
			case STN_U:				pr ? (cChord |= (RU)) : (cChord &= ~(RU)); break;
			case STN_FR:			pr ? (cChord |= (RF)) : (cChord &= ~(RF)); break;
			case STN_RR:			pr ? (cChord |= (RR)) : (cChord &= ~(RR)); break;
			case STN_PR:			pr ? (cChord |= (RP)) : (cChord &= ~(RP)); break;
			case STN_BR:			pr ? (cChord |= (RB)) : (cChord &= ~(RB)); break;
			case STN_LR:			pr ? (cChord |= (RL)) : (cChord &= ~(RL)); break;
			case STN_GR:			pr ? (cChord |= (RG)) : (cChord &= ~(RG)); break;
			case STN_TR:			pr ? (cChord |= (RT)) : (cChord &= ~(RT)); break;
			case STN_SR:			pr ? (cChord |= (RS)) : (cChord &= ~(RS)); break;
			case STN_DR:			pr ? (cChord |= (RD)) : (cChord &= ~(RD)); break;
			case STN_ZR:			pr ? (cChord |= (RZ)) : (cChord &= ~(RZ)); break;
	}

	// Check for key repeat in QWERTY mode
	return true; 
}
void matrix_scan_user(void) {
	// We abuse this for early sending of key
	// Key repeat only on QWER/SYMB layers
	if (cMode != QWERTY) return;

	// Check timers
	if (timer_elapsed(repTimer) > REP_DELAY) {
		// Process Key for report
		processQwerty();

		// Send report to host
		send_keyboard_report();
		repTimer = timer_read();
	}
};

// Helpers
bool processFakeSteno(void) {
	PJ( LSU,			SEND(KC_Q););
	PJ( LSD,			SEND(KC_A););
	PJ( LFT,			SEND(KC_W););
	PJ( LP,				SEND(KC_E););
	PJ( LH,				SEND(KC_R););
	PJ( LK,				SEND(KC_S););
	PJ( LW,				SEND(KC_D););
	PJ( LR,				SEND(KC_F););
	PJ( ST1,			SEND(KC_T););
	PJ( ST2,			SEND(KC_G););
	PJ( LA,				SEND(KC_C););
	PJ( LO,				SEND(KC_V););
	PJ( RE,				SEND(KC_N););
	PJ( RU,				SEND(KC_M););
	PJ( ST3,			SEND(KC_Y););
	PJ( ST4,			SEND(KC_H););
	PJ( RF,				SEND(KC_U););
	PJ( RP,				SEND(KC_I););
	PJ( RL,				SEND(KC_O););
	PJ( RT,				SEND(KC_P););
	PJ( RD,				SEND(KC_LBRC););
	PJ( RR,				SEND(KC_J););
	PJ( RB,				SEND(KC_K););
	PJ( RG,				SEND(KC_L););
	PJ( RS,				SEND(KC_SCLN););
	PJ( RZ,				SEND(KC_COMM););
	PJ( NUM,			SEND(KC_1););

	return false;
}
void clickMouse(uint8_t kc) {
#ifdef MOUSEKEY_ENABLE
	mousekey_on(kc);
	mousekey_send();

	// Store state for later use
	inMouse = true;
	mousePress = kc;
#endif
}
void SEND(uint8_t kc) {
	// Send Keycode, Does not work for Quantum Codes
	if (cMode == COMMAND && CMDLEN < MAX_CMD_BUF) {
		uprintf("CMD LEN: %d BUF: %d\n", CMDLEN, MAX_CMD_BUF);
		CMDBUF[CMDLEN] = kc;
		CMDLEN++;
	} 

	if (cMode != COMMAND) register_code(kc);
	return;
}
Commit	Line	Data
980a41e9 JB	1	// 2019, g Heavy Industries
	2
	3	#include QMK_KEYBOARD_H
	4	#include "mousekey.h"
	5	#include "keymap.h"
	6	#include "keymap_steno.h"
	7
	8	// Bitfield representing the current chord
	9	uint32_t cChord = 0;
	10
	11	// See if a given chord is pressed.
	12	// P will return
	13	// PJ will continue processing, removing the found chord
	14	#define P(chord, act) if (cChord == (chord)) { act; return true; }
	15	#define PJ(chord, act) if ((cChord & (chord)) == (chord)) { cChord ^= chord; act; }
	16
	17	// All Steno Codes
	18	// Shift to internal representation
	19	#define STN(n) (1L<<n)
	20
	21	//i.e) S(teno)R(ight)F
	22	enum ORDER {
	23	SFN = 0, SPWR, SST1, SST2, SST3, SST4, SNUM,
	24	SLSU, SLSD, SLT, SLK, SLP, SLW, SLH, SLR, SLA, SLO,
	25	SRE, SRU, SRF, SRR, SRP, SRB, SRL, SRG, SRT, SRS, SRD, SRZ
	26	};
	27
	28	// Break it all out
	29	#define FN STN(SFN)
	30	#define PWR STN(SPWR)
	31	#define ST1 STN(SST1)
	32	#define ST2 STN(SST2)
	33	#define ST3 STN(SST3)
	34	#define ST4 STN(SST4)
	35	#define NUM STN(SNUM) // No distinction between left and right
	36
	37	#define LSU STN(SLSU)
	38	#define LSD STN(SLSD)
	39	#define LFT STN(SLT) // (L)e(F)t (T), preprocessor conflict
	40	#define LK STN(SLK)
	41	#define LP STN(SLP)
	42	#define LW STN(SLW)
	43	#define LH STN(SLH)
	44	#define LR STN(SLR)
	45	#define LA STN(SLA)
	46	#define LO STN(SLO)
	47
	48	#define RE STN(SRE)
	49	#define RU STN(SRU)
	50	#define RF STN(SRF)
	51	#define RR STN(SRR)
	52	#define RP STN(SRP)
	53	#define RB STN(SRB)
	54	#define RL STN(SRL)
	55	#define RG STN(SRG)
	56	#define RT STN(SRT)
	57	#define RS STN(SRS)
	58	#define RD STN(SRD)
	59	#define RZ STN(SRZ)
	60
	61	bool processQwerty(void);
	62	bool processFakeSteno(void);
	63	void clickMouse(uint8_t kc);
	64	void SEND(uint8_t kc);
65	extern int getKeymapCount(void);
66
67	// Mode state
68	enum MODE { STENO = 0, QWERTY, COMMAND };
69	enum MODE cMode = STENO;
70	enum MODE pMode;
71	bool QWERSTENO = false;
72
73	// Command State
74	#define MAX_CMD_BUF 20
75	uint8_t CMDBUF[MAX_CMD_BUF];
76	uint8_t CMDLEN = 0;
77
78	// Key Repeat state
79	bool inChord = false;
80	uint16_t repTimer = 0;
81	#define REP_DELAY 300
82
83	// Mousekeys state
84	bool inMouse = false;
85	int8_t mousePress;
86
87	// All processing done at chordUp goes through here
88	bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]) {
89	// Check for mousekeys, this is release
90	#ifdef MOUSEKEY_ENABLE
91	if (inMouse) {
92	inMouse = false;
93	mousekey_off(mousePress);
94	mousekey_send();
95	}
96	#endif
97
98	// Toggle Serial/QWERTY steno
99	if (cChord == (PWR \| FN \| ST1 \| ST2)) {
100	uprintf("Fallback Toggle\n");
101	QWERSTENO = !QWERSTENO;
102
103	goto out;
104	}
105
106	// handle command mode
107	if (cChord == (PWR \| FN \| RD \| RZ)) {
108	uprintf("COMMAND Toggle\n");
109	if (cMode != COMMAND) { // Entering Command Mode
110	CMDLEN = 0;
111	pMode = cMode;
112	cMode = COMMAND;
113	} else { // Exiting Command Mode
114	cMode = pMode;
115
116	// Press all and release all
117	for (int i = 0; i < CMDLEN; i++) {
118	register_code(CMDBUF[i]);
119	}
120	clear_keyboard();
121	}
122
123	goto out;
124	}
125
126	// Handle Gaming Toggle,
127	if (cChord == (PWR \| FN \| ST2 \| ST3) && getKeymapCount() > 1) {
128	uprintf("Switching to QMK\n");
129	layer_on(1);
130	goto out;
131	}
132
133	// Lone FN press, toggle QWERTY
134	if (cChord == FN) {
135	(cMode == STENO) ? (cMode = QWERTY) : (cMode = STENO);
136	goto out;
137	}
138
139	// Check for Plover momentary
140	if (cMode == QWERTY && (cChord & FN)) {
141	cChord ^= FN;
142	goto steno;
143	}
144
145	// Do QWERTY and Momentary QWERTY
146	if (cMode == QWERTY \|\| (cMode == COMMAND) \|\| (cChord & (FN \| PWR))) {
147	if (cChord & FN) cChord ^= FN;
148	processQwerty();
149	goto out;
150	}
151
152	// Fallback NKRO Steno
153	if (cMode == STENO && QWERSTENO) {
154	processFakeSteno();
155	goto out;
156	}
157
158	steno:
159	// Hey that's a steno chord!
160	inChord = false;
161	cChord = 0;
162	return true;
163
164	out:
165	inChord = false;
166	clear_keyboard();
167	cChord = 0;
168	return false;
169	}
170
171	// Update Chord State
172	bool process_steno_user(uint16_t keycode, keyrecord_t *record) {
173	// Everything happens in here when steno keys come in.
174	// Bail on keyup
175	if (!record->event.pressed) return true;
176
177	// Update key repeat timers
178	repTimer = timer_read();
179	inChord = true;
180
181	// Switch on the press adding to chord
182	bool pr = record->event.pressed;
183	switch (keycode) {
184	// Mods and stuff
185	case STN_ST1: pr ? (cChord \|= (ST1)): (cChord &= ~(ST1)); break;
186	case STN_ST2: pr ? (cChord \|= (ST2)): (cChord &= ~(ST2)); break;
187	case STN_ST3: pr ? (cChord \|= (ST3)): (cChord &= ~(ST3)); break;
188	case STN_ST4: pr ? (cChord \|= (ST4)): (cChord &= ~(ST4)); break;
189	case STN_FN: pr ? (cChord \|= (FN)) : (cChord &= ~(FN)); break;
190	case STN_PWR: pr ? (cChord \|= (PWR)): (cChord &= ~(PWR)); break;
191	case STN_N1...STN_N6:
192	case STN_N7...STN_NC: pr ? (cChord \|= (NUM)): (cChord &= ~(NUM)); break;
193
194	// All the letter keys
195	case STN_S1: pr ? (cChord \|= (LSU)) : (cChord &= ~(LSU)); break;
196	case STN_S2: pr ? (cChord \|= (LSD)) : (cChord &= ~(LSD)); break;
197	case STN_TL: pr ? (cChord \|= (LFT)) : (cChord &= ~(LFT)); break;
198	case STN_KL: pr ? (cChord \|= (LK)) : (cChord &= ~(LK)); break;
199	case STN_PL: pr ? (cChord \|= (LP)) : (cChord &= ~(LP)); break;
200	case STN_WL: pr ? (cChord \|= (LW)) : (cChord &= ~(LW)); break;
201	case STN_HL: pr ? (cChord \|= (LH)) : (cChord &= ~(LH)); break;
202	case STN_RL: pr ? (cChord \|= (LR)) : (cChord &= ~(LR)); break;
203	case STN_A: pr ? (cChord \|= (LA)) : (cChord &= ~(LA)); break;
204	case STN_O: pr ? (cChord \|= (LO)) : (cChord &= ~(LO)); break;
205	case STN_E: pr ? (cChord \|= (RE)) : (cChord &= ~(RE)); break;
206	case STN_U: pr ? (cChord \|= (RU)) : (cChord &= ~(RU)); break;
207	case STN_FR: pr ? (cChord \|= (RF)) : (cChord &= ~(RF)); break;
208	case STN_RR: pr ? (cChord \|= (RR)) : (cChord &= ~(RR)); break;
209	case STN_PR: pr ? (cChord \|= (RP)) : (cChord &= ~(RP)); break;
210	case STN_BR: pr ? (cChord \|= (RB)) : (cChord &= ~(RB)); break;
211	case STN_LR: pr ? (cChord \|= (RL)) : (cChord &= ~(RL)); break;
212	case STN_GR: pr ? (cChord \|= (RG)) : (cChord &= ~(RG)); break;
213	case STN_TR: pr ? (cChord \|= (RT)) : (cChord &= ~(RT)); break;
214	case STN_SR: pr ? (cChord \|= (RS)) : (cChord &= ~(RS)); break;
215	case STN_DR: pr ? (cChord \|= (RD)) : (cChord &= ~(RD)); break;
216	case STN_ZR: pr ? (cChord \|= (RZ)) : (cChord &= ~(RZ)); break;
217	}
218
219	// Check for key repeat in QWERTY mode
220	return true;
221	}
222	void matrix_scan_user(void) {
223	// We abuse this for early sending of key
224	// Key repeat only on QWER/SYMB layers
225	if (cMode != QWERTY) return;
226
227	// Check timers
228	if (timer_elapsed(repTimer) > REP_DELAY) {
229	// Process Key for report
230	processQwerty();
231
232	// Send report to host
233	send_keyboard_report();
234	repTimer = timer_read();
235	}
236	};
237
238	// Helpers
239	bool processFakeSteno(void) {
240	PJ( LSU, SEND(KC_Q););
241	PJ( LSD, SEND(KC_A););
242	PJ( LFT, SEND(KC_W););
243	PJ( LP, SEND(KC_E););
244	PJ( LH, SEND(KC_R););
245	PJ( LK, SEND(KC_S););
246	PJ( LW, SEND(KC_D););
247	PJ( LR, SEND(KC_F););
248	PJ( ST1, SEND(KC_T););
249	PJ( ST2, SEND(KC_G););
250	PJ( LA, SEND(KC_C););
251	PJ( LO, SEND(KC_V););
252	PJ( RE, SEND(KC_N););
253	PJ( RU, SEND(KC_M););
254	PJ( ST3, SEND(KC_Y););
255	PJ( ST4, SEND(KC_H););
256	PJ( RF, SEND(KC_U););
257	PJ( RP, SEND(KC_I););
258	PJ( RL, SEND(KC_O););
259	PJ( RT, SEND(KC_P););
260	PJ( RD, SEND(KC_LBRC););
261	PJ( RR, SEND(KC_J););
262	PJ( RB, SEND(KC_K););
263	PJ( RG, SEND(KC_L););
264	PJ( RS, SEND(KC_SCLN););
265	PJ( RZ, SEND(KC_COMM););
266	PJ( NUM, SEND(KC_1););
267
268	return false;
269	}
270	void clickMouse(uint8_t kc) {
271	#ifdef MOUSEKEY_ENABLE
272	mousekey_on(kc);
273	mousekey_send();
274
275	// Store state for later use
276	inMouse = true;
277	mousePress = kc;
278	#endif
279	}
280	void SEND(uint8_t kc) {
281	// Send Keycode, Does not work for Quantum Codes
282	if (cMode == COMMAND && CMDLEN < MAX_CMD_BUF) {
283	uprintf("CMD LEN: %d BUF: %d\n", CMDLEN, MAX_CMD_BUF);
284	CMDBUF[CMDLEN] = kc;
285	CMDLEN++;
286	}
287
288	if (cMode != COMMAND) register_code(kc);
289	return;
290	}