keyboard/qmk-keychron-q3-colemak-dh
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add new keymap management on gh60

Browse Source
This commit is contained in:
tmk 2013-11-21 16:32:45 +09:00
parent 772ab7025d
commit 22e293696d
9 changed files with 143 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
keyboard/gh60/Makefile.lufa → keyboard/gh60/Makefile
View File

@ -48,9 +48,14 @@ TOP_DIR = ../..
TARGET_DIR = . TARGET_DIR = .
# project specific files # project specific files
SRC = keymap.c \ SRC = keymap_common.c \
matrix.c \ matrix.c \
led.c led.c
ifdef KEYMAP
SRC := keymap_$(KEYMAP).c $(SRC)
else
SRC := keymap_poker.c $(SRC)
endif
CONFIG_H = config.h CONFIG_H = config.h
@ -93,7 +98,7 @@ ARCH = AVR8
F_USB = $(F_CPU) F_USB = $(F_CPU)
# Interrupt driven control endpoint task(+60) # Interrupt driven control endpoint task(+60)
#OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
# Boot Section Size in *bytes* # Boot Section Size in *bytes*
@ -114,7 +119,7 @@ EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
CONSOLE_ENABLE = yes # Console for debug(+400) CONSOLE_ENABLE = yes # Console for debug(+400)
COMMAND_ENABLE = yes # Commands for debug and configuration COMMAND_ENABLE = yes # Commands for debug and configuration
SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend
#NKRO_ENABLE = yes # USB Nkey Rollover - not yet supported in LUFA NKRO_ENABLE = yes # USB Nkey Rollover - not yet supported in LUFA
# Optimize size but this may cause error "relocation truncated to fit" # Optimize size but this may cause error "relocation truncated to fit"
@ -127,15 +132,3 @@ VPATH += $(TOP_DIR)
include $(TOP_DIR)/protocol/lufa.mk include $(TOP_DIR)/protocol/lufa.mk
include $(TOP_DIR)/common.mk include $(TOP_DIR)/common.mk
include $(TOP_DIR)/rules.mk include $(TOP_DIR)/rules.mk
plain: OPT_DEFS += -DKEYMAP_PLAIN
plain: all
poker: OPT_DEFS += -DKEYMAP_POKER
poker: all
poker_set: OPT_DEFS += -DKEYMAP_POKER_SET
poker_set: all
poker_bit: OPT_DEFS += -DKEYMAP_POKER_BIT
poker_bit: all

64
keyboard/gh60/README.md
View File

