old-parkingkoncept/parkingkonceptvenv/lib/python3.7/site-packages/matplotlib/__pycache__/offsetbox.cpython-37.pyc

B
U<>]<5D><><00>@s<>
dZd
dl
Zd
dlmZmZmZ
d
dlmZ	
d
dl
mZ
d
dl
mZ
d
dlmZ
d
dlmZ
d
dlmZ
d
dlmZmZmZ
d
dl
mZ
d
dlmZmZmZ
d	Z d
d<0B>Zd0d
d<0E>
Z!d1dd<11>
Z"Gdd<13>de	j#<23>Z$Gdd<15>de$<24>Z%Gdd<17>de%<25>Z&Gdd<19>de%<25>Z'Gdd<1B>de$<24>Z(Gdd<1D>de$<24>Z)Gdd<1F>de$<24>Z*Gd d!<21>d!e$<24>Z+Gd"d#<23>d#e$<24>Z,Gd$d%<25>d%e,<2C>Z-Gd&d'<27>d'e$<24>Z.Gd(d)<29>d)e	j#e<1C>Z/Gd*d+<2B>d+e0<65>Z1Gd,d-<2D>d-e1<65>Z2Gd.d/<2F>d/e1<65>Z3dS)2a<32>
The OffsetBox is a simple container artist. The child artist are meant
to be drawn at a relative position to its parent.  The [VH]Packer,
DrawingArea and TextArea are derived from the OffsetBox.

The [VH]Packer automatically adjust the relative positions of their
children, which should be instances of the OffsetBox. This is used to
align similar artists together, e.g., in legend.

The DrawingArea can contain any Artist as a child. The
DrawingArea has a fixed width and height. The position of children
relative to the parent is fixed.  The TextArea is contains a single
Text instance. The width and height of the TextArea instance is the
width and height of the its child text.
<EFBFBD>N)<03>cbook<6F>	docstring<6E>rcParams)
<01>FontProperties)
<01>	BboxImage)<03>FancyBboxPatch<63>FancyArrowPatch<63>bbox_artist)
<01>_AnnotationBase)<03>Bbox<6F>BboxBase<73>TransformedBboxFcOstrt
||
<01>

dS)
N)<02>DEBUG<55>mbbox_artist)<02>args<67>kwargs<67>r<00></tmp/pip-install-i8dhxrtk/matplotlib/matplotlib/offsetbox.pyr	$s

r	<00>fixedc	s6
t|<00>\}}|d
krZt
<01>dg
<01>f
dd<04>|D<00>
<00>
}|dd<06>}|
dkrR|d<00>}
|
|fS|dkr<>|
dkrnd}
t|<04>
dkr<>|
t|<04>
t|<04>
d<00>nd<02>t
<01>dg
<01>f
d	d<04>|D<00>
<00>
}|dd<06>}|
|fS|d
k<02>
r$t|<04>
}|
dkr<>|<08>t|<04>
}
n|
t|<04>
|<00>|<08>t
<01>t|<04>
<01>
}|
|fStd|f
<00>
<01>
dS)a<>

    Given a list of (width, xdescent) of each boxes, calculate the
    total width and the x-offset positions of each items according to
    *mode*. xdescent is analogous to the usual descent, but along the
    x-direction. xdescent values are currently ignored.

    *wd_list* : list of (width, xdescent) of boxes to be packed.
    *sep* : spacing between boxes
    *total* : Intended total length. None if not used.
    *mode* : packing mode. 'fixed', 'expand', or 'equal'.
    rr
c
sg|]}
|
<01><00>qSrr)<02>.0<EFBFBD>
w)
<01>seprr<00>
<listcomp>>sz'_get_packed_offsets.<locals>.<listcomp>N<><4E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>expand<6E>
c
sg|]}
|
<01><00>qSrr)rr)
rrrrMs<00>equalzUnknown mode : %s)<08>zip<69>npZcumsum<75>len<65>sum<75>maxZarange<67>
ValueError)	<09>wd_list<73>totalr<00>modeZw_listZd_listZoffsets_<73>offsetsZmaxhr)
rr<00>_get_packed_offsets-s0

















r'<00>baselinecs<><00>d
krtdd<03>|D<00>
<01>
<01>|dkr^tdd<03>|D<00>
<01>
}tdd<03>|D<00>
<01>
}||<00>dd<08>|D<00>
}nj|d	krzd
}dd<08>|D<00>
}nN|dkr<>d
}<04>f
d
d<08>|D<00>
}n.|dkr<>d
}<04>f
dd<08>|D<00>
}nt
d|f
<00>
<01>
<01>||fS)a)
    Given a list of (height, descent) of each boxes, align the boxes
    with *align* and calculate the y-offsets of each boxes.
    total width and the offset positions of each items according to
    *mode*. xdescent is analogous to the usual descent, but along the
    x-direction. xdescent values are currently ignored.

    *hd_list* : list of (width, xdescent) of boxes to be aligned.
    *sep* : spacing between boxes
    *height* : Intended total length. None if not used.
    *align* : align mode. 'baseline', 'top', 'bottom', or 'center'.
    Nc
ss|]\}
}|
V
qdS)
Nr)r<00>
h<>
drrr<00>	<genexpr>msz'_get_aligned_offsets.<locals>.<genexpr>r(c
ss|]\}
}|
|V
qdS)
Nr)rr)r*rrrr+psc
ss|]\}
}|V
qdS)
Nr)rr)r*rrrr+qsc
Ssg|]\}
}d<00>qS)
gr)rr)r*rrrrssz(_get_aligned_offsets.<locals>.<listcomp>)<02>left<66>topgc
Ssg|]\}
}|<02>qSrr)rr)r*rrrrvs)<02>rightZbottomc
sg|]\}
}<02>|
|<00>qSrr)rr)r*)
<01>heightrrrys<00>centerc
s g|]\}
}<02>|
d|<00>qS)
g<00>?r)rr)r*)
r/rrr|szUnknown Align mode : %s)r!r")<06>hd_listr/<00>align<67>height_descentZdescentr&r)
r/r<00>_get_aligned_offsets^s$













r4cs<>eZ
dZd
Z<03>f
dd<03>Zdd<05>Zejjj	dd<07><00>
Zdd	<09>Z
d
d<0B>Zdd
<0A>Zdd<0F>Z
dd<11>Zdd<13>Zdd<15>Zdd<17>Zdd<19>Zdd<1B>Zdd<1D>Z<14>ZS)<1E>	OffsetBoxz<78>
    The OffsetBox is a simple container artist. The child artist are meant
    to be drawn at a relative position to its parent.
    c
s(t<00>j
|
|<02>

|<00>d
<01>

g|_d|_dS)NF)r
r
)<05>super<65>__init__Zset_clip_on<6F>	_children<65>_offset)<03>selfrr)
<01>	__class__rrr7<00>s

zOffsetBox.__init__cCs.tj
<01>||
<01>
x|<00><03>D]}|<02>|
<01>

qWd
S)z^
        Set the figure

        accepts a class:`~matplotlib.figure.Figure` instance
        N)<04>martist<73>Artist<73>
set_figure<EFBFBD>get_children)r:<00>fig<69>
crrrr><00>s

