Changeset 171

Timestamp:

02/28/09 09:47:24 (3 years ago)

Author:

tal

Message:

Merged ufo2 branch r95:170 into the trunk.

Files:

• trunk/Data/frequency.txt (deleted)
• trunk/Lib/robofab/__init__.py (modified) (1 diff)
• trunk/Lib/robofab/objects/family.py (deleted)
• trunk/Lib/robofab/objects/featureLib.py (deleted)
• trunk/Lib/robofab/objects/objectsBase.py (modified) (39 diffs)
• trunk/Lib/robofab/objects/objectsFL.py (modified) (15 diffs)
• trunk/Lib/robofab/objects/objectsRF.py (modified) (11 diffs)
• trunk/Lib/robofab/test/runAll.py (modified) (1 diff)
• trunk/Lib/robofab/test/testSupport.py (modified) (1 diff)
• trunk/Lib/robofab/test/test_RInfoFL.py (copied) (copied from branches/ufo2/Lib/robofab/test/test_RInfoFL.py)
• trunk/Lib/robofab/test/test_RInfoRF.py (copied) (copied from branches/ufo2/Lib/robofab/test/test_RInfoRF.py)
• trunk/Lib/robofab/test/test_fontLabUFOReadWrite.py (copied) (copied from branches/ufo2/Lib/robofab/test/test_fontLabUFOReadWrite.py)
• trunk/Lib/robofab/test/test_noneLabUFOReadWrite.py (copied) (copied from branches/ufo2/Lib/robofab/test/test_noneLabUFOReadWrite.py)
• trunk/Lib/robofab/test/test_objectsFL.py (modified) (1 diff)
• trunk/Lib/robofab/test/test_psHints.py (modified) (1 diff)
• trunk/Lib/robofab/test/test_ufoLib.py (copied) (copied from branches/ufo2/Lib/robofab/test/test_ufoLib.py)
• trunk/Lib/robofab/tools/fontlabFeatureSplitter.py (copied) (copied from branches/ufo2/Lib/robofab/tools/fontlabFeatureSplitter.py)
• trunk/Lib/robofab/tools/nameTable.py (deleted)
• trunk/Lib/robofab/tools/toolsAll.py (modified) (2 diffs)
• trunk/Lib/robofab/ufoLib.py (modified) (7 diffs)
• trunk/Scripts/RoboFabIntro/demo_FindCompatibleGlyphs.py (modified) (1 diff)
• trunk/Scripts/RoboFabIntro/intro_FontObject.py (modified) (2 diffs)
• trunk/Scripts/RoboFabIntro/intro_FoundrySettings.py (modified) (1 diff)
• trunk/Scripts/RoboFabIntro/intro_Kerning.py (modified) (1 diff)
• trunk/Scripts/RoboFabUtils/RobustBatchGenerate.py (modified) (1 diff)
• trunk/Scripts/RoboFabUtils/TestFontEquality.py (modified) (2 diffs)
• trunk/TestData (copied) (copied from branches/ufo2/TestData)
• trunk/TestData/TestFont1 (UFO1).ufo (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO1).ufo)
• trunk/TestData/TestFont1 (UFO1).ufo/fontinfo.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO1).ufo/fontinfo.plist)
• trunk/TestData/TestFont1 (UFO1).ufo/glyphs (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO1).ufo/glyphs)
• trunk/TestData/TestFont1 (UFO1).ufo/glyphs/A_.glif (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO1).ufo/glyphs/A_.glif)
• trunk/TestData/TestFont1 (UFO1).ufo/glyphs/B_.glif (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO1).ufo/glyphs/B_.glif)
• trunk/TestData/TestFont1 (UFO1).ufo/glyphs/contents.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO1).ufo/glyphs/contents.plist)
• trunk/TestData/TestFont1 (UFO1).ufo/groups.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO1).ufo/groups.plist)
• trunk/TestData/TestFont1 (UFO1).ufo/kerning.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO1).ufo/kerning.plist)
• trunk/TestData/TestFont1 (UFO1).ufo/lib.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO1).ufo/lib.plist)
• trunk/TestData/TestFont1 (UFO1).ufo/metainfo.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO1).ufo/metainfo.plist)
• trunk/TestData/TestFont1 (UFO2).ufo (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo)
• trunk/TestData/TestFont1 (UFO2).ufo/features.fea (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo/features.fea)
• trunk/TestData/TestFont1 (UFO2).ufo/fontinfo.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo/fontinfo.plist)
• trunk/TestData/TestFont1 (UFO2).ufo/glyphs (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo/glyphs)
• trunk/TestData/TestFont1 (UFO2).ufo/glyphs/A_.glif (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo/glyphs/A_.glif)
• trunk/TestData/TestFont1 (UFO2).ufo/glyphs/B_.glif (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo/glyphs/B_.glif)
• trunk/TestData/TestFont1 (UFO2).ufo/glyphs/contents.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo/glyphs/contents.plist)
• trunk/TestData/TestFont1 (UFO2).ufo/groups.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo/groups.plist)
• trunk/TestData/TestFont1 (UFO2).ufo/kerning.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo/kerning.plist)
• trunk/TestData/TestFont1 (UFO2).ufo/lib.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo/lib.plist)
• trunk/TestData/TestFont1 (UFO2).ufo/metainfo.plist (copied) (copied from branches/ufo2/TestData/TestFont1 (UFO2).ufo/metainfo.plist)
• trunk/TestData/TestFont1.vfb (copied) (copied from branches/ufo2/TestData/TestFont1.vfb)

trunk/Lib/robofab/__init__.py

@@ -76 +76 @@
-
-
-1, "develop", 3
-1.3
+2, "develop", 0
+2.0d

trunk/Lib/robofab/objects/objectsBase.py

