From 8932ab427fa2201a01a9930591a55525ddc8e0b5 Mon Sep 17 00:00:00 2001 From: Just van Rossum Date: Mon, 29 Aug 2022 19:28:46 +0200 Subject: [PATCH] Convert tabs to spaces --- Lib/fontTools/ttLib/ttGlyphSet.py | 426 +++++++++++++++--------------- 1 file changed, 213 insertions(+), 213 deletions(-) diff --git a/Lib/fontTools/ttLib/ttGlyphSet.py b/Lib/fontTools/ttLib/ttGlyphSet.py index 24441ea7e..8b01ea1b1 100644 --- a/Lib/fontTools/ttLib/ttGlyphSet.py +++ b/Lib/fontTools/ttLib/ttGlyphSet.py @@ -6,273 +6,273 @@ from copy import copy class _TTGlyphSet(object): - """Generic dict-like GlyphSet class that pulls metrics from hmtx and - glyph shape from TrueType or CFF. - """ + """Generic dict-like GlyphSet class that pulls metrics from hmtx and + glyph shape from TrueType or CFF. + """ - def __init__(self, ttFont, glyphs, glyphType): - """Construct a new glyphset. + def __init__(self, ttFont, glyphs, glyphType): + """Construct a new glyphset. - Args: - font (TTFont): The font object (used to get metrics). - glyphs (dict): A dictionary mapping glyph names to ``_TTGlyph`` objects. - glyphType (class): Either ``_TTGlyphCFF`` or ``_TTGlyphGlyf``. - """ - self._glyphs = glyphs - self._hmtx = ttFont["hmtx"] - self._vmtx = ttFont["vmtx"] if "vmtx" in ttFont else None - self._glyphType = glyphType + Args: + font (TTFont): The font object (used to get metrics). + glyphs (dict): A dictionary mapping glyph names to ``_TTGlyph`` objects. + glyphType (class): Either ``_TTGlyphCFF`` or ``_TTGlyphGlyf``. + """ + self._glyphs = glyphs + self._hmtx = ttFont["hmtx"] + self._vmtx = ttFont["vmtx"] if "vmtx" in ttFont else None + self._glyphType = glyphType - def keys(self): - return list(self._glyphs.keys()) + def keys(self): + return list(self._glyphs.keys()) - def has_key(self, glyphName): - return glyphName in self._glyphs + def has_key(self, glyphName): + return glyphName in self._glyphs - __contains__ = has_key + __contains__ = has_key - def __getitem__(self, glyphName): - horizontalMetrics = self._hmtx[glyphName] - verticalMetrics = self._vmtx[glyphName] if self._vmtx else None - return self._glyphType( - self, self._glyphs[glyphName], horizontalMetrics, verticalMetrics - ) + def __getitem__(self, glyphName): + horizontalMetrics = self._hmtx[glyphName] + verticalMetrics = self._vmtx[glyphName] if self._vmtx else None + return self._glyphType( + self, self._glyphs[glyphName], horizontalMetrics, verticalMetrics + ) - def __len__(self): - return len(self._glyphs) + def __len__(self): + return len(self._glyphs) - def get(self, glyphName, default=None): - try: - return self[glyphName] - except KeyError: - return default + def get(self, glyphName, default=None): + try: + return self[glyphName] + except KeyError: + return default class _TTGlyph(object): - """Wrapper for a TrueType glyph that supports the Pen protocol, meaning - that it has .draw() and .drawPoints() methods that take a pen object as - their only argument. Additionally there are 'width' and 'lsb' attributes, - read from the 'hmtx' table. + """Wrapper for a TrueType glyph that supports the Pen protocol, meaning + that it has .draw() and .drawPoints() methods that take a pen object as + their only argument. Additionally there are 'width' and 'lsb' attributes, + read from the 'hmtx' table. - If the font contains a 'vmtx' table, there will also be 'height' and 'tsb' - attributes. - """ + If the font contains a 'vmtx' table, there will also be 'height' and 'tsb' + attributes. + """ - def __init__(self, glyphset, glyph, horizontalMetrics=None, verticalMetrics=None): - """Construct a new _TTGlyph. + def __init__(self, glyphset, glyph, horizontalMetrics=None, verticalMetrics=None): + """Construct a new _TTGlyph. - Args: - glyphset (_TTGlyphSet): A glyphset object used to resolve components. - glyph (ttLib.tables._g_l_y_f.Glyph): The glyph object. - horizontalMetrics (int, int): The glyph's width and left sidebearing. - """ - self._glyphset = glyphset - self._glyph = glyph - if horizontalMetrics: - self.width, self.lsb = horizontalMetrics - else: - self.width, self.lsb = None, None - if verticalMetrics: - self.height, self.tsb = verticalMetrics - else: - self.height, self.tsb = None, None + Args: + glyphset (_TTGlyphSet): A glyphset object used to resolve components. + glyph (ttLib.tables._g_l_y_f.Glyph): The glyph object. + horizontalMetrics (int, int): The glyph's width and left sidebearing. + """ + self._glyphset = glyphset + self._glyph = glyph + if horizontalMetrics: + self.width, self.lsb = horizontalMetrics + else: + self.width, self.lsb = None, None + if verticalMetrics: + self.height, self.tsb = verticalMetrics + else: + self.height, self.tsb = None, None - def draw(self, pen): - """Draw the glyph onto ``pen``. See fontTools.pens.basePen for details - how that works. - """ - self._glyph.draw(pen) + def draw(self, pen): + """Draw the glyph onto ``pen``. See fontTools.pens.basePen for details + how that works. + """ + self._glyph.draw(pen) - def drawPoints(self, pen): - from fontTools.pens.pointPen import SegmentToPointPen + def drawPoints(self, pen): + from fontTools.pens.pointPen import SegmentToPointPen - self.draw(SegmentToPointPen(pen)) + self.draw(SegmentToPointPen(pen)) class _TTGlyphCFF(_TTGlyph): - pass + pass class _TTGlyphGlyf(_TTGlyph): - def draw(self, pen): - """Draw the glyph onto Pen. See fontTools.pens.basePen for details - how that works. - """ - glyfTable = self._glyphset._glyphs - glyph = self._glyph - offset = self.lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 - glyph.draw(pen, glyfTable, offset) + def draw(self, pen): + """Draw the glyph onto Pen. See fontTools.pens.basePen for details + how that works. + """ + glyfTable = self._glyphset._glyphs + glyph = self._glyph + offset = self.lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 + glyph.draw(pen, glyfTable, offset) - def drawPoints(self, pen): - """Draw the glyph onto PointPen. See fontTools.pens.pointPen - for details how that works. - """ - glyfTable = self._glyphset._glyphs - glyph = self._glyph - offset = self.lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 - glyph.drawPoints(pen, glyfTable, offset) + def drawPoints(self, pen): + """Draw the glyph onto PointPen. See fontTools.pens.pointPen + for details how that works. + """ + glyfTable = self._glyphset._glyphs + glyph = self._glyph + offset = self.lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 + glyph.drawPoints(pen, glyfTable, offset) class _TTVarGlyphSet(_TTGlyphSet): - def __init__(self, font, glyphs, glyphType, location, normalized): - self._ttFont = font - self._glyphs = glyphs - self._glyphType = glyphType + def __init__(self, font, glyphs, glyphType, location, normalized): + self._ttFont = font + self._glyphs = glyphs + self._glyphType = glyphType - if not normalized: - from fontTools.varLib.models import normalizeLocation, piecewiseLinearMap + if not normalized: + from fontTools.varLib.models import normalizeLocation, piecewiseLinearMap - axes = { - a.axisTag: (a.minValue, a.defaultValue, a.maxValue) - for a in font["fvar"].axes - } - location = normalizeLocation(location, axes) - if "avar" in font: - avar = font["avar"] - avarSegments = avar.segments - new_location = {} - for axis_tag, value in location.items(): - avarMapping = avarSegments.get(axis_tag, None) - if avarMapping is not None: - value = piecewiseLinearMap(value, avarMapping) - new_location[axis_tag] = value - location = new_location - del new_location + axes = { + a.axisTag: (a.minValue, a.defaultValue, a.maxValue) + for a in font["fvar"].axes + } + location = normalizeLocation(location, axes) + if "avar" in font: + avar = font["avar"] + avarSegments = avar.segments + new_location = {} + for axis_tag, value in location.items(): + avarMapping = avarSegments.get(axis_tag, None) + if avarMapping is not None: + value = piecewiseLinearMap(value, avarMapping) + new_location[axis_tag] = value + location = new_location + del new_location - self.location = location + self.location = location - def __getitem__(self, glyphName): - if glyphName not in self._glyphs: - raise KeyError(glyphName) - return self._glyphType(self, glyphName, self.location) + def __getitem__(self, glyphName): + if glyphName not in self._glyphs: + raise KeyError(glyphName) + return self._glyphType(self, glyphName, self.location) def _setCoordinates(glyph, coord, glyfTable): - # Handle phantom points for (left, right, top, bottom) positions. - assert len(coord) >= 4 - if not hasattr(glyph, "xMin"): - glyph.recalcBounds(glyfTable) - leftSideX = coord[-4][0] - rightSideX = coord[-3][0] - topSideY = coord[-2][1] - bottomSideY = coord[-1][1] + # Handle phantom points for (left, right, top, bottom) positions. + assert len(coord) >= 4 + if not hasattr(glyph, "xMin"): + glyph.recalcBounds(glyfTable) + leftSideX = coord[-4][0] + rightSideX = coord[-3][0] + topSideY = coord[-2][1] + bottomSideY = coord[-1][1] - for _ in range(4): - del coord[-1] + for _ in range(4): + del coord[-1] - if glyph.isComposite(): - assert len(coord) == len(glyph.components) - glyph.components = [copy(comp) for comp in glyph.components] - for p, comp in zip(coord, glyph.components): - if hasattr(comp, "x"): - comp.x, comp.y = p - elif glyph.numberOfContours == 0: - assert len(coord) == 0 - else: - assert len(coord) == len(glyph.coordinates) - glyph.coordinates = coord + if glyph.isComposite(): + assert len(coord) == len(glyph.components) + glyph.components = [copy(comp) for comp in glyph.components] + for p, comp in zip(coord, glyph.components): + if hasattr(comp, "x"): + comp.x, comp.y = p + elif glyph.numberOfContours == 0: + assert len(coord) == 0 + else: + assert len(coord) == len(glyph.coordinates) + glyph.coordinates = coord - glyph.recalcBounds(glyfTable) + glyph.recalcBounds(glyfTable) - horizontalAdvanceWidth = otRound(rightSideX - leftSideX) - verticalAdvanceWidth = otRound(topSideY - bottomSideY) - leftSideBearing = otRound(glyph.xMin - leftSideX) - topSideBearing = otRound(topSideY - glyph.yMax) - return ( - horizontalAdvanceWidth, - leftSideBearing, - verticalAdvanceWidth, - topSideBearing, - ) + horizontalAdvanceWidth = otRound(rightSideX - leftSideX) + verticalAdvanceWidth = otRound(topSideY - bottomSideY) + leftSideBearing = otRound(glyph.xMin - leftSideX) + topSideBearing = otRound(topSideY - glyph.yMax) + return ( + horizontalAdvanceWidth, + leftSideBearing, + verticalAdvanceWidth, + topSideBearing, + ) class _TTVarGlyph(_TTGlyph): - def __init__(self, glyphSet, glyphName, location): + def __init__(self, glyphSet, glyphName, location): - super().__init__(glyphSet._glyphs, glyphSet._glyphs[glyphName]) + super().__init__(glyphSet._glyphs, glyphSet._glyphs[glyphName]) - self._glyphSet = glyphSet - self._ttFont = glyphSet._ttFont - self._glyphs = glyphSet._glyphs - self._glyphName = glyphName - self._location = location + self._glyphSet = glyphSet + self._ttFont = glyphSet._ttFont + self._glyphs = glyphSet._glyphs + self._glyphName = glyphName + self._location = location class _TTVarGlyphCFF(_TTVarGlyph): - def draw(self, pen): - varStore = self._glyphs.varStore - if varStore is None: - blender = None - else: - from fontTools.varLib.varStore import VarStoreInstancer + def draw(self, pen): + varStore = self._glyphs.varStore + if varStore is None: + blender = None + else: + from fontTools.varLib.varStore import VarStoreInstancer - vsInstancer = getattr(self._glyphSet, "vsInstancer", None) - if vsInstancer is None: - self._glyphSet.vsInstancer = vsInstancer = VarStoreInstancer( - varStore.otVarStore, self._ttFont["fvar"].axes, self._location - ) - blender = vsInstancer.interpolateFromDeltas - self._glyph.draw(pen, blender) + vsInstancer = getattr(self._glyphSet, "vsInstancer", None) + if vsInstancer is None: + self._glyphSet.vsInstancer = vsInstancer = VarStoreInstancer( + varStore.otVarStore, self._ttFont["fvar"].axes, self._location + ) + blender = vsInstancer.interpolateFromDeltas + self._glyph.draw(pen, blender) - self.width = self._ttFont["hmtx"][self._glyphName][0] - if "HVAR" in self._ttFont: - hvar = self._ttFont["HVAR"].table - varidx = self._ttFont.getGlyphID(self._glyphName) - if hvar.AdvWidthMap is not None: - varidx = hvar.AdvWidthMap.mapping[self._glyphName] - vsInstancer = VarStoreInstancer( - hvar.VarStore, self._ttFont["fvar"].axes, self._location - ) - delta = vsInstancer[varidx] - self.width += delta + self.width = self._ttFont["hmtx"][self._glyphName][0] + if "HVAR" in self._ttFont: + hvar = self._ttFont["HVAR"].table + varidx = self._ttFont.getGlyphID(self._glyphName) + if hvar.AdvWidthMap is not None: + varidx = hvar.AdvWidthMap.mapping[self._glyphName] + vsInstancer = VarStoreInstancer( + hvar.VarStore, self._ttFont["fvar"].axes, self._location + ) + delta = vsInstancer[varidx] + self.width += delta class _TTVarGlyphGlyf(_TTVarGlyph): - def draw(self, pen): - self._drawWithPen(pen, isPointPen=False) + def draw(self, pen): + self._drawWithPen(pen, isPointPen=False) - def drawPoints(self, pen): - self._drawWithPen(pen, isPointPen=True) + def drawPoints(self, pen): + self._drawWithPen(pen, isPointPen=True) - def _drawWithPen(self, pen, isPointPen): - from fontTools.varLib.iup import iup_delta - from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates - from fontTools.varLib.models import supportScalar + def _drawWithPen(self, pen, isPointPen): + from fontTools.varLib.iup import iup_delta + from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates + from fontTools.varLib.models import supportScalar - glyf = self._ttFont["glyf"] - hMetrics = self._ttFont["hmtx"].metrics - vMetrics = getattr(self._ttFont.get("vmtx"), "metrics", None) + glyf = self._ttFont["glyf"] + hMetrics = self._ttFont["hmtx"].metrics + vMetrics = getattr(self._ttFont.get("vmtx"), "metrics", None) - variations = self._ttFont["gvar"].variations[self._glyphName] - coordinates, _ = glyf._getCoordinatesAndControls( - self._glyphName, hMetrics, vMetrics - ) - origCoords, endPts = None, None - for var in variations: - scalar = supportScalar(self._location, var.axes) - if not scalar: - continue - delta = var.coordinates - if None in delta: - if origCoords is None: - origCoords, control = glyf._getCoordinatesAndControls( - self._glyphName, hMetrics, vMetrics - ) - endPts = ( - control[1] if control[0] >= 1 else list(range(len(control[1]))) - ) - delta = iup_delta(delta, origCoords, endPts) - coordinates += GlyphCoordinates(delta) * scalar + variations = self._ttFont["gvar"].variations[self._glyphName] + coordinates, _ = glyf._getCoordinatesAndControls( + self._glyphName, hMetrics, vMetrics + ) + origCoords, endPts = None, None + for var in variations: + scalar = supportScalar(self._location, var.axes) + if not scalar: + continue + delta = var.coordinates + if None in delta: + if origCoords is None: + origCoords, control = glyf._getCoordinatesAndControls( + self._glyphName, hMetrics, vMetrics + ) + endPts = ( + control[1] if control[0] >= 1 else list(range(len(control[1]))) + ) + delta = iup_delta(delta, origCoords, endPts) + coordinates += GlyphCoordinates(delta) * scalar - glyph = copy(glyf[self._glyphName]) # Shallow copy - width, lsb, height, tsb = _setCoordinates(glyph, coordinates, glyf) - self.width = width - self.lsb = lsb - self.height = height - self.tsb = tsb - offset = lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 - if isPointPen: - glyph.drawPoints(pen, glyf, offset) - else: - glyph.draw(pen, glyf, offset) + glyph = copy(glyf[self._glyphName]) # Shallow copy + width, lsb, height, tsb = _setCoordinates(glyph, coordinates, glyf) + self.width = width + self.lsb = lsb + self.height = height + self.tsb = tsb + offset = lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 + if isPointPen: + glyph.drawPoints(pen, glyf, offset) + else: + glyph.draw(pen, glyf, offset)