zOffsetBox.set_figurecCs4tj
j<02>||
<01>
x|<00><04>D]}|dk	r|
|_qWdS)
N)r<r=<00>axes<65>fsetr?)r:ZaxrArrrrB<00>s


zOffsetBox.axescCs4x*|<00><00>D]}|<02>
|
<01>
\}}|r
||fSq
Wd
ifS)NF)r?<00>contains)r:<00>
mouseeventrA<00>
a<>
brrrrD<00>s





zOffsetBox.containscCs|
|_d
|_
dS)a>

        Set the offset.

        Parameters
        ----------
        xy : (float, float) or callable
            The (x,y) coordinates of the offset in display units.
            A callable must have the signature::

                def offset(width, height, xdescent, ydescent, renderer) -> (float, float)
        TN)r9<00>stale)r:<00>xyrrr<00>
set_offset<EFBFBD>s

zOffsetBox.set_offsetcCs"t|j
<01>
r|<00>
|
||||<05>S|j
S)
zC
        Get the offset

        accepts extent of the box
        )<02>callabler9)r:<00>widthr/<00>xdescent<6E>ydescent<6E>rendererrrr<00>
get_offset<EFBFBD>s
zOffsetBox.get_offsetcCs|
|_d
|_
dS)z6
        Set the width

        accepts float
        TN)rLrH)r:rLrrr<00>	set_width<74>s
zOffsetBox.set_widthcCs|
|_d
|_
dS)z7
        Set the height

        accepts float
        TN)r/rH)r:r/rrr<00>
set_height<EFBFBD>s
zOffsetBox.set_heightc

Csd
d<02>|jD<00>
S)z?
        Return a list of visible artists it contains.
        c
Ssg|]}
|
<01><00>r|
<01>qSr)
<01>get_visible)rrArrrr<00>sz2OffsetBox.get_visible_children.<locals>.<listcomp>)
r8)
r:rrr<00>get_visible_children<65>szOffsetBox.get_visible_childrenc


Cs|jS)
z7
        Return a list of artists it contains.
        )
r8)
r:rrrr?<00>szOffsetBox.get_childrencCstd
<01>
<01>
dS)N<>)
<01>	Exception)r:rOrrr<00>get_extent_offsets<74>s
zOffsetBox.get_extent_offsetscCs |<00>|
<01>
\}}}}}||||fS)
z@
        Return with, height, xdescent, ydescent of box
        )
rW)r:rOrr)<00>xd<78>ydr&rrr<00>
get_extent<EFBFBD>s
zOffsetBox.get_extentc	CsD|<00>|
<01>
\}}}}}|<00>
|||||
<01>\}}tj<03>||||||<03>S)
z8
        get the bounding box in display space.
        )rWrP<00>mtransformsr<00>from_bounds)	r:rOrr)rXrYr&<00>px<70>pyrrr<00>get_window_extent<6E>s

zOffsetBox.get_window_extentcCs<>|<00>|
<01>
\}}}}}|<00>
|||||
<01>\}}x>t|<00><03>|<06>D],\}	\}
}|	<09>||
||f<02>

|	<09>|
<01>

q:Wt||
d
tdd<03>
d<04>
d
|_dS)zm
        Update the location of children if necessary and draw them
        to the given *renderer*.
        Fg)
<01>pad)<02>fill<6C>propsN)	rWrPrrTrJ<00>drawr	<00>dictrH)r:rOrLr/rMrNr&r]r^rA<00>ox<6F>oyrrrrc<00>s



zOffsetBox.draw)<16>__name__<5F>
__module__<EFBFBD>__qualname__<5F>__doc__r7r>r<r=rB<00>setterrDrJrPrQrRrTr?rWrZr_rc<00>
__classcell__rr)
r;rr5<00>s


		r5cseZ
dZd<04>f
dd<03>	Z<03>ZS)<05>
PackerBaseNcs8t<00><00>
<01>
||_||_||_|
|_||_||_||_d
S)a<>
        Parameters
        ----------
        pad : float, optional
            Boundary pad.

        sep : float, optional
            Spacing between items.

        width : float, optional

        height : float, optional
           Width and height of the container box, calculated if
           `None`.

        align : str, optional
            Alignment of boxes. Can be one of ``top``, ``bottom``,
            ``left``, ``right``, ``center`` and ``baseline``

        mode : str, optional
            Packing mode.

        Notes
        -----
        *pad* and *sep* need to given in points and will be scale with
        the renderer dpi, while *width* and *height* need to be in
        pixels.
        N)	r6r7r/rLrr`r%r2r8)r:r`rrLr/r2r%<00>children)
r;rrr7
s





zPackerBase.__init__)NNNNNNN)rgrhrir7rlrr)
r;rrm

s


rmcs*eZ
dZd
Zd	<09>f
dd<06>	Zdd<08>Z<05>ZS)
<EFBFBD>VPackerz<72>
    The VPacker has its children packed vertically. It automatically
    adjust the relative positions of children in the drawing time.
    Nr(rc	st<00><00>
|
||||||<07>
d
S)ap
        Parameters
        ----------
        pad : float, optional
            Boundary pad.

        sep : float, optional
            Spacing between items.

        width : float, optional

        height : float, optional

            width and height of the container box, calculated if
            `None`.

        align : str, optional
            Alignment of boxes.

        mode : str, optional
            Packing mode.

        Notes
        -----
        *pad* and *sep* need to given in points and will be scale with
        the renderer dpi, while *width* and *height* need to be in
        pixels.
        N)r6r7)r:r`rrLr/r2r%rn)
r;rrr7;
szVPacker.__init__cs$
<00><00>d
<01>
}|j
|}|j|}|jdk	rZx0|<00><04>D]$}t|t<06>r2|jdkr2|<05>|j<03>

q2W<00>f
dd<05>|<00><04>D<00>
}dd<05>|D<00>
}dd<05>|D<00>
}t	||j|j
<EFBFBD>\}}	}
dd<05>|D<00>
}t||j||j<07>\}}
|
d	d<05>|D<00>
}||d
}||}||}|d||d||	|||t
t|
|<0E><02>
fS)zN
        update offset of childrens and return the extents of the box
        g<00>?Nrc
sg|]}
|
<01><00><00>
<01>qSr)
rZ)rrA)
rOrrrj
s
z.VPacker.get_extent_offsets.<locals>.<listcomp>c
Ss$g|]\}
}}}|
||||f<04>qSrr)rrr)rXrYrrrrl
sc
Ssg|]\}
}}}|
|f<02>qSrr)rrr)rXrYrrrrn
sc
Ssg|]\}
}}}||f<02>qSrr)rrr)rXrYrrrrs
sc
Ssg|]\}
}}}|<04>qSrr)rrr)rXrYrrrrw
sr
<00>)<0F>points_to_pixelsr`rrLrT<00>
isinstancermr%rQr4r2r'r/<00>listr)r:rO<00>dpicorr`rrA<00>whd_listr#rLrM<00>xoffsets<74>	pack_listr/Z	yoffsets_<73>yoffsetsrNr)
rOrrW\
s0




















zVPacker.get_extent_offsets)NNNNr(rN)rgrhrirjr7rWrlrr)
r;rro6
s