@@ -19 +19 @@
-from __future__ import division
-
-
+
+
+
+
+
-from robofab import RoboFabError
-from fontTools.misc.arrayTools import updateBounds, pointInRect, unionRect, sectRect
-from fontTools.pens.basePen import AbstractPen
-
-
+
-
-#constants for dealing with segments, points and bPoints
@@ -147 +150 @@
-                return n
-
-        # math operations for psHint object
-        # Note: math operations can change integers to floats.
-        def __add__(self, other):
-                assert isinstance(other, BasePostScriptHintValues)
-                copied = self.copy()
-                self._processMathOne(copied, other, add)
-                return copied
-
-        def __sub__(self, other):
-                assert isinstance(other, BasePostScriptHintValues)
-                copied = self.copy()
-                self._processMathOne(copied, other, sub)
-                return copied
-
-        def __mul__(self, factor):
-                #if isinstance(factor, tuple):
-                #       factor = factor[0]
-                copiedInfo = self.copy()
-                self._processMathTwo(copiedInfo, factor, mul)
-                return copiedInfo
-
-        __rmul__ = __mul__
-
-        def __div__(self, factor):
-                #if isinstance(factor, tuple):
-                #       factor = factor[0]
-                copiedInfo = self.copy()
-                self._processMathTwo(copiedInfo, factor, div)
-                return copiedInfo
-
-        __rdiv__ = __div__
-        
-        
-class BasePostScriptGlyphHintValues(BasePostScriptHintValues):
-        """ Base class for glyph-level postscript hinting information.
@@ -212 +182 @@
-                                new.append((int(round(n[0])), int(round(n[1]))))
-                        setattr(self, name, new)
+
+        # math operations for psHint object
+        # Note: math operations can change integers to floats.
+        def __add__(self, other):
+                assert isinstance(other, BasePostScriptHintValues)
+                copied = self.copy()
+                self._processMathOne(copied, other, add)
+                return copied
+
+        def __sub__(self, other):
+                assert isinstance(other, BasePostScriptHintValues)
+                copied = self.copy()
+                self._processMathOne(copied, other, sub)
+                return copied
+
+        def __mul__(self, factor):
+                #if isinstance(factor, tuple):
+                #       factor = factor[0]
+                copiedInfo = self.copy()
+                self._processMathTwo(copiedInfo, factor, mul)
+                return copiedInfo
+
+        __rmul__ = __mul__
+
+        def __div__(self, factor):
+                #if isinstance(factor, tuple):
+                #       factor = factor[0]
+                copiedInfo = self.copy()
+                self._processMathTwo(copiedInfo, factor, div)
+                return copiedInfo
+
+        __rdiv__ = __div__
-
-        def _processMathOne(self, copied, other, funct):
@@ -288 +290 @@
-                if data is not None:
-                        self.fromDict(data)
-                else:
-                        for name in self._attributeNames.keys():
-                                setattr(self, name, self._attributeNames[name]['default'])
-
-        def __repr__(self):
-                return "<PostScript Font Hints Values>"
+
+        # route attribute calls to info object
+
+        def _bluesToPairs(self, values):
+                values.sort()
+                finalValues = []
+                for value in values:
+                        if not finalValues or len(finalValues[-1]) == 2:
+                                finalValues.append([])
+                        finalValues[-1].append(value)
+                return finalValues
+
+        def _bluesFromPairs(self, values):
+                finalValues = []
+                for value1, value2 in values:
+                        finalValues.append(value1)
+                        finalValues.append(value2)
+                finalValues.sort()
+                return finalValues
+
+        def _get_blueValues(self):
+                values = self.getParent().info.postscriptBlueValues
+                if values is None:
+                        values = []
+                values = self._bluesToPairs(values)
+                return values
+
+        def _set_blueValues(self, values):
+                if values is None:
+                        values = []
+                values = self._bluesFromPairs(values)
+                self.getParent().info.postscriptBlueValues = values
+
+        blueValues = property(_get_blueValues, _set_blueValues)
+
+        def _get_otherBlues(self):
+                values = self.getParent().info.postscriptOtherBlues
+                if values is None:
+                        values = []
+                values = self._bluesToPairs(values)
+                return values
+
+        def _set_otherBlues(self, values):
+                if values is None:
+                        values = []
+                values = self._bluesFromPairs(values)
+                self.getParent().info.postscriptOtherBlues = values
+
+        otherBlues = property(_get_otherBlues, _set_otherBlues)
+
+        def _get_familyBlues(self):
+                values = self.getParent().info.postscriptFamilyBlues
+                if values is None:
+                        values = []
+                values = self._bluesToPairs(values)
+                return values
+
+        def _set_familyBlues(self, values):
+                if values is None:
+                        values = []
+                values = self._bluesFromPairs(values)
+                self.getParent().info.postscriptFamilyBlues = values
+
+        familyBlues = property(_get_familyBlues, _set_familyBlues)
+
+        def _get_familyOtherBlues(self):
+                values = self.getParent().info.postscriptFamilyOtherBlues
+                if values is None:
+                        values = []
+                values = self._bluesToPairs(values)
+                return values
+
+        def _set_familyOtherBlues(self, values):
+                if values is None:
+                        values = []
+                values = self._bluesFromPairs(values)
+                self.getParent().info.postscriptFamilyOtherBlues = values
+
+        familyOtherBlues = property(_get_familyOtherBlues, _set_familyOtherBlues)
+
+        def _get_vStems(self):
+                return self.getParent().info.postscriptStemSnapV
+
+        def _set_vStems(self, value):
+                if value is None:
+                        value = []
+                self.getParent().info.postscriptStemSnapV = list(value)
+
+        vStems = property(_get_vStems, _set_vStems)
+
+        def _get_hStems(self):
+                return self.getParent().info.postscriptStemSnapH
+
+        def _set_hStems(self, value):
+                if value is None:
+                        value = []
+                self.getParent().info.postscriptStemSnapH = list(value)
+
+        hStems = property(_get_hStems, _set_hStems)
+
+        def _get_blueScale(self):
+                return self.getParent().info.postscriptBlueScale
+
+        def _set_blueScale(self, value):
+                self.getParent().info.postscriptBlueScale = value
+
+        blueScale = property(_get_blueScale, _set_blueScale)
+
+        def _get_blueShift(self):
+                return self.getParent().info.postscriptBlueShift
+
+        def _set_blueShift(self, value):
+                self.getParent().info.postscriptBlueShift = value
+
+        blueShift = property(_get_blueShift, _set_blueShift)
+
+        def _get_blueFuzz(self):
+                return self.getParent().info.postscriptBlueFuzz
+
+        def _set_blueFuzz(self, value):
+                self.getParent().info.postscriptBlueFuzz = value
+
+        blueFuzz = property(_get_blueFuzz, _set_blueFuzz)
+
+        def _get_forceBold(self):
+                return self.getParent().info.postscriptForceBold
+
+        def _set_forceBold(self, value):
+                self.getParent().info.postscriptForceBold = value
+
+        forceBold = property(_get_forceBold, _set_forceBold)
-
-        def round(self):
@@ -335 +465 @@
-                                        new.append([int(round(m)) for m in n])
-                                setattr(self, name, new)
-        
-        
-        def _processMathOne(self, copied, other, funct):
-                for name, values in self._attributeNames.items():
-                        a = None
-                        b = None
-                        v = None
-                        if hasattr(copied, name):
-                                a = getattr(copied, name)
-                        if hasattr(other, name):
-                                b = getattr(other, name)
-                        if name in ['blueFuzz', 'blueScale', 'blueShift', 'forceBold']:
-                                # process single values
-                                if a is not None and b is not None:
-                                        v = funct(a, b)
-                                elif a is not None and b is None:
-                                        v = a
-                                elif b is not None and a is None:
-                                        v = b
-                                if v is not None:
-                                        setattr(copied, name, v)
-                        elif name in ['hStems', 'vStems']:
-                                if a is not None and b is not None:
-                                        if len(a) != len(b):
-                                                # can't do math with non matching zones
-                                                continue
-                                        l = len(a)
-                                        v = [funct(a[i], b[i]) for i in range(l)]
-                                if v is not None:
-                                        setattr(copied, name, v)
-                        else:
-                                if a is not None and b is not None:
-                                        if len(a) != len(b):
-                                                # can't do math with non matching zones
-                                                continue
-                                        l = len(a)
-                                        for i in range(l):
-                                                if v is None:
-                                                        v = []
-                                                ai = a[i]
-                                                bi = b[i]
-                                                l2 = min(len(ai), len(bi))
-                                                v2 = [funct(ai[j], bi[j]) for j in range(l2)]
-                                                v.append(v2)
-                                if v is not None:
-                                        setattr(copied, name, v)
-
-        def _processMathTwo(self, copied, factor, funct):
-                for name, values in self._attributeNames.items():
-                        a = None
-                        b = None
-                        v = None
-                        if hasattr(copied, name):
-                                a = getattr(copied, name)
-                        splitFactor = factor
-                        isVertical = self._attributeNames[name]['isVertical']
-                        if isinstance(factor, tuple):
-                                if isVertical:
-                                        splitFactor = factor[1]
-                                else:
-                                        splitFactor = factor[0]
-                        if name in ['blueFuzz', 'blueScale', 'blueShift', 'forceBold']:
-                                # process single values
-                                if a is not None:
-                                        v = funct(a, splitFactor)
-                                if v is not None:
-                                        setattr(copied, name, v)
-                        elif name in ['hStems', 'vStems']:
-                                if a is not None:
-                                        v = [funct(a[i], splitFactor) for i in range(len(a))]
-                                if v is not None:
-                                        setattr(copied, name, v)
-                        else:
-                                if a is not None:
-                                        for i in range(len(a)):
-                                                if v is None:
-                                                        v = []
-                                                v2 = [funct(a[i][j], splitFactor) for j in range(len(a[i]))]
-                                                v.append(v2)
-                                if v is not None:
-                                        setattr(copied, name, v)
-
-
@@ -592 +641 @@
-        def __repr__(self):
-                try:
-f
+postscriptF
-                except AttributeError:
-                        name = "unnamed_font"
@@ -644 +693 @@
-                return self.getGlyph(glyphName)
-
+        def __contains__(self, glyphName):
+                return self.has_key(glyphName)
+
-        def _hasChanged(self):
-                #mark the object as changed
@@ -730 +782 @@
-                                accent = self[accentName]
-                        except IndexError:
-f
+postscriptF
-                                continue
-                        localAnchors = {}
@@ -753 +805 @@
-                                        baseX, baseY = anchors[foundAnchor[1:]]
-                                except KeyError:
-f
+postscriptF
-                                        continue
-                                #calculate the accent componet offset values
@@ -832 +884 @@
-                                if not errors.has_key('Missing Glyphs'):
-                                        errors['Missing Glyphs'] = []
-f
+postscriptF
-                        if glyphName not in maxGlyphNames:
-                                fatalError = True
-                                if not errors.has_key('Missing Glyphs'):
-                                        errors['Missing Glyphs'] = []
-f
+postscriptF
-                        # if no major problems, proceed.
-                        if not fatalError:
@@ -881 +933 @@
-                                item = getattr(item, sub)
-                except (ImportError, AttributeError):
-                        from warnings import warn
-                        warn("Can't find glyph name to file name converter function, "
-                                "falling back to default scheme (%s)" % funcName, RoboFabWarning)
@@ -910 +961 @@
-                if fontParent is not None:
-                        try:
-f
+postscriptF
-                        except AttributeError:
-                                pass
@@ -1776 +1827 @@
-                        if fontParent is not None:
-                                try:
-f
+postscriptF
-                                except AttributeError: pass
-                try:
@@ -1789 +1840 @@
-        
-        def __mul__(self, factor):
-                from warnings import warn
-                warn("Contour math has been deprecated and is slated for removal.", DeprecationWarning)
-                n = self.copy()
@@ -1801 +1851 @@
-
-        def __add__(self, other):
-                from warnings import warn
-                warn("Contour math has been deprecated and is slated for removal.", DeprecationWarning)
-                n = self.copy()
@@ -1811 +1860 @@
-
-        def __sub__(self, other):
-                from warnings import warn
-                warn("Contour math has been deprecated and is slated for removal.", DeprecationWarning)
-                n = self.copy()
@@ -2186 +2234 @@
-                                if fontParent is not None:
-                                        try:
-f
+postscriptF
-                                        except AttributeError: pass
-                try:
@@ -2195 +2243 @@
-                
-        def __mul__(self, factor):
-                from warnings import warn
-                warn("Segment math has been deprecated and is slated for removal.", DeprecationWarning)
-                n = self.copy()
@@ -2207 +2254 @@
-
-        def __add__(self, other):
-                from warnings import warn
-                warn("Segment math has been deprecated and is slated for removal.", DeprecationWarning)
-                n = self.copy()
@@ -2216 +2262 @@
-
-        def __sub__(self, other):
-                from warnings import warn
-                warn("Segment math has been deprecated and is slated for removal.", DeprecationWarning)
-                n = self.copy()
@@ -2325 +2370 @@
-                                        if fontParent is not None:
-                                                try:
-f
+postscriptF
-                                                except AttributeError: pass
-                return "<RPoint for %s.%s[%s][%s]>"%(font, glyph, contourIndex, segmentIndex)
-        
-        def __add__(self, other):
-                from warnings import warn
-                warn("Point math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Add one point to another
@@ -2338 +2382 @@
-
-        def __sub__(self, other):
-                from warnings import warn
-                warn("Point math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Subtract one point from another
@@ -2346 +2389 @@
-
-        def __mul__(self, factor):
-                from warnings import warn
-                warn("Point math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Multiply the point with factor. Factor can be a tuple of 2 *(f1, f2)
@@ -2441 +2483 @@
-                                        if fontParent is not None:
-                                                try:
-f
+postscriptF
-                                                except AttributeError: pass
-                return "<RBPoint for %s.%s[%s][%s][%s]>"%(font, glyph, contourIndex, segmentIndex, `self.index`)
@@ -2447 +2489 @@
-        
-        def __add__(self, other):
-                from warnings import warn
-                warn("BPoint math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Add one bPoint to another
@@ -2457 +2498 @@
-
-        def __sub__(self, other):
-                from warnings import warn
-                warn("BPoint math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Subtract one bPoint from another
@@ -2467 +2507 @@
-
-        def __mul__(self, factor):
-                from warnings import warn
-                warn("BPoint math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Multiply the bPoint with factor. Factor can be a tuple of 2 *(f1, f2)
@@ -2680 +2719 @@
-                        if fontParent is not None:
-                                try:
-f
+postscriptF
-                                except AttributeError: pass
-                return "<RComponent for %s.%s.components[%s]>"%(font, glyph, `self.index`)
@@ -2709 +2748 @@
-
-        def __add__(self, other):
-                from warnings import warn
-                warn("Component math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Add one Component to another
@@ -2718 +2756 @@
-
-        def __sub__(self, other):
-                from warnings import warn
-                warn("Component math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Subtract one Component from another
@@ -2727 +2764 @@
-
-        def __mul__(self, factor):
-                from warnings import warn
-                warn("Component math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Multiply the Component with factor. Factor can be a tuple of 2 *(f1, f2)
@@ -2799 +2835 @@
-                        if fontParent is not None:
-                                try:
-f
+postscriptF
-                                except AttributeError: pass
-                return "<RAnchor for %s.%s.anchors[%s]>"%(font, glyph, `self.index`)
-
-        def __add__(self, other):
-                from warnings import warn
-                warn("Anchor math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Add one anchor to another
@@ -2812 +2847 @@
-
-        def __sub__(self, other):
-                from warnings import warn
-                warn("Anchor math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Substract one anchor from another
@@ -2820 +2854 @@
-
-        def __mul__(self, factor):
-                from warnings import warn
-                warn("Anchor math has been deprecated and is slated for removal.", DeprecationWarning)
-                #Multiply the anchor with factor. Factor can be a tuple of 2 *(f1, f2)
@@ -2899 +2932 @@
-                self.selected = False
-
-
-
-
+
-class BaseInfo(RBaseObject):
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        def __init__(self):
-                RBaseObject.__init__(self)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-class BaseGroups(dict):
-        
@@ -3269 +3054 @@
-                if fontParent is not None:
-                        try:
-f
+postscriptF
-                        except AttributeError: pass
-                return "<RGroups for %s>"%font
@@ -3313 +3098 @@
-                        #do we have a font?
-                        try:
-f
+postscriptF
-                        except AttributeError:
-                                #or do we have a glyph?
@@ -3358 +3143 @@
-                if fontParent is not None:
-                        try:
-f
+postscriptF
-                        except AttributeError: pass
-                return "<RKerning for %s>"%font
@@ -3706 +3491 @@
-                return self.__mul__(1.0/factor)
-        
-        

trunk/Lib/robofab/objects/objectsFL.py

@@ -6 +6 @@
-                AllFonts, NewGlyph
-from robofab.objects.objectsBase import BaseFont, BaseGlyph, BaseContour, BaseSegment,\
-
+Features, Base
-                roundPt, addPt, _box,\
-                MOVE, LINE, CORNER, CURVE, QCURVE, OFFCURVE,\
@@ -17 +17 @@
-from robofab.plistlib import Data, Dict, readPlist, writePlist
-from StringIO import StringIO
+from robofab import ufoLib
+from warnings import warn
+import datetime
+from robofab.tools.fontlabFeatureSplitter import splitFeaturesForFontLab
+
+
+try:
+        set
+except NameError:
+        from sets import Set as set
-
-# local encoding
@@ -23 +33 @@
-else:
-        LOCAL_ENCODING = "latin-1"
+
+_IN_UFO_EXPORT = False
-
-# a list of attributes that are to be copied when copying a glyph.
@@ -106 +118 @@
-        stem_snap_v_num(integer)
-        stem_snap_v
-        
-                
-        
- """
-
@@ -122 +131 @@
-                from robofab.objects.objectsRF import PostScriptFontHintValues as _PostScriptFontHintValues
-                return _PostScriptFontHintValues(data=self.asDict())
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-
-class PostScriptGlyphHintValues(BasePostScriptGlyphHintValues):
@@ -503 +378 @@
-        fl.Add(f)
-        rf = RFont(f)
-
-
+
+
+
+
-        return rf
-
@@ -560 +437 @@
-                self._lib = {}
-                self._supportHints = True
+                self.psHints = PostScriptFontHintValues(self)
+                self.psHints.setParent(self)
-
-        def keys(self):
@@ -601 +480 @@
-        
-
-
-
-
-
+
+
+
+
+
+
-
-        def _get_info(self):
@@ -610 +491 @@
-        
-        info = property(_get_info, doc="font info object")
-
+
+
+
+
+
+
-        def _get_kerning(self):
-                kerning = {}
@@ -1026 +912 @@
-                fl.ifont = self.fontIndex
-                fl.GenerateFont(flOutputType, finalPath)
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        def _writeOpenTypeFeaturesToLib(self, fontLib):
+                # this should only be used for UFO format version 1
-                flFont = self.naked()
-
-
-
+
-                if flFont.features:
-                        features = {}
@@ -1037 +1041 @@
-                        for feature in flFont.features:
-                                order.append(feature.tag)
-
+.rstrip() + "\n"
-                        fontLib["org.robofab.opentype.features"] = features
-                        fontLib["org.robofab.opentype.featureorder"] = order
-
-
-
-
+
+
+
+
+
-                from robofab.interface.all.dialogs import ProgressBar
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-                bar = None
-                if doProgress:
-
+
+
-                try:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                                if doHints:
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-                                if bar and not count % 10:
-                                        bar.tick(count)
-                                count = count + 1
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                except KeyboardInterrupt:
-
-
+
-                        bar = None
+                # kill the bar
-                if bar:
-                        bar.close()
-
+
-        def _getGlyphOrderFromLib(self, fontLib, glyphSet):
-                glyphOrder = fontLib.get("org.robofab.glyphOrder")
@@ -1130 +1153 @@
-                else:
-                        glyphNames = glyphSet.keys()
-                        # Sort according to unicode would be best, but is really
-                        # expensive...
-                        glyphNames.sort()
-                return glyphNames
-        
-
+
+
+
-                classes = fontLib.get("org.robofab.opentype.classes")
-                if classes is not None:
-                        del fontLib["org.robofab.opentype.classes"]
-
+
+
-                features = fontLib.get("org.robofab.opentype.features")
-                if features is not None:
@@ -1156 +1180 @@
-                                if oneFeature is not None:
-                                        orderedFeatures.append((tag, oneFeature))
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-
-
@@ -2292 +2265 @@
-                        # do we have a font?
-                        try:
-f
+postscriptF
-                        except AttributeError:
-                                # or do we have a glyph?
@@ -2609 +2582 @@
-                return i
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-class RInfo(BaseInfo):
-
+
-        """RoboFab wrapper for FL Font Info"""
-
+
-        _title = "FLInfo"
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        def __init__(self, font):
-BaseInfo.__init__(self
+super(RInfo, self).__init__(
-                self._object = font
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                self._object.weight_code = value
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                self._object.ms_charset = value
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/Lib/robofab/objects/objectsRF.py

@@ -2 +2 @@
-
-from robofab import RoboFabError, RoboFabWarning
-
+Features, Base
-                BaseGlyph, BaseContour, BaseSegment, BasePoint, BaseBPoint, BaseAnchor, BaseGuide, BaseComponent, \
-                relativeBCPIn, relativeBCPOut, absoluteBCPIn, absoluteBCPOut, _box,\
@@ -46 +46 @@
-        """Make a new font"""
-        new = RFont()
-
-
+
+
+
+
-        return new
-        
@@ -68 +70 @@
-        
-        def __init__(self, aFont=None, data=None):
-# read the data from the font.lib, it won't be anywhere else
+self.setParent(aFont)
-                BasePostScriptFontHintValues.__init__(self)
-                if aFont is not None:
-
+
+
+
-                        libData = aFont.lib.get(postScriptHintDataLibKey)
-                        if libData is not None:
-                                self.fromDict(libData)
+                                del libData[postScriptHintDataLibKey]
-                if data is not None:
-                        self.fromDict(data)
@@ -124 +129 @@
-                self.info = RInfo()
-                self.info.setParent(self)
+                self.features = RFeatures()
+                self.features.setParent(self)
-                self.groups = RGroups()
-                self.groups.setParent(self)
-                self.lib = RLib()
-                self.lib.setParent(self)
-                self.psHints = PostScriptFontHintValues(self)
-                self.psHints.setParent(self)
-                
-                if path:
-                        self._loadData(path)
+                else:
+                        self.psHints = PostScriptFontHintValues(self)
+                        self.psHints.setParent(self)
-                
-        def __setitem__(self, glyphName, glyph):
@@ -153 +160 @@
-        
-        def _loadData(self, path):
-                #Load the data into the font
-                from robofab.ufoLib import UFOReader
-
-
-
+
+
+
+
+
+
-                self.kerning.setChanged(False)
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                self.psHints = PostScriptFontHintValues(self)
-
+
+
+
+
+
+
-                self._hasNotChanged(doGlyphs=False)
-
+
-        def _loadGlyph(self, glyphName):
-                """Load a single glyph from the glyphSet, on request."""
@@ -330 +369 @@
-                
-
-saveNow=False
+formatVersion=2
-                """Save the Font in UFO format."""
-                # XXX note that when doing "save as" by specifying the destDir argument
@@ -338 +377 @@
-                # save.
-                from robofab.ufoLib import UFOWriter
+                from robofab.tools.fontlabFeatureSplitter import splitFeaturesForFontLab
-                # if no destination is given, or if
-                # the given destination is the current
@@ -346 +386 @@
-                else:
-                        saveAs = True
-u = UFOWriter(destDir)
+# start a progress bar
-                nonGlyphCount = 5
-                bar = None
-                if doProgress:
-                        from robofab.interface.all.dialogs import ProgressBar
-
+
+
+
-                try:
-
+
+
+
-                        if bar:
-'Saving info...'
-u
+"Saving info..."
+writer
-                        if bar:
-                                bar.tick()
+                        # kerning
-                        if self.kerning.changed or saveAs:
-                                if bar:
-
-
-
+
+
+
+
+
+
+
+
-                        if bar:
-                                bar.tick()
-if self.groups.changed:
+ features
-                        if bar:
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                        if bar:
-                                bar.tick()
-
-
-
-
-
+
+
+
-                        if bar:
-'Saving lib...'
-u.writeLib(self.l
+"Saving lib..."
+writer.writeLib(fontL
-                        if bar:
-                                bar.tick()
+                        # glyphs
-                        glyphNameToFileNameFunc = self.getGlyphNameToFileNameFunc()
-
+
+
-                        if len(self._scheduledForDeletion) != 0:
-                                if bar:
-'Removing deleted glyphs......'
+"Removing deleted glyphs..."
-                                for glyphName in self._scheduledForDeletion:
-                                        if glyphSet.has_key(glyphName):
@@ -393 +457 @@
-                                        bar.tick()
-                        if bar:
-'Saving glyphs...'
+"Saving glyphs..."
-                        count = nonGlyphCount
-                        if saveAs:
@@ -408 +472 @@
-                        glyphSet.writeContents()
-                        self._glyphSet = glyphSet
+                # only blindly stop if the user says to
-                except KeyboardInterrupt:
-                        bar.close()
-                        bar = None
+                # kill the progress bar
-                if bar:
-                        bar.close()
+                # reset internal stuff
-                self._path = destDir
-                self._scheduledForDeletion = []
-                self.setChanged(False)
-
+
-        def newGlyph(self, glyphName, clear=True):
-                """Make a new glyph with glyphName
@@ -1127 +1194 @@
-class RInfo(BaseInfo):
-        
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+

trunk/Lib/robofab/test/runAll.py

@@ -18 +18 @@
-                except ImportError:
-                        print "*** skipped", fileName
+                        continue
-        
-                suites.append(loader.loadTestsFromModule(mod))

trunk/Lib/robofab/test/testSupport.py

@@ -48 +48 @@
-        testRunner.run(testSuite)
-
+# font info values used by several tests
+
+fontInfoVersion1 = {
+        "familyName"   : "Some Font (Family Name)",
+        "styleName"        : "Regular (Style Name)",
+        "fullName"         : "Some Font-Regular (Postscript Full Name)",
+        "fontName"         : "SomeFont-Regular (Postscript Font Name)",
+        "menuName"         : "Some Font Regular (Style Map Family Name)",
+        "fontStyle"        : 64,
+        "note"             : "A note.",
+        "versionMajor" : 1,
+        "versionMinor" : 0,
+        "year"             : 2008,
+        "copyright"        : "Copyright Some Foundry.",
+        "notice"           : "Some Font by Some Designer for Some Foundry.",
+        "trademark"        : "Trademark Some Foundry",
+        "license"          : "License info for Some Foundry.",
+        "licenseURL"   : "http://somefoundry.com/license",
+        "createdBy"        : "Some Foundry",
+        "designer"         : "Some Designer",
+        "designerURL"  : "http://somedesigner.com",
+        "vendorURL"        : "http://somefoundry.com",
+        "unitsPerEm"   : 1000,
+        "ascender"         : 750,
+        "descender"        : -250,
+        "capHeight"        : 750,
+        "xHeight"          : 500,
+        "defaultWidth" : 400,
+        "slantAngle"   : -12.5,
+        "italicAngle"  : -12.5,
+        "widthName"        : "Medium (normal)",
+        "weightName"   : "Medium",
+        "weightValue"  : 500,
+        "fondName"         : "SomeFont Regular (FOND Name)",
+        "otFamilyName" : "Some Font (Preferred Family Name)",
+        "otStyleName"  : "Regular (Preferred Subfamily Name)",
+        "otMacName"        : "Some Font Regular (Compatible Full Name)",
+        "msCharSet"        : 0,
+        "fondID"           : 15000,
+        "uniqueID"         : 4000000,
+        "ttVendor"         : "SOME",
+        "ttUniqueID"   : "OpenType name Table Unique ID",
+        "ttVersion"        : "OpenType name Table Version",
+}
+
+fontInfoVersion2 = {
+        "familyName"                                             : "Some Font (Family Name)",
+        "styleName"                                                      : "Regular (Style Name)",
+        "styleMapFamilyName"                             : "Some Font Regular (Style Map Family Name)",
+        "styleMapStyleName"                                      : "regular",
+        "versionMajor"                                           : 1,
+        "versionMinor"                                           : 0,
+        "year"                                                           : 2008,
+        "copyright"                                                      : "Copyright Some Foundry.",
+        "trademark"                                                      : "Trademark Some Foundry",
+        "unitsPerEm"                                             : 1000,
+        "descender"                                                      : -250,
+        "xHeight"                                                        : 500,
+        "capHeight"                                                      : 750,
+        "ascender"                                                       : 750,
+        "italicAngle"                                            : -12.5,
+        "note"                                                           : "A note.",
+        "openTypeHeadCreated"                            : "2000/01/01 00:00:00",
+        "openTypeHeadLowestRecPPEM"                      : 10,
+        "openTypeHeadFlags"                                      : [0, 1],
+        "openTypeHheaAscender"                           : 750,
+        "openTypeHheaDescender"                          : -250,
+        "openTypeHheaLineGap"                            : 200,
+        "openTypeHheaCaretSlopeRise"             : 1,
+        "openTypeHheaCaretSlopeRun"                      : 0,
+        "openTypeHheaCaretOffset"                        : 0,
+        "openTypeNameDesigner"                           : "Some Designer",
+        "openTypeNameDesignerURL"                        : "http://somedesigner.com",
+        "openTypeNameManufacturer"                       : "Some Foundry",
+        "openTypeNameManufacturerURL"            : "http://somefoundry.com",
+        "openTypeNameLicense"                            : "License info for Some Foundry.",
+        "openTypeNameLicenseURL"                         : "http://somefoundry.com/license",
+        "openTypeNameVersion"                            : "OpenType name Table Version",
+        "openTypeNameUniqueID"                           : "OpenType name Table Unique ID",
+        "openTypeNameDescription"                        : "Some Font by Some Designer for Some Foundry.",
+        "openTypeNamePreferredFamilyName"        : "Some Font (Preferred Family Name)",
+        "openTypeNamePreferredSubfamilyName" : "Regular (Preferred Subfamily Name)",
+        "openTypeNameCompatibleFullName"         : "Some Font Regular (Compatible Full Name)",
+        "openTypeNameSampleText"                         : "Sample Text for Some Font.",
+        "openTypeNameWWSFamilyName"                      : "Some Font (WWS Family Name)",
+        "openTypeNameWWSSubfamilyName"           : "Regular (WWS Subfamily Name)",
+        "openTypeOS2WidthClass"                          : 5,
+        "openTypeOS2WeightClass"                         : 500,
+        "openTypeOS2Selection"                           : [3],
+        "openTypeOS2VendorID"                            : "SOME",
+        "openTypeOS2Panose"                                      : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+        "openTypeOS2FamilyClass"                         : [1, 1],
+        "openTypeOS2UnicodeRanges"                       : [0, 1],
+        "openTypeOS2CodePageRanges"                      : [0, 1],
+        "openTypeOS2TypoAscender"                        : 750,
+        "openTypeOS2TypoDescender"                       : -250,
+        "openTypeOS2TypoLineGap"                         : 200,
+        "openTypeOS2WinAscent"                           : 750,
+        "openTypeOS2WinDescent"                          : -250,
+        "openTypeOS2Type"                                        : [],
+        "openTypeOS2SubscriptXSize"                      : 200,
+        "openTypeOS2SubscriptYSize"                      : 400,
+        "openTypeOS2SubscriptXOffset"            : 0,
+        "openTypeOS2SubscriptYOffset"            : -100,
+        "openTypeOS2SuperscriptXSize"            : 200,
+        "openTypeOS2SuperscriptYSize"            : 400,
+        "openTypeOS2SuperscriptXOffset"          : 0,
+        "openTypeOS2SuperscriptYOffset"          : 200,
+        "openTypeOS2StrikeoutSize"                       : 20,
+        "openTypeOS2StrikeoutPosition"           : 300,
+        "openTypeVheaVertTypoAscender"           : 750,
+        "openTypeVheaVertTypoDescender"          : -250,
+        "openTypeVheaVertTypoLineGap"            : 200,
+        "openTypeVheaCaretSlopeRise"             : 0,
+        "openTypeVheaCaretSlopeRun"                      : 1,
+        "openTypeVheaCaretOffset"                        : 0,
+        "postscriptFontName"                             : "SomeFont-Regular (Postscript Font Name)",
+        "postscriptFullName"                             : "Some Font-Regular (Postscript Full Name)",
+        "postscriptSlantAngle"                           : -12.5,
+        "postscriptUniqueID"                             : 4000000,
+        "postscriptUnderlineThickness"           : 20,
+        "postscriptUnderlinePosition"            : -200,
+        "postscriptIsFixedPitch"                         : False,
+        "postscriptBlueValues"                           : [500, 510],
+        "postscriptOtherBlues"                           : [-250, -260],
+        "postscriptFamilyBlues"                          : [500, 510],
+        "postscriptFamilyOtherBlues"             : [-250, -260],
+        "postscriptStemSnapH"                            : [100, 120],
+        "postscriptStemSnapV"                            : [80, 90],
+        "postscriptBlueFuzz"                             : 1,
+        "postscriptBlueShift"                            : 7,
+        "postscriptBlueScale"                            : 0.039625,
+        "postscriptForceBold"                            : True,
+        "postscriptDefaultWidthX"                        : 400,
+        "postscriptNominalWidthX"                        : 400,
+        "postscriptWeightName"                           : "Medium",
+        "postscriptDefaultCharacter"             : ".notdef",
+        "postscriptWindowsCharacterSet"          : 1,
+        "macintoshFONDFamilyID"                          : 15000,
+        "macintoshFONDName"                                      : "SomeFont Regular (FOND Name)",
+}
+
+expectedFontInfo1To2Conversion = {
+        "familyName"                                            : "Some Font (Family Name)",
+        "styleMapFamilyName"                            : "Some Font Regular (Style Map Family Name)",
+        "styleMapStyleName"                                     : "regular",
+        "styleName"                                                     : "Regular (Style Name)",
+        "unitsPerEm"                                            : 1000,
+        "ascender"                                                      : 750,
+        "capHeight"                                                     : 750,
+        "xHeight"                                                       : 500,
+        "descender"                                                     : -250,
+        "italicAngle"                                           : -12.5,
+        "versionMajor"                                          : 1,
+        "versionMinor"                                          : 0,
+        "year"                                                          : 2008,
+        "copyright"                                                     : "Copyright Some Foundry.",
+        "trademark"                                                     : "Trademark Some Foundry",
+        "note"                                                          : "A note.",
+        "macintoshFONDFamilyID"                         : 15000,
+        "macintoshFONDName"                                     : "SomeFont Regular (FOND Name)",
+        "openTypeNameCompatibleFullName"        : "Some Font Regular (Compatible Full Name)",
+        "openTypeNameDescription"                       : "Some Font by Some Designer for Some Foundry.",
+        "openTypeNameDesigner"                          : "Some Designer",
+        "openTypeNameDesignerURL"                       : "http://somedesigner.com",
+        "openTypeNameLicense"                           : "License info for Some Foundry.",
+        "openTypeNameLicenseURL"                        : "http://somefoundry.com/license",
+        "openTypeNameManufacturer"                      : "Some Foundry",
+        "openTypeNameManufacturerURL"           : "http://somefoundry.com",
+        "openTypeNamePreferredFamilyName"       : "Some Font (Preferred Family Name)",
+        "openTypeNamePreferredSubfamilyName": "Regular (Preferred Subfamily Name)",
+        "openTypeNameCompatibleFullName"        : "Some Font Regular (Compatible Full Name)",
+        "openTypeNameUniqueID"                          : "OpenType name Table Unique ID",
+        "openTypeNameVersion"                           : "OpenType name Table Version",
+        "openTypeOS2VendorID"                           : "SOME",
+        "openTypeOS2WeightClass"                        : 500,
+        "openTypeOS2WidthClass"                         : 5,
+        "postscriptDefaultWidthX"                       : 400,
+        "postscriptFontName"                            : "SomeFont-Regular (Postscript Font Name)",
+        "postscriptFullName"                            : "Some Font-Regular (Postscript Full Name)",
+        "postscriptSlantAngle"                          : -12.5,
+        "postscriptUniqueID"                            : 4000000,
+        "postscriptWeightName"                          : "Medium",
+        "postscriptWindowsCharacterSet"         : 1
+}
+
+expectedFontInfo2To1Conversion = {
+        "familyName"    : "Some Font (Family Name)",
+        "menuName"              : "Some Font Regular (Style Map Family Name)",
+        "fontStyle"             : 64,
+        "styleName"             : "Regular (Style Name)",
+        "unitsPerEm"    : 1000,
+        "ascender"              : 750,
+        "capHeight"             : 750,
+        "xHeight"               : 500,
+        "descender"             : -250,
+        "italicAngle"   : -12.5,
+        "versionMajor"  : 1,
+        "versionMinor"  : 0,
+        "copyright"             : "Copyright Some Foundry.",
+        "trademark"             : "Trademark Some Foundry",
+        "note"                  : "A note.",
+        "fondID"                : 15000,
+        "fondName"              : "SomeFont Regular (FOND Name)",
+        "fullName"              : "Some Font Regular (Compatible Full Name)",
+        "notice"                : "Some Font by Some Designer for Some Foundry.",
+        "designer"              : "Some Designer",
+        "designerURL"   : "http://somedesigner.com",
+        "license"               : "License info for Some Foundry.",
+        "licenseURL"    : "http://somefoundry.com/license",
+        "createdBy"             : "Some Foundry",
+        "vendorURL"             : "http://somefoundry.com",
+        "otFamilyName"  : "Some Font (Preferred Family Name)",
+        "otStyleName"   : "Regular (Preferred Subfamily Name)",
+        "otMacName"             : "Some Font Regular (Compatible Full Name)",
+        "ttUniqueID"    : "OpenType name Table Unique ID",
+        "ttVersion"             : "OpenType name Table Version",
+        "ttVendor"              : "SOME",
+        "weightValue"   : 500,
+        "widthName"             : "Medium (normal)",
+        "defaultWidth"  : 400,
+        "fontName"              : "SomeFont-Regular (Postscript Font Name)",
+        "fullName"              : "Some Font-Regular (Postscript Full Name)",
+        "slantAngle"    : -12.5,
+        "uniqueID"              : 4000000,
+        "weightName"    : "Medium",
+        "msCharSet"             : 0,
+        "year"                  : 2008
+}

trunk/Lib/robofab/test/test_objectsFL.py

@@ -13 +13 @@
-from robofab.tools.glifImport import importAllGlifFiles
-from robofab.pens.digestPen import DigestPointPen
-, FabToFontToolsPenAdapter
+
-
-

trunk/Lib/robofab/test/test_psHints.py

@@ -103 +103 @@
-                >>> f["new"].psHints.asDict() == g.psHints.asDict()
-                True
-
-                # multiplication
-                >>> v = f.psHints * 2
-                >>> v.asDict() == {'vStems': [1000, 20], 'blueFuzz': 2, 'blueShift': 2, 'forceBold': 2, 'blueScale': 1.0, 'hStems': [200, 180]}
-                True
-
-                # division
-                >>> v = f.psHints / 2
-                >>> v.asDict() == {'vStems': [250.0, 5.0], 'blueFuzz': 0.5, 'blueShift': 0.5, 'forceBold': 0.5, 'blueScale': 0.25, 'hStems': [50.0, 45.0]}
-                True
-
-                # multiplication with x, y, factor
-                # note the h stems are multiplied by .5, the v stems (and blue values) are multiplied by 10
-                >>> v = f.psHints * (.5, 10)
-                >>> v.asDict() == {'vStems': [5000, 100], 'blueFuzz': 10, 'blueShift': 10, 'forceBold': 0.5, 'blueScale': 5.0, 'hStems': [50.0, 45.0]}
-                True
-
-                # multiplication with x, y, factor
-                # note the h stems are divided by .5, the v stems (and blue values) are divided by 10
-                >>> v = f.psHints / (.5, 10)
-                >>> v.asDict() == {'vStems': [50.0, 1.0], 'blueFuzz': 0.10000000000000001, 'blueShift': 0.10000000000000001, 'forceBold': 2.0, 'blueScale': 0.050000000000000003, 'hStems': [200.0, 180.0]}
-                True
-
-                >>> v = f.psHints * .333
-                >>> v.round()
-                >>> v.asDict() == {'vStems': [167, 3], 'blueScale': 0.16650000000000001, 'hStems': [33, 30]}
-                True
-
-        """
-

trunk/Lib/robofab/tools/toolsAll.py

@@ -13 +13 @@
-
-
-import robofab
-from robofab.plistlib import readPlist, writePlist
-
-def readFoundrySettings(dstPath):
-        """read the foundry settings xml file and return a keyed dict."""
-        fileName = os.path.basename(dstPath)
-        if not os.path.exists(dstPath):
-                import shutil
-                # hm -- a fresh install, make a new default settings file
-                print "RoboFab: creating a new foundry settings file at", dstPath
-                srcDir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(robofab.__file__))), 'Data')
-                srcPath = os.path.join(srcDir, 'template_' + fileName)
-                shutil.copy(srcPath, dstPath)
-        return readPlist(dstPath)
-
-def getFoundrySetting(key, path):
-        """get a specific setting from the foundry settings xml file."""
-        d = readFoundrySettings(path)
-        return d.get(key)
-
-writeFoundrySettings = writePlist
-
-def setFoundrySetting(key, value, dstPath):
-        """write a specific entry in the foundry settings xml file."""
-        d = readFoundrySettings(dstPath)
-        d[key] = value
-        writeFoundrySettings(d, dstPath)
-        
-def readGlyphConstructions():
-        """read GlyphConstruction and turn it into a dict"""
@@ -58 +30 @@
-                        glyphConstructions[name] = build
-        return glyphConstructions
-
-
-
-
-#

trunk/Lib/robofab/ufoLib.py

@@ -1 +1 @@
-""""
-A library for importing .ufo files and their descendants.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-"""
-
-
-import os
+import shutil
-from cStringIO import StringIO
+import calendar
-from robofab.plistlib import readPlist, writePlist
-from robofab.glifLib import GlyphSet, READ_MODE, WRITE_MODE
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-]
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-class UFOReader(object):
-
-read the various components of the .ufo
-
+
+Read the various components of the .ufo.
+
-        def __init__(self, path):
-                self._path = path
-
+
+
+
+
+
+
+
-        def _checkForFile(self, path):
-                if not os.path.exists(path):
-                        #print "missing file: %s" % path
-                        return False
-                else:
-                        return True
-
+
-        def readMetaInfo(self):
-
-
+
+
+
-                path = os.path.join(self._path, METAINFO_FILENAME)
-                if not self._checkForFile(path):
-
-
+
+
+
+
+
+
+
+
+
+
-        def readGroups(self):
-
-
+
+
+
-                path = os.path.join(self._path, GROUPS_FILENAME)
-                if not self._checkForFile(path):
-                        return {}
-                return readPlist(path)
-
+
-        def readInfo(self, info):
-
-
-
+
+
+
+
+
+
+
-                path = os.path.join(self._path, FONTINFO_FILENAME)
-                if not self._checkForFile(path):
- {}
+
-                infoDict = readPlist(path)
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                        try:
-key
+attr
-                        except AttributeError:
-
-
-
+
+
-        def readKerning(self):
-
-
+
+
+
-                path = os.path.join(self._path, KERNING_FILENAME)
-                if not self._checkForFile(path):
@@ -170 +294 @@
-                                kerning[left, right] = value
-                return kerning
-
+
-        def readLib(self):
-
-
+
+
+
-                path = os.path.join(self._path, LIB_FILENAME)
-                if not self._checkForFile(path):
-                        return {}
-                return readPlist(path)
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-        def getGlyphSet(self):
-
-
+
+
+
+
-                glyphsPath = os.path.join(self._path, GLYPHS_DIRNAME)
-                return GlyphSet(glyphsPath)
-
-        def getCharacterMapping(self):
-
+
+
-                lists of glyph names.
-                """
@@ -202 +342 @@
-
-
+# ----------
+# UFO Writer
+# ----------
+
+
-class UFOWriter(object):
-
-
-
-
-
-
-
+
+
+
+
+
+
-                self._path = path
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        def _makeDirectory(self, subDirectory=None):
-                path = self._path
@@ -218 +381 @@
-                if not os.path.exists(path):
-                        os.makedirs(path)
-                if not os.path.exists(os.path.join(path, METAINFO_FILENAME)):
-                        self._writeMetaInfo()
-                return path
-
+
-        def _writeMetaInfo(self):
+                self._makeDirectory()
-                path = os.path.join(self._path, METAINFO_FILENAME)
-{
-'creator': self.
-'formatVersion': self.formatVersion,
-}
+dict(
+creator=self._
+formatVersion=self._formatVersion
+)
-                writePlistAtomically(metaInfo, path)
-
+
-        def writeGroups(self, groups):
-
-
+
+
+
+
-                self._makeDirectory()
-                path = os.path.join(self._path, GROUPS_FILENAME)
@@ -242 +406 @@
-                elif os.path.exists(path):
-                        os.remove(path)
-
+
-        def writeInfo(self, info):
-
-
-
+
+
+
+
+
+
+
-                self._makeDirectory()
-                path = os.path.join(self._path, FONTINFO_FILENAME)
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        def writeKerning(self, kerning):
-
-
+
+
+
+
-                self._makeDirectory()
-                path = os.path.join(self._path, KERNING_FILENAME)
@@ -271 +452 @@
-                elif os.path.exists(path):
-                        os.remove(path)
-
+
-        def writeLib(self, libDict):
-
-
+
+
+
+
-                self._makeDirectory()
-                path = os.path.join(self._path, LIB_FILENAME)
@@ -282 +465 @@
-                        os.remove(path)
-
+        def writeFeatures(self, features):
+                """
+                Write features.fea. This method requires a
+                features string as an argument.
+                """
+                if self._formatVersion == 1:
+                        raise UFOLibError("features.fea is not allowed in UFO Format Version 1.")
+                self._makeDirectory()
+                path = os.path.join(self._path, FEATURES_FILENAME)
+                writeFileAtomically(features, path)
+
-        def makeGlyphPath(self):
-
-
+
+
+
+
-                glyphDir = self._makeDirectory(GLYPHS_DIRNAME)
-                return glyphDir
-
-        def getGlyphSet(self, glyphNameToFileNameFunc=None):
-
-
+
+
+
+
-                return GlyphSet(self.makeGlyphPath(), glyphNameToFileNameFunc)
+
+# ----------------
+# Helper Functions
+# ----------------
+
+def makeUFOPath(path):
+        """
+        Return a .ufo pathname.
+
+        >>> makeUFOPath("/directory/something.ext")
+        '/directory/something.ufo'
+        >>> makeUFOPath("/directory/something.another.thing.ext")
+        '/directory/something.another.thing.ufo'
+        """
+        dir, name = os.path.split(path)
+        name = ".".join([".".join(name.split(".")[:-1]), "ufo"])
+        return os.path.join(dir, name)
+
+def writePlistAtomically(obj, path):
+        """
+        Write a plist for "obj" to "path". Do this sort of atomically,
+        making it harder to cause corrupt files, for example when writePlist
+        encounters an error halfway during write. This also checks to see
+        if text matches the text that is already in the file at path.
+        If so, the file is not rewritten so that the modification date
+        is preserved.
+        """
+        f = StringIO()
+        writePlist(obj, f)
+        data = f.getvalue()
+        writeFileAtomically(data, path)
+
+def writeFileAtomically(text, path):
+        """Write text into a file at path. Do this sort of atomically
+        making it harder to cause corrupt files. This also checks to see
+        if text matches the text that is already in the file at path.
+        If so, the file is not rewritten so that the modification date
+        is preserved."""
+        if os.path.exists(path):
+                f = open(path, READ_MODE)
+                oldText = f.read()
+                f.close()
+                if text == oldText:
+                        return
+                # if the text is empty, remove the existing file
+                if not text:
+                        os.remove(path)
+        if text:
+                f = open(path, WRITE_MODE)
+                f.write(text)
+                f.close()
+
+# ----------------------
+# fontinfo.plist Support
+# ----------------------
+
+# Version 1
+
+fontInfoAttributesVersion1 = set([
+        "familyName",
+        "styleName",
+        "fullName",
+        "fontName",
+        "menuName",
+        "fontStyle",
+        "note",
+        "versionMajor",
+        "versionMinor",
+        "year",
+        "copyright",
+        "notice",
+        "trademark",
+        "license",
+        "licenseURL",
+        "createdBy",
+        "designer",
+        "designerURL",
+        "vendorURL",
+        "unitsPerEm",
+        "ascender",
+        "descender",
+        "capHeight",
+        "xHeight",
+        "defaultWidth",
+        "slantAngle",
+        "italicAngle",
+        "widthName",
+        "weightName",
+        "weightValue",
+        "fondName",
+        "otFamilyName",
+        "otStyleName",
+        "otMacName",
+        "msCharSet",
+        "fondID",
+        "uniqueID",
+        "ttVendor",
+        "ttUniqueID",
+        "ttVersion",
+])
+
+# Version 2
+
+# Validators
+
+def validateFontInfoVersion2ValueForAttribute(attr, value):
+        """
+        This performs very basic validation of the value for attribute
+        following the UFO fontinfo.plist specification. The results
+        of this should not be interpretted as *correct* for the font
+        that they are part of. This merely indicates that the value
+        is of the proper type and, where the specification defines
+        a set range of possible values for an attribute, that the
+        value is in the accepted range.
+        """
+        dataValidationDict = _fontInfoAttributesVersion2ValueData[attr]
+        valueType = dataValidationDict.get("type")
+        validator = dataValidationDict.get("valueValidator")
+        valueOptions = dataValidationDict.get("valueOptions")
+        # have specific options for the validator
+        if valueOptions is not None:
+                isValidValue = validator(value, valueOptions)
+        # no specific options
+        else:
+                if validator == _fontInfoTypeValidator:
+                        isValidValue = validator(value, valueType)
+                else:
+                        isValidValue = validator(value)
+        return isValidValue
+
+def _validateInfoVersion2Data(infoData):
+        validInfoData = {}
+        for attr, value in infoData.items():
+                isValidValue = validateFontInfoVersion2ValueForAttribute(attr, value)
+                if not isValidValue:
+                        raise UFOLibError("Invalid value for attribute %s (%s)." % (attr, repr(value)))
+                else:
+                        validInfoData[attr] = value
+        return infoData
+
+def _fontInfoTypeValidator(value, typ):
+        return isinstance(value, typ)
+
+def _fontInfoVersion2IntListValidator(values, validValues):
+        if not isinstance(values, (list, tuple)):
+                return False
+        valuesSet = set(values)
+        validValuesSet = set(validValues)
+        if len(valuesSet - validValuesSet) > 0:
+                return False
+        for value in values:
+                if not isinstance(value, int):
+                        return False
+        return True
+
+def _fontInfoVersion2StyleMapStyleNameValidator(value):
+        options = ["regular", "italic", "bold", "bold italic"]
+        return value in options
+
+def _fontInfoVersion2OpenTypeHeadCreatedValidator(value):
+        # format: 0000/00/00 00:00:00
+        if not isinstance(value, (str, unicode)):
+                return False
+        # basic formatting
+        if not len(value) == 19:
+                return False
+        if value.count(" ") != 1:
+                return False
+        date, time = value.split(" ")
+        if date.count("/") != 2:
+                return False
+        if time.count(":") != 2:
+                return False
+        # date
+        year, month, day = date.split("/")
+        if len(year) != 4:
+                return False
+        if len(month) != 2:
+                return False
+        if len(day) != 2:
+                return False
+        try:
+                year = int(year)
+                month = int(month)
+                day = int(day)
+        except ValueError:
+                return False
+        if month < 1 or month > 12:
+                return False
+        monthMaxDay = calendar.monthrange(year, month)
+        if month > monthMaxDay:
+                return False
+        # time
+        hour, minute, second = time.split(":")
+        if len(hour) != 2:
+                return False
+        if len(minute) != 2:
+                return False
+        if len(second) != 2:
+                return False
+        try:
+                hour = int(hour)
+                minute = int(minute)
+                second = int(second)
+        except ValueError:
+                return False
+        if hour < 0 or hour > 23:
+                return False
+        if minute < 0 or minute > 59:
+                return False
+        if second < 0 or second > 59:
+                return True
+        # fallback
+        return True
+
+def _fontInfoVersion2OpenTypeOS2WeightClassValidator(value):
+        if not isinstance(value, int):
+                return False
+        if value < 0:
+                return False
+        return True
+
+def _fontInfoVersion2OpenTypeOS2WidthClassValidator(value):
+        if not isinstance(value, int):
+                return False
+        if value < 1:
+                return False
+        if value > 9:
+                return False
+        return True
+
+def _fontInfoVersion2OpenTypeOS2PanoseValidator(values):
+        if not isinstance(values, (list, tuple)):
+                return False
+        if len(values) != 10:
+                return False
+        for value in values:
+                if not isinstance(value, int):
+                        return False
+        # XXX further validation?
+        return True
+
+def _fontInfoVersion2OpenTypeOS2FamilyClassValidator(values):
+        if not isinstance(values, (list, tuple)):
+                return False
+        if len(values) != 2:
+                return False
+        for value in values:
+                if not isinstance(value, int):
+                        return False
+        classID, subclassID = values
+        if classID < 0 or classID > 14:
+                return False
+        if subclassID < 0 or subclassID > 15:
+                return False
+        return True
+
+def _fontInfoVersion2PostscriptBluesValidator(values):
+        if not isinstance(values, (list, tuple)):
+                return False
+        if len(values) > 14:
+                return False
+        if len(values) % 2:
+                return False
+        for value in values:
+                if not isinstance(value, (int, float)):
+                        return False
+        return True
+
+def _fontInfoVersion2PostscriptOtherBluesValidator(values):
+        if not isinstance(values, (list, tuple)):
+                return False
+        if len(values) > 10:
+                return False
+        if len(values) % 2:
+                return False
+        for value in values:
+                if not isinstance(value, (int, float)):
+                        return False
+        return True
+
+def _fontInfoVersion2PostscriptStemsValidator(values):
+        if not isinstance(values, (list, tuple)):
+                return False
+        if len(values) > 12:
+                return False
+        for value in values:
+                if not isinstance(value, (int, float)):
+                        return False
+        return True
+
+def _fontInfoVersion2PostscriptWindowsCharacterSetValidator(value):
+        validValues = range(1, 21)
+        if value not in validValues:
+                return False
+        return True
+
+# Attribute Definitions
+# This defines the attributes, types and, in some
+# cases the possible values, that can exist is
+# fontinfo.plist.
+
+_fontInfoVersion2OpenTypeHeadFlagsOptions = range(0, 14)
+_fontInfoVersion2OpenTypeOS2SelectionOptions = [1, 2, 3, 4]
+_fontInfoVersion2OpenTypeOS2UnicodeRangesOptions = range(0, 128)
+_fontInfoVersion2OpenTypeOS2CodePageRangesOptions = range(0, 64)
+_fontInfoVersion2OpenTypeOS2TypeOptions = [0, 1, 2, 3, 8, 9]
+
+_fontInfoAttributesVersion2ValueData = {
+        "familyName"                                                    : dict(type=(str, unicode)),
+        "styleName"                                                             : dict(type=(str, unicode)),
+        "styleMapFamilyName"                                    : dict(type=(str, unicode)),
+        "styleMapStyleName"                                             : dict(type=(str, unicode), valueValidator=_fontInfoVersion2StyleMapStyleNameValidator),
+        "versionMajor"                                                  : dict(type=int),
+        "versionMinor"                                                  : dict(type=int),
+        "year"                                                                  : dict(type=int),
+        "copyright"                                                             : dict(type=(str, unicode)),
+        "trademark"                                                             : dict(type=(str, unicode)),
+        "unitsPerEm"                                                    : dict(type=(int, float)),
+        "descender"                                                             : dict(type=(int, float)),
+        "xHeight"                                                               : dict(type=(int, float)),
+        "capHeight"                                                             : dict(type=(int, float)),
+        "ascender"                                                              : dict(type=(int, float)),
+        "italicAngle"                                                   : dict(type=(float, int)),
+        "note"                                                                  : dict(type=(str, unicode)),
+        "openTypeHeadCreated"                                   : dict(type=(str, unicode), valueValidator=_fontInfoVersion2OpenTypeHeadCreatedValidator),
+        "openTypeHeadLowestRecPPEM"                             : dict(type=(int, float)),
+        "openTypeHeadFlags"                                             : dict(type="integerList", valueValidator=_fontInfoVersion2IntListValidator, valueOptions=_fontInfoVersion2OpenTypeHeadFlagsOptions),
+        "openTypeHheaAscender"                                  : dict(type=(int, float)),
+        "openTypeHheaDescender"                                 : dict(type=(int, float)),
+        "openTypeHheaLineGap"                                   : dict(type=(int, float)),
+        "openTypeHheaCaretSlopeRise"                    : dict(type=int),
+        "openTypeHheaCaretSlopeRun"                             : dict(type=int),
+        "openTypeHheaCaretOffset"                               : dict(type=(int, float)),
+        "openTypeNameDesigner"                                  : dict(type=(str, unicode)),
+        "openTypeNameDesignerURL"                               : dict(type=(str, unicode)),
+        "openTypeNameManufacturer"                              : dict(type=(str, unicode)),
+        "openTypeNameManufacturerURL"                   : dict(type=(str, unicode)),
+        "openTypeNameLicense"                                   : dict(type=(str, unicode)),
+        "openTypeNameLicenseURL"                                : dict(type=(str, unicode)),
+        "openTypeNameVersion"                                   : dict(type=(str, unicode)),
+        "openTypeNameUniqueID"                                  : dict(type=(str, unicode)),
+        "openTypeNameDescription"                               : dict(type=(str, unicode)),
+        "openTypeNamePreferredFamilyName"               : dict(type=(str, unicode)),
+        "openTypeNamePreferredSubfamilyName"    : dict(type=(str, unicode)),
+        "openTypeNameCompatibleFullName"                : dict(type=(str, unicode)),
+        "openTypeNameSampleText"                                : dict(type=(str, unicode)),
+        "openTypeNameWWSFamilyName"                             : dict(type=(str, unicode)),
+        "openTypeNameWWSSubfamilyName"                  : dict(type=(str, unicode)),
+        "openTypeOS2WidthClass"                                 : dict(type=int, valueValidator=_fontInfoVersion2OpenTypeOS2WidthClassValidator),
+        "openTypeOS2WeightClass"                                : dict(type=int, valueValidator=_fontInfoVersion2OpenTypeOS2WeightClassValidator),
+        "openTypeOS2Selection"                                  : dict(type="integerList", valueValidator=_fontInfoVersion2IntListValidator, valueOptions=_fontInfoVersion2OpenTypeOS2SelectionOptions),
+        "openTypeOS2VendorID"                                   : dict(type=(str, unicode)),
+        "openTypeOS2Panose"                                             : dict(type="integerList", valueValidator=_fontInfoVersion2OpenTypeOS2PanoseValidator),
+        "openTypeOS2FamilyClass"                                : dict(type="integerList", valueValidator=_fontInfoVersion2OpenTypeOS2FamilyClassValidator),
+        "openTypeOS2UnicodeRanges"                              : dict(type="integerList", valueValidator=_fontInfoVersion2IntListValidator, valueOptions=_fontInfoVersion2OpenTypeOS2UnicodeRangesOptions),
+        "openTypeOS2CodePageRanges"                             : dict(type="integerList", valueValidator=_fontInfoVersion2IntListValidator, valueOptions=_fontInfoVersion2OpenTypeOS2CodePageRangesOptions),
+        "openTypeOS2TypoAscender"                               : dict(type=(int, float)),
+        "openTypeOS2TypoDescender"                              : dict(type=(int, float)),
+        "openTypeOS2TypoLineGap"                                : dict(type=(int, float)),
+        "openTypeOS2WinAscent"                                  : dict(type=(int, float)),
+        "openTypeOS2WinDescent"                                 : dict(type=(int, float)),
+        "openTypeOS2Type"                                               : dict(type="integerList", valueValidator=_fontInfoVersion2IntListValidator, valueOptions=_fontInfoVersion2OpenTypeOS2TypeOptions),
+        "openTypeOS2SubscriptXSize"                             : dict(type=(int, float)),
+        "openTypeOS2SubscriptYSize"                             : dict(type=(int, float)),
+        "openTypeOS2SubscriptXOffset"                   : dict(type=(int, float)),
+        "openTypeOS2SubscriptYOffset"                   : dict(type=(int, float)),
+        "openTypeOS2SuperscriptXSize"                   : dict(type=(int, float)),
+        "openTypeOS2SuperscriptYSize"                   : dict(type=(int, float)),
+        "openTypeOS2SuperscriptXOffset"                 : dict(type=(int, float)),
+        "openTypeOS2SuperscriptYOffset"                 : dict(type=(int, float)),
+        "openTypeOS2StrikeoutSize"                              : dict(type=(int, float)),
+        "openTypeOS2StrikeoutPosition"                  : dict(type=(int, float)),
+        "openTypeVheaVertTypoAscender"                  : dict(type=(int, float)),
+        "openTypeVheaVertTypoDescender"                 : dict(type=(int, float)),
+        "openTypeVheaVertTypoLineGap"                   : dict(type=(int, float)),
+        "openTypeVheaCaretSlopeRise"                    : dict(type=int),
+        "openTypeVheaCaretSlopeRun"                             : dict(type=int),
+        "openTypeVheaCaretOffset"                               : dict(type=(int, float)),
+        "postscriptFontName"                                    : dict(type=(str, unicode)),
+        "postscriptFullName"                                    : dict(type=(str, unicode)),
+        "postscriptSlantAngle"                                  : dict(type=(float, int)),
+        "postscriptUniqueID"                                    : dict(type=int),
+        "postscriptUnderlineThickness"                  : dict(type=(int, float)),
+        "postscriptUnderlinePosition"                   : dict(type=(int, float)),
+        "postscriptIsFixedPitch"                                : dict(type=bool),
+        "postscriptBlueValues"                                  : dict(type="integerList", valueValidator=_fontInfoVersion2PostscriptBluesValidator),
+        "postscriptOtherBlues"                                  : dict(type="integerList", valueValidator=_fontInfoVersion2PostscriptOtherBluesValidator),
+        "postscriptFamilyBlues"                                 : dict(type="integerList", valueValidator=_fontInfoVersion2PostscriptBluesValidator),
+        "postscriptFamilyOtherBlues"                    : dict(type="integerList", valueValidator=_fontInfoVersion2PostscriptOtherBluesValidator),
+        "postscriptStemSnapH"                                   : dict(type="integerList", valueValidator=_fontInfoVersion2PostscriptStemsValidator),
+        "postscriptStemSnapV"                                   : dict(type="integerList", valueValidator=_fontInfoVersion2PostscriptStemsValidator),
+        "postscriptBlueFuzz"                                    : dict(type=(int, float)),
+        "postscriptBlueShift"                                   : dict(type=(int, float)),
+        "postscriptBlueScale"                                   : dict(type=(float, int)),
+        "postscriptForceBold"                                   : dict(type=bool),
+        "postscriptDefaultWidthX"                               : dict(type=(int, float)),
+        "postscriptNominalWidthX"                               : dict(type=(int, float)),
+        "postscriptWeightName"                                  : dict(type=(str, unicode)),
+        "postscriptDefaultCharacter"                    : dict(type=(str, unicode)),
+        "postscriptWindowsCharacterSet"                 : dict(type=int, valueValidator=_fontInfoVersion2PostscriptWindowsCharacterSetValidator),
+        "macintoshFONDFamilyID"                                 : dict(type=int),
+        "macintoshFONDName"                                             : dict(type=(str, unicode)),
+}
+fontInfoAttributesVersion2 = set(_fontInfoAttributesVersion2ValueData.keys())
+
+# insert the type validator for all attrs that
+# have no defined validator.
+for attr, dataDict in _fontInfoAttributesVersion2ValueData.items():
+        if "valueValidator" not in dataDict:
+                dataDict["valueValidator"] = _fontInfoTypeValidator
+
+# Version Conversion Support
+# These are used from converting from version 1
+# to version 2 or vice-versa.
+
+def _flipDict(d):
+        flipped = {}
+        for key, value in d.items():
+                flipped[value] = key
+        return flipped
+
+_fontInfoAttributesVersion1To2 = {
+        "menuName"              : "styleMapFamilyName",
+        "designer"              : "openTypeNameDesigner",
+        "designerURL"   : "openTypeNameDesignerURL",
+        "createdBy"             : "openTypeNameManufacturer",
+        "vendorURL"             : "openTypeNameManufacturerURL",
+        "license"               : "openTypeNameLicense",
+        "licenseURL"    : "openTypeNameLicenseURL",
+        "ttVersion"             : "openTypeNameVersion",
+        "ttUniqueID"    : "openTypeNameUniqueID",
+        "notice"                : "openTypeNameDescription",
+        "otFamilyName"  : "openTypeNamePreferredFamilyName",
+        "otStyleName"   : "openTypeNamePreferredSubfamilyName",
+        "otMacName"             : "openTypeNameCompatibleFullName",
+        "weightName"    : "postscriptWeightName",
+        "weightValue"   : "openTypeOS2WeightClass",
+        "ttVendor"              : "openTypeOS2VendorID",
+        "uniqueID"              : "postscriptUniqueID",
+        "fontName"              : "postscriptFontName",
+        "fondID"                : "macintoshFONDFamilyID",
+        "fondName"              : "macintoshFONDName",
+        "defaultWidth"  : "postscriptDefaultWidthX",
+        "slantAngle"    : "postscriptSlantAngle",
+        "fullName"              : "postscriptFullName",
+        # require special value conversion
+        "fontStyle"             : "styleMapStyleName",
+        "widthName"             : "openTypeOS2WidthClass",
+        "msCharSet"             : "postscriptWindowsCharacterSet"
+}
+_fontInfoAttributesVersion2To1 = _flipDict(_fontInfoAttributesVersion1To2)
+deprecatedFontInfoAttributesVersion2 = set(_fontInfoAttributesVersion1To2.keys())
+
+_fontStyle1To2 = {
+        64 : "regular",
+        1  : "italic",
+        32 : "bold",
+        33 : "bold italic"
+}
+_fontStyle2To1 = _flipDict(_fontStyle1To2)
+# Some UFO 1 files have 0
+_fontStyle1To2[0] = "regular"
+
+_widthName1To2 = {
+        "Ultra-condensed" : 1,
+        "Extra-condensed" : 2,
+        "Condensed"               : 3,
+        "Semi-condensed"  : 4,
+        "Medium (normal)" : 5,
+        "Semi-expanded"   : 6,
+        "Expanded"                : 7,
+        "Extra-expanded"  : 8,
+        "Ultra-expanded"  : 9
+}
+_widthName2To1 = _flipDict(_widthName1To2)
+# FontLab's default width value is "Normal".
+# Many format version 1 UFOs will have this.
+_widthName1To2["Normal"] = 5
+# FontLab has an "All" width value. In UFO 1
+# move this up to "Normal".
+_widthName1To2["All"] = 5
+# "medium" appears in a lot of UFO 1 files.
+_widthName1To2["medium"] = 5
+
+_msCharSet1To2 = {
+        0       : 1,
+        1       : 2,
+        2       : 3,
+        77      : 4,
+        128 : 5,
+        129 : 6,
+        130 : 7,
+        134 : 8,
+        136 : 9,
+        161 : 10,
+        162 : 11,
+        163 : 12,
+        177 : 13,
+        178 : 14,
+        186 : 15,
+        200 : 16,
+        204 : 17,
+        222 : 18,
+        238 : 19,
+        255 : 20
+}
+_msCharSet2To1 = _flipDict(_msCharSet1To2)
+
+def convertFontInfoValueForAttributeFromVersion1ToVersion2(attr, value):
+        """
+        Convert value from version 1 to version 2 format.
+        Returns the new attribute name and the converted value.
+        If the value is None, None will be returned for the new value.
+        """
+        # convert floats to ints if possible
+        if isinstance(value, float):
+                if int(value) == value:
+                        value = int(value)
+        if value is not None:
+                if attr == "fontStyle":
+                        v = _fontStyle1To2.get(value)
+                        if v is None:
+                                raise UFOLibError("Cannot convert value (%s) for attribute %s." % (repr(value), attr))
+                        value = v
+                elif attr == "widthName":
+                        v = _widthName1To2.get(value)
+                        if v is None:
+                                raise UFOLibError("Cannot convert value (%s) for attribute %s." % (repr(value), attr))
+                        value = v
+                elif attr == "msCharSet":
+                        v = _msCharSet1To2.get(value)
+                        if v is None:
+                                raise UFOLibError("Cannot convert value (%s) for attribute %s." % (repr(value), attr))
+                        value = v
+        attr = _fontInfoAttributesVersion1To2.get(attr, attr)
+        return attr, value
+
+def convertFontInfoValueForAttributeFromVersion2ToVersion1(attr, value):
+        """
+        Convert value from version 2 to version 1 format.
+        Returns the new attribute name and the converted value.
+        If the value is None, None will be returned for the new value.
+        """
+        if value is not None:
+                if attr == "styleMapStyleName":
+                        value = _fontStyle2To1.get(value)
+                elif attr == "openTypeOS2WidthClass":
+                        value = _widthName2To1.get(value)
+                elif attr == "postscriptWindowsCharacterSet":
+                        value = _msCharSet2To1.get(value)
+        attr = _fontInfoAttributesVersion2To1.get(attr, attr)
+        return attr, value
+
+def _convertFontInfoDataVersion1ToVersion2(data):
+        converted = {}
+        for attr, value in data.items():
+                # FontLab gives -1 for the weightValue
+                # for fonts wil no defined value. Many
+                # format version 1 UFOs will have this.
+                if attr == "weightValue" and value == -1:
+                        continue
+                newAttr, newValue = convertFontInfoValueForAttributeFromVersion1ToVersion2(attr, value)
+                # skip if the attribute is not part of version 2
+                if newAttr not in fontInfoAttributesVersion2:
+                        continue
+                # catch values that can't be converted
+                if value is None:
+                        raise UFOLibError("Cannot convert value (%s) for attribute %s." % (repr(value), newAttr))
+                # store
+                converted[newAttr] = newValue
+        return converted
+
+def _convertFontInfoDataVersion2ToVersion1(data):
+        converted = {}
+        for attr, value in data.items():
+                newAttr, newValue = convertFontInfoValueForAttributeFromVersion2ToVersion1(attr, value)
+                # only take attributes that are registered for version 1
+                if newAttr not in fontInfoAttributesVersion1:
+                        continue
+                # catch values that can't be converted
+                if value is None:
+                        raise UFOLibError("Cannot convert value (%s) for attribute %s." % (repr(value), newAttr))
+                # store
+                converted[newAttr] = newValue
+        return converted
+
+
+if __name__ == "__main__":
+        import doctest
+        doctest.testmod()

trunk/Scripts/RoboFabIntro/demo_FindCompatibleGlyphs.py

@@ -22 +22 @@
-
-print
-f
+postscriptF
-for d, names in compatibles.items():
-        if len(names) > 1:

trunk/Scripts/RoboFabIntro/intro_FontObject.py

@@ -31 +31 @@
-else:
-        # and another dialog.
-f
+postscriptF
-
-        # let's have a look at some of the attributes a RoboFab Font object has
@@ -38 +38 @@
-        # some of the attributes map straight to the FontLab Font class
-        # We just straightened the camelCase here and there
-f
+postscriptF
-        print "list of glyph names:", f.keys()
-        print 'ascender:', f.info.ascender

trunk/Scripts/RoboFabIntro/intro_FoundrySettings.py

@@ -51 +51 @@
-font.info.copyright = mySettings['copyright']
-font.info.trademark = mySettings['trademark']
-l
-l
-notice
-ttVendor
-vendo
-d
-d
+openTypeNameL
+openTypeNameL
+openTypeNameDescription
+openTypeOS2VendorID
+openTypeNameManufacture
+openTypeNameD
+openTypeNameD
-
-# and call the update method

trunk/Scripts/RoboFabIntro/intro_Kerning.py

@@ -30 +30 @@
-
-# kerning gives you access to some bits of global data
-f
+postscriptF
-print "the average kerning value is %s"%kerning.getAverage()
-min, max = kerning.getExtremes()

trunk/Scripts/RoboFabUtils/RobustBatchGenerate.py

@@ -26 +26 @@
-
-def generateOne(f, dstDir):
-f
+postscriptF
-        f.generate('mactype1',  dstDir)
-        

trunk/Scripts/RoboFabUtils/TestFontEquality.py

@@ -9 +9 @@
-line = []
-for n in af:
-f
+postscriptF
-results.append(line)
-
@@ -15 +15 @@
-        one = af[i]
-        line = []
-f
+postscriptF
-        for j in range(len(af)):
-                other = af[j]