Keymaps converted from 2D to 1D arrays

New `PER_KEY_DATA` and `PER_KEY_DATA_STACKED` macros
were introduced that can be used to feed keymap associated
information to functions, constructors or to initialize the
keymap. The user accessed macros `KEYMAP` and `KEYMAP_STACKED`
are now wrappers that pass `XXX` as default value for unused keys.

The new keymap array is named `keymap_linear`. The old symbol
name is now used for a deprecated compatibility wrapper data structure.

Signed-off-by: Florian Fleissner <florian.fleissner@inpartik.de>
pull/646/head
Florian Fleissner 6 years ago committed by Jesse Vincent
parent c6c1492f19
commit f0102dba00

@ -40,6 +40,14 @@ void setup();
extern HARDWARE_IMPLEMENTATION KeyboardHardware; extern HARDWARE_IMPLEMENTATION KeyboardHardware;
#ifdef PER_KEY_DATA_STACKED
#define KEYMAP_STACKED(...) { PER_KEY_DATA_STACKED(XXX, __VA_ARGS__) }
#endif
#ifdef PER_KEY_DATA
#define KEYMAP(...) { PER_KEY_DATA(XXX, __VA_ARGS__) }
#endif
#define ROWS (KeyboardHardware.matrix_rows) #define ROWS (KeyboardHardware.matrix_rows)
#define COLS (KeyboardHardware.matrix_columns) #define COLS (KeyboardHardware.matrix_columns)
#define LED_COUNT (KeyboardHardware.led_count) #define LED_COUNT (KeyboardHardware.led_count)

@ -180,20 +180,20 @@ constexpr size_t nListEntries(Args__...) {
#define BITFIELD(VAR_NAME, ...) BITFIELD__(VAR_NAME,, __VA_ARGS__) #define BITFIELD(VAR_NAME, ...) BITFIELD__(VAR_NAME,, __VA_ARGS__)
#define BITFIELD_PROGMEM(VAR_NAME, ...) BITFIELD__(VAR_NAME, const PROGMEM, __VA_ARGS__) #define BITFIELD_PROGMEM(VAR_NAME, ...) BITFIELD__(VAR_NAME, const PROGMEM, __VA_ARGS__)
#ifdef KEYMAP_GENERIC #ifdef PER_KEY_DATA
#define KEYMAP_BITFIELD(VAR_NAME, ...) \ #define KEYMAP_BITFIELD(VAR_NAME, ...) \
BITFIELD(VAR_NAME, KEYMAP_GENERIC(0 /*default for non-existent keys*/, __VA_ARGS__)) BITFIELD(VAR_NAME, PER_KEY_DATA(0 /*default for non-existent keys*/, __VA_ARGS__))
#define KEYMAP_BITFIELD_PROGMEM(VAR_NAME, ...) \ #define KEYMAP_BITFIELD_PROGMEM(VAR_NAME, ...) \
BITFIELD_PROGMEM(VAR_NAME, KEYMAP_GENERIC(0 /*default for non-existent keys*/, __VA_ARGS__)) BITFIELD_PROGMEM(VAR_NAME, PER_KEY_DATA(0 /*default for non-existent keys*/, __VA_ARGS__))
#endif #endif
#ifdef KEYMAP_STACKED_GENERIC #ifdef PER_KEY_DATA_STACKED
#define KEYMAP_BITFIELDK_STACKED(VAR_NAME, ...) \ #define KEYMAP_BITFIELD_STACKED(VAR_NAME, ...) \
BITFIELD(VAR_NAME, KEYMAP_STACKED_GENERIC(0 /*default for non-existent keys*/, __VA_ARGS__)) BITFIELD(VAR_NAME, PER_KEY_DATA_STACKED(0 /*default for non-existent keys*/, __VA_ARGS__))
#define KEYMAP_BITFIELD_STACKED_PROGMEM(VAR_NAME, ...) \ #define KEYMAP_BITFIELD_STACKED_PROGMEM(VAR_NAME, ...) \
BITFIELD_PROGMEM(VAR_NAME, KEYMAP_STACKED_GENERIC(0 /*default for non-existent keys*/, __VA_ARGS__)) BITFIELD_PROGMEM(VAR_NAME, PER_KEY_DATA_STACKED(0 /*default for non-existent keys*/, __VA_ARGS__))
#endif #endif
} // end namespace bitfields } // end namespace bitfields

