di0ib/keybrd
Archived
1
0
Fork 0
Code Releases Activity

rename StateLayers to LayerState

Browse Source
This commit is contained in:
wolfv6 2016-05-28 15:16:32 -06:00
parent f97ae6d23d
commit 0f511d5229
21 changed files with 91 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
doc/CHANGELOG.md
View File

@ -12,7 +12,7 @@ keybrd version 1.0.0 will be released when the public API is stable.
* Restructured the project directory to conform to Arduino library manager specifications
* Moved keybrd_DH library extension (for DodoHand) to its own repository
* Moved sketches to examples directory
* Replaced Key_Layered dependency on LayerManager with StateLayers class
* Replaced Key_Layered dependency on LayerManager with LayerState class
### Added
* Tutorials

16
doc/keybrd_library_developer_guide.md
View File

@ -34,9 +34,9 @@ Keybrd library class inheritance diagram
LED_AVR LED_MCP23018 LED_PCA9655E (one LED class for each type of IC)
StateLayersInterface
LayerStateInterface
|
StateLayers
LayerState
Key __
@ -81,7 +81,7 @@ single-layer dependency diagram with LEDs
multi-layer dependency diagram with LEDs and I/O Expander
```
matrix[1..*]
| stateLayers[1..*]
| layerStates[1..*]
row[1..*]_________________________________________/__ | \
| \ \ \ / \ | \
rowPort[1] rowPin[1] colPort[1] keys[1] / code_layer[1..*] LED[0..*]
@ -116,11 +116,11 @@ Example Code_Layer class names:
* Code_LayerHold
* Code_LayerLock
*StateLayer* class names start with "StateLayer" and end with a descriptive name.
Example StateLayer class names:
* StateLayer - basic StateLayer class in keybrd library
* StateLayer_DH - main StateLayer for the keybrd_DH library
* StateLayer_MF - StateLayer for Mouse Function sub-layers in the keybrd_DH library
*LayerState* class names start with "LayerState" and end with a descriptive name.
Example LayerState class names:
* LayerState - basic LayerState class in keybrd library
* LayerState_DH - main LayerState for the keybrd_DH library
* LayerState_MF - LayerState for Mouse Function sub-layers in the keybrd_DH library
*Code_Layered* class names start with "Code_Layered" and end with a descriptive name.
Example Code_Layered class names:

10
examples/keybrd_mapping_bb/keybrd_mapping_bb.ino
View File

@ -19,7 +19,7 @@ Uses the same variable naming convention as keybrd_DH.
#include <Code_ScS.h>
#include <Code_Shift.h>
#include <StateLayers.h>
#include <LayerState.h>
//#include <Code_LayerLock.h>
#include <Code_LayerHold.h>
@ -49,9 +49,9 @@ const uint8_t COL_PORT_L_COUNT = sizeof(ptrsColPorts_L)/sizeof(*ptrsColPorts_L);
// ================= CODES =====================
// -------------- LAYER CODES ------------------
StateLayers stateLayer;
//Code_LayerLock l_alpha(0, stateLayer);
Code_LayerHold l_fn(1, stateLayer);
LayerState layerState;
//Code_LayerLock l_alpha(0, layerState);
Code_LayerHold l_fn(1, layerState);
// --------------- SHIFT CODE ------------------
Code_Shift s_shift(MODIFIERKEY_LEFT_SHIFT);
@ -65,7 +65,7 @@ Code_Sc s_b(KEY_B);
Code_ScS s_exclamation(KEY_1);
Code_ScS s_at(KEY_2);
StateLayersInterface& Key_LayeredKeysArray::refStateLayers = stateLayer;
LayerStateInterface& Key_LayeredKeysArray::refLayerState = layerState;
// ============== LEFT MATRIX ==================
// --------------- LEFT KEYS -------------------

4
src/Code_LayerHold.cpp
View File

@ -2,10 +2,10 @@
void Code_LayerHold::press()
{
refStateLayers.hold(layer);
refLayerState.hold(layer);
}
void Code_LayerHold::release()
{
refStateLayers.unhold(layer);
refLayerState.unhold(layer);
}

10
src/Code_LayerHold.h
View File

@ -3,18 +3,18 @@
#include <inttypes.h>
#include <Code.h>
#include "StateLayers.h"
#include "LayerState.h"
/* Code_LayerHold calls StateLayers when pressed to change activeLayer.
/* Code_LayerHold calls LayerState when pressed to change activeLayer.
*/
class Code_LayerHold : public Code
{
private:
const uint8_t layer;
StateLayers& refStateLayers;
LayerState& refLayerState;
public:
Code_LayerHold(const uint8_t layer, StateLayers& refStateLayers)
: layer(layer), refStateLayers(refStateLayers) {}
Code_LayerHold(const uint8_t layer, LayerState& refLayerState)
: layer(layer), refLayerState(refLayerState) {}
virtual void press();
virtual void release();
};

2
src/Code_LayerLock.cpp
View File

@ -2,7 +2,7 @@
void Code_LayerLock::press()
{
refStateLayers.lock(layer);
refLayerState.lock(layer);
}
void Code_LayerLock::release()

10
src/Code_LayerLock.h
View File

@ -3,18 +3,18 @@
#include <inttypes.h>
#include <Code.h>
#include "StateLayers.h"
#include "LayerState.h"
/* Code_LayerLock calls StateLayers when pressed to change activeLayer.
/* Code_LayerLock calls LayerState when pressed to change activeLayer.
*/
class Code_LayerLock : public Code
{
private:
const uint8_t layer;
StateLayers& refStateLayers;
LayerState& refLayerState;
public:
Code_LayerLock(const uint8_t layer, StateLayers& refStateLayers)
: layer(layer), refStateLayers(refStateLayers) {}
Code_LayerLock(const uint8_t layer, LayerState& refLayerState)
: layer(layer), refLayerState(refLayerState) {}
virtual void press();
virtual void release();
};

2
src/Code_LayeredCodeSc.cpp
View File

@ -2,6 +2,6 @@
void Code_LayeredCodeSc::press()
{
layer = refStateLayers.getActiveLayer();
layer = refLayerState.getActiveLayer();
pressCode();
}

6
src/Code_LayeredCodeSc.h
View File

@ -3,18 +3,18 @@
#include <Arduino.h>
#include <inttypes.h>
#include <Code_LayeredCodeScBase.h>
#include <StateLayersInterface.h>
#include <LayerStateInterface.h>
/* Class Code_LayeredCodeSc is a 2-layer code, one object for each layer e.g.
layer0: ms_up //mouse up
layer1: KEY_UP //up arrow
When the key is pressed, the active layer is retrieved from refStateLayers,
When the key is pressed, the active layer is retrieved from refLayerState,
and the object for the active layer is sent to USB.
*/
class Code_LayeredCodeSc : public Code_LayeredCodeScBase
{
private:
static StateLayersInterface& refStateLayers;
static LayerStateInterface& refLayerState;
public:
Code_LayeredCodeSc(Code& refCode0, const uint16_t scancode1)
: Code_LayeredCodeScBase(refCode0, scancode1, 0) { }

2
src/Code_LayeredCodeScBase.h
View File

@ -7,7 +7,7 @@
/* Class Code_LayeredCodeScBase is a 2-layer code, one object for each layer e.g.
layer0: ms_up //mouse up
layer1: KEY_UP //up arrow
When the key is pressed, the active layer is retrieved from refStateLayers,
When the key is pressed, the active layer is retrieved from refLayerState,
and the object for the active layer is sent to USB.
*/
class Code_LayeredCodeScBase : public Code

2
src/Code_LayeredScSc.cpp
View File

@ -2,6 +2,6 @@
void Code_LayeredScSc::press()
{
layer = refStateLayers.getActiveLayer();
layer = refLayerState.getActiveLayer();
pressScancode();
}

6
src/Code_LayeredScSc.h
View File

@ -2,18 +2,18 @@
#define CODE_LAYEREDSCSC_H
#include <Arduino.h>
#include <inttypes.h>
#include <StateLayersInterface.h>
#include <LayerStateInterface.h>
#include <Code_LayeredScScBase.h>
/* Class Code_LayeredScSc is composed of two scancodes; "S" stands for Scancode.
layer is retreived from refStateLayers.
layer is retreived from refLayerState.
when layer=0, press sends scancode0
when layer=1, press sends scancode1
*/
class Code_LayeredScSc : public Code_LayeredScScBase
{
private:
static StateLayersInterface& refStateLayers;
static LayerStateInterface& refLayerState;
public:
Code_LayeredScSc(const uint16_t scancode0, const uint16_t scancode1)
: Code_LayeredScScBase(scancode0, scancode1) { }

2
src/Key_LayeredKeysArray.cpp
View File

@ -2,7 +2,7 @@
void Key_LayeredKeysArray::press()
{
layer = refStateLayers.getActiveLayer();
layer = refLayerState.getActiveLayer();
ptrsKeys[layer]->press();
}

6
src/Key_LayeredKeysArray.h
View File

@ -2,13 +2,13 @@
#define KEY_LAYEREDKEYSARRAY_H
#include <Arduino.h>
#include <inttypes.h>
#include <StateLayersInterface.h>
#include <LayerStateInterface.h>
#include <Key.h>
/* Class Key_LayeredKeysArray contains an array of Key pointers, one pointer per layer.
Codes are a kind of Key, so the Key pointers can point to Codes as well.
When the key is pressed, active layer is retreived from refStateLayers and
When the key is pressed, active layer is retreived from refLayerState and
the Key object of the active layer is called.
*/
class Key_LayeredKeysArray : public Key
@ -16,7 +16,7 @@ class Key_LayeredKeysArray : public Key
private:
Key *const *const ptrsKeys; //array of Key pointers, one Key per layer
uint8_t layer; //active layer when key was pressed
static StateLayersInterface& refStateLayers;
static LayerStateInterface& refLayerState;
public:
Key_LayeredKeysArray(Key *const ptrsKeys[]): ptrsKeys(ptrsKeys) {}
virtual void press();

12
src/StateLayers.cpp → src/LayerState.cpp
View File

@ -1,11 +1,11 @@
#include "StateLayers.h"
#include "LayerState.h"
void StateLayers::hold(const uint8_t layer)
void LayerState::hold(const uint8_t layer)
{
setActiveLayer(layer);
}
void StateLayers::unhold(const uint8_t layer)
void LayerState::unhold(const uint8_t layer)
{
if (layer == activeLayer);
{
@ -13,19 +13,19 @@ void StateLayers::unhold(const uint8_t layer)
}
}
void StateLayers::lock(const uint8_t layer)
void LayerState::lock(const uint8_t layer)
{
setActiveLayer(layer);
lockedLayer = layer;
}
//Derived classes override setActiveLayer() to also set LED indicator lights.
void StateLayers::setActiveLayer(const uint8_t layer)
void LayerState::setActiveLayer(const uint8_t layer)
{
activeLayer = layer;
}
uint8_t StateLayers::getActiveLayer()
uint8_t LayerState::getActiveLayer()
{
return activeLayer;
}

12
src/StateLayers.h → src/LayerState.h
View File

@ -2,20 +2,20 @@
#define LAYERSTATE_H
#include <inttypes.h>
#include <StateLayersInterface.h>
#include <LayerStateInterface.h>
/* basic StateLayers for keyboard.
When pressed, Code_Layer objects call StateLayers functions lock() or hold().
When pressed, Layered objects call StateLayers function getActiveLayer().
/* basic LayerState for keyboard.
When pressed, Code_Layer objects call LayerState functions lock() or hold().
When pressed, Layered objects call LayerState function getActiveLayer().
*/
class StateLayers : public StateLayersInterface
class LayerState : public LayerStateInterface
{
protected:
uint8_t activeLayer; //currently active layer
uint8_t lockedLayer; //most recently pressed lock layer
virtual void setActiveLayer(const uint8_t layer);
public:
StateLayers() : activeLayer(0), lockedLayer(0) {}
LayerState() : activeLayer(0), lockedLayer(0) {}
virtual void hold(uint8_t layer); //set activeLayer
virtual void unhold(const uint8_t layer); //restore activeLayer to lockedLayer
virtual void lock(uint8_t layer); //set activeLayer and lock it

11
src/LayerStateInterface.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef LAYERSTATEINTERFACE_H
#define LAYERSTATEINTERFACE_H
/* LayerStateInterface in an interface class
*/
class LayerStateInterface
{
public:
virtual uint8_t getActiveLayer()=0;
};
#endif

11
src/StateLayersInterface.h
View File

@ -1,11 +0,0 @@
#ifndef STATELAYERSINTERFACE_H
#define STATELAYERSINTERFACE_H
/* StateLayersInterface in an interface class
*/
class StateLayersInterface
{
public:
virtual uint8_t getActiveLayer()=0;
};
#endif

22
tutorials/keybrd_3a_multi-layer_annotated/keybrd_3a_multi-layer_annotated.ino
View File

@ -26,7 +26,7 @@ Holding the fn key down makes it the active layer. Releasing the fn key restore
//Codes
#include <Code_Sc.h>
#include <StateLayers.h>
#include <LayerState.h>
#include <Code_LayerHold.h>
#include <Key_LayeredKeysArray.h>
@ -57,15 +57,15 @@ enum assings Id numbers to the layers.
*/
enum layers { NORMAL, FN };
/*
stateLayer keeps track of the active layer. The default layer number is 0.
layerState keeps track of the active layer. The default layer number is 0.
*/
StateLayers stateLayer;
LayerState layerState;
/*
The Code_LayerHold constructor parameter specifies a layer Id number and a StateLayer.
When l_fn is pressed, it tells stateLayer to change the active layer to 1.
When l_fn is released, it tells stateLayer to restore the normal layer.
The Code_LayerHold constructor parameter specifies a layer Id number and a LayerState.
When l_fn is pressed, it tells layerState to change the active layer to 1.
When l_fn is released, it tells layerState to restore the normal layer.
*/
Code_LayerHold l_fn(FN, stateLayer);
Code_LayerHold l_fn(FN, layerState);
// ---------------- SCAN CODES -----------------
Code_Sc s_a(KEY_A);
@ -102,15 +102,15 @@ Key* const ptrsCodes_01[] = { &s_b, &s_2 };
Key_LayeredKeysArray k_01(ptrsCodes_01);
/*
Key_LayeredKeysArray has a static variable refStateLayers defined here.
It is a reference to stateLayer.
Key_LayeredKeysArray has a static variable refLayerState defined here.
It is a reference to layerState.
*/
StateLayersInterface& Key_LayeredKeysArray::refStateLayers = stateLayer;
LayerStateInterface& Key_LayeredKeysArray::refLayerState = layerState;
/*
HOW LAYERED OBJECTS WORK
When a Key_LayeredKeysArray object is pressed,
it gets the active layer from stateLayer and then sends the scancode for the active layer.
it gets the active layer from layerState and then sends the scancode for the active layer.
*/
// ------------------- ROWS --------------------

8
tutorials/keybrd_3b_autoShift_annotated/keybrd_3b_autoShift_annotated.ino
View File

@ -26,7 +26,7 @@ Holding the fn key down makes it the active layer. Releasing the fn key restore
#include <Code_Sc.h>
#include <Code_ScS.h>
#include <Code_Shift.h>
#include <StateLayers.h>
#include <LayerState.h>
#include <Code_LayerHold.h>
#include <Key_LayeredKeysArray.h>
@ -54,8 +54,8 @@ The CODES section instantiates six codes, one for each item in the layout:
// ---------------- LAYER CODE -----------------
enum layers { NORMAL, FN };
StateLayers stateLayer;
Code_LayerHold l_fn(FN, stateLayer);
LayerState layerState;
Code_LayerHold l_fn(FN, layerState);
// ---------------- SCAN CODES -----------------
/*
@ -115,7 +115,7 @@ Key_LayeredKeysArray k_00(ptrsCodes_00);
Key* const ptrsCodes_01[] = { &s_b, &s_at };
Key_LayeredKeysArray k_01(ptrsCodes_01);
StateLayersInterface& Key_LayeredKeysArray::refStateLayers = stateLayer;
LayerStateInterface& Key_LayeredKeysArray::refLayerState = layerState;
// ------------------- ROWS --------------------
Key* const ptrsKeys_0[] = { &k_00, &k_01 };

26
tutorials/tutorial_3a_multi-layer_keyboard.md
View File

@ -19,20 +19,20 @@ The following pseudo code has just enough detail to show how layer schemes work.
**Key_Layer** objects select the active layer.
The "layer" variable is a layer id number.
When a Key_Layer object is pressed, it tells StateLayer to update the active layer.
When a Key_Layer object is pressed, it tells LayerState to update the active layer.
```
class Key_Layer
{
int layer
StateLayer& refStateLayer
press() { refStateLayer.setActiveLayer(layer) }
LayerState& refLayerState
press() { refLayerState.setActiveLayer(layer) }
}
```
**StateLayer** objects keep track of the active layer.
A StateLayer's activeLayer is always up to date.
**LayerState** objects keep track of the active layer.
A LayerState's activeLayer is always up to date.
```
class StateLayer
class LayerState
{
int activeLayer
setActiveLayer(int layer) { activeLayer = layer }
@ -42,13 +42,13 @@ class StateLayer
**Key_Layered** objects contain multiple Key pointers, one Key pointer for each layer.
Layer ids are used like indexes to select the appropriate key.
When a Key_Layered object is pressed, it gets the active layer from StateLayer, and then sends the key of the active layer.
When a Key_Layered object is pressed, it gets the active layer from LayerState, and then sends the key of the active layer.
```
class Key_Layered
{
Key** ptrsKeys //array of Key pointers, one Key pointer per layer
StateLayer& refStateLayer
press() { layer = refStateLayer.getActiveLayer()
LayerState& refLayerState
press() { layer = refLayerState.getActiveLayer()
ptrsKeys[layer]->press() }
}
```
@ -63,7 +63,7 @@ Dependency diagram
|
v
+------------+
| StateLayer |
| LayerState |
+------------+
^
|
@ -81,8 +81,8 @@ Key_Layer classes include:
* Code_LayerHold
* Code_LayerLock
A basic StateLayer class is:
* StateLayer
A basic LayerState class is:
* LayerState
Key_Layered classes include:
* Code_LayeredScSc
@ -108,7 +108,7 @@ Example single-layer Code classes include:
## A simple multi-layer keybrd sketch
The [keybrd_3a_multi-layer_annotated.ino](keybrd_3a_multi-layer_annotated/keybrd_3a_multi-layer_annotated.ino)
sketch uses three layer-scheme classes:
* StateLayers
* LayerState
* Code_LayerHold
* Key_LayeredKeysArray