]> git.donarmstrong.com Git - kiibohd-kll.git/blobdiff - backends/kiibohd.py
Adding backend specific template and output defaults.
[kiibohd-kll.git] / backends / kiibohd.py
index 19168a256cc7046dd5f72867a4e8e274a72a3013..ca1f4fbb926a8d54fda481e9c9467645ea69aa1d 100644 (file)
@@ -30,44 +30,15 @@ from datetime import date
 sys.path.append( os.path.expanduser('..') )
 
 from kll_lib.containers import *
-
-
-### Decorators ###
-
- ## Print Decorator Variables
-ERROR = '\033[5;1;31mERROR\033[0m:'
-WARNING = '\033[5;1;33mWARNING\033[0m:'
-
+from kll_lib.backends import *
 
 
 ### Classes ###
 
-class Backend:
-       # Initializes backend
-       # Looks for template file and builds list of fill tags
-       def __init__( self, templatePath, definesTemplatePath ):
-               # Does template exist?
-               if not os.path.isfile( templatePath ):
-                       print ( "{0} '{1}' does not exist...".format( ERROR, templatePath ) )
-                       sys.exit( 1 )
-
-               self.definesTemplatePath = definesTemplatePath
-               self.templatePath = templatePath
-               self.fill_dict = dict()
-
-               # Generate list of fill tags
-               self.tagList = []
-               with open( templatePath, 'r' ) as openFile:
-                       for line in openFile:
-                               match = re.findall( '<\|([^|>]+)\|>', line )
-                               for item in match:
-                                       self.tagList.append( item )
-               with open( definesTemplatePath, 'r' ) as openFile:
-                       for line in openFile:
-                               match = re.findall( '<\|([^|>]+)\|>', line )
-                               for item in match:
-                                       self.tagList.append( item )
-
+class Backend( BackendBase ):
+       # Default templates and output files
+       templatePaths = ["templates/kiibohdKeymap.h", "templates/kiibohdDefs.h"]
+       outputPaths = ["generatedKeymap.h", "kll_defs.h"]
 
        # USB Code Capability Name
        def usbCodeCapability( self ):
@@ -100,8 +71,24 @@ class Backend:
                else:
                        gitChangesStr = "    None\n"
 
+               # Prepare BaseLayout and Layer Info
+               baseLayoutInfo = ""
+               defaultLayerInfo = ""
+               partialLayersInfo = ""
+               for file, name in zip( variables.baseLayout['*LayerFiles'], variables.baseLayout['*NameStack'] ):
+                       baseLayoutInfo += "//    {0}\n//      {1}\n".format( name, file )
+               if '*LayerFiles' in variables.layerVariables[0].keys():
+                       for file, name in zip( variables.layerVariables[0]['*LayerFiles'], variables.layerVariables[0]['*NameStack'] ):
+                               defaultLayerInfo += "//    {0}\n//      {1}\n".format( name, file )
+               if '*LayerFiles' in variables.layerVariables[1].keys():
+                       for layer in range( 1, len( variables.layerVariables ) ):
+                               partialLayersInfo += "//    Layer {0}\n".format( layer )
+                               if len( variables.layerVariables[ layer ]['*LayerFiles'] ) > 0:
+                                       for file, name in zip( variables.layerVariables[ layer ]['*LayerFiles'], variables.layerVariables[ layer ]['*NameStack'] ):
+                                               partialLayersInfo += "//     {0}\n//       {1}\n".format( name, file )
+
+
                ## Information ##
-               # TODO
                self.fill_dict['Information']  = "// This file was generated by the kll compiler, DO NOT EDIT.\n"
                self.fill_dict['Information'] += "// Generation Date:    {0}\n".format( date.today() )
                self.fill_dict['Information'] += "// KLL Backend:        {0}\n".format( "kiibohd" )
@@ -109,9 +96,9 @@ class Backend:
                self.fill_dict['Information'] += "// KLL Git Changes:{0}".format( gitChangesStr )
                self.fill_dict['Information'] += "// Compiler arguments:\n{0}".format( compilerArgs )
                self.fill_dict['Information'] += "//\n"