@ -93,7 +93,7 @@ class ErgoDox : public kaleidoscope::Hardware {
static void readMatrixRow(uint8_t row); static void readMatrixRow(uint8_t row);
}; };
#define KEYMAP_STACKED( \ #define PER_KEY_DATA_STACKED(dflt, \
/* left hand, spatial positions */ \ /* left hand, spatial positions */ \
r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, \ r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, \
r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, \ r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, \
@ -115,23 +115,22 @@ class ErgoDox : public kaleidoscope::Hardware {
r5c12, r5c11, r5c10 ) \ r5c12, r5c11, r5c10 ) \
\ \
/* matrix positions */ \ /* matrix positions */ \
{ \
{ r0c0, r1c0, r2c0, r3c0, r4c0, XXX }, \
{ r0c1, r1c1, r2c1, r3c1, r4c1, r5c1 }, \
{ r0c2, r1c2, r2c2, r3c2, r4c2, r5c2 }, \
{ r0c3, r1c3, r2c3, r3c3, r4c3, r5c3 }, \
{ r0c4, r1c4, r2c4, r3c4, r4c4, r5c4 }, \
{ r0c5, r1c5, r2c5, r3c5, XXX, r5c5 }, \
{ r0c6, r1c6, XXX, r3c6, XXX, r5c6 }, \
\ \
{ r0c7, r1c7, XXX, r3c7, XXX, r5c7 }, \ r0c0, r1c0, r2c0, r3c0, r4c0, dflt, \
{ r0c8, r1c8, r2c8, r3c8, XXX, r5c8 }, \ r0c1, r1c1, r2c1, r3c1, r4c1, r5c1, \
{ r0c9, r1c9, r2c9, r3c9, r4c9, r5c9 }, \ r0c2, r1c2, r2c2, r3c2, r4c2, r5c2, \
{ r0c10, r1c10, r2c10, r3c10, r4c10, r5c10 }, \ r0c3, r1c3, r2c3, r3c3, r4c3, r5c3, \
{ r0c11, r1c11, r2c11, r3c11, r4c11, r5c11 }, \ r0c4, r1c4, r2c4, r3c4, r4c4, r5c4, \
{ r0c12, r1c12, r2c12, r3c12, r4c12, r5c12 }, \ r0c5, r1c5, r2c5, r3c5, dflt, r5c5, \
{ r0c13, r1c13, r2c13, r3c13, r4c13, XXX } \ r0c6, r1c6, dflt, r3c6, dflt, r5c6, \
} \
r0c7, r1c7, dflt, r3c7, dflt, r5c7, \
r0c8, r1c8, r2c8, r3c8, dflt, r5c8, \
r0c9, r1c9, r2c9, r3c9, r4c9, r5c9, \
r0c10, r1c10, r2c10, r3c10, r4c10, r5c10, \
r0c11, r1c11, r2c11, r3c11, r4c11, r5c11, \
r0c12, r1c12, r2c12, r3c12, r4c12, r5c12, \
r0c13, r1c13, r2c13, r3c13, r4c13, dflt
} }
} }
} }

