Python Font.newGlyph方法代码示例

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [as 别名]
 def test_glyph_dispatcher_new(self):
     font = Font()
     font.newGlyph("A")
     glyph = font["A"]
     pen = glyph.getPointPen()
     pen.beginPath()
     pen.addPoint((0, 0), segmentType="line")
     pen.addPoint((0, 100), segmentType="line")
     pen.addPoint((100, 100), segmentType="line")
     pen.addPoint((100, 0), segmentType="line")
     pen.endPath()
     contour = glyph[0]
     self.assertEqual(contour.getParent(), glyph)
     self.assertEqual(contour.dispatcher, font.dispatcher)
     component = Component()
     glyph.appendComponent(component)
     self.assertEqual(component.getParent(), glyph)
     self.assertEqual(component.dispatcher, font.dispatcher)
     anchor = Anchor()
     glyph.appendAnchor(anchor)
     self.assertEqual(anchor.getParent(), glyph)
     self.assertEqual(anchor.dispatcher, font.dispatcher)
     guideline = Guideline()
     glyph.appendGuideline(guideline)
     self.assertEqual(guideline.getParent(), glyph)
     self.assertEqual(guideline.dispatcher, font.dispatcher)

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [as 别名]
def compileDecompileCompareDumps(features, expectedDump):
    # make the font
    font = Font()
    font.info.unitsPerEm = 1000
    font.info.ascender = 750
    font.info.descender = -250
    font.info.xHeight = 500
    font.info.capHeight = 750
    font.info.familyName = "Test"
    font.info.styleName = "Regular"
    glyphNames = [i for i in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
    for glyphName in glyphNames:
        font.newGlyph(glyphName)
        glyph = font[glyphName]
        glyph.unicode = AGL2UV.get(glyphName)
    font.features.text = features
    # compile to OTF
    handle, path = tempfile.mkstemp()
    compiler = OTFCompiler()
    errors = compiler.compile(font, path)["makeotf"]
    # extract the features
    try:
        tables = decompileBinaryToObject(path, compress=True)
    # print compiler errors
    except TTLibError:
        print errors
    # get rid of the temp file
    finally:
        os.remove(path)
    # dump
    writer = DumpWriter()
    tables["GSUB"].write(writer)
    dump = writer.dump()
    # compare
    compareDumps(expectedDump, dump)

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [as 别名]
 def test_glyph_dispatcher_inserted(self):
     font = Font()
     font.newGlyph("A")
     glyph = font["A"]
     pen = glyph.getPointPen()
     pen.beginPath()
     pen.addPoint((0, 0), segmentType="line")
     pen.addPoint((0, 100), segmentType="line")
     pen.addPoint((100, 100), segmentType="line")
     pen.addPoint((100, 0), segmentType="line")
     pen.endPath()
     contour = glyph[0]
     component = Component()
     glyph.appendComponent(component)
     anchor = Anchor()
     glyph.appendAnchor(anchor)
     guideline = Guideline()
     glyph.appendGuideline(guideline)
     sourceGlyph = glyph
     newFont = Font()
     insertedGlyph = newFont.insertGlyph(sourceGlyph)
     contour = insertedGlyph[0]
     self.assertTrue(contour.getParent(), insertedGlyph)
     self.assertTrue(contour.dispatcher, newFont.dispatcher)
     component = insertedGlyph.components[0]
     self.assertTrue(component.getParent(), insertedGlyph)
     self.assertTrue(component.dispatcher, newFont.dispatcher)
     anchor = insertedGlyph.anchors[0]
     self.assertTrue(anchor.getParent(), insertedGlyph)
     self.assertTrue(anchor.dispatcher, newFont.dispatcher)
     guideline = insertedGlyph.guidelines[0]
     self.assertTrue(guideline.getParent(), insertedGlyph)
     self.assertTrue(guideline.dispatcher, newFont.dispatcher)

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [as 别名]
def testDummyFont():
    from defcon import Font
    font = Font()
    for i, glyphName in enumerate(("a", "grave", "f", "i", "agrave")):
        font.newGlyph(glyphName)
        testDummyGlyph(font[glyphName], i)
        font[glyphName].width = 60 + 10 * i
    return font

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [as 别名]
def _makeTestFont():
    from fontTools.agl import AGL2UV
    from defcon import Font
    font = Font()
    for name in "ABCD":
        font.newGlyph(name)
        font.newGlyph(name + ".alt1")
        font.newGlyph(name + ".alt2")
    for glyph in font:
        glyph.unicode = AGL2UV.get(glyph.name)
    return font

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [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 newGlyph [as 别名]
 def test_markColor(self):
     from defcon.objects.font import Font
     font = Font()
     font.newGlyph("A")
     glyph = font["A"]
     self.assertIsNone(glyph.markColor)
     glyph.markColor = "1,0,1,0"
     self.assertEqual(glyph.markColor, "1,0,1,0")
     glyph.markColor = "1,0,1,0"
     self.assertEqual(glyph.markColor, "1,0,1,0")
     glyph.markColor = None
     self.assertIsNone(glyph.markColor)

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [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 newGlyph [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 newGlyph [as 别名]
 def test_add_classes(self):
     ufo = Font()
     glyph = ufo.newGlyph('grave')
     glyph.appendAnchor(glyph.anchorClass(
         anchorDict={'name': '_top', 'x': 100, 'y': 200}))
     glyph = ufo.newGlyph('cedilla')
     glyph.appendAnchor(glyph.anchorClass(
         anchorDict={'name': '_bottom', 'x': 100, 'y': 0}))
     lines = []
     writer = MarkFeatureWriter(
         ufo, anchorList=(('bottom', '_bottom'),), mkmkAnchorList=(),
         ligaAnchorList=((('top_1', 'top_2'), '_top'),))
     writer._addClasses(lines, doMark=True, doMkmk=True)
     self.assertEqual(
         '\n'.join(lines).strip(),
         'markClass cedilla <anchor 100 0> @MC_bottom;\n\n'
         'markClass grave <anchor 100 200> @MC_top;')

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [as 别名]
 def test_bottomMargin_get(self):
     font = Font(getTestFontPath())
     glyph = font["A"]
     self.assertEqual(glyph.bottomMargin, 0)
     glyph = font["B"]
     self.assertEqual(glyph.bottomMargin, 0)
     # empty glyph
     glyph = font.newGlyph("D")
     self.assertIsNone(glyph.bottomMargin)

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [as 别名]
 def test_topMargin_get(self):
     from defcon.test.testTools import getTestFontPath
     from defcon.objects.font import Font
     font = Font(getTestFontPath())
     glyph = font["A"]
     self.assertEqual(glyph.topMargin, -200)
     # empty glyph
     glyph = font.newGlyph("D")
     self.assertIsNone(glyph.topMargin)

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [as 别名]
def createRandomFont():
    from defcon import Font
    
    maxGlyphs = 1000
    maxContours = 10
    maxSegments = 10
    maxBox = 700
    drawCallbacks = [drawLineTo, drawCurveTo]
    f = Font()
    for i in range(maxGlyphs):
        name = "%s" %i
        f.newGlyph(name)
        g = f[name]
        g.width = maxBox
        pen = g.getPen()
        for c in range(maxContours):
            drawMoveTo(pen, maxBox)
            for s in range(maxSegments):            
                random.choice(drawCallbacks)(pen, maxBox)
            drawClosePath(pen)
    return f

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [as 别名]
    def test_glyph_unicodes_changed(self):
        font = Font(getTestFontPath())
        glyph = font["A"]
        glyph.unicodes = [123, 456]
        self.assertEqual(font.unicodeData[123], ["A"])
        self.assertEqual(font.unicodeData[456], ["A"])
        self.assertEqual(font.unicodeData[66], ["B"])

        font = Font(getTestFontPath())
        glyph = font.newGlyph("test")
        glyph.unicodes = [65]
        self.assertEqual(font.unicodeData[65], ["test", "A"])

# 需要导入模块: from defcon import Font [as 别名]
# 或者: from defcon.Font import newGlyph [as 别名]
    def test_decomposeComponent_nested_components(self):
        font = Font()
        font.newGlyph("baseGlyph")
        baseGlyph = font["baseGlyph"]
        pointPen = baseGlyph.getPointPen()
        pointPen.beginPath(identifier="contour1")
        pointPen.addPoint((0, 0), "move", identifier="point1")
        pointPen.addPoint((0, 100), "line")
        pointPen.addPoint((100, 100), "line")
        pointPen.addPoint((100, 0), "line")
        pointPen.addPoint((0, 0), "line")
        pointPen.endPath()

        font.newGlyph("referenceGlyph1")
        referenceGlyph1 = font["referenceGlyph1"]
        pointPen = referenceGlyph1.getPointPen()
        pointPen.addComponent("baseGlyph", (1, 0, 0, 1, 3, 6))
        font.newGlyph("referenceGlyph2")
        referenceGlyph2 = font["referenceGlyph2"]
        pointPen = referenceGlyph2.getPointPen()
        pointPen.addComponent("referenceGlyph1", (1, 0, 0, 1, 10, 20))
        referenceGlyph2.decomposeAllComponents()
        self.assertEqual(len(referenceGlyph2.components), 0)
        self.assertEqual(len(referenceGlyph1.components), 1)
        self.assertEqual(len(referenceGlyph2), 1)
        self.assertEqual(referenceGlyph2.bounds, (13, 26, 113, 126))