-               self.fill_dict['Information'] += "// - Base Layer -\n"
-               self.fill_dict['Information'] += "// - Default Layer -\n"
-               self.fill_dict['Information'] += "// - Partial Layers -\n"
+               self.fill_dict['Information'] += "// - Base Layer -\n{0}".format( baseLayoutInfo )
+               self.fill_dict['Information'] += "// - Default Layer -\n{0}".format( defaultLayerInfo )
+               self.fill_dict['Information'] += "// - Partial Layers -\n{0}".format( partialLayersInfo )
 
 
                ## Variable Information ##
@@ -173,7 +160,7 @@ class Backend:
 
                                        # Add each of the arguments of the capability
                                        for arg in range( 0, len( resultItem[1] ) ):
-                                               self.fill_dict['ResultMacros'] += "0x{0:02X}, ".format( resultItem[1][ arg ] )
+                                               self.fill_dict['ResultMacros'] += "{0}, ".format( resultItem[1][ arg ] )
 
                        # If sequence is longer than 1, append a sequence spacer at the end of the sequence
                        # Required by USB to end at sequence without holding the key down
@@ -304,52 +291,21 @@ class Backend:
                        # Lookup first scancode in map
                        firstScanCode = macros.firstScanCode[ layer ]
 
+                       # Generate stacked name
+                       stackName = ""
+                       if '*NameStack' in variables.layerVariables[ layer ].keys():
+                               for name in range( 0, len( variables.layerVariables[ layer ]['*NameStack'] ) ):
+                                       stackName += "{0} + ".format( variables.layerVariables[ layer ]['*NameStack'][ name ] )
+                               stackName = stackName[:-3]
+
                        # Default map is a special case, always the first index
-                       # TODO Fix names
                        if layer == 0:
-                               self.fill_dict['LayerIndexList'] += '\tLayer_IN( default_scanMap, "DefaultMap", 0x{0:02X} ),\n'.format( firstScanCode )
+                               self.fill_dict['LayerIndexList'] += '\tLayer_IN( default_scanMap, "D: {1}", 0x{0:02X} ),\n'.format( firstScanCode, stackName )
                        else:
-                               self.fill_dict['LayerIndexList'] += '\tLayer_IN( layer{0}_scanMap, "Layer {0}", 0x{1:02X} ),\n'.format( layer, firstScanCode )
+                               self.fill_dict['LayerIndexList'] += '\tLayer_IN( layer{0}_scanMap, "{0}: {2}", 0x{1:02X} ),\n'.format( layer, firstScanCode, stackName )
                self.fill_dict['LayerIndexList'] += "};"
 
 
                ## Layer State ##
                self.fill_dict['LayerState'] = "uint8_t LayerState[ LayerNum ];"
 
-
-       # Generates the output keymap with fill tags filled
-       def generate( self, outputPath, definesOutputPath ):
-               # Process each line of the template, outputting to the target path
-               with open( outputPath, 'w' ) as outputFile:
-                       with open( self.templatePath, 'r' ) as templateFile:
-                               for line in templateFile:
-                                       # TODO Support multiple replacements per line
-                                       # TODO Support replacement with other text inline
-                                       match = re.findall( '<\|([^|>]+)\|>', line )
-
-                                       # If match, replace with processed variable
-                                       if match:
-                                               outputFile.write( self.fill_dict[ match[ 0 ] ] )
-                                               outputFile.write("\n")
-
-                                       # Otherwise, just append template to output file
-                                       else:
-                                               outputFile.write( line )
-
-               # Process each line of the defines template, outputting to the target path
-               with open( definesOutputPath, 'w' ) as outputFile:
-                       with open( self.definesTemplatePath, 'r' ) as templateFile:
-                               for line in templateFile:
-                                       # TODO Support multiple replacements per line
-                                       # TODO Support replacement with other text inline
-                                       match = re.findall( '<\|([^|>]+)\|>', line )
-
-                                       # If match, replace with processed variable
-                                       if match:
-                                               outputFile.write( self.fill_dict[ match[ 0 ] ] )
-                                               outputFile.write("\n")
-
-                                       # Otherwise, just append template to output file
-                                       else:
-                                               outputFile.write( line )
-