@ -48,17 +48,16 @@ class KBD4x: public kaleidoscope::hardware::ATMegaKeyboard {
void resetDevice(); void resetDevice();
}; };
#define KEYMAP( \ #define PER_KEY_DATA(dflt, \
R0C0, R0C1, R0C2, R0C3, R0C4, R0C5, R0C6, R0C7, R0C8, R0C9, R0C10, R0C11, \ R0C0, R0C1, R0C2, R0C3, R0C4, R0C5, R0C6, R0C7, R0C8, R0C9, R0C10, R0C11, \
R1C0, R1C1, R1C2, R1C3, R1C4, R1C5, R1C6, R1C7, R1C8, R1C9, R1C10, R1C11, \ R1C0, R1C1, R1C2, R1C3, R1C4, R1C5, R1C6, R1C7, R1C8, R1C9, R1C10, R1C11, \
R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \
R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C7, R3C8, R3C9, R3C10, R3C11 \ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C7, R3C8, R3C9, R3C10, R3C11 \
) { \ ) \
{ R0C0, R0C1, R0C2, R0C3, R0C4, R0C5, R0C6, R0C7, R0C8, R0C9, R0C10, R0C11, }, \ R0C0, R0C1, R0C2, R0C3, R0C4, R0C5, R0C6, R0C7, R0C8, R0C9, R0C10, R0C11, \
{ R1C0, R1C1, R1C2, R1C3, R1C4, R1C5, R1C6, R1C7, R1C8, R1C9, R1C10, R1C11, }, \ R1C0, R1C1, R1C2, R1C3, R1C4, R1C5, R1C6, R1C7, R1C8, R1C9, R1C10, R1C11, \
{ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, }, \ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \
{ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C5, R3C7, R3C8, R3C9, R3C10, R3C11, } \ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C5, R3C7, R3C8, R3C9, R3C10, R3C11
}
} }
} }

@ -100,7 +100,7 @@ class Model01 : public kaleidoscope::Hardware {
#include "kaleidoscope/hardware/key_indexes.h" #include "kaleidoscope/hardware/key_indexes.h"
#define KEYMAP_STACKED( \ #define PER_KEY_DATA_STACKED(dflt, \
r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, \ r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, \
r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, \ r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, \
r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, \ r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, \
@ -114,25 +114,22 @@ class Model01 : public kaleidoscope::Hardware {
r2c9, r3c10, r3c11, r3c12, r3c13, r3c14, r3c15, \ r2c9, r3c10, r3c11, r3c12, r3c13, r3c14, r3c15, \
r3c8, r2c8, r1c8, r0c8, \ r3c8, r2c8, r1c8, r0c8, \
r3c9, ...) \ r3c9, ...) \
{ \ \
{r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c7, r0c8, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15}, \ r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c7, r0c8, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15, \
{r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c7, r1c8, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15}, \ r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c7, r1c8, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15, \
{r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c6, r2c7, r2c8, r2c9, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15}, \ r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c6, r2c7, r2c8, r2c9, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15, \
{r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r3c6, r3c7, r3c8, r3c9, r3c10, r3c11, r3c12, r3c13, r3c14, RESTRICT_ARGS_COUNT((r3c15), 64, KEYMAP_STACKED, ##__VA_ARGS__)}, \ r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r3c6, r3c7, r3c8, r3c9, r3c10, r3c11, r3c12, r3c13, r3c14, RESTRICT_ARGS_COUNT((r3c15), 64, KEYMAP_STACKED, ##__VA_ARGS__)
}
#define KEYMAP( \ #define PER_KEY_DATA(dflt, \
r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15, \ r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15, \
r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15, \ r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15, \
r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15, \ r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15, \
r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r2c6, r2c9, r3c10, r3c11, r3c12, r3c13, r3c14, r3c15, \ r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r2c6, r2c9, r3c10, r3c11, r3c12, r3c13, r3c14, r3c15, \
r0c7, r1c7, r2c7, r3c7, r3c8, r2c8, r1c8, r0c8, \ r0c7, r1c7, r2c7, r3c7, r3c8, r2c8, r1c8, r0c8, \
r3c6, r3c9, ...) \ r3c6, r3c9, ...) \
{ \ r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c7, r0c8, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15, \
{r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c7, r0c8, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15}, \ r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c7, r1c8, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15, \
{r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c7, r1c8, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15}, \ r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c6, r2c7, r2c8, r2c9, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15, \
{r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c6, r2c7, r2c8, r2c9, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15}, \ r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r3c6, r3c7, r3c8, r3c9, r3c10, r3c11, r3c12, r3c13, r3c14, RESTRICT_ARGS_COUNT((r3c15), 64, KEYMAP, ##__VA_ARGS__)
{r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r3c6, r3c7, r3c8, r3c9, r3c10, r3c11, r3c12, r3c13, r3c14, RESTRICT_ARGS_COUNT((r3c15), 64, KEYMAP, ##__VA_ARGS__)}, \
}
#endif #endif

@ -43,17 +43,17 @@ class Planck: public kaleidoscope::hardware::ATMegaKeyboard {
static constexpr int8_t led_count = 0; static constexpr int8_t led_count = 0;
}; };
#define KEYMAP( \ #define PER_KEY_DATA(dflt, \
R0C0, R0C1, R0C2, R0C3, R0C4, R0C5, R0C6, R0C7, R0C8, R0C9, R0C10, R0C11, \ R0C0, R0C1, R0C2, R0C3, R0C4, R0C5, R0C6, R0C7, R0C8, R0C9, R0C10, R0C11, \
R1C0, R1C1, R1C2, R1C3, R1C4, R1C5, R1C6, R1C7, R1C8, R1C9, R1C10, R1C11, \ R1C0, R1C1, R1C2, R1C3, R1C4, R1C5, R1C6, R1C7, R1C8, R1C9, R1C10, R1C11, \
R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \
R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 \ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 \
) { \ ) \
{ R0C0, R0C1, R0C2, R0C3, R0C4, R0C5, R0C6, R0C7, R0C8, R0C9, R0C10, R0C11, }, \ R0C0, R0C1, R0C2, R0C3, R0C4, R0C5, R0C6, R0C7, R0C8, R0C9, R0C10, R0C11, \
{ R1C0, R1C1, R1C2, R1C3, R1C4, R1C5, R1C6, R1C7, R1C8, R1C9, R1C10, R1C11, }, \ R1C0, R1C1, R1C2, R1C3, R1C4, R1C5, R1C6, R1C7, R1C8, R1C9, R1C10, R1C11, \
{ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, }, \ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \
{ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11, } \ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11
}
} }
} }