@ -10,28 +10,20 @@ DIY compact keyboard designed and run by komar007 and Geekhack community.
## Build ## Build
Move to this directory then just run `make` like: Move to this directory then just run `make` like:
$ make -f Makfile.[pjrc|lufa] $ make
Use `Makefile.pjrc` if you want to use PJRC stack or use `Makefile.lufa` for LUFA stack. Use `make -f Makefile.pjrc` if you want to use PJRC stack but I find no reason to do so now.
## Boot Magic
Plugin pressing these `Boot Magic` key.
- `Fn` key for bootloader kick up.
- `D` key for Debug enable.
## Keymap ## Keymap
Two version of keymap are available. `Plan`, `Poker` and `Funky`(default). Several version of keymap are available; `plain`, `poker_bit`, `poker_set`, `hasu` and `poker`(default). See keymap document(you can find in README.md of top) and `keymap_*.c` to define your own favourite keymap.
See keymap.c to define your own favourite keymap.
$ make -f Makefile.[pjrc|lufa] [plain|poker] $ make KEYMAP=[poker|plain|poker_set|poker_bit|hasu]
### 1. Plain keymap ### 1. Plain keymap
This will be useful if you want to use key mapping tool like AHK. Even without any Fn layer. This will be useful if you want to use key mapping tool like AHK.
See [keymap_plain.h](keymap_plain.h) for detail. See [keymap_plain.c](keymap_plain.c) for detail.
#### 1.0 Plain Default Layer #### 1.0 Plain Default Layer
,-----------------------------------------------------------. ,-----------------------------------------------------------.
@ -48,9 +40,13 @@ See [keymap_plain.h](keymap_plain.h) for detail.
### 2 Poker keymap ### 2 Poker keymap
See [keymap_poker.h](keymap_poker.h) for Poker layer emulation, [keymap_poker_bit.h](keymap_poker_bit.h) and [keymap_poker_set.h](keymap_poker_set.h) for better support of Esc and arrow. [keymap_poker.c](keymap_poker.c) emulates original Poker layer emulation.
[keymap_poker_bit.c](keymap_poker_bit.c) and [keymap_poker_set.c](keymap_poker_set.c) offers better support of Esc and arrow like:
These keymap supports Colemak, Dvorak and Workmans, use `Magic` + {`1`, `2`, `3`} to switch and `Magic` + `0` to return to Qwerty. Fn + Esc = `
Fn + {left, down, up, right} = {home, pgdown, pgup, end}
`poker` keymap supports Colemak, Dvorak and Workmans, use `Magic` + {`1`, `2`, `3`} to switch and `Magic` + `0` to return to Qwerty, where `Magic` is `LShift` + `RShift`.
#### 2.0 Poker Default Layer #### 2.0 Poker Default Layer
,-----------------------------------------------------------. ,-----------------------------------------------------------.
@ -65,32 +61,6 @@ See [keymap_poker.h](keymap_poker.h) for Poker layer emulation, [keymap_poker_bi
|Ctrl|Gui |Alt | Space |Fn |Gui |App |Ctrl| |Ctrl|Gui |Alt | Space |Fn |Gui |App |Ctrl|
`-----------------------------------------------------------' `-----------------------------------------------------------'
#### 2.1 Poker Arrow Layer
,-----------------------------------------------------------.
| | | | | | | | | | | | | | |
|-----------------------------------------------------------|
| | | | | | | | | | | | | | |
|-----------------------------------------------------------|
| | | | | | | | | | | | | |
|-----------------------------------------------------------|
| | | | | | | | | | | | Up |
|-----------------------------------------------------------|
| | | | |Fn |Left|Down|Righ|
`-----------------------------------------------------------'
#### 2.2 Poker Esc Layer
,-----------------------------------------------------------.
|Esc| | | | | | | | | | | | | |
|-----------------------------------------------------------|
| | | | | | | | | | | | | | |
|-----------------------------------------------------------|
| | | | | | | | | | | | | |
|-----------------------------------------------------------|
| | | | | | | | | | | | |
|-----------------------------------------------------------|
| | | | |Fn | | | |
`-----------------------------------------------------------'
#### 2.1 Poker Fn Layer #### 2.1 Poker Fn Layer
,-----------------------------------------------------------. ,-----------------------------------------------------------.
|Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12| | |Esc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12| |
@ -99,17 +69,15 @@ See [keymap_poker.h](keymap_poker.h) for Poker layer emulation, [keymap_poker_bi
|-----------------------------------------------------------| |-----------------------------------------------------------|
| |Lef|Dow|Rig| | |Psc|Slk|Pau| |Tsk|End| | | |Lef|Dow|Rig| | |Psc|Slk|Pau| |Tsk|End| |
|-----------------------------------------------------------| |-----------------------------------------------------------|
| |Del| |Web|Mut|VoU|VoD| |PgU|PgD|Del| | | |Del| |Web|Mut|VoU|VoD| |PgU|PgD|Del| Up |
|-----------------------------------------------------------| |-----------------------------------------------------------|
| | | | FnS |Fn | | | | | | | | FnS |Fn |Left|Down|Righ|
`-----------------------------------------------------------' `-----------------------------------------------------------'
### 3. Funky keymap ### 3. Hasu keymap
This is my keymap(default) with HHKB, Vi cursor and Mousekey layer. This is my keymap with HHKB, Vi cursor and Mousekey layer. See [keymap_hasu.c](keymap_hasu.c) for detail.
See [keymap.c](keymap.c) for detail.
#### 3.0 Funky Default Layer #### 3.0 Funky Default Layer
,-----------------------------------------------------------. ,-----------------------------------------------------------.

30
keyboard/gh60/keymap_common.c Normal file
View File

@ -0,0 +1,30 @@
/*
Copyright 2012,2013 Jun Wako <wakojun@gmail.com>
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/>.
*/
#include "keymap_common.h"
/* translates key to keycode */
uint8_t keymap_key_to_keycode(uint8_t layer, key_t key)
{
return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
}
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint8_t keycode)
{
return (action_t){ .code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]) };
}

