-/* Copyright (C) 2014 by Jacob Alexander
+/* Copyright (C) 2014-2015 by Jacob Alexander
*
* This file is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
uint16_t macroStepCounter = 0;
-// Key Trigger List Buffer
+// Key Trigger List Buffer and Layer Cache
+// The layer cache is set on press only, hold and release events refer to the value set on press
TriggerGuide macroTriggerListBuffer[ MaxScanCode ];
uint8_t macroTriggerListBufferSize = 0;
+var_uint_t macroTriggerListLayerCache[ MaxScanCode ];
// Pending Trigger Macro Index List
// * Any trigger macros that need processing from a previous macro processing loop
// Sets the given layer with the specified layerState
void Macro_layerState( uint8_t state, uint8_t stateType, uint16_t layer, uint8_t layerState )
{
+ // Ignore if layer does not exist
+ if ( layer >= LayerNum )
+ return;
+
// Is layer in the LayerIndexStack?
uint8_t inLayerIndexStack = 0;
uint16_t stackItem = 0;
// Only use capability on press
// TODO Analog
- // XXX To make sense, this code be on press or release. Or it could even be a sticky shift (why? dunno) -HaaTa
- if ( stateType == 0x00 && state != 0x01 ) // All normal key conditions except press
+ if ( stateType == 0x00 && state != 0x03 ) // Only on release
return;
// Get layer index from arguments
// Looks up the trigger list for the given scan code (from the active layer)
// NOTE: Calling function must handle the NULL pointer case
-nat_ptr_t *Macro_layerLookup( uint8_t scanCode )
+nat_ptr_t *Macro_layerLookup( TriggerGuide *guide, uint8_t latch_expire )
{
+ uint8_t scanCode = guide->scanCode;
+
+ // TODO Analog
+ // If a normal key, and not pressed, do a layer cache lookup
+ if ( guide->type == 0x00 && guide->state != 0x01 )
+ {
+ // Cached layer
+ var_uint_t cachedLayer = macroTriggerListLayerCache[ scanCode ];
+
+ // Lookup map, then layer
+ nat_ptr_t **map = (nat_ptr_t**)LayerIndex[ cachedLayer ].triggerMap;
+ const Layer *layer = &LayerIndex[ cachedLayer ];
+
+ return map[ scanCode - layer->first ];
+ }
+
// If no trigger macro is defined at the given layer, fallthrough to the next layer
for ( uint16_t layerIndex = 0; layerIndex < macroLayerIndexStackSize; layerIndex++ )
{
// Check if latch has been pressed for this layer
// XXX Regardless of whether a key is found, the latch is removed on first lookup
- uint8_t latch = LayerState[ layerIndex ] & 0x02;
- if ( latch )
+ uint8_t latch = LayerState[ macroLayerIndexStack[ layerIndex ] ] & 0x02;
+ if ( latch && latch_expire )
{
- LayerState[ layerIndex ] &= ~0x02;
+ Macro_layerState( 0, 0, macroLayerIndexStack[ layerIndex ], 0x02 );
}
// Only use layer, if state is valid
&& scanCode >= layer->first
&& *map[ scanCode - layer->first ] != 0 )
{
+ // Set the layer cache
+ macroTriggerListLayerCache[ scanCode ] = macroLayerIndexStack[ layerIndex ];
+
return map[ scanCode - layer->first ];
}
}
&& scanCode >= layer->first
&& *map[ scanCode - layer->first ] != 0 )
{
+ // Set the layer cache to default map
+ macroTriggerListLayerCache[ scanCode ] = 0;
+
return map[ scanCode - layer->first ];
}
}
+// Update the scancode using a list of TriggerGuides
+// TODO Handle led state and analog
+inline void Macro_triggerState( void *triggers, uint8_t num )
+{
+ // Copy each of the TriggerGuides to the TriggerListBuffer
+ for ( uint8_t c = 0; c < num; c++ )
+ macroTriggerListBuffer[ macroTriggerListBufferSize++ ] = ((TriggerGuide*)triggers)[ c ];
+}
+
+
// Update the scancode key state
// States:
// * 0x00 - Off
// Evaluate/Update TriggerMacro
-inline TriggerMacroEval Macro_evalTriggerMacro( var_uint_t triggerMacroIndex )
+TriggerMacroEval Macro_evalTriggerMacro( var_uint_t triggerMacroIndex )
{
// Lookup TriggerMacro
const TriggerMacro *macro = &TriggerMacroList[ triggerMacroIndex ];
if ( macroTriggerListBuffer[ key ].state == 0x00 && macroTriggerListBuffer[ key ].state != 0x01 )
continue;
+ // TODO Analog
+ // If this is a release case, indicate to layer lookup for possible latch expiry
+ uint8_t latch_expire = macroTriggerListBuffer[ key ].state == 0x03;
+
// Lookup Trigger List
- nat_ptr_t *triggerList = Macro_layerLookup( macroTriggerListBuffer[ key ].scanCode );
+ nat_ptr_t *triggerList = Macro_layerLookup( ¯oTriggerListBuffer[ key ], latch_expire );
// Number of Triggers in list
nat_ptr_t triggerListSize = triggerList[0];
void cliFunc_capList( char* args )
{
print( NL );
- info_msg("Capabilities List");
+ info_msg("Capabilities List ");
printHex( CapabilitiesNum );
// Iterate through all of the capabilities and display them