@ -52,20 +52,19 @@ class Splitography: public kaleidoscope::hardware::ATMegaKeyboard {
static constexpr int8_t led_count = 0; static constexpr int8_t led_count = 0;
}; };
#define KEYMAP( \ #define PER_KEY_DATA(dflt, \
r0c0 ,r0c1 ,r0c2 ,r0c3 ,r0c4 ,r0c5 ,r0c6 ,r0c7 ,r0c8 ,r0c9 ,r0c10 ,r0c11 \ r0c0 ,r0c1 ,r0c2 ,r0c3 ,r0c4 ,r0c5 ,r0c6 ,r0c7 ,r0c8 ,r0c9 ,r0c10 ,r0c11 \
,r1c0 ,r1c1 ,r1c2 ,r1c3 ,r1c4 ,r1c5 ,r1c6 ,r1c7 ,r1c8 ,r1c9 ,r1c10 ,r1c11 \ ,r1c0 ,r1c1 ,r1c2 ,r1c3 ,r1c4 ,r1c5 ,r1c6 ,r1c7 ,r1c8 ,r1c9 ,r1c10 ,r1c11 \
,r2c0 ,r2c1 ,r2c2 ,r2c3 ,r2c4 ,r2c5 ,r2c6 ,r2c7 ,r2c8 ,r2c9 ,r2c10 ,r2c11 \ ,r2c0 ,r2c1 ,r2c2 ,r2c3 ,r2c4 ,r2c5 ,r2c6 ,r2c7 ,r2c8 ,r2c9 ,r2c10 ,r2c11 \
,r3c4 ,r3c5 ,r3c6 ,r3c7 \ ,r3c4 ,r3c5 ,r3c6 ,r3c7 \
) \ ) \
{ \ \
{ r0c0 ,r0c1 ,r0c2 ,r0c3 ,r0c4 ,r0c5 , r0c6 ,r0c7 ,r0c8 ,r0c9 ,r0c10 ,r0c11 }, \ r0c0 ,r0c1 ,r0c2 ,r0c3 ,r0c4 ,r0c5 , r0c6 ,r0c7 ,r0c8 ,r0c9 ,r0c10 ,r0c11, \
{ r1c0 ,r1c1 ,r1c2 ,r1c3 ,r1c4 ,r1c5 , r1c6 ,r1c7 ,r1c8 ,r1c9 ,r1c10 ,r1c11 }, \ r1c0 ,r1c1 ,r1c2 ,r1c3 ,r1c4 ,r1c5 , r1c6 ,r1c7 ,r1c8 ,r1c9 ,r1c10 ,r1c11, \
{ r2c0 ,r2c1 ,r2c2 ,r2c3 ,r2c4 ,r2c5 , r2c6 ,r2c7 ,r2c8 ,r2c9 ,r2c10 ,r2c11 }, \ r2c0 ,r2c1 ,r2c2 ,r2c3 ,r2c4 ,r2c5 , r2c6 ,r2c7 ,r2c8 ,r2c9 ,r2c10 ,r2c11, \
{ XXX ,XXX ,XXX ,XXX ,r3c4 ,r3c5 ,r3c6 ,r3c7 ,XXX ,XXX ,XXX ,XXX } \ dflt ,dflt ,dflt ,dflt ,r3c4 ,r3c5 ,r3c6 ,r3c7 ,dflt ,dflt ,dflt ,dflt
}
#define KEYMAP_STACKED( \ #define PER_KEY_DATA_STACKED(dflt, \
r0c0 ,r0c1 ,r0c2 ,r0c3 ,r0c4 ,r0c5 \ r0c0 ,r0c1 ,r0c2 ,r0c3 ,r0c4 ,r0c5 \
,r1c0 ,r1c1 ,r1c2 ,r1c3 ,r1c4 ,r1c5 \ ,r1c0 ,r1c1 ,r1c2 ,r1c3 ,r1c4 ,r1c5 \
,r2c0 ,r2c1 ,r2c2 ,r2c3 ,r2c4 ,r2c5 \ ,r2c0 ,r2c1 ,r2c2 ,r2c3 ,r2c4 ,r2c5 \
@ -76,12 +75,10 @@ class Splitography: public kaleidoscope::hardware::ATMegaKeyboard {
,r2c6 ,r2c7 ,r2c8 ,r2c9 ,r2c10 ,r2c11 \ ,r2c6 ,r2c7 ,r2c8 ,r2c9 ,r2c10 ,r2c11 \
,r3c6 ,r3c7 \ ,r3c6 ,r3c7 \
) \ ) \
{ \ r0c0 ,r0c1 ,r0c2 ,r0c3 ,r0c4 ,r0c5 ,r0c6 ,r0c7 ,r0c8 ,r0c9 ,r0c10 ,r0c11, \
{ r0c0 ,r0c1 ,r0c2 ,r0c3 ,r0c4 ,r0c5 , r0c6 ,r0c7 ,r0c8 ,r0c9 ,r0c10 ,r0c11 }, \ r1c0 ,r1c1 ,r1c2 ,r1c3 ,r1c4 ,r1c5 ,r1c6 ,r1c7 ,r1c8 ,r1c9 ,r1c10 ,r1c11, \
{ r1c0 ,r1c1 ,r1c2 ,r1c3 ,r1c4 ,r1c5 , r1c6 ,r1c7 ,r1c8 ,r1c9 ,r1c10 ,r1c11 }, \ r2c0 ,r2c1 ,r2c2 ,r2c3 ,r2c4 ,r2c5 ,r2c6 ,r2c7 ,r2c8 ,r2c9 ,r2c10 ,r2c11, \
{ r2c0 ,r2c1 ,r2c2 ,r2c3 ,r2c4 ,r2c5 , r2c6 ,r2c7 ,r2c8 ,r2c9 ,r2c10 ,r2c11 }, \ dflt ,dflt ,dflt ,dflt ,r3c4 ,r3c5 ,r3c6 ,r3c7 ,dflt ,dflt ,dflt ,dflt
{ XXX ,XXX ,XXX ,XXX ,r3c4 ,r3c5 ,r3c6 ,r3c7 ,XXX ,XXX ,XXX ,XXX } \
}
} }
} }