69
keyboard/gh60/keymap_common.h Normal file
View File

@ -0,0 +1,69 @@
/*
Copyright 2012,2013 Jun Wako <wakojun@gmail.com>
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/>.
*/
#ifndef KEYMAP_COMMON_H
#define KEYMAP_COMMON_H
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include "keycode.h"
#include "action.h"
#include "action_macro.h"
#include "report.h"
#include "host.h"
#include "print.h"
#include "debug.h"
#include "keymap.h"
extern const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS];
extern const uint16_t fn_actions[];
/* GH60 keymap definition macro
* K2C, K31 and K3C are extra keys for ISO
*/
#define KEYMAP( \
K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \
K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, \
K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D, \
K40, K41, K42, K45, K4A, K4B, K4C, K4D \
) { \
{ KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07, KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D }, \
{ KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17, KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D }, \
{ KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27, KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D }, \
{ KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37, KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D }, \
{ KC_##K40, KC_##K41, KC_##K42, KC_NO, KC_NO, KC_##K45, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D } \
}
/* ANSI valiant. No extra keys for ISO */
#define KEYMAP_ANSI( \
K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \
K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2D, \
K30, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3D, \
K40, K41, K42, K45, K4A, K4B, K4C, K4D \
) KEYMAP( \
K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \
K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, NO, K2D, \
K30, NO, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, NO, K3D, \
K40, K41, K42, K45, K4A, K4B, K4C, K4D \
)
#endif

108
keyboard/gh60/keymap.c → keyboard/gh60/keymap_hasu.c
View File

