# Source code for fontTools.pens.recordingPen

    """Pen recording operations that can be accessed or replayed."""
    from fontTools.pens.basePen import AbstractPen, DecomposingPen
    from fontTools.pens.pointPen import AbstractPointPen

    __all__ = [
    	"replayRecording",
    	"RecordingPen",
    	"DecomposingRecordingPen",
    	"RecordingPointPen",
    ]

    def replayRecording(recording, pen):
    	"""Replay a recording, as produced by RecordingPen or DecomposingRecordingPen,
    	to a pen.

    	Note that recording does not have to be produced by those pens.
    	It can be any iterable of tuples of method name and tuple-of-arguments.
    	Likewise, pen can be any objects receiving those method calls.
    	"""
    	for operator,operands in recording:
    		getattr(pen, operator)(*operands)

    class RecordingPen(AbstractPen):
    	"""Pen recording operations that can be accessed or replayed.

    	The recording can be accessed as pen.value; or replayed using
    	pen.replay(otherPen).

    	:Example:

    		from fontTools.ttLib import TTFont
    		from fontTools.pens.recordingPen import RecordingPen

    		glyph_name = 'dollar'
    		font_path = 'MyFont.otf'

    		font = TTFont(font_path)
    		glyphset = font.getGlyphSet()
    		glyph = glyphset[glyph_name]

    		pen = RecordingPen()
    		glyph.draw(pen)
    		print(pen.value)
    	"""

    	def __init__(self):
    		self.value = []
    	def moveTo(self, p0):
    		self.value.append(('moveTo', (p0,)))
    	def lineTo(self, p1):
    		self.value.append(('lineTo', (p1,)))
    	def qCurveTo(self, *points):
    		self.value.append(('qCurveTo', points))
    	def curveTo(self, *points):
    		self.value.append(('curveTo', points))
    	def closePath(self):
    		self.value.append(('closePath', ()))
    	def endPath(self):
    		self.value.append(('endPath', ()))
    	def addComponent(self, glyphName, transformation):
    		self.value.append(('addComponent', (glyphName, transformation)))
    	def replay(self, pen):
    		replayRecording(self.value, pen)

    class DecomposingRecordingPen(DecomposingPen, RecordingPen):
    	""" Same as RecordingPen, except that it doesn't keep components
    	as references, but draws them decomposed as regular contours.

    	The constructor takes a single 'glyphSet' positional argument,
    	a dictionary of glyph objects (i.e. with a 'draw' method) keyed
    	by thir name::

    		>>> class SimpleGlyph(object):
    		...     def draw(self, pen):
    		...         pen.moveTo((0, 0))
    		...         pen.curveTo((1, 1), (2, 2), (3, 3))
    		...         pen.closePath()
    		>>> class CompositeGlyph(object):
    		...     def draw(self, pen):
    		...         pen.addComponent('a', (1, 0, 0, 1, -1, 1))
    		>>> glyphSet = {'a': SimpleGlyph(), 'b': CompositeGlyph()}
    		>>> for name, glyph in sorted(glyphSet.items()):
    		...     pen = DecomposingRecordingPen(glyphSet)
    		...     glyph.draw(pen)
    		...     print("{}: {}".format(name, pen.value))
    		a: [('moveTo', ((0, 0),)), ('curveTo', ((1, 1), (2, 2), (3, 3))), ('closePath', ())]
    		b: [('moveTo', ((-1, 1),)), ('curveTo', ((0, 2), (1, 3), (2, 4))), ('closePath', ())]
    	"""
    	# raises KeyError if base glyph is not found in glyphSet
    	skipMissingComponents = False

    class RecordingPointPen(AbstractPointPen):
    	"""PointPen recording operations that can be accessed or replayed.

    	The recording can be accessed as pen.value; or replayed using
    	pointPen.replay(otherPointPen).

    	:Example:

    		from defcon import Font
    		from fontTools.pens.recordingPen import RecordingPointPen

    		glyph_name = 'a'
    		font_path = 'MyFont.ufo'

    		font = Font(font_path)
    		glyph = font[glyph_name]

    		pen = RecordingPointPen()
    		glyph.drawPoints(pen)
    		print(pen.value)

    		new_glyph = font.newGlyph('b')
    		pen.replay(new_glyph.getPointPen())
    	"""

    	def __init__(self):
    		self.value = []

    	def beginPath(self, identifier=None, **kwargs):
    		if identifier is not None:
    			kwargs["identifier"] = identifier
    		self.value.append(("beginPath", (), kwargs))

    	def endPath(self):
    		self.value.append(("endPath", (), {}))

    	def addPoint(self, pt, segmentType=None, smooth=False, name=None, identifier=None, **kwargs):
    		if identifier is not None:
    			kwargs["identifier"] = identifier
    		self.value.append(("addPoint", (pt, segmentType, smooth, name), kwargs))

    	def addComponent(self, baseGlyphName, transformation, identifier=None, **kwargs):
    		if identifier is not None:
    			kwargs["identifier"] = identifier
    		self.value.append(("addComponent", (baseGlyphName, transformation), kwargs))

    	def replay(self, pointPen):
    		for operator, args, kwargs in self.value:
    			getattr(pointPen, operator)(*args, **kwargs)

    if __name__ == "__main__":
    	pen = RecordingPen()
    	pen.moveTo((0, 0))
    	pen.lineTo((0, 100))
    	pen.curveTo((50, 75), (60, 50), (50, 25))
    	pen.closePath()
    	from pprint import pprint
    	pprint(pen.value)