@ -70,20 +70,19 @@ class Atreus: public kaleidoscope::hardware::ATMegaKeyboard {
protected: protected:
}; };
#define KEYMAP( \ #define PER_KEY_DATA(dflt, \
R0C0, R0C1, R0C2, R0C3, R0C4, R0C7, R0C8, R0C9, R0C10, R0C11, \ R0C0, R0C1, R0C2, R0C3, R0C4, R0C7, R0C8, R0C9, R0C10, R0C11, \
R1C0, R1C1, R1C2, R1C3, R1C4, R1C7, R1C8, R1C9, R1C10, R1C11, \ R1C0, R1C1, R1C2, R1C3, R1C4, R1C7, R1C8, R1C9, R1C10, R1C11, \
R2C0, R2C1, R2C2, R2C3, R2C4, R2C7, R2C8, R2C9, R2C10, R2C11, \ R2C0, R2C1, R2C2, R2C3, R2C4, R2C7, R2C8, R2C9, R2C10, R2C11, \
R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 \ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 \
) \ ) \
{ \ \
{ R0C0, R0C1, R0C2, R0C3, R0C4, XXX, R0C7, R0C8, R0C9, R0C10, R0C11 }, \ R0C0, R0C1, R0C2, R0C3, R0C4, XXX, R0C7, R0C8, R0C9, R0C10, R0C11, \
{ R1C0, R1C1, R1C2, R1C3, R1C4, XXX, R1C7, R1C8, R1C9, R1C10, R1C11 }, \ R1C0, R1C1, R1C2, R1C3, R1C4, XXX, R1C7, R1C8, R1C9, R1C10, R1C11, \
{ R2C0, R2C1, R2C2, R2C3, R2C4, R3C5, R2C7, R2C8, R2C9, R2C10, R2C11 }, \ R2C0, R2C1, R2C2, R2C3, R2C4, R3C5, R2C7, R2C8, R2C9, R2C10, R2C11, \
{ R3C0, R3C1, R3C2, R3C3, R3C4, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 } \ R3C0, R3C1, R3C2, R3C3, R3C4, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11
}
#define KEYMAP_STACKED( \ #define PER_KEY_DATA_STACKED(dflt, \
R0C0, R0C1, R0C2, R0C3, R0C4, \ R0C0, R0C1, R0C2, R0C3, R0C4, \
R1C0, R1C1, R1C2, R1C3, R1C4, \ R1C0, R1C1, R1C2, R1C3, R1C4, \
R2C0, R2C1, R2C2, R2C3, R2C4, \ R2C0, R2C1, R2C2, R2C3, R2C4, \
@ -94,12 +93,10 @@ class Atreus: public kaleidoscope::hardware::ATMegaKeyboard {
R2C7, R2C8, R2C9, R2C10, R2C11, \ R2C7, R2C8, R2C9, R2C10, R2C11, \
R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 \ R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 \
) \ ) \
{ \ R0C0, R0C1, R0C2, R0C3, R0C4, dflt, R0C7, R0C8, R0C9, R0C10, R0C11, \
{ R0C0, R0C1, R0C2, R0C3, R0C4, XXX, R0C7, R0C8, R0C9, R0C10, R0C11 }, \ R1C0, R1C1, R1C2, R1C3, R1C4, dflt, R1C7, R1C8, R1C9, R1C10, R1C11, \
{ R1C0, R1C1, R1C2, R1C3, R1C4, XXX, R1C7, R1C8, R1C9, R1C10, R1C11 }, \ R2C0, R2C1, R2C2, R2C3, R2C4, R3C5, R2C7, R2C8, R2C9, R2C10, R2C11, \
{ R2C0, R2C1, R2C2, R2C3, R2C4, R3C5, R2C7, R2C8, R2C9, R2C10, R2C11 }, \ R3C0, R3C1, R3C2, R3C3, R3C4, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11
{ R3C0, R3C1, R3C2, R3C3, R3C4, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 } \
}
} }
} }
} }

