Python Font.keys方法代码示例

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
 def test_insertGlyph(self):
     font = Font(getTestFontPath())
     glyph = Glyph()
     glyph.name = "NewGlyphTest"
     self.assertEqual(sorted(font.keys()), ["A", "B", "C"])
     font.insertGlyph(glyph)
     self.assertEqual(sorted(font.keys()), ["A", "B", "C", "NewGlyphTest"])

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
 def test_keys(self):
     font = Font(getTestFontPath())
     self.assertEqual(sorted(font.keys()), ["A", "B", "C"])
     del font["A"]
     self.assertEqual(sorted(font.keys()), ["B", "C"])
     font.newGlyph("A")
     self.assertEqual(sorted(font.keys()), ["A", "B", "C"])
     font = Font()
     self.assertEqual(font.keys(), set())
     font.newGlyph("A")
     self.assertEqual(sorted(font.keys()), ["A"])

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
 def test_newGlyph(self):
     font = Font(getTestFontPath())
     glyph = font.newGlyph("NewGlyphTest")
     self.assertEqual(glyph.name, "NewGlyphTest")
     self.assertTrue(glyph.dirty)
     self.assertTrue(font.dirty)
     self.assertEqual(sorted(font.keys()), ["A", "B", "C", "NewGlyphTest"])

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
 def test_updateGlyphOrder_rename(self):
     font = Font(getTestFontPath())
     self.assertEqual(font.glyphOrder, [])
     font.glyphOrder = sorted(font.keys())
     self.assertEqual(font.glyphOrder, ["A", "B", "C"])
     font.updateGlyphOrder(addedGlyph="new", removedGlyph="B")
     self.assertEqual(font.glyphOrder, ["A", "new", "C"])

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
    def test_name_set(self):
        font = Font(getTestFontPath())
        glyph = font["A"]
        glyph.name = "RenamedGlyph"
        self.assertEqual(glyph.name, "RenamedGlyph")
        self.assertEqual(sorted(font.keys()), ["B", "C", "RenamedGlyph"])

        font = Font(getTestFontPath())
        glyph = font["A"]
        glyph.name = "A"
        self.assertFalse(glyph.dirty)

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
 def test_glyphOrder(self):
     font = Font(getTestFontPath())
     self.assertEqual(font.glyphOrder, [])
     font.glyphOrder = sorted(font.keys())
     self.assertEqual(font.glyphOrder, ["A", "B", "C"])
     layer = font.layers.defaultLayer
     layer.newGlyph("X")
     self.assertEqual(sorted(layer.keys()), ["A", "B", "C", "X"])
     self.assertEqual(font.glyphOrder, ["A", "B", "C", "X"])
     del layer["A"]
     self.assertEqual(font.glyphOrder, ["A", "B", "C", "X"])
     del layer["X"]
     self.assertEqual(font.glyphOrder, ["A", "B", "C"])
     layer["B"].name = "Y"
     self.assertEqual(font.glyphOrder, ["A", "Y", "C"])

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
 def test_delitem(self):
     path = makeTestFontCopy()
     font = Font(path)
     del font["A"]
     self.assertTrue(font.dirty)
     font.newGlyph("NewGlyphTest")
     del font["NewGlyphTest"]
     self.assertEqual(sorted(font.keys()), ["B", "C"])
     self.assertEqual(len(font), 2)
     self.assertFalse("A" in font)
     font.save()
     fileNames = glob.glob(os.path.join(path, 'glyphs', '*.glif'))
     fileNames = [os.path.basename(fileName) for fileName in fileNames]
     self.assertEqual(sorted(fileNames), ["B_.glif", "C_.glif"])
     with self.assertRaises(KeyError):
         del font["NotInFont"]

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
except ImportError:
    # on command line
    fontPaths = sys.argv[1:]
    platform = 'CL'


if len(fontPaths):

    for fontPath in fontPaths:
        f = Font(fontPath)
        if not enc:
            # only necessary once for multiple UFOs
            enc = makeEnc(f, platform)

        remainingGlyphs = sorted(list(set(f.keys()) - set(enc)))

        f.lib['com.typemytype.robofont.sort'] = {
            'ascending': enc+remainingGlyphs,
            'type': 'glyphList'}
        f.lib['public.glyphOrder'] = enc+remainingGlyphs

        grey = [0.5, 0.5, 0.5, 0.5]
        for gName in remainingGlyphs:
            if gName in f:
                f[gName].lib['com.typemytype.robofont.mark'] = grey

        if platform == 'CL':
            f.save()
            print 'sorted', f.path

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
 def test_glyph_name_change(self):
     font = Font(getTestFontPath())
     glyph = font["A"]
     glyph.name = "NameChangeTest"
     self.assertEqual(sorted(font.keys()), ["B", "C", "NameChangeTest"])
     self.assertTrue(font.dirty)

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
            lang = lang.strip(';')
            if script not in scripts:
                scripts[script] = []
            if lang not in scripts[script]:
                scripts[script].append(lang)
    return OrderedDict((script, tuple(langs)) for script,langs in scripts.items())


if __name__ == '__main__':
    from defcon import Font

    font = Font(path=sys.argv[2])
    for mergePath in sys.argv[3:]:
        merge = Font(path=mergePath)
        # merge glyphs
        for name in merge.keys():
            glyph = merge[name]
            # had an error related to anchors, but I don't need anchors here
            glyph.anchors = []
            font.insertGlyph(glyph, name=name)
        # merge groups
        font.groups.update(merge.groups)
        # merge kerning
        font.kerning.update(merge.kerning)



    # scripts = {'arab': ('dflt', 'ARA ', 'URD ', 'FAR '), 'latn': ('dflt', 'TRK ')}
    # scripts = scriptsFromFea(sys.argv[1])
    # scripts = {'arab': ('dflt', ), 'latn': ('dflt', )}
    scripts = {

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import keys [as 别名]
import sys, os
def ufoGlyphOrderSetter(existingOrder, newOrder):
    outOrder=[]
    for glyphName in newOrder:
        if glyphName not in existingOrder:
            outOrder.append(glyphName)
    return outOrder

arguments=sys.argv
fontList=arguments[2:]

print "Merging fonts..."
print os.getcwd()
new_ufo = Font()
new_ufo = Font(fontList[0])

for font in fontList[1:]:
    source= Font(font)
    if source.kerning._dataOnDisk is not None:
        pair_list=source.kerning.keys()
        for pair in pair_list:
            new_ufo.kerning[pair]=source.kerning[pair]
    glyph_name_list=ufoGlyphOrderSetter(new_ufo.keys(), source.keys())
    for glyph_name in glyph_name_list:
        glyph = source[glyph_name]
        print glyph_name,
        new_ufo._glyphSet._insertGlyph(glyph)

new_ufo.save(arguments[1])
print "\nMerge complete!"