Remove references to FL (stub out missing methods)

1 files changed, 67 insertions, 80 deletions

diff --git a/scripts/lib/fontbuild/mix.py b/scripts/lib/fontbuild/mix.py
index 06c62dc..507a5dd 100644
--- a/scripts/lib/fontbuild/mix.py
+++ b/scripts/lib/fontbuild/mix.py
@@ -1,6 +1,9 @@
-from FL import *
 from numpy import array, append
 import copy
+from robofab.objects.objectsRF import RPoint
+from robofab.world import OpenFont
+from decomposeGlyph import decomposeGlyph
+
 
 class FFont:
     "Font wrapper for floating point operations"
@@ -17,24 +20,23 @@ class FFont:
             self.vstems = list(f.vstems)
         elif f != None:
             self.copyFromFont(f)
-        
-    def copyFromFont(self,f):
-        for g in f.glyphs:
+
+    def copyFromFont(self, f):
+        for g in f:
             self.glyphs[g.name] = FGlyph(g)
-        self.hstems = [s for s in f.stem_snap_h[0]]
-        self.vstems = [s for s in f.stem_snap_v[0]]
-    
-            
-    def copyToFont(self,f):
-        for g in f.glyphs:
+        self.hstems = [s for s in f.info.postscriptStemSnapH]
+        self.vstems = [s for s in f.info.postscriptStemSnapV]
+
+    def copyToFont(self, f):
+        for g in f:
             try:
                 gF = self.glyphs[g.name]
                 gF.copyToGlyph(g)
             except:
                 print "Copy to glyph failed for" + g.name
-        f.stem_snap_h[0] = self.hstems
-        f.stem_snap_v[0] = self.vstems
-        
+        f.info.postscriptStemSnapH = self.hstems
+        f.info.postscriptStemSnapV = self.vstems
+
     def getGlyph(self, gname):
         try:
             return self.glyphs[gname]
@@ -59,10 +61,10 @@ class FGlyph:
     "provides a temporary floating point compatible glyph data structure"
     
     def __init__(self, g=None):
-        self.nodes = []
+        self.contours = []
         self.width = 0.
         self.components = []
-        self.kerning = []
+#        self.kerning = []
         self.anchors = []
         if g != None:
             self.copyFromGlyph(g)
@@ -74,27 +76,27 @@ class FGlyph:
         self.width = len(valuesX)
         valuesX.append(g.width)
         for c in g.components:
-            self.components.append((len(valuesX),len(valuesY)))
-            valuesX.append(c.scale.x)
-            valuesY.append(c.scale.y)
-            valuesX.append(c.delta.x)
-            valuesY.append(c.delta.y)
-        
+            self.components.append((len(valuesX), len(valuesY)))
+            valuesX.append(c.scale[0])
+            valuesY.append(c.scale[1])
+            valuesX.append(c.offset[0])
+            valuesY.append(c.offset[1])
+
         for a in g.anchors:
             self.anchors.append((len(valuesX), len(valuesY)))
             valuesX.append(a.x)
             valuesY.append(a.y)
-                
-        for i in range(len(g.nodes)):
-            self.nodes.append([])
-            for j in range (len(g.nodes[i])):
-                self.nodes[i].append( (len(valuesX), len(valuesY)) )
-                valuesX.append(g.nodes[i][j].x)
-                valuesY.append(g.nodes[i][j].y)
-                
-        for k in g.kerning:
-            self.kerning.append(KerningPair(k))
-            
+
+        for i in range(len(g)):
+            self.contours.append([])
+            for j in range (len(g[i].points)):
+                self.contours[i].append((len(valuesX), len(valuesY)))
+                valuesX.append(g[i].points[j].x)
+                valuesY.append(g[i].points[j].y)
+
+#        for k in g.kerning:
+#            self.kerning.append(KerningPair(k))
+
         self.dataX = array(valuesX)
         self.dataY = array(valuesY)
         
@@ -102,24 +104,26 @@ class FGlyph:
         g.width = self._derefX(self.width)
         if len(g.components) == len(self.components):
             for i in range(len(self.components)):
-                g.components[i].scale.x = self._derefX( self.components[i][0] + 0)
-                g.components[i].scale.y = self._derefY( self.components[i][1] + 0)
-                g.components[i].deltas[0].x = self._derefX( self.components[i][0] + 1)
-                g.components[i].deltas[0].y = self._derefY( self.components[i][1] + 1)
-        g.kerning = []
+                g.components[i].scale[0] = self._derefX(self.components[i][0] + 0)
+                g.components[i].scale[1] = self._derefY(self.components[i][1] + 0)
+                g.components[i].offset[0] = self._derefX(self.components[i][0] + 1)
+                g.components[i].offset[1] = self._derefY(self.components[i][1] + 1)
+#        g.kerning = []
         if len(g.anchors) == len(self.anchors):
             for i in range(len(self.anchors)):
                 g.anchors[i].x = self._derefX( self.anchors[i][0])
                 g.anchors[i].y = self._derefY( self.anchors[i][1])