rocs*eZ
dZd
Zd	<09>f
dd<06>	Zdd<08>Z<05>ZS)
<EFBFBD>HPackerz<72>
    The HPacker has its children packed horizontally. It automatically
    adjusts the relative positions of children at draw time.
    Nr(rc	st<00><00>
|
||||||<07>
d
S)aW
        Parameters
        ----------
        pad : float, optional
            Boundary pad.

        sep : float, optional
            Spacing between items.

        width : float, optional

        height : float, optional
           Width and height of the container box, calculated if
           `None`.

        align : str
           Alignment of boxes.

        mode : str
           Packing mode.

        Notes
        -----
        *pad* and *sep* need to given in points and will be scale with
        the renderer dpi, while *width* and *height* need to be in
        pixels.
        N)r6r7)r:r`rrLr/r2r%rn)
r;rrr7<00>
szHPacker.__init__cs2
<00><00>d
<01>
}|j
|}|j|}<04>f
dd<03>|<00><03>D<00>
}|sNd|d|||gfS|jdkr<>tdd<07>|D<00>
<01>
}tdd<07>|D<00>
<01>
}||}n|jd|}d	d<03>|D<00>
}	t|	|j|j<07>\}}}
d
d<03>|D<00>
}t||j	||j
<EFBFBD>\}}
|
dd<03>|D<00>
}|dd}||}|d||d|||||tt||
<EFBFBD><02>
fS)
zM
        update offset of children and return the extents of the box
        g<00>?c
sg|]}
|
<01><00><00>
<01>qSr)
rZ)rrA)
rOrrr<00>
s
z.HPacker.get_extent_offsets.<locals>.<listcomp>rpNc
ss|]\}
}}}||V
qdS)
Nr)rrr)rXrYrrrr+<00>
sz-HPacker.get_extent_offsets.<locals>.<genexpr>c
ss|]\}
}}}|V
qdS)
Nr)rrr)rXrYrrrr+<00>
sc
Ssg|]\}
}}}||f<02>qSrr)rrr)rXrYrrrr<00>
sc
Ssg|]\}
}}}|
|f<02>qSrr)rrr)rXrYrrrr<00>
sc
Ssg|]\}
}}}|<03>qSrr)rrr)rXrYrrrr<00>
sr
)
rqr`rrTr/r!r4r2r'rLr%rsr)r:rOrtr`rrur3rNr/r1rxrwrLZ	xoffsets_rvrMr)
rOrrW<00>
s2



















zHPacker.get_extent_offsets)NNNNr(rN)rgrhrirjr7rWrlrr)
r;rry<00>
s



rycs@eZ
dZd
<0A>f
dd<04>	Zdd<06>Zdd<08>Zdd	d
<EFBFBD>
Zdd<0C>Z<07>ZS)<0F>	PaddedBoxNFc	s^t<00><00>
<01>
||_|
g
|_td
ddddddd<07>|_|jjdd	d
<EFBFBD>
|dk	rT|j<05>|<04>

||_dS)z<>
        *pad* : boundary pad

        .. note::
          *pad* need to given in points and will be
          scale with the renderer dpi, while *width* and *height*
          need to be in pixels.
        )ggg<00>?r<00>
krT)rIrLr/<00>	facecolor<6F>	edgecolor<6F>mutation_scale<6C>snap<61>squarer
)
r`N)	r6r7r`r8r<00>patch<63>set_boxstyle<6C>update<74>
_drawFrame)r:<00>childr`<00>
draw_frameZpatch_attrs)
r;rrr7<00>
s








zPaddedBox.__init__cCsT|
<01>d
<01>
}|j
|}|jd<00>|
<01>
\}}}}|d||d|||||dg
fS)zN
        update offset of childrens and return the extents of the box
        g<00>?r
rp)r
r
)rqr`r8rZ)r:rOrtr`rr)rXrYrrrrW<00>
s




zPaddedBox.get_extent_offsetscCs<>|<00>|
<01>
\}}}}}|<00>
|||||
<01>\}}x4t|<00><03>|<06>D]"\}	\}
}|	<09>||
||f<02>

q:W|<00>|
<01>

x|<00><03>D]}	|	<09>|
<01>

qtWd
|_dS)zm
        Update the location of children if necessary and draw them
        to the given *renderer*.
        FN)rWrPrrTrJr<>rcrH)r:rOrLr/rMrNr&r]r^rArerfrrrrc<00>
s



zPaddedBox.drawcCs4|j<00>
|
j|
j|
j|
j<05>
|r*|j<00>|<02>

d
|_dS)NT)r<><00>
set_bounds<EFBFBD>x0<78>y0rLr/<00>set_mutation_scalerH)r:<00>bbox<6F>fontsizerrr<00>update_frames




zPaddedBox.update_framecCs*|<00>|
<01>
}|<00>
|<02>

|jr&|j<03>|
<01>

dS)
N)r_r<>r<>r<>rc)r:rOr<>rrrr<>s



zPaddedBox.draw_frame)NFN)
N)	rgrhrir7rWrcr<>r<>rlrr)
r;rrz<00>
s


rzcs|eZ
dZd
Zd<19>f
dd<05>	Zedd<07><00>
Zejdd<07><00>
Zd	d
<EFBFBD>Zdd<0C>Z	d
d<0E>Z
dd<10>Zdd<12>Zdd<14>Z
dd<16>Zdd<18>Z<0F>ZS)<1A>DrawingAreaz<61>
    The DrawingArea can contain any Artist as a child. The DrawingArea
    has a fixed width and height. The position of children relative to
    the parent is fixed. The children can be clipped at the
    boundaries of the parent.
    <20>FcsXt<00><00>
<01>
|
|_||_||_||_||_t<07><08>|_	|j	<09>
<EFBFBD>
|j	<09>d
d
<01>
t<07><08>|_dS)z<>
        *width*, *height* : width and height of the container box.
        *xdescent*, *ydescent* : descent of the box in x- and y-direction.
        *clip* : Whether to clip the children
        r
N)
r6r7rLr/rMrN<00>_clip_childrenr[<00>Affine2D<32>offset_transform<72>clear<61>	translate<74>
dpi_transform)r:rLr/rMrNZclip)
r;rrr7+s








zDrawingArea.__init__c


Cs|jS)
zl
        If the children of this DrawingArea should be clipped
        by DrawingArea bounding box.
        )
r<>)
r:rrr<00>
clip_childrenAszDrawingArea.clip_childrencCst|
<01>
|_
d
|_dS)NT)<03>boolr<6C>rH)r:<00>valrrrr<>Is

c

Cs|j|j
S)
zf
        Return the :class:`~matplotlib.transforms.Transform` applied
        to the children
        )r<>r<>)
r:rrr<00>
get_transformNszDrawingArea.get_transformc
Csd
S)z+
        set_transform is ignored.
        Nr)r:<00>
trrr<00>
set_transformUszDrawingArea.set_transformcCs0|
|_|j
<01><02>
|j
<01>|
d
|
d<00>
d|_dS)z<>
        Set the offset of the container.

        Parameters
        ----------
        xy : (float, float)
            The (x,y) coordinates of the offset in display units.
        r
rTN)r9r<>r<>r<>rH)r:rIrrrrJ[s	


zDrawingArea.set_offsetc


Cs|jS)
z1
        return offset of the container.
        )
r9)
r:rrrrPjszDrawingArea.get_offsetcCs8|<00>|
<01>
\}}}}|<00>
<01>\}}tj<03>||||||<03>S)
z8
        get the bounding box in display space.
        )rZrPr[rr\)r:rOrr)rXrYrerfrrrr_ps
zDrawingArea.get_window_extentcCs.|
<01>d
<01>
}|j
||j||j||j|fS)z@
        Return with, height, xdescent, ydescent of box
        g<00>?)rqrLr/rMrN)r:rO<00>dpi_corrrrrZys


zDrawingArea.get_extentcCsP|j<00>
|
<01>

|
<01><02>s"|
<01>|<00><04><00>

|jd
k	r4|j|
_|j}|d
k	rL|
<01>|<02>

d
S)z?Add any :class:`~matplotlib.artist.Artist` to the container boxN)r8<00>appendZis_transform_setr<74>r<>rB<00>figurer>)r:rFr@rrr<00>
add_artist<EFBFBD>s







zDrawingArea.add_artistc	Cs<>|
<01>d
<01>
}|j
<01><02>
|j
<01>||<02>
t<04>t<06>ddgd|jg|j	|jg|j	dgg<04>
|<00>
<EFBFBD><00>}x4|jD]*}|jr<>|j
s<>|js<>|<04>|<03>

|<04>|
<01>

q`Wt||
dtdd<05>
d<06>
d|_dS)z#
        Draw the children
        g<00>?r
