rename Key_LayeredKeysArray to Key_LayeredKeys

doc/keybrd_library_developer_guide.md

@@ -53,7 +53,7 @@ Keybrd library class inheritance diagram
 	Key
 	 |____
 	 |    \
-	 |   Key_LayeredKeysArray
+	 |   Key_LayeredKeys
 	 |
 	 |___________________________
 	 |     \                     \
@@ -162,7 +162,7 @@ Example LayerState class names:
 *Key_Layered* class names start with "Key_Layered" and end with a descriptive name.
 Example Key_Layered class names:
 * Key_LayeredScSc
-* Key_LayeredKeysArray
+* Key_LayeredKeys
 
 Style guide
 -----------

src/Key_LayeredKeys.cpp

@@ -0,0 +1,13 @@
+#include "Key_LayeredKeys.h"
+
+void Key_LayeredKeys::press()
+{
+    layer = refLayerState.getActiveLayer();
+
+    ptrsKeys[layer]->press();
+}
+
+void Key_LayeredKeys::release()
+{
+    ptrsKeys[layer]->release();
+}

src/Key_LayeredKeys.h

@@ -1,24 +1,24 @@
-#ifndef KEY_LAYEREDKEYSARRAY_H
-#define KEY_LAYEREDKEYSARRAY_H
+#ifndef KEY_LAYEREDKEYS_H
+#define KEY_LAYEREDKEYS_H
 #include <Arduino.h>
 #include <inttypes.h>
 #include <LayerStateInterface.h>
 #include <Key.h>
 
-/* Class Key_LayeredKeysArray contains an array of Key pointers, one pointer per layer.
+/* Class Key_LayeredKeys contains an array of Key pointers, one pointer per layer.
 Codes are a kind of Key, so the Key pointers can point to Codes or Keys.
 
 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
+class Key_LayeredKeys : 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 LayerStateInterface& refLayerState;
     public:
-        Key_LayeredKeysArray(Key* const ptrsKeys[]): ptrsKeys(ptrsKeys) {}
+        Key_LayeredKeys(Key* const ptrsKeys[]): ptrsKeys(ptrsKeys) {}
         virtual void press();
         virtual void release();
 };

src/Key_LayeredKeysArray.cpp

@@ -1,13 +0,0 @@
-#include "Key_LayeredKeysArray.h"
-
-void Key_LayeredKeysArray::press()
-{
-    layer = refLayerState.getActiveLayer();
-
-    ptrsKeys[layer]->press();
-}
-
-void Key_LayeredKeysArray::release()
-{
-    ptrsKeys[layer]->release();
-}

tutorials/keybrd_3a_multi-layer/keybrd_3a_multi-layer.ino

@@ -20,7 +20,7 @@ Holding the fn key down makes it the active layer.  Releasing the fn key restore
 #include <Code_Sc.h>
 #include <LayerState.h>
 #include <Code_LayerHold.h>
-#include <Key_LayeredKeysArray.h>
+#include <Key_LayeredKeys.h>
 
 //Matrix
 #include <Row.h>
@@ -67,23 +67,23 @@ Code_Sc s_shift(MODIFIERKEY_LEFT_SHIFT);
 
 /* =================== KEYS ====================
 Here we pack Codes into keys.
-The Key_LayeredKeysArray constructor takes one array of Code pointers - one Code object per layer.
+The Key_LayeredKeys constructor takes one array of Code pointers - one Code object per layer.
 
 The Key object names in this sketch start with a "k_" followed by row-column coordinates.
 */
 Key* const ptrsCodes_01[] = { &s_a, &s_1 };
-Key_LayeredKeysArray k_01(ptrsCodes_01);
+Key_LayeredKeys k_01(ptrsCodes_01);
 
 Key* const ptrsCodes_11[] = { &s_b, &s_2 };
-Key_LayeredKeysArray k_11(ptrsCodes_11);
+Key_LayeredKeys k_11(ptrsCodes_11);
 
-/* Key_LayeredKeysArray has a reference to layerState.
-Thus Key_LayeredKeysArray can call layerState to get the active layer id.
+/* Key_LayeredKeys has a reference to layerState.
+Thus Key_LayeredKeys can call layerState to get the active layer id.
 */
-LayerStateInterface& Key_LayeredKeysArray::refLayerState = layerState;
+LayerStateInterface& Key_LayeredKeys::refLayerState = layerState;
 
 /* HOW LAYERED OBJECTS WORK
-When a Key_LayeredKeysArray object is pressed, it gets the active layer id from layerState.
+When a Key_LayeredKeys object is pressed, it gets the active layer id from layerState.
 It then uses the layer id as an array index to call the Code of the active layer.
 The Code object then sends its scancode over USB.
 */

