Code coverage report for fontkit/src/layout/KernProcessor.coffee

Statements: 65.96% (31 / 47)      Branches: 52% (13 / 25)      Functions: 100% (4 / 4)      Lines: 78.38% (29 / 37)      Ignored: none     

All files » fontkit/src/layout/ » KernProcessor.coffee
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 671   2     3 15   12 12 12     12   12 24 24       24       24 24 24     12 8196         12 10   2   12 10   2   12 12                     24     24   12   1  
class KernProcessor
  constructor: (@font) ->
    @kern = @font.kern
    
  process: (glyphs, positions) ->
    for glyph, glyphIndex in glyphs
      break if glyphIndex + 1 >= glyphs.length
      
      left = glyphs[glyphIndex].id
      right = glyphs[glyphIndex + 1].id
      positions[glyphIndex].xAdvance += @getKerning(left, right)
      
  getKerning: (left, right) ->
    res = 0
    
    for table in @kern.tables
      Icontinue if table.coverage.crossStream
      switch table.version
        when 0
          continue unless table.coverage.horizontal
        when 1
          Icontinue if table.coverage.vertical or table.coverage.variation
        else
          throw new Error "Unsupported kerning table version #{table.version}"
      
      val = 0
      s = table.subtable
      switch table.format
        when 0
          # TODO: binary search
          for pair in s.pairs
            Iif pair.left is left and pair.right is right
              val = pair.value
              break
              
        when 2
          if left >= s.leftTable.firstGlyph and left < s.leftTable.firstGlyph + s.leftTable.nGlyphs
            leftOffset = s.leftTable.offsets[left - s.leftTable.firstGlyph]
          else
            leftOffset = s.array.off
          
          if right >= s.rightTable.firstGlyph and right < s.rightTable.firstGlyph + s.rightTable.nGlyphs
            rightOffset = s.rightTable.offsets[right - s.rightTable.firstGlyph]
          else
            rightOffset = 0
            
          index = (leftOffset + rightOffset - s.array.off) / 2
          val = s.array.values.get(index)
              
        when 3
          return 0 if left >= s.glyphCount or right >= s.glyphCount
          val = s.kernValue[s.kernIndex[s.leftClass[left] * s.rightClassCount + s.rightClass[right]]]
              
        else
          throw new Error "Unsupported kerning sub-table format #{table.format}"
          
      # Microsoft supports the override flag, which resets the result
      # Otherwise, the sum of the results from all subtables is returned
      Iif table.coverage.override
        res = val
      else
        res += val
          
    return res
    
module.exports = KernProcessor