Fg)
r`)rarbN)rqr<>r<>Zscaler[ZTransformedPath<74>mpath<74>Pathr/rLr<>r8r<>ZclipboxZ	_clippathZ
set_clip_pathrcr	rdrH)r:rOr<>ZtpathrArrrrc<00>s















zDrawingArea.draw)r<>r<>F)rgrhrirjr7<00>propertyr<79>rkr<>r<>rJrPr_rZr<>rcrlrr)
r;rr<>#s
		r<>c@szeZ
dZd
Zddd<05>
Zdd<07>Zdd	<09>Zd
d<0B>Zdd
<0A>Zdd<0F>Z	dd<11>Z
dd<13>Zdd<15>Zdd<17>Z
dd<19>Zdd<1B>Zdd<1D>ZdS)<1F>TextAreaz<61>
    The TextArea is contains a single Text instance. The text is
    placed at (0,0) with baseline+left alignment. The width and height
    of the TextArea instance is the width and height of the its child
    text.
    NTcCs<>|d
kri}d|krd|d<tj
dd|
f|<02>
|_t<03>|<00>

|jg
|_t<06><07>|_|j<08>	<09>
|j<08>
dd<04>
t<06><07>|_|j<02>|j|j<00>

||_
||_d
S)aG
        Parameters
        ----------
        s : str
            a string to be displayed.

        textprops : dictionary, optional, default: None
            Dictionary of keyword parameters to be passed to the
            `~matplotlib.text.Text` instance contained inside TextArea.

        multilinebaseline : bool, optional
            If `True`, baseline for multiline text is adjusted so that it is
            (approximately) center-aligned with singleline text.

        minimumdescent : bool, optional
            If `True`, the box has a minimum descent of "p".
        N<>var(r
)<0F>mtextZText<78>_textr5r7r8r[r<>r<>r<>r<><00>_baseline_transformr<6D><00>_multilinebaseline<6E>_minimumdescent)r:<00>
s<>	textpropsZmultilinebaseline<6E>minimumdescentrrrr7<00>s














zTextArea.__init__cCs|j<00>
|
<01>

d
|_dS)z&Set the text of this area as a string.TN)r<><00>set_textrH)r:r<>rrrr<><00>s
zTextArea.set_textc

Cs
|j<00>
<01>S)
z5Returns the string representation of this area's text)r<><00>get_text)
r:rrrr<><00>szTextArea.get_textcCs|
|_d
|_
dS)z<>
        Set multilinebaseline .

        If True, baseline for multiline text is adjusted so that it is
        (approximately) center-aligned with single-line text.
        TN)r<>rH)r:r<>rrr<00>set_multilinebaseline<6E>s
zTextArea.set_multilinebaselinec


Cs|jS)
z)
        get multilinebaseline .
        )
r<>)
r:rrr<00>get_multilinebaseline<6E>szTextArea.get_multilinebaselinecCs|
|_d
|_
dS)z<>
        Set minimumdescent .

        If True, extent of the single line text is adjusted so that
        it has minimum descent of "p"
        TN)r<>rH)r:r<>rrr<00>set_minimumdescent<6E>s
zTextArea.set_minimumdescentc


Cs|jS)
z%
        get minimumdescent.
        )
r<>)
r:rrr<00>get_minimumdescent<6E>szTextArea.get_minimumdescentc
Csd
S)z+
        set_transform is ignored.
        Nr)r:r<>rrrr<>szTextArea.set_transformcCs0|
|_|j
<01><02>
|j
<01>|
d
|
d<00>
d|_dS)z<>
        Set the offset of the container.

        Parameters
        ----------
        xy : (float, float)
            The (x,y) coordinates of the offset in display units.
        r
rTN)r9r<>r<>r<>rH)r:rIrrrrJ	s	


zTextArea.set_offsetc


Cs|jS)
z1
        return offset of the container.
        )
r9)
r:rrrrPszTextArea.get_offsetcCs8|<00>|
<01>
\}}}}|<00>
<01>\}}tj<03>||||||<03>S)
z8
        get the bounding box in display space.
        )rZrPr[rr\)r:rOrr)rXrYrerfrrrr_s

zTextArea.get_window_extentcCs<>|
jd
|j
jdd<03>\}}}|j
<01>|
<01>
\}}}|j|j}}	|j<06><07>
t|<06>
dkr<>|j	r<>d|	d||}
|j<06>
d||
<00>
|
}n,t|||	|<00>}|<00><0C>r<>t||<04>}||}	||	d|fS)N<>lpF)
Zismathrg<00>?r
g)
Zget_text_width_height_descentr<74>Z_fontpropertiesZ_get_layoutrLr/r<>r<>rr<>r<>r!r<>)r:rO<00>
_Zh_Zd_r<5F><00>infor*rr)Zd_newZh_drrrrZ&s







zTextArea.get_extentcCs,|j<00>
|
<01>

t||
d
tdd<03>
d<04>
d
|_dS)z#
        Draw the children
        Fg)
r`)rarbN)r<>rcr	rdrH)r:rOrrrrcCs
z
TextArea.draw)NNT)rgrhrirjr7r<>r<>r<>r<>r<>r<>r<>rJrPr_rZrcrrrrr<><00>s 


)

r<>c@sXeZ
dZd
Zdd<03>Zdd<05>Zdd<07>Zdd	<09>Zd
d<0B>Zdd
<0A>Z	dd<0F>Z
dd<11>Zdd<13>ZdS)<15>AuxTransformBoxaX
    Offset Box with the aux_transform. Its children will be
    transformed with the aux_transform first then will be
    offseted. The absolute coordinate of the aux_transform is meaning
    as it will be automatically adjust so that the left-lower corner
    of the bounding box of children will be set to (0,0) before the
    offset transform.

    It is similar to drawing area, except that the extent of the box
    is not predetermined but calculated from the window extent of its
    children. Furthermore, the extent of the children will be
    calculated in the transformed coordinate.
    cCsJ|
