o
    e                     @   s   d Z ddlmZmZ ddlmZ g dZdd ZG dd deZG d	d
 d
eeZ	G dd deZ
dddZedkr_e Zed ed eddd e  ddlmZ eej dS dS )z:Pen recording operations that can be accessed or replayed.    )AbstractPenDecomposingPen)AbstractPointPen)replayRecordingRecordingPenDecomposingRecordingPenRecordingPointPenlerpRecordingsc                 C   s    | D ]\}}t |||  qdS )a2  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.
    N)getattr)	recordingpenoperatoroperands r   J/var/www/myenv/lib/python3.10/site-packages/fontTools/pens/recordingPen.pyr      s   r   c                   @   sd   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dd Zdd Zdd ZeZdS )r   a8  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)
    c                 C   
   g | _ d S Nvalueselfr   r   r   __init__2      
zRecordingPen.__init__c                 C      | j d|ff d S )NmoveTor   append)r   p0r   r   r   r   5      zRecordingPen.moveToc                 C   r   )NlineTor   )r   p1r   r   r   r   8   r   zRecordingPen.lineToc                 G      | j d|f d S )NqCurveTor   r   pointsr   r   r   r"   ;      zRecordingPen.qCurveToc                 G   r!   )NcurveTor   r#   r   r   r   r&   >   r%   zRecordingPen.curveToc                 C      | j d d S )N)	closePathr   r   r   r   r   r   r(   A      zRecordingPen.closePathc                 C   r'   )N)endPathr   r   r   r   r   r   r*   D   r)   zRecordingPen.endPathc                 C   s   | j d||ff d S )NaddComponentr   )r   	glyphNametransformationr   r   r   r+   G   s   zRecordingPen.addComponentc                 C   s   | j d|||ff d S )NaddVarComponentr   )r   r,   r-   locationr   r   r   r.   J   s   zRecordingPen.addVarComponentc                 C   s   t | j| d S r   )r   r   )r   r   r   r   r   replayM   r)   zRecordingPen.replayN)__name__
__module____qualname____doc__r   r   r   r"   r&   r(   r*   r+   r.   r0   drawr   r   r   r   r      s    r   c                   @   s   e Zd ZdZdZdS )r   a  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', ())]
    FN)r1   r2   r3   r4   skipMissingComponentsr   r   r   r   r   S   s    r   c                   @   sX   e Zd ZdZdd ZdddZdd Z	dd
dZdddZ	dddZ	dd Z
e
ZdS )r   as  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())
    c                 C   r   r   r   r   r   r   r   r      r   zRecordingPointPen.__init__Nc                 K   s&   |d ur||d< | j dd|f d S )N
identifier	beginPathr   r   )r   r7   kwargsr   r   r   r8      s   zRecordingPointPen.beginPathc                 C   s   | j ddi f d S )Nr*   r   r   r   r   r   r   r*      r   zRecordingPointPen.endPathFc                 K   s.   |d ur||d< | j d||||f|f d S )Nr7   addPointr   )r   ptsegmentTypesmoothnamer7   r9   r   r   r   r:      s   zRecordingPointPen.addPointc                 K   s*   |d ur||d< | j d||f|f d S )Nr7   r+   r   )r   baseGlyphNamer-   r7   r9   r   r   r   r+      s   zRecordingPointPen.addComponentc                 K   s,   |d ur||d< | j d|||f|f d S )Nr7   r.   r   )r   r?   r-   r/   r7   r9   r   r   r   r.      s
   z!RecordingPointPen.addVarComponentc                 C   s*   | j D ]\}}}t|||i | qd S r   )r   r
   )r   pointPenr   argsr9   r   r   r   r0      s   zRecordingPointPen.replayr   )NFNN)r1   r2   r3   r4   r   r8   r*   r:   r+   r.   r0   
drawPointsr   r   r   r   r   p   s    



	r         ?c                 #   s    t | t |krtdt | t |f t| |D ]-\\}}\}}||kr.td||f |dkr6td fddt||D }||fV  qdS )a  Linearly interpolate between two recordings. The recordings
    must be decomposed, i.e. they must not contain any components.

    Factor is typically between 0 and 1. 0 means the first recording,
    1 means the second recording, and 0.5 means the average of the
    two recordings. Other values are possible, and can be useful to
    extrapolate. Defaults to 0.5.

    Returns a generator with the new recording.
    zMismatched lengths: %d and %dzMismatched operations: %s, %sr+   zCannot interpolate componentsc                    s8   g | ]\\}}\}}|||    |||    fqS r   r   ).0x1y1x2y2factorr   r   
<listcomp>   s    z"lerpRecordings.<locals>.<listcomp>N)len
ValueErrorzip)
recording1
recording2rJ   op1args1op2args2mid_argsr   rI   r   r	      s   
r	   __main__)r   r   )r   d   )2   K   )<   rX   )rX      )pprintN)rC   )r4   fontTools.pens.basePenr   r   fontTools.pens.pointPenr   __all__r   r   r   r   r	   r1   r   r   r   r&   r(   r\   r   r   r   r   r   <module>   s$    	8
@