@ -48,20 +48,18 @@ class Atreus2: public kaleidoscope::hardware::ATMegaKeyboard {
protected: protected:
}; };
#define KEYMAP( \ #define PER_KEY_DATA(dflt, \
R0C0, R0C1, R0C2, R0C3, R0C4, R0C7, R0C8, R0C9, R0C10, R0C11, \ R0C0, R0C1, R0C2, R0C3, R0C4, R0C7, R0C8, R0C9, R0C10, R0C11, \
R1C0, R1C1, R1C2, R1C3, R1C4, R1C7, R1C8, R1C9, R1C10, R1C11, \ R1C0, R1C1, R1C2, R1C3, R1C4, R1C7, R1C8, R1C9, R1C10, R1C11, \
R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \
R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 \ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 \
) \ ) \
{ \ R0C0, R0C1, R0C2, R0C3, R0C4, XXX, XXX, R0C7, R0C8, R0C9, R0C10, R0C11, \
{ R0C0, R0C1, R0C2, R0C3, R0C4, XXX, XXX, R0C7, R0C8, R0C9, R0C10, R0C11 }, \ R1C0, R1C1, R1C2, R1C3, R1C4, XXX, XXX, R1C7, R1C8, R1C9, R1C10, R1C11, \
{ R1C0, R1C1, R1C2, R1C3, R1C4, XXX, XXX, R1C7, R1C8, R1C9, R1C10, R1C11 }, \ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \
{ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11 }, \ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11
{ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 } \
}
#define KEYMAP_STACKED( \ #define PER_KEY_DATA_STACKED(dflt, \
R0C0, R0C1, R0C2, R0C3, R0C4, \ R0C0, R0C1, R0C2, R0C3, R0C4, \
R1C0, R1C1, R1C2, R1C3, R1C4, \ R1C0, R1C1, R1C2, R1C3, R1C4, \
R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, \ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, \
@ -72,12 +70,10 @@ class Atreus2: public kaleidoscope::hardware::ATMegaKeyboard {
R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \ R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \
R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 \ R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 \
) \ ) \
{ \ R0C0, R0C1, R0C2, R0C3, R0C4, XXX, XXX, R0C7, R0C8, R0C9, R0C10, R0C11, \
{ R0C0, R0C1, R0C2, R0C3, R0C4, XXX, XXX, R0C7, R0C8, R0C9, R0C10, R0C11 }, \ R1C0, R1C1, R1C2, R1C3, R1C4, XXX, XXX, R1C7, R1C8, R1C9, R1C10, R1C11, \
{ R1C0, R1C1, R1C2, R1C3, R1C4, XXX, XXX, R1C7, R1C8, R1C9, R1C10, R1C11 }, \ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11, \
{ R2C0, R2C1, R2C2, R2C3, R2C4, R2C5, R2C6, R2C7, R2C8, R2C9, R2C10, R2C11 }, \ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11
{ R3C0, R3C1, R3C2, R3C3, R3C4, R3C5, R3C6, R3C7, R3C8, R3C9, R3C10, R3C11 } \
}
} }
} }
} }