-        for k in self.kerning:
-            g.kerning.append(KerningPair(k))
-        for i in range( len(g.nodes)) :
-            for j in range (len(g.nodes[i])):
-                g.nodes[i][j].x = self._derefX( self.nodes[i][j][0] )
-                g.nodes[i][j].y = self._derefY( self.nodes[i][j][1] )
-    
-    def isCompatible(self,g):
-        return len(self.dataX) == len(g.dataX) and len(self.dataY) == len(g.dataY) and len(g.nodes) == len(self.nodes)
+#        for k in self.kerning:
+#            g.kerning.append(KerningPair(k))
+        for i in range(len(g)) :
+            for j in range (len(g[i].points)):
+                g[i].points[j].x = self._derefX(self.contours[i][j][0])
+                g[i].points[j].y = self._derefY(self.contours[i][j][1])
+
+    def isCompatible(self, g):
+        return (len(self.dataX) == len(g.dataX) and
+                len(self.dataY) == len(g.dataY) and
+                len(g.contours) == len(self.contours))
     
     def __add__(self,g):
         if self.isCompatible(g):
@@ -170,15 +174,15 @@ class FGlyph:
         
         gF.dataX += (g.dataX - gF.dataX) * v.x
         gF.dataY += (g.dataY - gF.dataY) * v.y
-        gF.kerning = interpolateKerns(self,g,v)
+#        gF.kerning = interpolateKerns(self, g, v)
         return gF
     
     def copy(self):
         ng = FGlyph()
-        ng.nodes = list(self.nodes)
+        ng.contours = list(self.contours)
         ng.width = self.width
         ng.components = list(self.components)
-        ng.kerning = list(self.kerning)
+#        ng.kerning = list(self.kerning)
         ng.anchors = list(self.anchors)
         ng.dataX = self.dataX.copy()
         ng.dataY = self.dataY.copy()
@@ -198,10 +202,9 @@ class FGlyph:
     
 
 class Master:
-    
-    
-    def __init__(self,font=None,v=0,ifont=None, kernlist=None, overlay=None):
-        if isinstance(font,FFont):
+
+    def __init__(self, font=None, v=0, kernlist=None, overlay=None):
+        if isinstance(font, FFont):
             self.font = None
             self.ffont = font
         elif isinstance(font,str):
@@ -210,10 +213,9 @@ class Master:
             self.font = font
         else:
             self.font = font
-            self.ifont = ifont
             self.ffont = FFont(font)
         if isinstance(v,float) or isinstance(v,int):
-            self.v = Point(v,v)
+            self.v = RPoint(v, v)
         else:
             self.v = v
         if kernlist != None:
@@ -226,34 +228,19 @@ class Master:
             #TODO implement class based kerning / external kerning file
     
     def openFont(self, path, overlayPath=None):
-        fl.Open(path,True)
-        self.ifont = fl.ifont
-        for g in fl.font.glyphs:
+        self.font = OpenFont(path)
+        for g in self.font:
           size = len(g)
           csize = len(g.components)
           if (size > 0 and csize > 0):
-            g.Decompose()
+            decomposeGlyph(g)
 
-        self.ifont = fl.ifont
-        self.font = fl.font
         if overlayPath != None:
-            fl.Open(overlayPath,True)
-            ifont = self.ifont
+            overlayFont = OpenFont(overlayPath)
             font = self.font
-            overlayIfont = fl.ifont
-            overlayFont = fl.font
+            for overlayGlyph in overlayFont:
+                font.insertGlyph(overlayGlyph)
 
-            for overlayGlyph in overlayFont.glyphs:
-                glyphIndex = font.FindGlyph(overlayGlyph.name)
-                if glyphIndex != -1:
-                    oldGlyph = Glyph(font.glyphs[glyphIndex])
-                    kernlist = [KerningPair(k) for k in oldGlyph.kerning]
-                    font.glyphs[glyphIndex] = Glyph(overlayGlyph)
-                    font.glyphs[glyphIndex].kerning = kernlist
-                else:
-                    font.glyphs.append(overlayGlyph)
-            fl.UpdateFont(ifont)
-            fl.Close(overlayIfont)
         self.ffont = FFont(self.font)
 
 
@@ -261,7 +248,7 @@ class Mix:
     def __init__(self,masters,v):
         self.masters = masters
         if isinstance(v,float) or isinstance(v,int):
-            self.v = Point(v,v)
+            self.v = RPoint(v,v)
         else:
             self.v = v
     
@@ -282,9 +269,9 @@ class Mix:
         return ffont
     
     def generateFont(self, baseFont):
-        newFont = Font(baseFont)
+        newFont = baseFont.copy()
         #self.mixStems(newFont)  todo _ fix stems code
-        for g in newFont.glyphs:
+        for g in newFont:
             gF = self.mixGlyphs(g.name)
             if gF == None:
                 g.mark = True
@@ -338,4 +325,4 @@ def interpolateKerns(gA,gB,v):
         if matchedKern != None:
             kernValue = interpolate(kA.value, matchedKern.value, v.x)
             kerns.append(KerningPair(kA.key,kernValue))
-    return kerns
\ No newline at end of file
+    return kerns