@ -1,77 +1,8 @@
/* #include "keymap_common.h"
Copyright 2012,2013 Jun Wako <wakojun@gmail.com>
This program is free software: you can redistribute it and/or modify const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
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/>.
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/pgmspace.h>
#include "keycode.h"
#include "action.h"
#include "action_macro.h"
#include "report.h"
#include "host.h"
#include "print.h"
#include "debug.h"
#include "keymap.h"
/* GH60 keymap definition macro
* K2C, K31 and K3C are extra keys for ISO
*/
#define KEYMAP( \
K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \
K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2C, K2D, \
K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D, \
K40, K41, K42, K45, K4A, K4B, K4C, K4D \
) { \
{ KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07, KC_##K08, KC_##K09, KC_##K0A, KC_##K0B, KC_##K0C, KC_##K0D }, \
{ KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17, KC_##K18, KC_##K19, KC_##K1A, KC_##K1B, KC_##K1C, KC_##K1D }, \
{ KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27, KC_##K28, KC_##K29, KC_##K2A, KC_##K2B, KC_##K2C, KC_##K2D }, \
{ KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_##K34, KC_##K35, KC_##K36, KC_##K37, KC_##K38, KC_##K39, KC_##K3A, KC_##K3B, KC_##K3C, KC_##K3D }, \
{ KC_##K40, KC_##K41, KC_##K42, KC_NO, KC_NO, KC_##K45, KC_NO, KC_NO, KC_NO, KC_NO, KC_##K4A, KC_##K4B, KC_##K4C, KC_##K4D } \
}
/* ANSI valiant. No extra keys for ISO */
#define KEYMAP_ANSI( \
K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \
K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, K2D, \
K30, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3D, \
K40, K41, K42, K45, K4A, K4B, K4C, K4D \
) KEYMAP( \
K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, \
K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C, K1D, \
K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, NO, K2D, \
K30, NO, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, NO, K3D, \
K40, K41, K42, K45, K4A, K4B, K4C, K4D \
)
#if defined(KEYMAP_PLAIN)
#include "keymap_plain.h"
#elif defined(KEYMAP_POKER)
#include "keymap_poker.h"
#elif defined(KEYMAP_POKER_SET)
#include "keymap_poker_set.h"
#elif defined(KEYMAP_POKER_BIT)
#include "keymap_poker_bit.h"
#else
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* /*
* Funky * Hasu
*/ */
/* Keymap 0: Default Layer /* Keymap 0: Default Layer
* ,-----------------------------------------------------------. * ,-----------------------------------------------------------.
@ -200,7 +131,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* /*
* Fn action definition * Fn action definition
*/ */
static const uint16_t PROGMEM fn_actions[] = { const uint16_t PROGMEM fn_actions[] = {
[0] = ACTION_LAYER_MOMENTARY(4), [0] = ACTION_LAYER_MOMENTARY(4),
[1] = ACTION_LAYER_TAP_KEY(5, KC_SLASH), [1] = ACTION_LAYER_TAP_KEY(5, KC_SLASH),
[2] = ACTION_LAYER_TAP_KEY(6, KC_SCLN), [2] = ACTION_LAYER_TAP_KEY(6, KC_SCLN),
@ -212,34 +143,3 @@ static const uint16_t PROGMEM fn_actions[] = {
[8] = ACTION_DEFAULT_LAYER_SET(3), // set workman layout [8] = ACTION_DEFAULT_LAYER_SET(3), // set workman layout
[9] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_GRV), [9] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_GRV),
}; };
#endif
#define KEYMAPS_SIZE (sizeof(keymaps) / sizeof(keymaps[0]))
#define FN_ACTIONS_SIZE (sizeof(fn_actions) / sizeof(fn_actions[0]))
/* translates key to keycode */
uint8_t keymap_key_to_keycode(uint8_t layer, key_t key)
{
if (layer < KEYMAPS_SIZE) {
return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]);
} else {
// XXX: this may cuaes bootlaoder_jump inconsistent fail.
//debug("key_to_keycode: base "); debug_dec(layer); debug(" is invalid.\n");
// fall back to layer 0
return pgm_read_byte(&keymaps[0][(key.row)][(key.col)]);
}
}
/* translates Fn keycode to action */
action_t keymap_fn_to_action(uint8_t keycode)
{
action_t action;
if (FN_INDEX(keycode) < FN_ACTIONS_SIZE) {
action.code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]);
} else {
action.code = ACTION_NO;
}
return action;
}

6
keyboard/gh60/keymap_plain.h → keyboard/gh60/keymap_plain.c
View File

@ -1,4 +1,6 @@
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { #include "keymap_common.h"
const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* 0: qwerty */ /* 0: qwerty */
KEYMAP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ KEYMAP(ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \
TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, \ TAB, Q, W, E, R, T, Y, U, I, O, P, LBRC,RBRC,BSLS, \
@ -6,4 +8,4 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
LSFT,NO, Z, X, C, V, B, N, M, COMM,DOT, SLSH,NO, RSFT, \ LSFT,NO, Z, X, C, V, B, N, M, COMM,DOT, SLSH,NO, RSFT, \
LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL), LCTL,LGUI,LALT, SPC, RALT,RGUI,APP, RCTL),
}; };
static const uint16_t PROGMEM fn_actions[] = {}; const uint16_t PROGMEM fn_actions[] = {};