@ -0,0 +1,79 @@
/* Kaleidoscope - Firmware for computer input devices
* Copyright (C) 2013-2018 Keyboard.io, Inc.
*
* 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, version 3.
*
* 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/>.
*/
#pragma once
#include "kaleidoscope/key_defs.h"
extern const Key keymaps_linear[][ROWS * COLS];
namespace kaleidoscope {
inline
Key keyFromKeymap(uint8_t layer, uint8_t row, uint8_t col) {
return pgm_read_word(&keymaps_linear[layer][row * COLS + col]);
}
namespace internal {
// This class mimics a three-dimensional array as formerly used to
// store keymap arrays in progmem. It wraps the new one dimentional
// keymap array.
class Keymaps2DInterface {
public:
class KeymapLayer {
const Key * const keymap_layer_;
public:
KeymapLayer(const Key * const keymap_layer) : keymap_layer_(keymap_layer) {}
class KeymapRow {
const Key * const keymap_row_;
public:
KeymapRow(const Key * const keymap_row) : keymap_row_(keymap_row) {}
const Key &operator[](uint8_t col) {
return keymap_row_[col];
}
};
KeymapRow operator[](uint8_t row) {
return KeymapRow(keymap_layer_ + row * COLS);
}
};
KeymapLayer operator[](uint8_t layer) {
return KeymapLayer(keymaps_linear[layer]);
}
};
}
}
#define _DEPRECATED_MESSAGE_2D_KEYMAP_ARRAY \
"Accessing the keymap array directly is deprecated. Please use the function "\
"keyFromKeymap() to access keys. The keymap array will be removed in future "\
"versions of the firmware"
DEPRECATED(2D_KEYMAP_ARRAY)
extern kaleidoscope::internal::Keymaps2DInterface keymaps;