|_t
<01>|<00>

t<03><04>|_|j<05><06>
|j<05>d
d
<01>
t<03><04>|_|j<08><06>
dS)Nr
)	<09>
aux_transformr5r7r[r<>r<>r<>r<><00>ref_offset_transform)r:r<>rrrr7\s








zAuxTransformBox.__init__cCs$|j<00>
|
<01>

|
<01>|<00><03><00>

d
|_dS)z?Add any :class:`~matplotlib.artist.Artist` to the container boxTN)r8r<>r<>r<>rH)r:rFrrrr<>js

zAuxTransformBox.add_artistc

Cs|j|j
|jS)
zf
        Return the :class:`~matplotlib.transforms.Transform` applied
        to the children
        )r<>r<>r<>)
r:rrrr<>ps

zAuxTransformBox.get_transformc
Csd
S)z+
        set_transform is ignored.
        Nr)r:r<>rrrr<>yszAuxTransformBox.set_transformcCs0|
|_|j
<01><02>
|j
<01>|
d
|
d<00>
d|_dS)z<>
        Set the offset of the container.

        Parameters
        ----------
        xy : (float, float)
            The (x,y) coordinates of the offset in display units.
        r
rTN)r9r<>r<>r<>rH)r:rIrrrrJs	


zAuxTransformBox.set_offsetc


Cs|jS)
z1
        return offset of the container.
        )
r9)
r:rrrrP<00>szAuxTransformBox.get_offsetcCs8|<00>|
<01>
\}}}}|<00>
<01>\}}tj<03>||||||<03>S)
z8
        get the bounding box in display space.
        )rZrPr[rr\)r:rOrr)rXrYrerfrrrr_<00>s

z!AuxTransformBox.get_window_extentcs||j<00>
<01>}|j<02><03>
|j<00><03>
<00>f
d
d<02>|jD<00>
}tj<06>|<03>
}|j<02>|j	|j
<00>
|jj|<02>}|j<00>|<05>

|j
|jddfS)Nc
sg|]}
|
<01><00><00>
<01>qSr)
r_)rrA)
rOrrr<00>sz.AuxTransformBox.get_extent.<locals>.<listcomp>g)r<>Z	to_valuesr<73>r<>r8r[r<00>unionr<6E>r<>r<>Zmatrix_from_valuesZ
set_matrixrLr/)r:rOZ_offZbboxesZubZmtxr)
rOrrZ<00>s






zAuxTransformBox.get_extentcCs:x|jD]}|<02>
|
<01>

qWt||
d
tdd<03>
d<04>
d
|_dS)z#
        Draw the children
        Fg)