tutorials/keybrd_3b_autoShift/keybrd_3b_autoShift.ino

@@ -22,7 +22,7 @@ Holding the fn key down makes it the active layer.  Releasing the fn key restore
 #include <Code_Shift.h>
 #include <LayerState.h>
 #include <Code_LayerHold.h>
-#include <Key_LayeredKeysArray.h>
+#include <Key_LayeredKeys.h>
 
 //Matrix
 #include <Row_uC.h>
@@ -92,12 +92,12 @@ When the user presses '!' or '@' on the fn layer:
 
 // =================== KEYS ====================
 Key* const ptrsCodes_01[] = { &s_a, &s_exclamation };
-Key_LayeredKeysArray k_01(ptrsCodes_01);
+Key_LayeredKeys k_01(ptrsCodes_01);
 
 Key* const ptrsCodes_11[] = { &s_b, &s_at };
-Key_LayeredKeysArray k_11(ptrsCodes_11);
+Key_LayeredKeys k_11(ptrsCodes_11);
 
-LayerStateInterface& Key_LayeredKeysArray::refLayerState = layerState;
+LayerStateInterface& Key_LayeredKeys::refLayerState = layerState;
 
 // =================== ROWS ====================
 Key* const ptrsKeys_0[] = { &s_shift, &k_01 };

tutorials/keybrd_5_LEDs/keybrd_5_LEDs.ino

@@ -17,7 +17,7 @@ This sketch:
 #include <Code_LEDLock.h>
 #include <LayerState_LED.h>
 #include <Code_LayerHold.h>
-#include <Key_LayeredKeysArray.h>
+#include <Key_LayeredKeys.h>
 
 #include <Row_uC.h>
 #include <ScanDelay.h>
@@ -73,12 +73,12 @@ Code_Sc s_2(KEY_2);
 
 // =================== KEYS ====================
 Key* const ptrsCodes_01[] = { &s_a, &s_1 };
-Key_LayeredKeysArray k_01(ptrsCodes_01);
+Key_LayeredKeys k_01(ptrsCodes_01);
 
 Key* const ptrsCodes_11[] = { &s_b, &s_2 };
-Key_LayeredKeysArray k_11(ptrsCodes_11);
+Key_LayeredKeys k_11(ptrsCodes_11);
 
-LayerStateInterface& Key_LayeredKeysArray::refLayerState = layerState;
+LayerStateInterface& Key_LayeredKeys::refLayerState = layerState;
 
 // =================== ROWS ====================
 Key* const ptrsKeys_0[] = { &o_capsLock, &k_01 };

tutorials/tutorial_3a_multi-layer_keyboard.md

@@ -26,7 +26,7 @@ The sketch annotations explain how multi-layer keyboards work.
 The sketch uses three layer-scheme classes:
 * LayerState
 * Code_LayerHold
-* Key_LayeredKeysArray
+* Key_LayeredKeys
 
 The internal workings of these three classes are revealed in the next section.
 
@@ -58,11 +58,11 @@ class LayerState
 };
 ```
 
-**Key_LayeredKeysArray** objects contain an array of keys, one key for each layer.
-Key_LayeredKeysArray objects use layer ids as Key_LayeredKeysArray indexes.
-When a Key_LayeredKeysArray object is pressed, it gets the active layer from LayerState, and sends the corresponding key.
+**Key_LayeredKeys** objects contain an array of keys, one key for each layer.
+Key_LayeredKeys objects use layer ids as Key_LayeredKeys indexes.
+When a Key_LayeredKeys object is pressed, it gets the active layer from LayerState, and sends the corresponding key.
 ```
-class Key_LayeredKeysArray
+class Key_LayeredKeys
 {
     Key** ptrsKeys;         //array of Key pointers, one Key pointer per layer
     LayerState& refLayerState;
@@ -88,7 +88,7 @@ Dependency diagram
                |getActiveLayer()
                |
     +----------------------+
-    | Key_LayeredKeysArray |
+    | Key_LayeredKeys |
     +----------------------+
 ```
 Layer-scheme classes
@@ -104,7 +104,7 @@ A basic LayerState class is:
 * LayerState
 
 Key_Layered classes include:
-* Key_LayeredKeysArray
+* Key_LayeredKeys
 * Key_LayeredScSc
 * Key_LayeredCodeSc