@ -21,7 +21,7 @@
// that should be enough for almost any layout. // that should be enough for almost any layout.
#define MAX_LAYERS sizeof(uint32_t) * 8; #define MAX_LAYERS sizeof(uint32_t) * 8;
// The total number of defined layers in the firmware sketch keymaps[] // The total number of defined layers in the firmware sketch keymaps_linear[]
// array. If the keymap wasn't defined using KEYMAPS(), set it to the // array. If the keymap wasn't defined using KEYMAPS(), set it to the
// highest possible number of layers. // highest possible number of layers.
uint8_t layer_count __attribute__((weak)) = MAX_LAYERS; uint8_t layer_count __attribute__((weak)) = MAX_LAYERS;
@ -93,11 +93,7 @@ Key Layer_::eventHandler(Key mappedKey, byte row, byte col, uint8_t keyState) {
} }
Key Layer_::getKeyFromPROGMEM(uint8_t layer, byte row, byte col) { Key Layer_::getKeyFromPROGMEM(uint8_t layer, byte row, byte col) {
Key key; return keyFromKeymap(layer, row, col);
key.raw = pgm_read_word(&(keymaps[layer][row][col]));
return key;
} }
void Layer_::updateLiveCompositeKeymap(byte row, byte col) { void Layer_::updateLiveCompositeKeymap(byte row, byte col) {

@ -18,17 +18,21 @@
#include <Arduino.h> #include <Arduino.h>
#include "kaleidoscope/key_defs.h" #include "kaleidoscope/key_defs.h"
#include "kaleidoscope/keymaps.h"
#include KALEIDOSCOPE_HARDWARE_H #include KALEIDOSCOPE_HARDWARE_H
extern const Key keymaps[][ROWS][COLS];
// Macro for defining the keymap. This should be used in the sketch // Macro for defining the keymap. This should be used in the sketch
// file (*.ino) to define the keymap[] array that holds the user's // file (*.ino) to define the keymap[] array that holds the user's
// layers. It also computes the number of layers in that keymap. // layers. It also computes the number of layers in that keymap.
#define KEYMAPS(layers...) \ #define KEYMAPS(layers...) __NL__ \
const Key keymaps[][ROWS][COLS] PROGMEM = { layers }; \ const Key keymaps_linear[][ROWS*COLS] PROGMEM = { layers }; __NL__ \
uint8_t layer_count = sizeof(keymaps) / sizeof(*keymaps); uint8_t layer_count __NL__ \
= sizeof(keymaps_linear) / sizeof(*keymaps_linear); __NL__ \
__NL__ \
/* This deprecated compatibility wrapper is removed by the linker if __NL__ \
it is not accessed nowhere. __NL__ \
*/ __NL__ \
kaleidoscope::internal::Keymaps2DInterface keymaps;
extern uint8_t layer_count; extern uint8_t layer_count;

Loading…
Cancel
Save