r`)rarbN)r8rcr	rdrH)r:rOrArrrrc<00>s

zAuxTransformBox.drawN)
rgrhrirjr7r<>r<>r<>rJrPr_rZrcrrrrr<>Ns

	r<>cs<>eZ
dZd
ZdZdddddddd	d
dd<0C>
Zd)<29>f
dd<12>	Zdd<14>Zdd<16>Zdd<18>Z	dd<1A>Z
dd<1C>Zd*dd<1E>
Zdd <20>Z
d+d!d"<22>
Zd,d#d$<24>
Zd%d&<26>Zd'd(<28>Z<11>ZS)-<2D>AnchoredOffsetboxa7

    An offset box placed according to the legend location
    loc. AnchoredOffsetbox has a single child. When multiple children
    is needed, use other OffsetBox class to enclose them.  By default,
    the offset box is anchored against its parent axes. You may
    explicitly specify the bbox_to_anchor.
    <20>rrp<00><00><00><00><00><00>	<00>
)
zupper rightz
upper leftz
lower leftzlower rightr.zcenter leftzcenter rightzlower centerzupper centerr0皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?<3F><00>?NTc	
	s
t<00>j
f|	<09>

|<00>||<08>
|<00>|<04>

t|
t<05>rjy|j|
}
Wn,tk
rh


td
|
d<02>	|j<06>
f<00>
<01>
YnX|
|_
||_||_|dkr<>t
tdd<05>
|_n6t|t<10>r<>t
f|<05>
|_d|kr<>|j<0F>td<00>

n||_tdddd	d
|j<0F><13>dd<0C>|_|jjd
dd<0F>
||_dS)a<>
        loc is a string or an integer specifying the legend location.
        The valid location codes are::

        'upper right'  : 1,
        'upper left'   : 2,
        'lower left'   : 3,
        'lower right'  : 4,
        'right'        : 5, (same as 'center right', for back-compatibility)
        'center left'  : 6,
        'center right' : 7,
        'lower center' : 8,
        'upper center' : 9,
        'center'       : 10,

        pad : pad around the child for drawing a frame. given in
          fraction of fontsize.

        borderpad : pad between offsetbox frame and the bbox_to_anchor,

        child : OffsetBox instance that will be anchored.

        prop : font property. This is only used as a reference for paddings.

        frameon : draw a frame box if True.

        bbox_to_anchor : bbox to anchor. Use self.axes.bbox if None.

        bbox_transform : with which the bbox_to_anchor will be transformed.

        z4Unrecognized location "%s". Valid locations are
	%s
z
	Nzlegend.fontsize)
<01>sizer<65>)ggg<00>?rr{T)rIrLr/r|r}r~rr<>r
)
r`)r6r7<00>set_bbox_to_anchor<6F>	set_childrr<00>str<74>codes<65>KeyErrorr"<00>join<69>loc<6F>	borderpadr`rr<00>proprdZset_sizer<00>get_size_in_pointsr<73>r<>r<>)
r:r<>r`r<>r<>r<><00>frameon<6F>bbox_to_anchorZbbox_transformr)
r;rrr7<00>s4%




















zAnchoredOffsetbox.__init__cCs |
|_|
d
k	r|j
|
_
d|_d
S)zset the child to be anchoredNT)<03>_childrBrH)r:r<>rrrr<>s


zAnchoredOffsetbox.set_childc


Cs|jS)
zreturn the child)
r<>)
r:rrr<00>	get_child"szAnchoredOffsetbox.get_childc


Cs|jg
S)
zreturn the list of children)
r<>)
r:rrrr?&szAnchoredOffsetbox.get_childrencCsT|<00><00><00>
|
<01>
\}}}}|
<01>|j<03><04><00>
}|j|}|d
||d
|||||fS)zq
        return the extent of the artist. The extent of the child
        added with the pad is returned
        rp)r<>rZrqr<>r<>r`)r:rOrr)rXrYr<>r`rrrrZ*s


zAnchoredOffsetbox.get_extentc
Cs6|jd
kr|j
jS|j}
|
d
kr&|jSt|j|
<01>Sd
S)zB
        return the bbox that the legend will be anchored
        N)<05>_bbox_to_anchorrBr<><00>_bbox_to_anchor_transformr
)r:<00>	transformrrr<00>get_bbox_to_anchor5s




z$AnchoredOffsetbox.get_bbox_to_anchorcCs<>|
d
kst|
t
<01>r|
|_nZyt|
<01>
}Wn$tk
rJ


tdt|
<01>
<00>
<01>
YnX|dkrh|
d|
dddg}
tj|
<01>|_||_	d|_
d
S)aF

        set the bbox that the child will be anchored.

        *bbox* can be a Bbox instance, a list of [left, bottom, width,
        height], or a list of [left, bottom] where the width and
        height will be assumed to be zero. The bbox will be
        transformed to display coordinate by the given transform.
        NzInvalid argument for bbox : %srpr
rT)rrrr<>r<00>	TypeErrorr"r<>rr\r<>rH)r:r<>r<><00>
lrrrr<>Cs	





z$AnchoredOffsetbox.set_bbox_to_anchorcCsJ|<00>|
<01>

|<00>
|
<01>
\}}}}|<00>|||||
<01>\}}t<03>||||||<03>S)
z8
        get the bounding box in display space.
        )<05>_update_offset_funcrZrPrr\)r:rOrr)rXrYrerfrrrr_\s



z#AnchoredOffsetbox.get_window_extentcCs4|d
kr|
<01>|j
<01><02><00>
}||fdd<03>
}|<00>|<03>

d
S)zs
        Update the offset func which depends on the dpi of the
        renderer (because of the padding).
        NcSsHt<00>
d
d
||
<01>}|j|}|<06><03>}	|<06>|j||	|<08>\}
}|
|||fS)Nr
)rr\r<>r<><00>_get_anchored_bboxr<78>)rr)rXrYrOr<>r:r<>r<>r<>r<>r<>rrrr9ns








z6AnchoredOffsetbox._update_offset_func.<locals>._offset)rqr<>r<>rJ)r:rOr<>r9rrrr<>es


z%AnchoredOffsetbox._update_offset_funccCs.|j<00>
|
j|
j|
j|
j<05>
|r*|j<00>|<02>

dS)
N)r<>r<>r<>r<>rLr/r<>)r:r<>r<>rrrr<>{s


zAnchoredOffsetbox.update_framec
Cs<>|<00><00>sd
S|
<01>
|j<02><03><00>
}|<00>|
|<02>
|jrP|<00>|
<01>
}|<00>||<02>
|j<08>	|
<01>

|<00>
|
<01>
\}}}}|<00>|||||
<01>\}}	|<00><0C><00>
||	f<02>

|<00><0C><00>	|
<01>

d|_d
S)zdraw the artistNF)rSrqr<>r<>r<>r<>r_r<>r<>rcrZrPr<>rJrH)
r:rOr<>r<>rLr/rMrNr]r^rrrrc<00>s






zAnchoredOffsetbox.drawcCs<>|
td
d<02>kst
<01>
td<02>
\}}}}}	}
}}}
}}|d|d|d|	d|
d|d|d|
d	|d
|di
}||
}|<03>|<00>
}|j||d<0C>}|j|jfS)
z{
        return the position of the bbox anchored at the parentbbox
        with the loc code, with the borderpad.
        r<00>ZNEZNWZSWZSE<53>
E<>
W<>
S<>
N<>
C)
<01>	container)<06>range<67>AssertionErrorZpaddedZanchoredr<64>r<>)r:r<>r<>Z
parentbboxr<EFBFBD>ZBESTZURZULZLLZLR<4C>
RZCL<43>CRZLCZUCr<43>Zanchor_coefsrAr<>Zanchored_boxrrrr<><00>s 










z$AnchoredOffsetbox._get_anchored_bbox)r<>r<>NNTNN)
N)
N)
N)rgrhrirj<00>zorderr<72>r7r<>r<>r?rZr<>r<>r_r<>r<>rcr<>rlrr)
r;rr<><00>s6












D
	

r<>cs"eZ
dZd
Zd<07>f
dd<06>	Z<04>ZS)<08>AnchoredTextz&
    AnchoredOffsetbox with Text.
    皙<><E79A99><EFBFBD><EFBFBD><EFBFBD>?<3F><00>?Nc	sr|d
kri}ddddh}|t|<05>
@r2t
jddd<08>
t|
|d	d
<EFBFBD>|_|jj<05><06>}t<07>j|f
|||j|d<0B>|<06><02>

d
S)a<>
        Parameters
        ----------
        s : string
            Text.

        loc : str
            Location code.

        pad : float, optional
            Pad between the text and the frame as fraction of the font
            size.

        borderpad : float, optional
            Pad between the frame and the axes (or *bbox_to_anchor*).

        prop : dictionary, optional, default: None
            Dictionary of keyword parameters to be passed to the
            `~matplotlib.text.Text` instance contained inside AnchoredText.

        Notes
        -----
        Other keyword parameters of `AnchoredOffsetbox` are also
        allowed.
        NZhaZhorizontalalignmentr<74>Zverticalalignmentz3.1z<EFBFBD>Mixing horizontalalignment or verticalalignment with AnchoredText is not supported, deprecated since %(version)s, and will raise an exception %(removal)s.)
<01>messageF)r<>r<>)r`r<>r<>r<>)	<09>setrZwarn_deprecatedr<64><00>txtr<74>Zget_fontpropertiesr6r7)	r:r<>r<>r`r<>r<>rZ	badkwargs<67>fp)
r;rrr7<00>s









zAnchoredText.__init__)r<>r<>N)rgrhrirjr7rlrr)
r;rr<><00>sr<>c	@s^eZ
dZddd<07>
Zdd	<09>Zd
d<0B>Zdd
<0A>Zdd<0F>Zdd<11>Zdd<13>Z	dd<15>Z
dd<17>Zdd<19>ZdS)<1B>OffsetImagerN<>@FTcKsVt<00>
|<00>

|
|_tf|j|||||||	d
<01>|<0B><02>
|_|jg
|_|<00>|<02>

|<00>|
<01>

dS)N)r<><00>cmap<61>norm<72>
interpolation<6F>origin<69>
filternorm<EFBFBD>	filterrad<61>resample)	r5r7<00>_dpi_corrr_<00>imager8<00>set_zoom<6F>set_data)r:<00>arr<72>zoomr<6D>r<>r<>r<>r<>r<>r<>r<>rrrrr7<00>s













zOffsetImage.__init__cCs$t<00>
|
<01>
|_|j<03>|j<02>

d
|_dS)NT)rZasarray<61>_datar<61>r<>rH)r:r<>rrrr<>s


zOffsetImage.set_datac


Cs|jS)
N)
r<>)
r:rrr<00>get_datas
zOffsetImage.get_datacCs|
|_d
|_
dS)NT)<02>_zoomrH)r:r<>rrrr<>s

zOffsetImage.set_zoomc


Cs|jS)
N)
r
)
r:rrr<00>get_zooms
zOffsetImage.get_zoomc


Cs|jS)
z1
        return offset of the container.
        )
r9)
r:rrrrP'szOffsetImage.get_offsetc


Cs|jg
S)
N)
r<>)
r:rrrr?-s
zOffsetImage.get_childrencCs8|<00>|
<01>
\}}}}|<00>
<01>\}}tj<03>||||||<03>S)
z8
        get the bounding box in display space.
        )rZrPr[rr\)r:rOrr)rXrYrerfrrrr_0s

zOffsetImage.get_window_extentc	Cs^|jr|
<01>
d
<01>
}nd
}|<00><02>}|<00><03>}|jdd<02>\}}||||||}}||ddfS)Ng<00>?rpr
)r<>rqr

r<><00>shape)	r:rOr<>r<><00>data<74>nyZnxrr)rrrrZ8s




zOffsetImage.get_extentcCs|j<00>
|
<01>

d
|_dS)z#
        Draw the children
        FN)r<>rcrH)r:rOrrrrcEszOffsetImage.draw)	rNNNNrr<>FT)
rgrhrir7r<>r<>r<>r

rPr?r_rZrcrrrrr<><00>s$









r<>c@s<>eZ
dZd
ZdZdd<04>Zejd"d
d<0B>
<01>
Ze	dd
<0A><00>
Z
e
jdd
<0A><00>
Z
e	dd<10><00>
Zejdd<10><00>
Zdd<13>Z
dd<15>Zdd<17>Zd#dd<19>
Zd$dd<1B>
Zdd<1D>Zdd<1F>Zd d!<21>ZdS)%<25>AnnotationBboxzD
    Annotation-like class, but with offsetbox instead of Text.
    r<>c

Csd
|jd|jdfS)NzAnnotationBbox(%g,%g)r
r)
rI)
r:rrr<00>__str__Ts
zAnnotationBbox.__str__Nr
T皙<54><E79A99><EFBFBD><EFBFBD><EFBFBD>?<3F>g<00>?g<00>?c
	Ks<>tj
j|f
|
<0A>

tj||||d
<01>
|
|_||_|<00>|<0C>

|dkrH||_n||_|dkr^||_n||_|dk	r<>|j<05>	dd<04>|_
td|j<05>
|_nd|_
d|_|	|_
tdddd	d
|j<0F><10>dd<0C>|_|jjd
|d<0E>
|
r<EFBFBD>|jjf|
<EFBFBD>

||_dS)ao
        *offsetbox* : OffsetBox instance

        *xycoords* : same as Annotation but can be a tuple of two
           strings which are interpreted as x and y coordinates.

        *boxcoords* : similar to textcoords as Annotation but can be a
           tuple of two strings which are interpreted as x and y
           coordinates.

        *box_alignment* : a tuple of two floats for a vertical and
           horizontal alignment of the offset box w.r.t. the *boxcoords*.
           The lower-left corner is (0.0) and upper-right corner is (1.1).

        other parameters are identical to that of Annotation.
        )<02>xycoords<64>annotation_clipN<70>relpos)g<00>?g<00>?<3F>r
r
<00>rr)ggg<00>?rr{T)rIrLr/r|r}r~rr<>)
r`)r
r

)r<r=r7r
<00>	offsetbox<6F>
arrowprops<EFBFBD>set_fontsize<7A>xybox<6F>	boxcoords<64>pop<6F>
_arrow_relposr<00>arrow_patch<63>_box_alignmentrr<>r<>r<>r<>r<>r<>)r:r
rIr
r	
r
r<>r`r

Z
box_alignmentZ	bboxpropsr
r<>rrrrr7Ws<


















zAnnotationBbox.__init__c


Cs|jS)
N)
r
)
r:rrr<00>xyann<6E>szAnnotationBbox.xyanncCs|
|_d
|_
dS)NT)r
rH)r:r
rrrr
<00>s
c


Cs|jS)
N)
r
)
r:rrr<00>	anncoords<64>szAnnotationBbox.anncoordscCs|
|_d
|_
dS)NT)r
rH)r:Zcoordsrrrr
<00>s
cCs|j<00>
|
<01>
\}}||fS)
N)r
rD)r:<00>eventr<74>ZtinforrrrD<00>s
zAnnotationBbox.containsc
Cs"|j|j
g}
|jr|
<01>|j<02>

|
S)
N)r
r<>r
r<>)r:rnrrrr?<00>s



zAnnotationBbox.get_childrencCs4|jdk	r|j<00>
|
<01>

|j<02>
|
<01>

tj<04>
||
<01>
dS)
N)r
r>r
r<r=)r:r@rrrr><00>s



zAnnotationBbox.set_figurecCs&|
d
krtd}
t
|
d<03>
|_d|_d
S)z(
        set fontsize in points
        Nzlegend.fontsize)
r<>T)rrr<>rH)r:r<>rrrr
<00>s

zAnnotationBbox.set_fontsizecCs
|j<00>
<01>S)
z+
        return fontsize in points
        )r<>r<>)r:r<>rrr<00>get_fontsize<7A>szAnnotationBbox.get_fontsizecCsF|<00>|
<01>
}|<00>
|
|<02>
|
<01>|<00><03><00>
}|j<04>|<03>

|jrB|j<06>|<03>

d
S)zQ
        Update the pixel positions of the annotated point and the text.
        N)<07>_get_position_xy<78>_update_position_xyboxrqr
r<>r<>r
)r:rO<00>xy_pixelr~rrr<00>update_positions<6E>s



zAnnotationBbox.update_positionscCs<>
|j\}}t
|jt<03>rT|j\}}|<00>|
|||<05>\}}|<00>|
|||<06>\}	}
||
}}n|<00>|
|||j<02>\}}|j<05>|
<01>
\}
}}}|j\}}|j<05>|||
|||||f<02>

|j<05>	|
<01>
}|j
<EFBFBD>|j|j
|j|j<0F>
|\}}||}}|j<10>
r<>|j<10><11>}|j}|j|j|d
}|j
|j|d}|j<13>||f||f<02>
|j<15><16>}|<16>d|<18>}|
<01>|<19>
}|j<13>|<19>

|<16>d|j
<EFBFBD>}|j<13>|<1A>

dS)z`
        Update the pixel positions of the annotation text and the arrow
        patch.
        r
