blob: 6e2f0d3189ae86fe5296e68a350e584490c866ed [file] [log] [blame]
from __future__ import print_function, division, absolute_import
from fontTools.misc.py23 import *
from array import array
from fontTools.pens.basePen import LoggingPen
from fontTools.pens.transformPen import TransformPen
from fontTools.ttLib.tables import ttProgram
from fontTools.ttLib.tables._g_l_y_f import Glyph
from fontTools.ttLib.tables._g_l_y_f import GlyphComponent
from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates
__all__ = ["TTGlyphPen"]
# the max value that can still fit in an F2Dot14:
# 1.99993896484375
MAX_F2DOT14 = 0x7FFF / (1 << 14)
class TTGlyphPen(LoggingPen):
"""Pen used for drawing to a TrueType glyph.
If `handleOverflowingTransforms` is True, the components' transform values
are checked that they don't overflow the limits of a F2Dot14 number:
-2.0 <= v < +2.0. If any transform value exceeds these, the composite
glyph is decomposed.
An exception to this rule is done for values that are very close to +2.0
(both for consistency with the -2.0 case, and for the relative frequency
these occur in real fonts). When almost +2.0 values occur (and all other
values are within the range -2.0 <= x <= +2.0), they are clamped to the
maximum positive value that can still be encoded as an F2Dot14: i.e.
If False, no check is done and all components are translated unmodified
into the glyf table, followed by an inevitable `struct.error` once an
attempt is made to compile them.
def __init__(self, glyphSet, handleOverflowingTransforms=True):
self.glyphSet = glyphSet
self.handleOverflowingTransforms = handleOverflowingTransforms
def init(self):
self.points = []
self.endPts = []
self.types = []
self.components = []
def _addPoint(self, pt, onCurve):
def _popPoint(self):
def _isClosed(self):
return (
(not self.points) or
(self.endPts and self.endPts[-1] == len(self.points) - 1))
def lineTo(self, pt):
self._addPoint(pt, 1)
def moveTo(self, pt):
assert self._isClosed(), '"move"-type point must begin a new contour.'
self._addPoint(pt, 1)
def qCurveTo(self, *points):
assert len(points) >= 1
for pt in points[:-1]:
self._addPoint(pt, 0)
# last point is None if there are no on-curve points
if points[-1] is not None:
self._addPoint(points[-1], 1)
def closePath(self):
endPt = len(self.points) - 1
# ignore anchors (one-point paths)
if endPt == 0 or (self.endPts and endPt == self.endPts[-1] + 1):
# if first and last point on this path are the same, remove last
startPt = 0
if self.endPts:
startPt = self.endPts[-1] + 1
if self.points[startPt] == self.points[endPt]:
endPt -= 1
def endPath(self):
# TrueType contours are always "closed"
def addComponent(self, glyphName, transformation):
self.components.append((glyphName, transformation))
def _buildComponents(self, componentFlags):
if self.handleOverflowingTransforms:
# we can't encode transform values > 2 or < -2 in F2Dot14,
# so we must decompose the glyph if any transform exceeds these
overflowing = any(s > 2 or s < -2
for (glyphName, transformation) in self.components
for s in transformation[:4])
components = []
for glyphName, transformation in self.components:
if glyphName not in self.glyphSet:
"skipped non-existing component '%s'", glyphName
if (self.points or
(self.handleOverflowingTransforms and overflowing)):
# can't have both coordinates and components, so decompose
tpen = TransformPen(self, transformation)
component = GlyphComponent()
component.glyphName = glyphName
component.x, component.y = transformation[4:]
transformation = transformation[:4]
if transformation != (1, 0, 0, 1):
if (self.handleOverflowingTransforms and
any(MAX_F2DOT14 < s <= 2 for s in transformation)):
# clamp values ~= +2.0 so we can keep the component
transformation = tuple(MAX_F2DOT14 if MAX_F2DOT14 < s <= 2
else s for s in transformation)
component.transform = (transformation[:2], transformation[2:])
component.flags = componentFlags
return components
def glyph(self, componentFlags=0x4):
assert self._isClosed(), "Didn't close last contour."
components = self._buildComponents(componentFlags)
glyph = Glyph()
glyph.coordinates = GlyphCoordinates(self.points)
glyph.endPtsOfContours = self.endPts
glyph.flags = array("B", self.types)
if components:
glyph.components = components
glyph.numberOfContours = -1
glyph.numberOfContours = len(glyph.endPtsOfContours)
glyph.program = ttProgram.Program()
return glyph