muflax
/
ergodox-firmware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ergodox-firmware/src/main.h

57 lines
1.7 KiB
C
Raw Normal View History

intermitent checkin; lots of stuff; i2c on hold; kb logic in progress
2012-03-27 12:06:52 +02:00
/* ----------------------------------------------------------------------------
removed linked lists; changed KBFUN_FUNCTION_ARGS handling - linked lists need to be rewritten to be more memory efficient - all kbfun functions are now of type `(void kbfun_...(void))`, and the arguments they need are passed via a group of global `main_arg_...` variables (and other `main_...` variables)
2012-08-07 00:57:23 +02:00
* main() : functions and data that may be useful externally
intermitent checkin; lots of stuff; i2c on hold; kb logic in progress
2012-03-27 12:06:52 +02:00
* ----------------------------------------------------------------------------
* Copyright (c) 2012 Ben Blazak <benblazak.dev@gmail.com>
* Released under The MIT License (MIT) (see "license.md")
* Project located at <https://github.com/benblazak/ergodox-firmware>
* ------------------------------------------------------------------------- */
reorganization (large one) (mostly moving files)
2012-07-31 23:48:31 +02:00
#ifndef MAIN_h
#define MAIN_h
intermitent checkin; lots of stuff; i2c on hold; kb logic in progress
2012-03-27 12:06:52 +02:00
removed linked lists; changed KBFUN_FUNCTION_ARGS handling - linked lists need to be rewritten to be more memory efficient - all kbfun functions are now of type `(void kbfun_...(void))`, and the arguments they need are passed via a group of global `main_arg_...` variables (and other `main_...` variables)
2012-08-07 00:57:23 +02:00
#include <stdbool.h>
#include <stdint.h>
#include "./keyboard/matrix.h"
reorganization (large one) (mostly moving files)
2012-07-31 23:48:31 +02:00
removed linked lists; changed KBFUN_FUNCTION_ARGS handling - linked lists need to be rewritten to be more memory efficient - all kbfun functions are now of type `(void kbfun_...(void))`, and the arguments they need are passed via a group of global `main_arg_...` variables (and other `main_...` variables)
2012-08-07 00:57:23 +02:00
// --------------------------------------------------------------------
adding sticky key functionality This function gives similar behavior to sticky keys for modifiers available on most operating systems. It is considered an accessibility feature because it alleviates the user from having to hold down modifiers while pressing a key to produce the modified key function. It is useful for fast touch typing because you can avoid chording motions which both strain your hands and take your hands out of home-row position while pressing normal alpha keys. This function emulates the 3-state behavior which is default on OS X and optional in Windows where the modifier cycles between Off->Once->Locked states. This is particularly handy for symbol layers where you typically only type one symbol before you want to return to unmodified typing (layer 0), e.g. 'if (condition) { a = "b" + "c"; }'. If you assign a symbol layer to a thumb key as a layer sticky cycle, you can type the entire line of code without taking your hands out of home row position and you do not need to toggle off the layer after each symbol is pressed, only immediately before keying the symbol. The exact behavior of the layer sticky cycle function is defined as follows for each state: 1) One time down (set on key press) - The layer was not active and the key has been pressed but not yet released. The layer is pushed in the one time down state. 2) One time up (set on key release) - The layer was active when the layer sticky key was released. If a key on this layer (not set to transparent) was pressed before the key was released, the layer will be popped. If a non-transparent key was not pressed, the layer is popped and pushed again in the one time up state. 3) Locked (set on key press) - The layer was active and in the one time up state when the layer sticky key was pressed again. The layer will be popped if the function is invoked on a subsequent keypress.
2013-04-08 09:49:35 +02:00
typedef enum StickyState
{
eStickyNone,
eStickyOnceDown,
eStickyOnceUp,
eStickyLock
} StickyState;
removed linked lists; changed KBFUN_FUNCTION_ARGS handling - linked lists need to be rewritten to be more memory efficient - all kbfun functions are now of type `(void kbfun_...(void))`, and the arguments they need are passed via a group of global `main_arg_...` variables (and other `main_...` variables)
2012-08-07 00:57:23 +02:00
extern bool (*main_kb_is_pressed)[KB_ROWS][KB_COLUMNS];
extern bool (*main_kb_was_pressed)[KB_ROWS][KB_COLUMNS];
changed the way layers are handled note: NOT YET TESTED, only compiled
2012-11-30 21:06:41 +01:00
extern uint8_t main_layers_pressed[KB_ROWS][KB_COLUMNS];
removed linked lists; changed KBFUN_FUNCTION_ARGS handling - linked lists need to be rewritten to be more memory efficient - all kbfun functions are now of type `(void kbfun_...(void))`, and the arguments they need are passed via a group of global `main_arg_...` variables (and other `main_...` variables)
2012-08-07 00:57:23 +02:00
extern uint8_t main_loop_row;
extern uint8_t main_loop_col;
extern uint8_t main_arg_layer;
changed the way layers are handled note: NOT YET TESTED, only compiled
2012-11-30 21:06:41 +01:00
extern uint8_t main_arg_layer_offset;
removed linked lists; changed KBFUN_FUNCTION_ARGS handling - linked lists need to be rewritten to be more memory efficient - all kbfun functions are now of type `(void kbfun_...(void))`, and the arguments they need are passed via a group of global `main_arg_...` variables (and other `main_...` variables)
2012-08-07 00:57:23 +02:00
extern uint8_t main_arg_row;
extern uint8_t main_arg_col;
extern bool main_arg_is_pressed;
extern bool main_arg_was_pressed;
adding sticky key functionality This function gives similar behavior to sticky keys for modifiers available on most operating systems. It is considered an accessibility feature because it alleviates the user from having to hold down modifiers while pressing a key to produce the modified key function. It is useful for fast touch typing because you can avoid chording motions which both strain your hands and take your hands out of home-row position while pressing normal alpha keys. This function emulates the 3-state behavior which is default on OS X and optional in Windows where the modifier cycles between Off->Once->Locked states. This is particularly handy for symbol layers where you typically only type one symbol before you want to return to unmodified typing (layer 0), e.g. 'if (condition) { a = "b" + "c"; }'. If you assign a symbol layer to a thumb key as a layer sticky cycle, you can type the entire line of code without taking your hands out of home row position and you do not need to toggle off the layer after each symbol is pressed, only immediately before keying the symbol. The exact behavior of the layer sticky cycle function is defined as follows for each state: 1) One time down (set on key press) - The layer was not active and the key has been pressed but not yet released. The layer is pushed in the one time down state. 2) One time up (set on key release) - The layer was active when the layer sticky key was released. If a key on this layer (not set to transparent) was pressed before the key was released, the layer will be popped. If a non-transparent key was not pressed, the layer is popped and pushed again in the one time up state. 3) Locked (set on key press) - The layer was active and in the one time up state when the layer sticky key was pressed again. The layer will be popped if the function is invoked on a subsequent keypress.
2013-04-08 09:49:35 +02:00
extern bool main_arg_any_non_trans_key_pressed;
extern bool main_arg_trans_key_pressed;
removed linked lists; changed KBFUN_FUNCTION_ARGS handling - linked lists need to be rewritten to be more memory efficient - all kbfun functions are now of type `(void kbfun_...(void))`, and the arguments they need are passed via a group of global `main_arg_...` variables (and other `main_...` variables)
2012-08-07 00:57:23 +02:00
// --------------------------------------------------------------------
changed the way layers are handled note: NOT YET TESTED, only compiled
2012-11-30 21:06:41 +01:00
void main_exec_key (void);
uint8_t main_layers_peek (uint8_t offset);
adding sticky key functionality This function gives similar behavior to sticky keys for modifiers available on most operating systems. It is considered an accessibility feature because it alleviates the user from having to hold down modifiers while pressing a key to produce the modified key function. It is useful for fast touch typing because you can avoid chording motions which both strain your hands and take your hands out of home-row position while pressing normal alpha keys. This function emulates the 3-state behavior which is default on OS X and optional in Windows where the modifier cycles between Off->Once->Locked states. This is particularly handy for symbol layers where you typically only type one symbol before you want to return to unmodified typing (layer 0), e.g. 'if (condition) { a = "b" + "c"; }'. If you assign a symbol layer to a thumb key as a layer sticky cycle, you can type the entire line of code without taking your hands out of home row position and you do not need to toggle off the layer after each symbol is pressed, only immediately before keying the symbol. The exact behavior of the layer sticky cycle function is defined as follows for each state: 1) One time down (set on key press) - The layer was not active and the key has been pressed but not yet released. The layer is pushed in the one time down state. 2) One time up (set on key release) - The layer was active when the layer sticky key was released. If a key on this layer (not set to transparent) was pressed before the key was released, the layer will be popped. If a non-transparent key was not pressed, the layer is popped and pushed again in the one time up state. 3) Locked (set on key press) - The layer was active and in the one time up state when the layer sticky key was pressed again. The layer will be popped if the function is invoked on a subsequent keypress.
2013-04-08 09:49:35 +02:00
uint8_t main_layers_peek_sticky (uint8_t offset);
uint8_t main_layers_push (uint8_t layer, uint8_t sticky);
changed the way layers are handled note: NOT YET TESTED, only compiled
2012-11-30 21:06:41 +01:00
void main_layers_pop_id (uint8_t id);
uint8_t main_layers_get_offset_id (uint8_t id);
intermitent checkin; lots of stuff; i2c on hold; kb logic in progress
2012-03-27 12:06:52 +02:00
#endif