rr~<00>patchAN)r
rrr
<00>tupleZ_get_xyr
rZr
rJr_r<>r<>r<>r<>rLr/r
<00>copyr
r
Z
set_positionsr<73>r<>r
rqr<>Z
set_patchA)r:rOr
<00>
x<>
yZxcoordZycoord<72>x1<78>y1Zx2<78>y2Zox0Zoy0rr)rXrYZ_fwZ_fhr<68>Zox1Zoy1r*r
<00>fsr~r
rrrr
<00>s6








(











z%AnnotationBbox._update_position_xyboxcCs<>|
d
k	r|
|_|<00>
<01>sd
S|<00>|
<01>
}|<00>|
|<02>s4d
S|<00>|
<01>

|jd
k	rt|jjd
krh|jd
k	rh|j|j_|j<05>|
<01>

|jr<>|j	<09>|
<01>

|j
<EFBFBD>|
<01>

d|_d
S)zN
        Draw the :class:`Annotation` object to the given *renderer*.
        NF)Z	_rendererrSr
Z	_check_xyr
r
r<>rcr<>r<>r
rH)r:rOr
rrrrc s 












zAnnotationBbox.draw)
Nr
NTr
Nr
NNN)
N)
N)rgrhrirjr<>r
rZdedent_interpdr7r<>r
rkr
rDr?r>r
r
r
r
rcrrrrr
Ns2








?




