Adding full partial layer support.

[kiibohd-kll.git] / kll_lib / containers.py

diff --git a/kll_lib/containers.py b/kll_lib/containers.py
index 5bf9e70c9c771c78408aff146aa41c306b4f67aa..d54ff1029e8d7e3a5b5c8a244ba59c93056c0d44 100644 (file)
--- a/kll_lib/containers.py
+++ b/kll_lib/containers.py
@@ -18,6 +18,8 @@
 
 ### Imports ###
 
+import copy
+
 
 
 ### Decorators ###
@@ -86,6 +88,10 @@ class Macros:
                # Macro Storage
                self.macros = [ dict() ]
 
+               # Base Layout Storage
+               self.baseLayout = None
+               self.layerLayoutMarkers = []
+
                # Correlated Macro Data
                self.resultsIndex = dict()
                self.triggersIndex = dict()
@@ -100,10 +106,23 @@ class Macros:
        def __repr__( self ):
                return "{0}".format( self.macros )
 
+       def completeBaseLayout( self ):
+               # Copy base layout for later use when creating partial layers and add marker
+               self.baseLayout = copy.deepcopy( self.macros[ 0 ] )
+               self.layerLayoutMarkers.append( copy.deepcopy( self.baseLayout ) ) # Not used for default layer, just simplifies coding
+
+       def removeUnmarked( self ):
+               # Remove all of the unmarked mappings from the partial layer
+               for trigger in self.layerLayoutMarkers[ self.layer ].keys():
+                       del self.macros[ self.layer ][ trigger ]
+
        def addLayer( self ):
                # Increment layer count, and append another macros dictionary
                self.layer += 1
-               self.macros.append( dict() )
+               self.macros.append( copy.deepcopy( self.baseLayout ) )
+
+               # Add a layout marker for each layer
+               self.layerLayoutMarkers.append( copy.deepcopy( self.baseLayout ) )
 
        # Use for ScanCode trigger macros
        def appendScanCode( self, trigger, result ):
@@ -123,6 +142,10 @@ class Macros:
        def replaceScanCode( self, trigger, result ):
                self.macros[ self.layer ][ trigger ] = [ result ]
 
+               # Mark layer scan code, so it won't be removed later
+               if not self.baseLayout is None:
+                       del self.layerLayoutMarkers[ self.layer ][ trigger ]
+
        # Return a list of ScanCode triggers with the given USB Code trigger
        def lookupUSBCodes( self, usbCode ):
                scanCodeList = []
@@ -200,24 +223,31 @@ class Macros:
                        self.triggerList.append( [ [] ] * 0xFF )
                        self.maxScanCode.append( 0x00 )
 
-                       # Iterate through triggersIndex to locate necessary ScanCodes and corresponding triggerIndex
-                       for triggerItem in self.triggersIndex.keys():
-                               # Iterate over the trigger portion of the triggerItem (other part is the index)
-                               for sequence in triggerItem[ 0 ]:
-                                       for combo in sequence:
-                                               # Append triggerIndex for each found scanCode of the Trigger List
-                                               # Do not re-add if triggerIndex is already in the Trigger List
-                                               if not triggerItem[1] in self.triggerList[ layer ][ combo ]:
-                                                       # Append is working strangely with list pre-initialization
-                                                       # Doing a 0 check replacement instead -HaaTa
-                                                       if len( self.triggerList[ layer ][ combo ] ) == 0:
-                                                               self.triggerList[ layer ][ combo ] = [ triggerItem[ 1 ] ]
-                                                       else:
-                                                               self.triggerList[ layer ][ combo ].append( triggerItem[1] )
-
-                                               # Look for max Scan Code
-                                               if combo > self.maxScanCode[ layer ]:
-                                                       self.maxScanCode[ layer ] = combo
+                       # Iterate through trigger macros to locate necessary ScanCodes and corresponding triggerIndex
+                       for trigger in self.macros[ layer ].keys():
+                               for variant in range( 0, len( self.macros[ layer ][ trigger ] ) ):
+                                       # Identify result index
+                                       resultIndex = self.resultsIndex[ self.macros[ layer ][ trigger ][ variant ] ]
+
+                                       # Identify trigger index
+                                       triggerIndex = self.triggersIndex[ tuple( [ trigger, resultIndex ] ) ]
+
+                                       # Iterate over the trigger to locate the ScanCodes
+                                       for sequence in trigger:
+                                               for combo in sequence:
+                                                       # Append triggerIndex for each found scanCode of the Trigger List
+                                                       # Do not re-add if triggerIndex is already in the Trigger List
+                                                       if not triggerIndex in self.triggerList[ layer ][ combo ]:
+                                                               # Append is working strangely with list pre-initialization
+                                                               # Doing a 0 check replacement instead -HaaTa
+                                                               if len( self.triggerList[ layer ][ combo ] ) == 0:
+                                                                       self.triggerList[ layer ][ combo ] = [ triggerIndex ]
+                                                               else:
+                                                                       self.triggerList[ layer ][ combo ].append( triggerIndex )
+
+                                                       # Look for max Scan Code
+                                                       if combo > self.maxScanCode[ layer ]:
+                                                               self.maxScanCode[ layer ] = combo
 
                        # Shrink triggerList to actual max size
                        self.triggerList[ layer ] = self.triggerList[ layer ][ : self.maxScanCode[ layer ] + 1 ]