6
keyboard/gh60/keymap_poker.h → keyboard/gh60/keymap_poker.c
View File

@ -1,4 +1,6 @@
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { #include "keymap_common.h"
const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* 0: qwerty */ /* 0: qwerty */
KEYMAP_ANSI( KEYMAP_ANSI(
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \
@ -88,7 +90,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
TRNS,TRNS,TRNS,FN6, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \ TRNS,TRNS,TRNS,FN6, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, TRNS, \
TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS), TRNS,TRNS,TRNS, TRNS, TRNS,TRNS,TRNS,TRNS),
}; };
static const uint16_t PROGMEM fn_actions[] = { const uint16_t PROGMEM fn_actions[] = {
/* Poker Layout */ /* Poker Layout */
[0] = ACTION_LAYER_MOMENTARY(6), // to Fn overlay [0] = ACTION_LAYER_MOMENTARY(6), // to Fn overlay
[1] = ACTION_LAYER_TOGGLE(4), // toggle arrow overlay [1] = ACTION_LAYER_TOGGLE(4), // toggle arrow overlay

6
keyboard/gh60/keymap_poker_bit.h → keyboard/gh60/keymap_poker_bit.c
View File

@ -1,7 +1,9 @@
#include "keymap_common.h"
// Poker fix with toggle and bit operation // Poker fix with toggle and bit operation
// Fn + Esc = ` // Fn + Esc = `
// Fn + {left, down, up, right} = {home, pgdown, pgup, end} // Fn + {left, down, up, right} = {home, pgdown, pgup, end}
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* 0: qwerty */ /* 0: qwerty */
KEYMAP_ANSI( KEYMAP_ANSI(
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \
@ -38,7 +40,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, UP, \ TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, UP, \
TRNS,TRNS,TRNS, TRNS, TRNS,LEFT,DOWN,RGHT), TRNS,TRNS,TRNS, TRNS, TRNS,LEFT,DOWN,RGHT),
}; };
static const uint16_t PROGMEM fn_actions[] = { const uint16_t PROGMEM fn_actions[] = {
/* Poker Layout */ /* Poker Layout */
[0] = ACTION_LAYER_BIT_XOR(1, 0b0101, ON_BOTH), // Poker Fn(with fix for Esc) [0] = ACTION_LAYER_BIT_XOR(1, 0b0101, ON_BOTH), // Poker Fn(with fix for Esc)
[1] = ACTION_LAYER_TOGGLE(5), // Poker Arrow toggle [1] = ACTION_LAYER_TOGGLE(5), // Poker Arrow toggle

6
keyboard/gh60/keymap_poker_set.h → keyboard/gh60/keymap_poker_set.c
View File

@ -1,7 +1,9 @@
#include "keymap_common.h"
// Poker fix with set(state transition) // Poker fix with set(state transition)
// Fn + Esc = ` // Fn + Esc = `
// Fn + {left, down, up, right} = {home, pgdown, pgup, end} // Fn + {left, down, up, right} = {home, pgdown, pgup, end}
static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* 0: qwerty */ /* 0: qwerty */
KEYMAP_ANSI( KEYMAP_ANSI(
GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \ GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, MINS,EQL, BSPC, \
@ -63,7 +65,7 @@ static const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* /*
* Fn action definition * Fn action definition
*/ */
static const uint16_t PROGMEM fn_actions[] = { const uint16_t PROGMEM fn_actions[] = {
/* Poker Layout */ /* Poker Layout */
[0] = ACTION_LAYER_SET(4, ON_PRESS), // FN0 move to Fn'd when press [0] = ACTION_LAYER_SET(4, ON_PRESS), // FN0 move to Fn'd when press
[1] = ACTION_LAYER_SET(5, ON_PRESS), // FN1 move to Fn'd arrow when press [1] = ACTION_LAYER_SET(5, ON_PRESS), // FN1 move to Fn'd arrow when press