:r
c@sjeZ
dZd
Zddd<04>
Zdd<06>Zdd<08>Zd	d
<EFBFBD>Zdd<0C>Zd
d<0E>Z	dd<10>Z
dd<12>Zdd<14>Zdd<16>Z
dd<18>ZdS)<1B>
DraggableBasea.
    Helper base class for a draggable artist (legend, offsetbox).

    Derived classes must override the following methods::

        def save_offset(self):
            '''
            Called when the object is picked for dragging; should save the
            reference position of the artist.
            '''

        def update_offset(self, dx, dy):
            '''
            Called during the dragging; (*dx*, *dy*) is the pixel offset from
            the point where the mouse drag started.
            '''

    Optionally, you may override the following methods::

        def artist_picker(self, artist, evt):
            '''The picker method that will be used.'''
            return self.ref_artist.contains(evt)

        def finalize_offset(self):
            '''Called when the mouse is released.'''

    In the current implementation of `DraggableLegend` and
    `DraggableAnnotation`, `update_offset` places the artists in display
    coordinates, and `finalize_offset` recalculates their position in axes
    coordinate and set a relevant attribute.
    FcCs`|
|_d
|_
|jjj|_|o"|jj|_|j<03>d|j<07>}|j<03>d|j<08>}|
<01>	|j
<EFBFBD>

||g|_dS)NFZ
pick_eventZbutton_release_event)<0C>
ref_artist<EFBFBD>
got_artistr<EFBFBD><00>canvasZ
supports_blit<69>	_use_blit<69>mpl_connect<63>on_pick<63>
on_releaseZ
set_picker<EFBFBD>
artist_picker<65>cids)r:r)
<00>use_blit<69>c2<63>c3rrrr7^s




zDraggableBase.__init__cCs@|<00><00>r<|j
r<|
j|j}|
j|j}|<00>||<03>
|j<07><08>
dS)
N)	<09>_check_still_parentedr*
r"
<00>mouse_xr#
<00>mouse_y<5F>
update_offsetr+
rc)r:<00>evt<76>dx<64>dyrrr<00>	on_motionks





zDraggableBase.on_motioncCsh|<00><00>rd|j
rd|
j|j}|
j|j}|<00>||<03>
|j<07>|j	<09>

|j
<EFBFBD>|j
jj
<0A>

|j<07>|j
jj<0F>

dS)
N)r5
r*
r"
r6
r#
r7
r8
r+
Zrestore_region<6F>
backgroundr)
rcr<><00>_cachedRenderer<65>blitr<74>)r:r9
r:
r;
rrr<00>on_motion_blitrs






zDraggableBase.on_motion_blitcCs<>|<00><00>r<>|
j
|jkr<>|
jj|_|
jj|_d
|_|j	r<>|j<02>
d
<01>

|j<0B><0C>
|j<0B>
|jjj<0F>
|_|j<02>|jjj<11>

|j<0B>|jjj<0F>

|j<0B>d|j<14>|_n|j<0B>d|j<16>|_|<00><17>
dS)NTZmotion_notify_event)r5
<00>artistr)
rEr"
r6
r#
r7
r*
r,
<00>set_animatedr+
rcZcopy_from_bboxr<78>r<>r=
r>
r?
r-
r@
<00>_c1r<
<00>save_offset)r:r9
rrrr.
{s 
















zDraggableBase.on_pickcCs@|<00><00>r<|j
r<|<00><02>
d
|_
|j<03>|j<05>

|jr<|j<07>d
<01>

dS)NF)	r5
r*
<00>finalize_offsetr+
<00>mpl_disconnectrC
r,
r)
rB
)r:r
rrrr/
<00>s




zDraggableBase.on_releasec

Cs |jj
dkr|<00><02>
d
SdSdS)NFT)r)
r<><00>
disconnect)
r:rrrr5
<00>s


z#DraggableBase._check_still_parentedc
CsLx|jD]}
|j
<01>|
<01>

qWy
|j}Wntk
r:


YnX|j
<01>|<02>

d
S)zDisconnect the callbacks.N)r1
r+
rF
rC
<00>AttributeError)r:ZcidZc1rrrrG
<00>s





zDraggableBase.disconnectcCs|j<00>
|<02>
S)
N)r)
rD)r:rA
r9
rrrr0
<00>s
zDraggableBase.artist_pickerc


CsdS)
Nr)
r:rrrrD
<00>s
zDraggableBase.save_offsetc
CsdS)
Nr)r:r:
r;
rrrr8
<00>s
zDraggableBase.update_offsetc


CsdS)
Nr)
r:rrrrE
<00>s
zDraggableBase.finalize_offsetN)
F)rgrhrirjr7r<
r@
r.
r/
r5
rG
r0
rD
r8
rE
rrrrr(
=s

		r(
c@s.eZ
dZddd<03>
Zdd<05>Zdd<07>Zdd	<09>Zd
S)<0C>DraggableOffsetBoxFcCstj
||
|d
<01>
||_dS)N)
r2
)r(
r7r
)r:r)
r
r2
rrrr7<00>s

zDraggableOffsetBox.__init__c
CsN|j}
|
j
j}|
<01>|<02>
\}}}}|
<01>|||||<02>}|\|_|_|j<00>|<07>

dS)
N)r
r<>r>
rZrP<00>offsetbox_x<5F>offsetbox_yrJ)r:r
rOrr)rXrY<00>offsetrrrrD
<00>s





zDraggableOffsetBox.save_offsetcCs$|j|
|j
|f}|j<02>|<03>

dS)
N)rJ
rK
r
rJ)r:r:
r;
<00>
loc_in_canvasrrrr8
<00>s

z DraggableOffsetBox.update_offsetc

Cs>|j}
|
j
j}|
<01>|<02>
\}}}}|
j\}}||||f}	|	S)
N)r
r<>r>
rZr9)
r:r
rOrr)rXrYrerfrM
rrr<00>get_loc_in_canvas<61>s






z$DraggableOffsetBox.get_loc_in_canvasN)
F)rgrhrir7rD
r8
rN
rrrrrI
<00>s

rI
c@s&eZ
dZd	dd<03>
Zdd<05>Zdd<07>ZdS)
<EFBFBD>DraggableAnnotationFcCstj
||
|d
<01>
|
|_dS)N)
r2
)r(
r7<00>
annotation)r:rP
r2
rrrr7<00>s

zDraggableAnnotation.__init__c
Cs"|j}
|
<01>
<01><00>|
j<03>
\|_|_dS)
N)rP
r<>r<>r
rerf)r:<00>annrrrrD
<00>s

zDraggableAnnotation.save_offsetcCs.|j}|<03>
<01><00><02><00>|j|
|j|f<02>
|_dS)
N)rP
r<><00>invertedr<64>rerfr
)r:r:
r;
rQ
rrrr8
<00>s


z!DraggableAnnotation.update_offsetN)
F)rgrhrir7rD
r8
rrrrrO
<00>s

rO
)
r)
r()4rjZnumpyrZ
matplotlibrrrZmatplotlib.artistrA
r<Zmatplotlib.path<74>pathr<68>Zmatplotlib.text<78>textr<74>Zmatplotlib.transformsZ
transformsr[Zmatplotlib.font_managerrZmatplotlib.imagerZmatplotlib.patchesrrr	rr
rrr
rr'r4r=r5rmroryrzr<>r<>r<>r<>r<>r<>r
<00>objectr(
rI
rO
rrrr<00><module>sF







	
1
%,LNS(ny1ip{