3 ƽh@@sdZddlmZmZddlmZmZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlZddlmZddlZddlZddlmZmZmZmZmZmZmZmZm Z m!Z!ddl"m#Z#ddl$m%Z%dd l&m'Z'dd l(m)Z)dd l*m+Z+e j,e-Z.d d d ddddddddddd Z/dddddddddddddd Z0dTddZ1ddZ2Gdd d Z3Gd!d"d"Z4Gd#d$d$Z5Gd%d&d&Z6Gd'd(d(e6Z7Gd)d*d*e6Z8Gd+d,d,e6Z9Gd-d.d.e6Z:Gd/d0d0eZ;Gd1d2d2e:ZdUd7d8Z?d9d:Z@dffd;d<ZAGd=d>d>ZBdVd?d@ZCdWdAdBZDGdCdDdDeEZFGdEdFdFZGejHZHGdGdHdHeIeZJGdIdJdJZKGdKdLdLZLejMdMGdNdOdOZNGdPdQdQZOGdRdSdSeOZPdS)Xa Abstract base classes define the primitives that renderers and graphics contexts must implement to serve as a Matplotlib backend. `RendererBase` An abstract base class to handle drawing/rendering operations. `FigureCanvasBase` The abstraction layer that separates the `.Figure` from the backend specific details like a user interface drawing area. `GraphicsContextBase` An abstract base class that provides color, line styles, etc. `Event` The base class for all of the Matplotlib event handling. Derived classes such as `KeyEvent` and `MouseEvent` store the meta data like keys and buttons pressed, x and y locations in pixel and `~.axes.Axes` coordinates. `ShowBase` The base class for the ``Show`` class of each interactive backend; the 'show' callable is then set to ``Show.__call__``. `ToolContainerBase` The base class for the Toolbar class of each interactive backend. )contextmanagersuppress)EnumIntEnumN)WeakKeyDictionary) backend_toolscbookcolorstextpath tight_bbox transformswidgets get_backendis_interactivercParams)Gcf) ToolManager)Affine2D)Path) _setattr_cmzEncapsulated Postscriptz Joint Photographic Experts GroupzPortable Document FormatzPGF code for LaTeXzPortable Network GraphicsZ PostscriptzRaw RGBA bitmapzScalable Vector GraphicszTagged Image File Format) epsZjpgZjpegZpdfZpgfZpngZpsrawZrgbasvgZsvgzZtifZtiffzmatplotlib.backends.backend_pszmatplotlib.backends.backend_aggzmatplotlib.backends.backend_pdfzmatplotlib.backends.backend_pgfzmatplotlib.backends.backend_svgcCs |dkr d}|t|<|t|<dS)a$ Register a backend for saving to a given file format. Parameters ---------- format : str File extension backend : module string or canvas class Backend for handling file output description : str, default: "" Description of the file type. N)_default_backends_default_filetypes)formatbackend descriptionr>/tmp/pip-build-7iwl8md4/matplotlib/matplotlib/backend_bases.pyregister_backendXs r!cCs6|tkr dSt|}t|tr2tj|j}|t|<|S)zv Return the registered default canvas for given file format. Handles deferred import of required backend. N)r isinstancestr importlib import_module FigureCanvas)rZ backend_classrrr get_registered_canvas_classks  r'cs(eZdZdZfddZdEddZddZdFd d ZdGd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZdHddZdd Zd!d"Zejd#d$dId&d'ZdJd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!d?d@Z"dAdBZ#dCdDZ$Z%S)K RendererBasea' An abstract base class to handle drawing/rendering operations. The following methods must be implemented in the backend for full functionality (though just implementing :meth:`draw_path` alone would give a highly capable backend): * :meth:`draw_path` * :meth:`draw_image` * :meth:`draw_gouraud_triangle` The following methods *should* be implemented in the backend for optimization reasons: * :meth:`draw_text` * :meth:`draw_markers` * :meth:`draw_path_collection` * :meth:`draw_quad_mesh` cstjd|_tj|_dS)N)super__init__ _texmanagerr Z TextToPath _text2path)self) __class__rr r*s zRendererBase.__init__NcCsdS)zz Open a grouping element with label *s* and *gid* (if set) as id. Only used by the SVG renderer. Nr)r-sgidrrr open_groupszRendererBase.open_groupcCsdS)zb Close a grouping element with label *s*. Only used by the SVG renderer. Nr)r-r/rrr close_groupszRendererBase.close_groupcCstdS)z?Draw a `~.path.Path` instance using the given affine transform.N)NotImplementedError)r-gcpath transformrgbFacerrr draw_pathszRendererBase.draw_pathc CsXxR|j|ddD]@\}}t|r|dd\} } |j|||tjj| | |qWdS)a3 Draw a marker at each of the vertices in path. This includes all vertices, including control points on curves. To avoid that behavior, those vertices should be removed before calling this function. This provides a fallback implementation of draw_markers that makes multiple calls to :meth:`draw_path`. Some backends may want to override this method in order to draw the marker only once and reuse it multiple times. Parameters ---------- gc : `.GraphicsContextBase` The graphics context. marker_trans : `matplotlib.transforms.Transform` An affine transform applied to the marker. trans : `matplotlib.transforms.Transform` An affine transform applied to the path. F)ZsimplifyN)Z iter_segmentslenr8r r translate) r-r4Z marker_pathZ marker_transr5transr7Zverticescodesxyrrr draw_markersszRendererBase.draw_markerscCs|j|||}xt|j|||t|||||| | | | | D]J\}}}}}|\}}|dks\|dkrp|j}|j|||j||||q6WdS)a Draw a collection of paths selecting drawing properties from the lists *facecolors*, *edgecolors*, *linewidths*, *linestyles* and *antialiaseds*. *offsets* is a list of offsets to apply to each of the paths. The offsets in *offsets* are first transformed by *offsetTrans* before being applied. *offset_position* may be either "screen" or "data" depending on the space that the offsets are in; "data" is deprecated. This provides a fallback implementation of :meth:`draw_path_collection` that makes multiple calls to :meth:`draw_path`. Some backends may want to override this in order to render each set of path data only once, and then reference that path multiple times with the different offsets, colors, styles etc. The generator methods :meth:`_iter_collection_raw_paths` and :meth:`_iter_collection` are provided to help with (and standardize) the implementation across backends. It is highly recommended to use those generators, so that changes to the behavior of :meth:`draw_path_collection` can be made globally. rN)_iter_collection_raw_paths_iter_collectionlistfrozenr<r8)r-r4master_transformpathsall_transformsoffsets offsetTrans facecolors edgecolors linewidths linestyles antialiasedsurlsoffset_positionpath_idsxoyopath_idgc0r7r5r6rrr draw_path_collections  z!RendererBase.draw_path_collectionc Cs^ddlm} | j|||} | dkr&|} tj|jgt} |j||| g|||| | g| gdgd S)z Fallback implementation of :meth:`draw_quad_mesh` that generates paths and then calls :meth:`draw_path_collection`. r)QuadMeshNZscreen)Zmatplotlib.collectionsrXZconvert_mesh_to_pathsnparray get_linewidthfloatrW)r-r4rFZ meshWidthZ meshHeightZ coordinatesrIrJrKZ antialiasedrLrXrGrMrrr draw_quad_meshs  zRendererBase.draw_quad_meshcCstdS)a Draw a Gouraud-shaded triangle. Parameters ---------- gc : `.GraphicsContextBase` The graphics context. points : array-like, shape=(3, 2) Array of (x, y) points for the triangle. colors : array-like, shape=(3, 4) RGBA colors for each point of the triangle. transform : `matplotlib.transforms.Transform` An affine transform to apply to the points. N)r3)r-r4pointsr r6rrr draw_gouraud_trianglesz"RendererBase.draw_gouraud_trianglecCs4|j}x&t||D]\}}|j||||qWdS)a Draw a series of Gouraud triangles. Parameters ---------- points : array-like, shape=(N, 3, 2) Array of *N* (x, y) points for the triangles. colors : array-like, shape=(N, 3, 4) Array of *N* RGBA colors for each point of the triangles. transform : `matplotlib.transforms.Transform` An affine transform to apply to the points. N)rEzipr_)r-r4Ztriangles_arrayZ colors_arrayr6Ztricolrrr draw_gouraud_trianglessz#RendererBase.draw_gouraud_trianglesc csrt|}t|}t||}|dkr&dStj}x>t|D]2}|||} |r\t|||}| ||fVq8WdS)a Helper method (along with :meth:`_iter_collection`) to implement :meth:`draw_path_collection` in a space-efficient manner. This method yields all of the base path/transform combinations, given a master transform, a list of paths and list of transforms. The arguments should be exactly what is passed in to :meth:`draw_path_collection`. The backend should take each yielded path and transform and create an object that can be referenced (reused) later. rN)r;maxr ZIdentityTransformranger) r-rFrGrHNpaths NtransformsNr6ir5rrr rB1s  z'RendererBase._iter_collection_raw_pathsc Cs`t|}|dks0t|t|ko*dknr4dSt|t|}t|t|}||d|S)a| Compute how many times each raw path object returned by _iter_collection_raw_paths would be used when calling _iter_collection. This is intended for the backend to decide on the tradeoff between using the paths in-line and storing them once and reusing. Rounds up in case the number of uses is not the same for every path. r)r;rc) r-rGrHrIrKrLreZ Npath_idsrgrrr _iter_collection_uses_per_pathOs (z+RendererBase._iter_collection_uses_per_pathc#cszt|}t|}t|}t||}t|}t|}t| }t| }t| }t| }| dkrhtjddd|dkrx|dks|dkrdS|r|j|}|j}|j||dkrd}|dkr|jdd \}}xt|D]}|||}|rZ|||\}}| dkrZ|r$t ||||}n|}|j||fd g\\}}\} }!| | }|!| }t j |ont j |stq|r|||}|r|r|j| |||r|j | |||||}"t|"dkr|"d dkr|jdn |j |"n |j |"|dk r0t|dkr0|d dkr0d}|j| |||rZ|j| |||||||fVqW|jdS) a Helper method (along with :meth:`_iter_collection_raw_paths`) to implement :meth:`draw_path_collection` in a space-efficient manner. This method yields all of the path, offset and graphics context combinations to draw the path collection. The caller should already have looped over the results of :meth:`_iter_collection_raw_paths` to draw this collection. The arguments should be the same as that passed into :meth:`draw_path_collection`, with the exception of *path_ids*, which is a list of arbitrary objects that the backend will use to reference one of the paths created in the :meth:`_iter_collection_raw_paths` stage. Each yielded result is of the form:: xo, yo, path_id, gc, rgbFace where *xo*, *yo* is an offset; *path_id* is one of the elements of *path_ids*; *gc* is a graphics context and *rgbFace* is a color to use for filling the path. dataz3.3zaSupport for offset_position='data' is deprecated since %(since)s and will be removed %(removal)s.)messagerNg)rr)rr)r;rcrwarn_deprecatedr6new_gccopy_properties set_linewidthrdrrYisfinite set_dashesset_foregroundset_antialiasedset_urlrestore)#r-r4rFrHrRrIrJrKrLrMrNrOrPrQrfreZNoffsetsrgZ NfacecolorsZ NedgecolorsZ NlinewidthsZ NlinestylesZNaaZNurlsZtoffsetsrVr7rSrTrhrUr6ZxpZypfgrrr rC`sx              zRendererBase._iter_collectioncCsdS)z Get the factor by which to magnify images passed to :meth:`draw_image`. Allows a backend to have images at a different resolution to other artists. g?r)r-rrr get_image_magnificationsz$RendererBase.get_image_magnificationcCstdS)a Draw an RGBA image. Parameters ---------- gc : `.GraphicsContextBase` A graphics context with clipping information. x : scalar The distance in physical units (i.e., dots or pixels) from the left hand side of the canvas. y : scalar The distance in physical units (i.e., dots or pixels) from the bottom side of the canvas. im : array-like, shape=(N, M, 4), dtype=np.uint8 An array of RGBA pixels. transform : `matplotlib.transforms.Affine2DBase` If and only if the concrete backend is written such that :meth:`option_scale_image` returns ``True``, an affine transformation (i.e., an `.Affine2DBase`) *may* be passed to :meth:`draw_image`. The translation vector of the transformation is given in physical units (i.e., dots or pixels). Note that the transformation does not override *x* and *y*, and has to be applied *before* translating the result by *x* and *y* (this can be accomplished by adding *x* and *y* to the translation vector defined by *transform*). N)r3)r-r4r?r@Zimr6rrr draw_imageszRendererBase.draw_imagecCsdS)a* Return whether image composition by Matplotlib should be skipped. Raster backends should usually return False (letting the C-level rasterizer take care of image composition); vector backends should usually return ``not rcParams["image.composite_image"]``. Fr)r-rrr option_image_nocompositesz%RendererBase.option_image_nocompositecCsdS)z Return whether arbitrary affine transformations in :meth:`draw_image` are supported (True for most vector backends). Fr)r-rrr option_scale_imageszRendererBase.option_scale_imagez3.3ismathTeX!c Cs|j||||||dddS)z TeX)r~N)_draw_text_as_path) r-r4r?r@r/propangler~mtextrrr draw_texszRendererBase.draw_texFc Cs|j|||||||dS)a Draw the text instance. Parameters ---------- gc : `.GraphicsContextBase` The graphics context. x : float The x location of the text in display coords. y : float The y location of the text baseline in display coords. s : str The text string. prop : `matplotlib.font_manager.FontProperties` The font properties. angle : float The rotation angle in degrees anti-clockwise. mtext : `matplotlib.text.Text` The original text object to be rendered. Notes ----- **Note for backend implementers:** When you are trying to determine if you have gotten your bounding box right (which is what enables the text layout/alignment to work properly), it helps to change the line in text.py:: if 0: bbox_artist(self, renderer) to if 1, and then the actual bounding box will be plotted along with your text. N)r) r-r4r?r@r/rrr~rrrr draw_texts#zRendererBase.draw_textcCs|j}|j|j}|j|||d\} } t| | } tj|}|jrv|j\} } t j ||j j |j || |}n t j ||j j |j ||}| |fS)aO Return the text path and transform. Parameters ---------- prop : `matplotlib.font_manager.FontProperties` The font property. s : str The text to be converted. ismath : bool or "TeX" If True, use mathtext parser. If "TeX", use *usetex* mode. )r~)r,points_to_pixelsget_size_in_pointsZ get_text_pathrrYZdeg2radflipyget_canvas_width_heightrscaleZ FONT_SCALErotater<)r-r?r@r/rrr~Z text2pathfontsizeZvertsr>r5widthheightr6rrr _get_text_path_transform)s      z%RendererBase._get_text_path_transformc Cs@|j||||||\}} |j} |jd|j||| | ddS)a Draw the text by converting them to paths using textpath module. Parameters ---------- prop : `matplotlib.font_manager.FontProperties` The font property. s : str The text to be converted. usetex : bool Whether to use usetex mode. ismath : bool or "TeX" If True, use mathtext parser. If "TeX", use *usetex* mode. g)r7N)rget_rgbrrr8) r-r4r?r@r/rrr~r5r6colorrrr rKs  zRendererBase._draw_text_as_pathcCs|dkr:|jj}|j}|j|||d\}}}|||fS|jd} |rf|jjj|| |} | ddS|jj} |jj|} |j} | j | | | j |d| d| j \}}| j }|d}|d}|d}|||fS) z Get the width, height, and descent (offset from the bottom to the baseline), in display coords, of the string *s* with `.FontProperties` *prop*. r)rendererHrrng)flagsgP@) r,get_texmanagerrget_text_width_height_descentrZmathtext_parserparseZ_get_hinting_flagZ _get_fontZset_sizeZset_textget_width_heightZ get_descent)r-r/rr~Z texmanagerrwhddpiZdimsrfontsizerrr r`s*        z*RendererBase.get_text_width_height_descentcCsdS)z Return whether y values increase from top to bottom. Note that this only affects drawing of texts and images. Tr)r-rrr rszRendererBase.flipycCsdS)z5Return the canvas width and height in display coords.ri)ririr)r-rrr rsz$RendererBase.get_canvas_width_heightcCs$|jdkrddlm}||_|jS)z"Return the `.TexManager` instance.Nr) TexManager)r+Zmatplotlib.texmanagerr)r-rrrr rs  zRendererBase.get_texmanagercCstS)z/Return an instance of a `.GraphicsContextBase`.)GraphicsContextBase)r-rrr rpszRendererBase.new_gccCs|S)a Convert points to display units. You need to override this function (unless your backend doesn't have a dpi, e.g., postscript or svg). Some imaging systems assume some value for pixels per inch:: points to pixels = points * pixels_per_inch/72 * dpi/72 Parameters ---------- points : float or array-like a float or a numpy array of float Returns ------- Points converted to pixels r)r-r^rrr rszRendererBase.points_to_pixelscCsdS)zW Switch to the raster renderer. Used by `.MixedModeRenderer`. Nr)r-rrr start_rasterizingszRendererBase.start_rasterizingcCsdS)z Switch back to the vector renderer and draw the contents of the raster renderer as an image on the vector renderer. Used by `.MixedModeRenderer`. Nr)r-rrr stop_rasterizingszRendererBase.stop_rasterizingcCsdS)z Switch to a temporary renderer for image filtering effects. Currently only supported by the agg renderer. Nr)r-rrr start_filterszRendererBase.start_filtercCsdS)z Switch back to the original renderer. The contents of the temporary renderer is processed with the *filter_func* and is drawn on the original renderer as an image. Currently only supported by the agg renderer. Nr)r-Z filter_funcrrr stop_filterszRendererBase.stop_filtercCsddttD}t|f|S)a  Context manager to temporary disable drawing. This is used for getting the drawn size of Artists. This lets us run the draw process to update any Python state but does not pay the cost of the draw_XYZ calls on the canvas. cSs(i|] }|jds|dkrdd|qS)Zdraw_r1r2c_sdS)Nr)argskwargsrrr sz8RendererBase._draw_disabled...)r1r2) startswith).0 meth_namerrr s z/RendererBase._draw_disabled..)dirr(r)r-Zno_opsrrr _draw_disableds zRendererBase._draw_disabled)N)N)N)N)rN)FN)&__name__ __module__ __qualname____doc__r*r1r2r8rArWr]r_rbrBrjrCrzr{r|r}rZ_delete_parameterrrrrrrrrrprrrrrr __classcell__rr)r.r r(ysB    !-d !    %"  r(c@s6eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-ZdMd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!dNd@dAZ"dBdCZ#dDdEZ$dFdGZ%dHdIZ&dOdKdLZ'dJS)Prz=An abstract base class that provides color, line styles, etc.cCs~d|_d|_d|_d|_d|_d|_d |_d|_d|_d|_ d |_ d|_ t j td |_td |_d|_d|_d|_d|_dS) N?FributtrroundZsolidz hatch.colorzhatch.linewidth)rN)rrrr)_alpha _forced_alpha _antialiased _capstyle _cliprect _clippath_dashes _joinstyle _linestyle _linewidth_rgb_hatchr to_rgbar _hatch_color_hatch_linewidth_url_gid_snap_sketch)r-rrr r*s$ zGraphicsContextBase.__init__cCs|j|_|j|_|j|_|j|_|j|_|j|_|j|_|j|_|j|_|j |_ |j |_ |j |_ |j |_ |j |_ |j|_|j|_|j|_|j|_dS)z"Copy properties from *gc* to self.N)rrrrrrrrrrrrrrrrrr)r-r4rrr rqs$z#GraphicsContextBase.copy_propertiescCsdS)z Restore the graphics context from the stack - needed only for backends that save graphics contexts on a stack. Nr)r-rrr rx szGraphicsContextBase.restorecCs|jS)zc Return the alpha value used for blending - not supported on all backends. )r)r-rrr get_alphaszGraphicsContextBase.get_alphacCs|jS)zAReturn whether the object should try to do antialiased rendering.)r)r-rrr get_antialiasedsz#GraphicsContextBase.get_antialiasedcCs|jS)zU Return the capstyle as a string in ('butt', 'round', 'projecting'). )r)r-rrr get_capstylesz GraphicsContextBase.get_capstylecCs|jS)zX Return the clip rectangle as a `~matplotlib.transforms.Bbox` instance. )r)r-rrr get_clip_rectangle sz&GraphicsContextBase.get_clip_rectanglecCs|jdk r|jjSdS)z Return the clip path in the form (path, transform), where path is a `~.path.Path` instance, and transform is an affine transform to apply to the path before clipping. N)NN)rZget_transformed_path_and_affine)r-rrr get_clip_path&s  z!GraphicsContextBase.get_clip_pathcCs|jS)aX Return the dash style as an (offset, dash-list) pair. The dash list is a even-length list that gives the ink on, ink off in points. See p. 107 of to PostScript `blue book`_ for more info. Default value is (None, None). .. _blue book: https://www-cdf.fnal.gov/offline/PostScript/BLUEBOOK.PDF )r)r-rrr get_dashes0s zGraphicsContextBase.get_dashescCs|jS)z Return whether the value given by get_alpha() should be used to override any other alpha-channel values. )r)r-rrr get_forced_alpha=sz$GraphicsContextBase.get_forced_alphacCs|jS)zAReturn the line join style as one of ('miter', 'round', 'bevel').)r)r-rrr get_joinstyleDsz!GraphicsContextBase.get_joinstylecCs|jS)z Return the line width in points.)r)r-rrr r[Hsz!GraphicsContextBase.get_linewidthcCs|jS)z0Return a tuple of three or four floats from 0-1.)r)r-rrr rLszGraphicsContextBase.get_rgbcCs|jS)z+Return a url if one is set, None otherwise.)r)r-rrr get_urlPszGraphicsContextBase.get_urlcCs|jS)z;Return the object identifier if one is set, None otherwise.)r)r-rrr get_gidTszGraphicsContextBase.get_gidcCs|jS)a Return the snap setting, which can be: * True: snap vertices to the nearest pixel center * False: leave vertices as-is * None: (auto) If the path contains only rectilinear line segments, round to the nearest pixel center )r)r-rrr get_snapXs zGraphicsContextBase.get_snapcCs6|dk r||_d|_n d|_d|_|j|jdddS)aB Set the alpha value used for blending - not supported on all backends. If ``alpha=None`` (the default), the alpha components of the foreground and fill colors will be used to set their respective transparencies (where applicable); otherwise, ``alpha`` will override them. NTg?F)isRGBA)rrrur)r-alpharrr set_alphacs zGraphicsContextBase.set_alphacCstt||_dS)z>Set whether object should be drawn with antialiased rendering.N)intboolr)r-brrr rvtsz#GraphicsContextBase.set_antialiasedcCstjdddg|d||_dS)z>Set the capstyle to be one of ('butt', 'round', 'projecting').rrZ projecting)csN)r_check_in_listr)r-rrrr set_capstyleysz GraphicsContextBase.set_capstylecCs ||_dS)zT Set the clip rectangle with sequence (left, bottom, width, height) N)r)r-Z rectanglerrr set_clip_rectangle~sz&GraphicsContextBase.set_clip_rectanglecCstjtjdf|d||_dS)z Set the clip path and transformation. Parameters ---------- path : `~matplotlib.transforms.TransformedPath` or None N)r5)rZ_check_isinstancer ZTransformedPathr)r-r5rrr set_clip_pathsz!GraphicsContextBase.set_clip_pathcCs6|dk r(tj|}tj|dkr(td||f|_dS)a Set the dash style for the gc. Parameters ---------- dash_offset : float or None The offset (usually 0). dash_list : array-like or None The on-off sequence as points. Notes ----- ``(None, None)`` specifies a solid line. See p. 107 of to PostScript `blue book`_ for more info. .. _blue book: https://www-cdf.fnal.gov/offline/PostScript/BLUEBOOK.PDF Ngz,All values in the dash list must be positive)rYZasarrayany ValueErrorr)r-Z dash_offsetZ dash_listdlrrr rts  zGraphicsContextBase.set_dashesFcCsV|jr"|r"|dd|jf|_n0|jr:tj||j|_n|rF||_n tj||_dS)z Set the foreground color. Parameters ---------- fg : color isRGBA : bool If *fg* is known to be an ``(r, g, b, a)`` tuple, *isRGBA* can be set to True to improve performance. Nrn)rrrr r)r-ryrrrr rus z"GraphicsContextBase.set_foregroundcCstjdddg|d||_dS)zsz-TimerBase.remove_callback..N)rrorremovepopindex)r-rrrfuncsrrr remove_callbacks  zTimerBase.remove_callbackcCsdS)z0Used to set interval on underlying timer object.Nr)r-rrr rszTimerBase._timer_set_intervalcCsdS)z3Used to set single shot on underlying timer object.Nr)r-rrr rsz TimerBase._timer_set_single_shotcCsTx8|jD].\}}}|||}|dkr|jj|||fqWt|jdkrP|jdS)z Runs all function that have been registered as callbacks. Functions can return False (or 0) if they should not be called any more. If there are no callbacks, the timer is automatically stopped. rN)rr r;r)r-rrrretrrr _on_timers  zTimerBase._on_timer)NN)N)rrrrr*rrrrrpropertyrsetterrrr rrrrrrr rs      rc@seZdZdZdddZdS)Eventa A Matplotlib event. Attach additional attributes as defined in :meth:`FigureCanvasBase.mpl_connect`. The following attributes are defined and shown with their default values Attributes ---------- name : str The event name. canvas : `FigureCanvasBase` The backend-specific canvas instance generating the event. guiEvent The GUI event that triggered the Matplotlib event. NcCs||_||_||_dS)N)namecanvasguiEvent)r-rrrrrr r*szEvent.__init__)N)rrrrr*rrrr rsrc@seZdZdZddZdS) DrawEventa An event triggered by a draw operation on the canvas In most backends callbacks subscribed to this callback will be fired after the rendering is complete but before the screen is updated. Any extra artists drawn to the canvas's renderer will be reflected without an explicit call to ``blit``. .. warning:: Calling ``canvas.draw`` and ``canvas.blit`` in these callbacks may not be safe with all backends and may cause infinite recursion. In addition to the `Event` attributes, the following event attributes are defined: Attributes ---------- renderer : `RendererBase` The renderer for the draw event. cCstj|||||_dS)N)rr*r)r-rrrrrr r*szDrawEvent.__init__N)rrrrr*rrrr rsrc@seZdZdZddZdS) ResizeEventa An event triggered by a canvas resize In addition to the `Event` attributes, the following event attributes are defined: Attributes ---------- width : int Width of the canvas in pixels. height : int Height of the canvas in pixels. cCs"tj||||j\|_|_dS)N)rr*rrr)r-rrrrr r*szResizeEvent.__init__N)rrrrr*rrrr rs rc@seZdZdZdS) CloseEventz,An event triggered by a figure being closed.N)rrrrrrrr rsrc@s&eZdZdZdZdddZddZdS) LocationEventan An event that has a screen location. The following additional attributes are defined and shown with their default values. In addition to the `Event` attributes, the following event attributes are defined: Attributes ---------- x : int x position - pixels from left of canvas. y : int y position - pixels from bottom of canvas. inaxes : `~.axes.Axes` or None The `~.axes.Axes` instance over which the mouse is, if any. xdata : float or None x data coordinate of the mouse. ydata : float or None y data coordinate of the mouse. Nc Cstj||||d|dk r"t|n||_|dk r8t|n||_d|_d|_d|_|dks`|dkrl|jdS|j j dkr|j j||f|_n |j j |_|jdk ry"|jj j }|j ||f\}}Wntk rYnX||_||_|jdS)zE (*x*, *y*) in figure coords ((0, 0) = bottom left). )rN)rr*rr?r@inaxesxdataydata_update_enter_leaver mouse_grabberZ transDatainvertedr6r) r-rrr?r@rr=rrrrr r*s*    zLocationEvent.__init__c Cstjdk rltj}|j|jkry|jdk r8|jjjd|Wntk rNYnX|jdk r|jjjd|n|jdk r|jjjd||t_dS)z+Process the figure/axes enter leave events.Naxes_leave_eventaxes_enter_event)r lasteventrrrprocess Exception)r-lastrrr r;s     z!LocationEvent._update_enter_leave)N)rrrrr"r*rrrrr rs #rc@s eZdZdZdZdZdZdZdS) MouseButtonrir9rn N)rrrLEFTZMIDDLERIGHTBACKFORWARDrrrr r&Vs r&c@s"eZdZdZd ddZddZdS) MouseEventa@ A mouse event ('button_press_event', 'button_release_event', 'scroll_event', 'motion_notify_event'). In addition to the `Event` and `LocationEvent` attributes, the following attributes are defined: Attributes ---------- button : None or `MouseButton` or {'up', 'down'} The button pressed. 'up' and 'down' are used for scroll events. Note that in the nbagg backend, both the middle and right clicks return RIGHT since right clicking will bring up the context menu in some browsers. Note that LEFT and RIGHT actually refer to the "primary" and "secondary" buttons, i.e. if the user inverts their left and right buttons ("left-handed setting") then the LEFT button will be the one physically on the right. key : None or str The key pressed when the mouse event triggered, e.g. 'shift'. See `KeyEvent`. .. warning:: This key is currently obtained from the last 'key_press_event' or 'key_release_event' that occurred within the canvas. Thus, if the last change of keyboard state occurred while the canvas did not have focus, this attribute will be wrong. step : float The number of scroll steps (positive for 'up', negative for 'down'). This applies only to 'scroll_event' and defaults to 0 otherwise. dblclick : bool Whether the event is a double-click. This applies only to 'button_press_event' and is False otherwise. In particular, it's not used in 'button_release_event'. Examples -------- :: def on_press(event): print('you pressed', event.button, event.xdata, event.ydata) cid = fig.canvas.mpl_connect('button_press_event', on_press) NrFc CsH|tjjkrt|}||_||_||_||_tj|||||| ddS)zw (*x*, *y*) in figure coords ((0, 0) = bottom left) button pressed None, 1, 2, 3, 'up', 'down' )rN) r& __members__valuesbuttonkeystepdblclickrr*) r-rrr?r@r0r1r2r3rrrr r*szMouseEvent.__init__cCsB|jd|jd|jd|jd|jd|jd|jd|jS)Nz: xy=(z, z ) xydata=(z ) button=z dblclick=z inaxes=)rr?r@rrr0r3r)r-rrr __str__szMouseEvent.__str__)NNrFN)rrrrr*r4rrrr r-^s1 r-c@seZdZdZdddZdS) PickEventa A pick event, fired when the user picks a location on the canvas sufficiently close to an artist. Attrs: all the `Event` attributes plus Attributes ---------- mouseevent : `MouseEvent` The mouse event that generated the pick. artist : `matplotlib.artist.Artist` The picked artist. other Additional attributes may be present depending on the type of the picked object; e.g., a `~.Line2D` pick may define different extra attributes than a `~.PatchCollection` pick. Examples -------- Bind a function ``on_pick()`` to pick events, that prints the coordinates of the picked data point:: ax.plot(np.rand(100), 'o', picker=5) # 5 points tolerance def on_pick(event): line = event.artist xdata, ydata = line.get_data() ind = event.ind print('on pick line:', np.array([xdata[ind], ydata[ind]]).T) cid = fig.canvas.mpl_connect('pick_event', on_pick) NcKs,tj||||||_||_|jj|dS)N)rr* mouseeventartist__dict__update)r-rrr6r7rrrrr r*szPickEvent.__init__)N)rrrrr*rrrr r5s r5c@seZdZdZdddZdS)KeyEventa A key event (key press, key release). Attach additional attributes as defined in :meth:`FigureCanvasBase.mpl_connect`. In addition to the `Event` and `LocationEvent` attributes, the following attributes are defined: Attributes ---------- key : None or str the key(s) pressed. Could be **None**, a single case sensitive ascii character ("g", "G", "#", etc.), a special key ("control", "shift", "f1", "up", etc.) or a combination of the above (e.g., "ctrl+alt+g", "ctrl+alt+G"). Notes ----- Modifier keys will be prefixed to the pressed key and will be in the order "ctrl", "alt", "super". The exception to this rule is when the pressed key is itself a modifier key, therefore "ctrl+alt" and "alt+control" can both be valid key values. Examples -------- :: def on_key(event): print('you pressed', event.key, event.xdata, event.ydata) cid = fig.canvas.mpl_connect('key_press_event', on_key) rNcCs ||_tj||||||ddS)N)r)r1rr*)r-rrr1r?r@rrrr r*szKeyEvent.__init__)rrN)rrrrr*rrrr r:s!r:csGdddtfdd}tj||d|j}|dkr^|jj}t|jjd|d|}zZy|tj|j dWn0k r}z|j \}\|_ |Sd}~XnXt |d Wd||_XWdQRXdS) z Get the renderer that would be used to save a `~.Figure`, and cache it on the figure. If you need a renderer without any active draw methods use renderer._draw_disabled to temporary patch them out at your call site. c@s eZdZdS)z_get_renderer..DoneN)rrrrrrr Donesr;cs |dS)Nr)r)r;rr _drawsz_get_renderer.._draw)drawNprint_)rz6 did not call Figure.draw, so no renderer is available) r$rrrget_default_filetypegetattr_get_output_canvasioBytesIOrrZ_cachedRenderer RuntimeError)figure print_methodr<Z orig_canvasfmtexcrr)r;r _get_renderers   rIcCs&t|do$|jdk o$t|jdddkS)aP Return whether we are in a a terminal IPython, but non interactive. When in _terminal_ IPython, ip.parent will have and `interact` attribute, if this attribute is False we do not setup eventloop integration as the user will _not_ interact with IPython. In all other case (ZMQKernel, or is interactive), we do. parentNZinteractF)hasattrrJr@)iprrr $_is_non_interactive_terminal_ipythons  rMcs>dkrtjtdStjtjfdd}|S)ae Decorator for the final print_* methods that accept keyword arguments. If any unused keyword arguments are left, this decorator will warn about them, and as part of the warning, will attempt to specify the function that the user actually called, instead of the backend-specific method. If unable to determine which function the user called, it will specify `.savefig`. For compatibility across backends, this does not warn about keyword arguments added by `FigureCanvasBase.print_figure` for use in a subset of backends, because the user would not have added them directly. N) extra_kwargsc sd}tjd}d}x\tjdD]N\}}|dkr0Ptjd|jjddrj|j|jjrl|jj}|dkrld}qPqWj }|rx dD]}||kr|j |dqWx.wrapper) functoolspartial_check_savefig_extra_argsinspect signaturewraps)rrNrcr)rNrrbr rf,s  )rfc@seZdZdZdZddddddd d d d d dddgZdZeZe j ddZ ddZ e ejddZeddZddZddZdjddZdd Zd!d"Zd#d$Zdkd%d&Zdld'd(Zdmd)d*Zd+d,Zdnd-d.Zdod0d1Zdpd2d3Zdqd4d5Z drd6d7Z!dsd8d9Z"d:d;Z#dd?Z%d@dAZ&dBdCZ'e j(dDdEdFZ)dGdHZ*e dIdJZ+e dKdLZ,dMdNZ-dtdddddPdQdRZ.e dSdTZ/dUdVZ0dWdXZ1dYdZZ2d[d\Z3d]d^Z4d_d`Z5e6Z7dudadbZ8dcddZ9dvdfdgZ:dhdiZ;dS)wFigureCanvasBasez The canvas the figure renders into. Attributes ---------- figure : `matplotlib.figure.Figure` A high-level figure instance. N resize_event draw_eventkey_press_eventkey_release_eventbutton_press_eventbutton_release_event scroll_eventmotion_notify_event pick_eventfigure_enter_eventfigure_leave_eventr!r  close_eventcCst|dot|dS)z+If this Canvas sub-class supports blitting.Zcopy_from_bboxZrestore_region)rK)clsrrr supports_blits zFigureCanvasBase.supports_blitcCs|jd|_d|_|j|||_d|_tj|_t j |_ d|_ d|_ d\|_|_|jd|j|_|jd|j|_d|_d|_d|_dS)NTFrorq)NN)_fix_ipython_backend2gui_is_idle_drawing _is_saving set_canvasrEmanagerrZCallbackRegistryrr ZLockDraw widgetlock_button_key_lastx_lasty mpl_connectpickZbutton_pick_idZscroll_pick_idrtoolbar)r-rErrr r*s     zFigureCanvasBase.__init__cCsdtjkrdSddl}|j}|s&dSddlm}t|d sJt|d rNdSt|dd}dddd d d j|}|rt |r|j |dS) NIPythonr) pylabtoolsZ backend2guiZenable_matplotlibrequired_interactive_frameworkZqtgtk3wxZosx)Zqt5Zqt4rrmacosx) sysmodulesrZ get_ipythonZ IPython.corerrKr@rZrMZ enable_gui)rwrrLptZrifZbackend2gui_rifrrr rys      z)FigureCanvasBase._fix_ipython_backend2guic csd|_z dVWdd|_XdS)NTF)rz)r-rrr _idle_draw_cntxs z FigureCanvasBase._idle_draw_cntxcCs|jS)z Return whether the renderer is in the process of saving to a file, rather than rendering for an on-screen buffer. )r{)r-rrr is_savingszFigureCanvasBase.is_savingcCs|jjs|jj|dS)N)r~lockedrEr)r-r6rrr rs zFigureCanvasBase.pickcCsdS)z0Blit the canvas in bbox (default entire canvas).Nr)r-bboxrrr blitszFigureCanvasBase.blitcCsdS)zSet the canvas size in pixels.Nr)r-rrrrr resizeszFigureCanvasBase.resizecCs"d}t|||}|jj||dS)z@Pass a `DrawEvent` to all functions connected to ``draw_event``.rlN)rrr#)r-rr/eventrrr rls zFigureCanvasBase.draw_eventcCs(d}t||}|jj|||jdS)zV Pass a `ResizeEvent` to all functions connected to ``resize_event``. rkN)rrr# draw_idle)r-r/rrrr rks zFigureCanvasBase.resize_eventc CsBd}y t|||d}|jj||Wnttfk r<YnXdS)zT Pass a `CloseEvent` to all functions connected to ``close_event``. rv)rN)rrr# TypeErrorAttributeError)r-rr/rrrr rvs zFigureCanvasBase.close_eventcCs4||_d}t||||j|j|d}|jj||dS)zV Pass a `KeyEvent` to all functions connected to ``key_press_event``. rm)rN)rr:rrrr#)r-r1rr/rrrr rms z FigureCanvasBase.key_press_eventcCs4d}t||||j|j|d}|jj||d|_dS)zX Pass a `KeyEvent` to all functions connected to ``key_release_event``. rn)rN)r:rrrr#r)r-r1rr/rrrr rns z"FigureCanvasBase.key_release_eventcKs2d}t||||fd|ji|}|jj||dS)z Callback processing for pick events. This method will be called by artists who are picked and will fire off `PickEvent` callbacks registered listeners. rsrN)r5rrr#)r-r6r7rr/rrrr rss zFigureCanvasBase.pick_eventc CsH|dkrd|_nd|_d}t|||||j|j||d}|jj||dS)a{ Callback processing for scroll events. Backend derived classes should call this function on any scroll wheel event. (*x*, *y*) are the canvas coords ((0, 0) is lower left). button and key are as defined in `MouseEvent`. This method will call all functions connected to the 'scroll_event' with a `MouseEvent` instance. rZupZdownrq)r2rN)rr-rrr#)r-r?r@r2rr/r6rrr rqs  zFigureCanvasBase.scroll_eventFc Cs6||_d}t||||||j||d}|jj||dS)a Callback processing for mouse button press events. Backend derived classes should call this function on any mouse button press. (*x*, *y*) are the canvas coords ((0, 0) is lower left). button and key are as defined in `MouseEvent`. This method will call all functions connected to the 'button_press_event' with a `MouseEvent` instance. ro)r3rN)rr-rrr#)r-r?r@r0r3rr/r6rrr ro/s  z#FigureCanvasBase.button_press_eventc Cs4d}t||||||j|d}|jj||d|_dS)a& Callback processing for mouse button release events. Backend derived classes should call this function on any mouse button release. This method will call all functions connected to the 'button_release_event' with a `MouseEvent` instance. Parameters ---------- x : float The canvas coordinates where 0=left. y : float The canvas coordinates where 0=bottom. guiEvent The native UI event that generated the Matplotlib event. rp)rN)r-rrr#r)r-r?r@r0rr/rrrr rp@sz%FigureCanvasBase.button_release_eventc Cs>|||_|_d}t|||||j|j|d}|jj||dS)a Callback processing for mouse movement events. Backend derived classes should call this function on any motion-notify-event. This method will call all functions connected to the 'motion_notify_event' with a `MouseEvent` instance. Parameters ---------- x : float The canvas coordinates where 0=left. y : float The canvas coordinates where 0=bottom. guiEvent The native UI event that generated the Matplotlib event. rr)rN)rrr-rrrr#)r-r?r@rr/rrrr rrXs z$FigureCanvasBase.motion_notify_eventcCs&|jjdtjdt_d\|_|_dS)a# Callback processing for the mouse cursor leaving the canvas. Backend derived classes should call this function when leaving canvas. Parameters ---------- guiEvent The native UI event that generated the Matplotlib event. ruN)NN)rr#rr"rr)r-rrrr leave_notify_eventqs z#FigureCanvasBase.leave_notify_eventcCs\|dk r |\}}|||_|_nd}d}tjdddddtd||||}|jjd|dS)a Callback processing for the mouse cursor entering the canvas. Backend derived classes should call this function when entering canvas. Parameters ---------- guiEvent The native UI event that generated the Matplotlib event. xy : (float, float) The coordinate location of the pointer when the canvas is entered. Nz3.0z3.5enter_notify_eventzvSince %(since)s, %(name)s expects a location but your backend did not pass one. This will become an error %(removal)s.)Zremovalrrlrt)rrrrorrr#)r-rxyr?r@rrrr rsz#FigureCanvasBase.enter_notify_eventcs0fdd|jjD}|r(tj|}nd}|S)as Return the topmost visible `~.axes.Axes` containing the point *xy*. Parameters ---------- xy : (float, float) (x, y) pixel positions from left/bottom of the canvas. Returns ------- `~matplotlib.axes.Axes` or None The topmost visible axes containing the point, or None if no axes. cs$g|]}|jjr|jr|qSr)patchZcontains_point get_visible)ra)rrr rsz+FigureCanvasBase.inaxes..N)rEget_axesr_topmost_artist)r-rZ axes_listaxesr)rr rs  zFigureCanvasBase.inaxescCs |jd|fkrtd||_dS)z Set the child `~.axes.Axes` which is grabbing the mouse events. Usually called by the widgets themselves. It is an error to call this if the mouse is already grabbed by another axes. Nz&Another Axes already grabs mouse input)rrD)r-axrrr grab_mouseszFigureCanvasBase.grab_mousecCs|j|krd|_dS)z Release the mouse grab held by the `~.axes.Axes` *ax*. Usually called by the widgets. It is ok to call this even if *ax* doesn't have the mouse grab currently. N)r)r-rrrr release_mouses zFigureCanvasBase.release_mousecOsdS)zRender the `.Figure`.Nr)r-rrrrr r=szFigureCanvasBase.drawc Os*|js&|j|j||WdQRXdS)a Request a widget redraw once control returns to the GUI event loop. Even if multiple calls to `draw_idle` occur before control returns to the GUI event loop, the figure will only be rendered once. Notes ----- Backends may choose to override the method and implement their own strategy to prevent multiple renderings. N)rzrr=)r-rrrrr rs  zFigureCanvasBase.draw_idlez3.2cCsdS)z Draw a cursor in the event.axes if inaxes is not None. Use native GUI drawing for efficiency if possible Nr)r-rrrr draw_cursorszFigureCanvasBase.draw_cursorcCst|jjjt|jjjfS)z Return the figure width and height in points or pixels (depending on the backend), truncated to integers. )rrErrr)r-rrr rsz!FigureCanvasBase.get_width_heightcCs|jS)z>Return dict of savefig file formats supported by this backend.) filetypes)rwrrr get_supported_filetypessz(FigureCanvasBase.get_supported_filetypescCs>i}x4|jjD]&\}}|j|gj|||jqW|S)a Return a dict of savefig file formats supported by this backend, where the keys are a file type name, such as 'Joint Photographic Experts Group', and the values are a list of filename extensions used for that filetype, such as ['jpg', 'jpeg']. )ritems setdefaultrsort)rwZ groupingsextrrrr get_supported_filetypes_groupeds z0FigureCanvasBase.get_supported_filetypes_groupedcCs|dk rBtjtj|j}t|d|s^td|d|dnt|d|rV|St|}|rl|j|Stdj |dj t |j dS)a3 Set the canvas in preparation for saving the figure. Parameters ---------- backend : str or None If not None, switch the figure canvas to the ``FigureCanvas`` class of the given backend. fmt : str If *backend* is None, then determine a suitable canvas class for saving to format *fmt* -- either the current canvas class, if it supports *fmt*, or whatever `get_registered_canvas_class` returns; switch the figure canvas to that canvas class. Nr>zThe z backend does not support z outputz4Format {!r} is not supported (supported formats: {})z, ) r$r%rZ_backend_module_namer&rKrr'switch_backendsrjoinsortedr)r-rrGZ canvas_classrrr rAs z#FigureCanvasBase._get_output_canvasportrait) bbox_inches pad_inchesbbox_extra_artistsrc*Ks|dkrtt|tjrtj|}t|tr@tjj|ddd}|dksP|dkrt|j}t|trt|jdd|}|j }|j | |} t | d|} |dkrt d}|dkrt |j d|j j}tj|dd tj|j |d tj| d d |j j}|j j}|dkrt d }tj|dr0|}|dkrBt d}tj|drT|}|j j||j j||dkr~t d}|r"|dkrt|j tj| |d}t|dr|jnt}||j j|WdQRX|j j|| d}|dkrt d}|j|}tj |j || j!}||f}nd}z | |f|||||d| }Wd|rZ|rZ||j j||j j||j j"|X|SQRXWdQRXWdQRXdS)a Render the figure to hardcopy. Set the figure patch face and edge colors. This is useful because some of the GUIs have a gray figure face color background and you'll probably want to override this on hardcopy. Parameters ---------- filename : str or path-like or file-like The file where the figure is saved. dpi : float, default: :rc:`savefig.dpi` The dots per inch to save the figure in. facecolor : color or 'auto', default: :rc:`savefig.facecolor` The facecolor of the figure. If 'auto', use the current figure facecolor. edgecolor : color or 'auto', default: :rc:`savefig.edgecolor` The edgecolor of the figure. If 'auto', use the current figure edgecolor. orientation : {'landscape', 'portrait'}, default: 'portrait' Only currently applies to PostScript printing. format : str, optional Force a specific file format. If not given, the format is inferred from the *filename* extension, and if that fails from :rc:`savefig.format`. bbox_inches : 'tight' or `.Bbox`, default: :rc:`savefig.bbox` Bounding box in inches: only the given portion of the figure is saved. If 'tight', try to figure out the tight bbox of the figure. pad_inches : float, default: :rc:`savefig.pad_inches` Amount of padding around the figure when *bbox_inches* is 'tight'. bbox_extra_artists : list of `~matplotlib.artist.Artist`, optional A list of extra artists that will be considered when the tight bbox is calculated. backend : str, optional Use a non-default backend to render the file, e.g. to render a png file with the "cairo" backend rather than the default "agg", or a pdf file with the "pgf" backend rather than the default "pdf". Note that the default backend is normally sufficient. See :ref:`the-builtin-backends` for a list of valid backends for each file format. Custom backends can be referenced as "module://...". Nrir.zprint_%sz savefig.dpirEZ _original_dpi)r})rT)r{zsavefig.facecolorautozsavefig.edgecolorz savefig.bboxZtight)rRr)rzsavefig.pad_inches)rrPrQrRrS)#r"osPathLikefspathr#r5splitextr?rstriplowerrAr@rrErrrZ get_facecolorZ get_edgecolorZ _str_equalZ set_facecolorZ set_edgecolorrIrdrerKrrr=Z get_tightbboxZpaddedr Z adjust_bbox fixed_dpir|)r-filenamerrPrQrRrrrrrrrrFZ origfacecolorZ origedgecolorrctxZ restore_bboxZ_bbox_inches_restoreresultrrr rO#s6                       zFigureCanvasBase.print_figurecCstdS)z Return the default savefig file format as specified in :rc:`savefig.format`. The returned string does not include a period. This method is overridden in backends that only support a single file type. zsavefig.format)r)rwrrr r?s z%FigureCanvasBase.get_default_filetypecCs|jdk r|jjSdS)z Return the title text of the window containing the figure, or None if there is no window (e.g., a PS backend). N)r}get_window_title)r-rrr rs z!FigureCanvasBase.get_window_titlecCs|jdk r|jj|dS)z Set the title text of the window containing the figure. Note that this has no effect if there is no window (e.g., a PS backend). N)r}set_window_title)r-titlerrr rs z!FigureCanvasBase.set_window_titlecCs0|jp d}|jdd}|j}|d|}|S)zl Return a string, which includes extension, suitable for use as a default filename. image _r)rreplacer?)r-Zdefault_basenameZdefault_filetypedefault_filenamerrr get_default_filenames    z%FigureCanvasBase.get_default_filenamecCs||j}|j|_|S)aS Instantiate an instance of FigureCanvasClass This is used for backend switching, e.g., to instantiate a FigureCanvasPS from a FigureCanvasGTK. Note, deep copying is not done, so any changes to one of the instances (e.g., setting figure size or line props), will be reflected in the other )rEr{)r-ZFigureCanvasClassZ newCanvasrrr rs z FigureCanvasBase.switch_backendscCs|jj||S)a. Bind function *func* to event *s*. Parameters ---------- s : str One of the following events ids: - 'button_press_event' - 'button_release_event' - 'draw_event' - 'key_press_event' - 'key_release_event' - 'motion_notify_event' - 'pick_event' - 'resize_event' - 'scroll_event' - 'figure_enter_event', - 'figure_leave_event', - 'axes_enter_event', - 'axes_leave_event' - 'close_event'. func : callable The callback function to be executed, which must have the signature:: def func(event: Event) -> Any For the location events (button and key press/release), if the mouse is over the axes, the ``inaxes`` attribute of the event will be set to the `~matplotlib.axes.Axes` the event occurs is over, and additionally, the variables ``xdata`` and ``ydata`` attributes will be set to the mouse location in data coordinates. See `.KeyEvent` and `.MouseEvent` for more info. Returns ------- cid A connection id that can be used with `.FigureCanvasBase.mpl_disconnect`. Examples -------- :: def on_press(event): print('you pressed', event.button, event.xdata, event.ydata) cid = canvas.mpl_connect('button_press_event', on_press) )rconnect)r-r/rrrr rs5zFigureCanvasBase.mpl_connectcCs |jj|S)z Disconnect the callback with id *cid*. Examples -------- :: cid = canvas.mpl_connect('button_press_event', on_press) # ... later canvas.mpl_disconnect(cid) )rZ disconnect)r-cidrrr mpl_disconnect s zFigureCanvasBase.mpl_disconnectcCs|j||dS)a Create a new backend-specific subclass of `.Timer`. This is useful for getting periodic events through the backend's native event loop. Implemented only for backends with GUIs. Parameters ---------- interval : int Timer interval in milliseconds. callbacks : List[Tuple[callable, Tuple, Dict]] Sequence of (func, args, kwargs) where ``func(*args, **kwargs)`` will be executed by the timer every *interval*. Callbacks which return ``False`` or ``0`` will be removed from the timer. Examples -------- >>> timer = fig.canvas.new_timer(callbacks=[(f1, (1,), {'a': 3})]) )rr) _timer_cls)r-rrrrr new_timer/ szFigureCanvasBase.new_timercCsdS)zu Flush the GUI events for the figure. Interactive backends need to reimplement this method. Nr)r-rrr flush_eventsH szFigureCanvasBase.flush_eventsrcCsR|dkrtj}d}d}d|_x0|jrL|||krL|jtj||d7}qWdS)aK Start a blocking event loop. Such an event loop is used by interactive functions, such as `~.Figure.ginput` and `~.Figure.waitforbuttonpress`, to wait for events. The event loop blocks until a callback function triggers `stop_event_loop`, or *timeout* is reached. If *timeout* is 0 or negative, never timeout. Only interactive backends need to reimplement this method and it relies on `flush_events` being properly implemented. Interactive backends should implement this in a more native way. rg{Gz?TriN)rYinf_loopingrtimesleep)r-timeoutZtimestepcounterrrr start_event_loopO s z!FigureCanvasBase.start_event_loopcCs d|_dS)z Stop the current blocking event loop. Interactive backends need to reimplement this to match `start_event_loop` FN)r)r-rrr stop_event_loopk sz FigureCanvasBase.stop_event_loop)N)N)N)N)N)FN)N)N)N)NN)NNNrN)NN)r)X|j||rNdnddd|j||rhdnddd|j|j| kr2d||jj||jjgkr2||jj}||jj}d$d%d&d'g}y&||j||fdt|\}}Wntk rYn*X|j|ddd|j|ddd|jn.|j|kr|j}|dkrh|jd|j jjnb|dkr`y|jdWn<tk r}zt j!t"||jdWYdd}~XnX|j jjn|j|krh|j#}|dkr|j$d|j jjnb|dkr`y|j$dWn<tk rX}zt j!t"||j$dWYdd}~XnX|j jjn|j|krx|j j%D]B}|j&dk r|j'dk r|j(|rt)j*ddd|j+dqWn|jj,r`|jdkr`t-|jd}|t|j j%kr`x\t.|j j%D]J\}}|j&dk r|j'dk r|j(|rt)j*ddd|j+||kqWdS)(a Implement the default Matplotlib key bindings for the canvas and toolbar described at :ref:`key-event-handling`. Parameters ---------- event : `KeyEvent` A key press/release event. canvas : `FigureCanvasBase`, default: ``event.canvas`` The backend-specific canvas instance. This parameter is kept for back-compatibility, but, if set, should always be equal to ``event.canvas``. toolbar : `NavigationToolbar2`, default: ``event.canvas.toolbar`` The navigation cursor toolbar. This parameter is kept for back-compatibility, but, if set, should always be equal to ``event.canvas.toolbar``. Nzkeymap.fullscreenz keymap.homez keymap.backzkeymap.forwardz keymap.panz keymap.zoomz keymap.savez keymap.quitzkeymap.quit_allz keymap.gridzkeymap.grid_minorz keymap.yscalez keymap.xscalezkeymap.all_axescSs4tdd|DrdStdd|Ds,dSdSdS)Ncss|]}|jjVqdS)N)gridliner)rtickrrr szDkey_press_handler.._get_uniform_gridstate..Tcss|]}|jjVqdS)N)rr)rrrrr r sF)allr)Zticksrrr _get_uniform_gridstate s z1key_press_handler.._get_uniform_gridstateFTrimajorZbothr?)whichZaxisr@logZlinearz3.3ziToggling axes navigation from the keyboard is deprecated since %(since)s and will be removed %(removal)s.)rl0)FF)TF)TT)FT)FF)TF)TT)FT)/r1rrrdict __getitem__r}full_screen_togglerrZ destroy_figrEZ destroy_allhomebackforwardpan_update_cursorzoom save_figurerxaxisZ minorTicksyaxisZ majorTicksr r;rZgridrZ get_yscaleZ set_yscale_logwarningr#Z get_xscaleZ set_xscalerr?r@in_axesrroZ set_navigateisdigitr enumerate)rrrZfullscreen_keysZ home_keysZ back_keysZ forward_keysZpan_keysZ zoom_keysZ save_keysZ quit_keysZ quit_all_keysZ grid_keysZgrid_minor_keysZtoggle_yscale_keysZtoggle_xscale_keysZall_keysrrZx_stateZy_statecyclerrHZscalexrnrhrrr key_press_handleru s                         &     &              rcCs`|dkr|j}|dkr|j}|dk r\tt|j}|tdkrH|jn|tdkr\|jdS)z The default Matplotlib button actions for extra mouse buttons. Parameters are as for `key_press_handler`, except that *event* is a `MouseEvent`. Nz keymap.backzkeymap.forward)rrr#r&r0rrr)rrrZ button_namerrr button_press_handler. s   rc@seZdZdZdS)NonGuiExceptionz6Raised when trying show a figure in a non-GUI backend.N)rrrrrrrr rA src@sneZdZdZddZejdeddZddZ d d Z d d Z d dZ ddZ ddZddZddZdS)FigureManagerBasea( A backend-independent abstraction of a figure container and controller. The figure manager is used by pyplot to interact with the window in a backend-independent way. It's an adapter for the real (GUI) framework that represents the visual figure on screen. GUI backends define from this class to translate common operations such as *show* or *resize* to the GUI-specific code. Non-GUI backends do not support these operations an can just use the base class. This following basic operations are accessible: **Window operations** - `~.FigureManagerBase.show` - `~.FigureManagerBase.destroy` - `~.FigureManagerBase.full_screen_toggle` - `~.FigureManagerBase.resize` - `~.FigureManagerBase.get_window_title` - `~.FigureManagerBase.set_window_title` **Key and mouse button press handling** The figure manager sets up default key and mouse button press handling by hooking up the `.key_press_handler` to the matplotlib event system. This ensures the same shortcuts and mouse actions across backends. **Other operations** Subclasses will have additional attributes and functions to access additional functionality. This is of course backend-specific. For example, most GUI backends have ``window`` and ``toolbar`` attributes that give access to the native GUI widgets of the respective framework. Attributes ---------- canvas : `FigureCanvasBase` The backend-specific canvas instance. num : int or str The figure number. key_press_handler_id : int The default key handler cid, when using the toolmanager. To disable the default key press handling use:: figure.canvas.mpl_disconnect( figure.canvas.manager.key_press_handler_id) button_press_handler_id : int The default mouse button handler cid, when using the toolmanager. To disable the default button press handling use:: figure.canvas.mpl_disconnect( figure.canvas.manager.button_press_handler_id) cs|_|_|_d_d_tddkrNjjdj_jjdj_t jddkrft |j nd_ d_ jj jfdd}dS)Nr toolmanagerrmrocs"jdkrjdk rjjdS)N)rrr9)fig)r-rr notify_axes_change sz6FigureManagerBase.__init__..notify_axes_change)rr}numZkey_press_handler_idZbutton_press_handler_idrr key_press button_pressmplrrErrZadd_axobserver)r-rrrr)r-r r* s    zFigureManagerBase.__init__z3.3cCsdS)Nr)r-rrr statusbar szFigureManagerBase.statusbarcCs"tjdkrtdtddS)a For GUI backends, show the figure window and redraw. For non-GUI backends, raise an exception, unless running headless (i.e. on Linux with an unset DISPLAY); this exception is converted to a warning in `.Figure.show`. ZheadlesszMatplotlib is currently using z8, which is a non-GUI backend, so cannot show the figure.N)rZ"_get_running_interactive_frameworkrr)r-rrr show s zFigureManagerBase.showcCsdS)Nr)r-rrr destroy szFigureManagerBase.destroycCsdS)Nr)r-rrr r sz$FigureManagerBase.full_screen_togglecCsdS)z0For GUI backends, resize the window (in pixels).Nr)r-rrrrr r szFigureManagerBase.resizecCstddkrt|dS)zm Implement the default Matplotlib key bindings defined at :ref:`key-event-handling`. rrN)rr)r-rrrr r s zFigureManagerBase.key_presscCstddkrt|dS)z>The default Matplotlib button actions for extra mouse buttons.rrN)rr)r-rrrr r s zFigureManagerBase.button_presscCsdS)z Return the title text of the window containing the figure, or None if there is no window (e.g., a PS backend). rr)r-rrr r sz"FigureManagerBase.get_window_titlecCsdS)z Set the title text of the window containing the figure. This has no effect for non-GUI (e.g., PS) backends. Nr)r-rrrr r sz"FigureManagerBase.set_window_titleN)rrrrr*rrrrrrrrrrrrrrrr rF s9 rc@s,eZdZdZdZdZddZeddZdS) _Moderzpan/zoomz zoom rectcCs|jS)N)value)r-rrr r4 sz _Mode.__str__cCs|tjk r|jSdS)N)rNONEr)r-rrr _navigate_mode sz_Mode._navigate_modeN) rrrrPANZOOMr4rrrrrr r s rc sPeZdZdZdeZfddZddZd d!Zd"d#Zd$d%Z d&d'Z d(d)Z e j d*d+d,d-d.Zd/d0Zed1d2Zd3d4Zd5d6Ze j d*d7d8Ze j d*d9d:Zd;d<Zfd=d>Zd?d@ZfdAdBZdCdDZfdEdFZdGdHZfdIdJZdKdLZe j d*dMd,dNdOZdPdQZ dRdSZ!dTdUZ"dVdWZ#dXdYZ$dZd[Z%Z&S)fNavigationToolbar2a? Base class for the navigation cursor, version 2. Backends must implement a canvas that handles connections for 'button_press_event' and 'button_release_event'. See :meth:`FigureCanvasBase.mpl_connect` for more information. They must also define :meth:`save_figure` save the current figure :meth:`set_cursor` if you want the pointer icon to change :meth:`draw_rubberband` (optional) draw the zoom to rect "rubberband" rectangle :meth:`set_message` (optional) display message :meth:`set_history_buttons` (optional) you can change the history back / forward buttons to indicate disabled / enabled state. and override ``__init__`` to set up the toolbar -- without forgetting to call the base-class init. Typically, ``__init__`` needs to set up toolbar buttons connected to the `home`, `back`, `forward`, `pan`, `zoom`, and `save_figure` methods and using standard icons in the "images" subdirectory of the data path. That's it, we'll do the rest! HomeReset original viewrBackBack to previous viewrForwardForward to next viewrNPanFLeft button pans, Right button zooms x/y fixes axis, CTRL fixes aspectmoverZoom3Zoom to rectangle x/y fixes axis, CTRL fixes aspect zoom_to_rectrSubplotsConfigure subplotssubplotsconfigure_subplotsSaveSave the figurefilesavercs||_||_tj|_d|_tj|_tj j |dddd}|rD||jj d|j |_ |jj d|j |_|jj d|j|_d|_d|_tj|_|jdS)NTz3.3zPlease fully initialize the toolbar in your subclass' __init__; a fully empty _init_toolbar implementation may be kept for compatibility with earlier versions of Matplotlib.)Z allow_emptysinceZaddendumrorprr)rrrZStack _nav_stack_xypresscursorsPOINTER _lastCursor_deprecate_method_override _init_toolbarr_zoom_pan_handlerZ _id_pressZ _id_release mouse_move_id_drag _zoom_info_button_pressedrrmodeset_history_buttons)r-rinit)r.rr r* s(     zNavigationToolbar2.__init__cCsdS)z.Display a message on toolbar or in status bar.Nr)r-r/rrr set_message8 szNavigationToolbar2.set_messagecCsdS)z Draw a rectangle rubberband to indicate zoom limits. Note that it is not guaranteed that ``x0 <= x1`` and ``y0 <= y1``. Nr)r-rZx0Zy0x1y1rrr draw_rubberband; sz"NavigationToolbar2.draw_rubberbandcCsdS)zRemove the rubberband.Nr)r-rrr remove_rubberbandB sz$NavigationToolbar2.remove_rubberbandcGs|jj|j|jdS)z Restore the original view. For convenience of being directly connected as a GUI callback, which often get passed additional parameters, this method accepts arbitrary parameters, but does not use them. N)r rr- _update_view)r-rrrr rE s zNavigationToolbar2.homecGs|jj|j|jdS)z Move back up the view lim stack. For convenience of being directly connected as a GUI callback, which often get passed additional parameters, this method accepts arbitrary parameters, but does not use them. N)r rr-r4)r-rrrr rQ s zNavigationToolbar2.backcGs|jj|j|jdS)z Move forward in the view lim stack. For convenience of being directly connected as a GUI callback, which often get passed additional parameters, this method accepts arbitrary parameters, but does not use them. N)r rr-r4)r-rrrr r] s zNavigationToolbar2.forwardz3.3r*) alternativecCstdS)a This is where you actually build the GUI widgets (called by __init__). The icons ``home.xpm``, ``back.xpm``, ``forward.xpm``, ``hand.xpm``, ``zoom_to_rect.xpm`` and ``filesave.xpm`` are standard across backends (there are ppm versions in CVS also). You just need to set the callbacks home : self.home back : self.back forward : self.forward hand : self.pan zoom_to_rect : self.zoom filesave : self.save_figure You only need to define the last one - the others are in the base class implementation. N)r3)r-rrr r&i sz NavigationToolbar2._init_toolbarcCs|j s|j r2|jtjkr|jtjtj|_nZ|jtjkr`|jtjkr`|jtjtj|_n,|jtj kr|jtj kr|jtj tj |_dS)zV Update the cursor after a mouse move event or a tool (de)activation. N) rr,r$r"r# set_cursorrr Z SELECT_REGIONr ZMOVE)r-rrrr r s          z!NavigationToolbar2._update_cursorc cs\tjt|dtj |_}|j|dkrRz|jtjdVWd|j|jXndVdS)a Set the cursor to a wait cursor when drawing the canvas. In order to avoid constantly changing the cursor when the canvas changes frequently, do nothing if this context was triggered during the last second. (Optimally we'd prefer only setting the wait cursor if the *current* draw takes too long, but the current draw blocks the GUI thread). _draw_timeriN) rr@rYrr7r6r"ZWAITr$)r-Zlast_draw_timerrr _wait_cursor_for_draw_cm s   z+NavigationToolbar2._wait_cursor_for_draw_cmc s|jjrjjryjjjj}Wnttfk rHYqX|j}fddjj D}|rt j |}|jj k r|j }|dk r|j|j}|r|d|}|j|n |j|jdS)Ncs&g|]}|jdr|jr|qS)r)containsr)rr)rrr r sz1NavigationToolbar2.mouse_move.. )rr get_navigateZ format_coordrrr OverflowErrorrZ_mouseover_setrrrZget_cursor_dataZformat_cursor_datar/r,)r-rr/ZartistsrrkZdata_strr)rr r( s$      zNavigationToolbar2.mouse_movecCsp|jtjkr6|jdkr"|j|n|jdkr6|j||jtjkrl|jdkrX|j|n|jdkrl|j|dS)Nrorp) r,rr r press_pan release_panr  press_zoom release_zoom)r-rrrr r' s         z$NavigationToolbar2._zoom_pan_handlercCsdS)z*Called whenever a mouse button is pressed.Nr)r-rrrr press szNavigationToolbar2.presscCsdS)z"Callback for mouse button release.Nr)r-rrrr release szNavigationToolbar2.releasecGsl|jtjkr$tj|_|jjj|ntj|_|jj|x"|jjjD]}|j |jj qFW|j |jdS)z[ Toggle the pan/zoom tool. Pan with left button, zoom with right. N) r,rr rrr~rBrErset_navigate_moderr/)r-rrrrr r s  zNavigationToolbar2.pancs|jdkr|j|_n d|_dS|jdkr2|j|j|j}}g|_xt|jj j D]r\}}|dk rX|dk rX|j |rX|j rX|j rX|j|||j|jj||f|jj|j|jjd|j|_qXWtjj|ddd}|dk r||dS) z1Callback for mouse button press in pan/zoom mode.rirnNrrz3.3zCalling an overridden press() at pan start is deprecated since %(since)s and will be removed %(removal)s; override press_pan() instead.)rrl)rirn)r0r+r  push_currentr?r@r!rrrErrr;Zcan_panZ start_panrrr)rdrag_panrr%rA)r-rr?r@rhrrA)r.rr r= s(   zNavigationToolbar2.press_pancCs:x*|jD] \}}|j|j|j|j|jqW|jjdS)z'Callback for dragging in pan/zoom mode.N)r!rEr+r1r?r@rr)r-rrindrrr rE szNavigationToolbar2.drag_pancs|jdkrdS|jj|j|jjd|j|_x|jD]\}}|jq6W|jsTdSg|_d|_|jt j j |ddd}|dk r|||j dS)z3Callback for mouse button release in pan/zoom mode.Nrrz3.3zCalling an overridden release() at pan stop is deprecated since %(since)s and will be removed %(removal)s; override release_pan() instead.)rrl) r+rrr)rr(r!Zend_panrDrr%rAr<)r-rrrFrB)r.rr r> s"   zNavigationToolbar2.release_pancGsl|jtjkr$tj|_|jjj|ntj|_|jj|x"|jjjD]}|j |jj qFW|j |jdS)zToggle zoom to rect mode.N) r,rr rrr~rBrErrCrr/)r-rrrrr r s  zNavigationToolbar2.zoomcsjd krdSjdks"jdkr&dSfdd|jjjD}|sHdS|jdkr\|j|jjd|j }jdkrzdndjjf||d |_ t j j |d d d }|dk r|dS)z5Callback for mouse button press in zoom to rect mode.rirnNcs*g|]"}|jr|jr|jr|qSr)rr;Zcan_zoom)rr)rrr r1 sz1NavigationToolbar2.press_zoom..rrinout) directionstart_xyrrz3.3zCalling an overridden press() at zoom start is deprecated since %(since)s and will be removed %(removal)s; override press_zoom() instead.)rrl)rirn)r0r?r@rrErr rDr drag_zoomr*rr%rA)r-rrZid_zoomrA)r.)rr r?+ s&     zNavigationToolbar2.press_zoomcCs|jd}|jdd}tj||j|jgg|jj|jj\\}}\}}|jdkr^|jj \}}n|jdkrt|jj \}}|j |||||dS)z#Callback for dragging in zoom mode.rJrrr?r@N) r*rYZclipr?r@rminrcr1Z intervalyZ intervalxr2)r-rrJrr0r1Zx2y2rrr rKF s *   zNavigationToolbar2.drag_zoomc st|jdkrdS|jj|jd|j|jd\}}xt|jdD]\}|j|j}}t||dkrv|jdkst||dkr|jdkrd|_ t j j |dd d }|dk r|||j dStfd d |jdd|D}tfd d |jdd|D} j||||f|jd|j|| qFW|j d|_|jt j j|dd d }|dk rp||dS)z7Callback for mouse button release in zoom to rect mode.NrrJrr@r?z3.3zCalling an overridden release() at zoom stop is deprecated since %(since)s and will be removed %(removal)s; override release_zoom() instead.)rrlc3s|]}jj|VqdS)N)Zget_shared_x_axesjoined)rprev)rrr rr sz2NavigationToolbar2.release_zoom..c3s|]}jj|VqdS)N)Zget_shared_y_axesrO)rrP)rrr rt srI)r*rrr3rr?r@absr1r!rr%rAr<rZ_set_view_from_bboxrDrB) r-rZstart_xZstart_yrhr?r@rBZtwinxZtwiny)r.)rr r@R s<    zNavigationToolbar2.release_zoomcCs,|jjtdd|jjjD|jdS)z9Push the current view limits and position onto the stack.cSs0i|](}|j|jdj|jjff|qS)T)Z _get_view get_positionrE)rrrrr r sz3NavigationToolbar2.push_current..N)r pushrrrErr-)r-rrr rD s zNavigationToolbar2.push_currentztoolbar.canvas.draw_idle()cCs |jdS)z)Redraw the canvases, update the locators.N)r<)r-rrr r= szNavigationToolbar2.drawcCsx|jjjD]}t|dd}t|dd}g}|dk rR|j|j|j|j|dk rv|j|j|j|jx|D]}tjj |q|WqW|jj dS)Nrr) rrErr@rZget_major_locatorZget_minor_locatorrZtickerZ+_if_refresh_overridden_call_and_emit_deprecr)r-rrrZlocatorslocrrr r< s   zNavigationToolbar2._drawcCsj|j}|dkrdSt|j}x:|D]2\}\}\}}|j||j|d|j|dq&W|jjdS)zi Update the viewlim and position from the view and position stack for each axes. Noriginalactive)r rDrZ _set_viewZ _set_positionrr)r-Znav_inforrviewZpos_origZ pos_activerrr r4 s   zNavigationToolbar2._update_viewcGstdS)zSave the current figure.N)r3)r-rrrr r szNavigationToolbar2.save_figurecCsdS)aL Set the current cursor to one of the :class:`Cursors` enums values. If required by the backend, this method should trigger an update in the backend event loop after the cursor is set, as this method may be called e.g. before a long-running task during which the GUI is not updated. Nr)r-cursorrrr r6 szNavigationToolbar2.set_cursorcCs|jj|jdS)zReset the axes stack.N)r clearr-)r-rrr r9 s zNavigationToolbar2.updatecCsdS)z*Enable or disable the back/forward button.Nr)r-rrr r- sz&NavigationToolbar2.set_history_buttonsr r rrrrrrrrrrNNNNrrrrrrrrrrrrNNNNrrrr) rZr[r\r]r^r_r`rarb)'rrrrZ toolitemsr*r/r2r3rrrrrr&rrr8r(r'rArBrr=rEr>rr?rKr@rDr=r<r4rr6r9r-rrr)r.r r  sV!           5  r c@s^eZdZdZdZddZddZddd Zd d Zd d Z ddZ ddZ ddZ ddZ dS)ToolContainerBasez Base class for all tool containers, e.g. toolbars. Attributes ---------- toolmanager : `.ToolManager` The tools with which this `ToolContainer` wants to communicate. z.pngcs2|_|jdfdd|jdfdddS)Ntool_message_eventcs j|jS)N)r/rl)r)r-rr r sz,ToolContainerBase.__init__..Ztool_removed_eventcsj|jjS)N)remove_toolitemtoolr)r)r-rr r s)rtoolmanager_connect)r-rr)r-r r* szToolContainerBase.__init__cCs|j|jj|jjdS)zc Capture the 'tool_trigger_[name]' This only gets used for toggled tools. N)toggle_toolitemrfrtoggled)r-rrrr _tool_toggled_cbk sz#ToolContainerBase._tool_toggled_cbkricCsr|jj|}|j|j}t|dddk }|j|j||||j||rn|jjd|j|j |j rn|j |jddS)aV Add a tool to this container. Parameters ---------- tool : tool_like The tool to add, see `.ToolManager.get_tool`. group : str The name of the group to add this tool to. position : int, default: -1 The position within the group to place this tool. riNztool_trigger_%sT) rZget_tool_get_image_filenamerr@ add_toolitemrrrgrjrirh)r-rfgrouppositionrtogglerrr add_tool s    zToolContainerBase.add_toolcCsX|sdStjd}x@|||jt||t|||jgD]}tjj|r<|Sq.ShowcsjS)N)r)r-)rwrr r sz&_Backend.export..Show.mainloopN)rrrrr)rwrr Show sr)rr&r~r}r|rr)setattrrrrr@ShowBase)rwrrr)rwr export sz_Backend.export)rrrrr&rr~rrrr}r|rr staticmethodrrrrr ry s  %ryc@seZdZdZdddZdS)rz} Simple base class to generate a ``show()`` function in backends. Subclass must override ``mainloop()`` method. NcCs |j|dS)N)r)r)r-rrrr __call__ szShowBase.__call__)N)rrrrrrrrr r sr)N)N)NN)NN)Qr contextlibrrenumrrrdr$rgrBloggingrrTrrrVweakrefrnumpyrYrrrtoolsrr r r r r rrrZmatplotlib._pylab_helpersrZmatplotlib.backend_managersrZmatplotlib.transformsrZmatplotlib.pathrZmatplotlib.cbookr getLoggerrrrrr!r'r(rrrrrrrr&r-r5r:rIrMrfrjrrr$rrr"r#rr rcrrwryrrrrr s 0       hAXK)( $@ :   to