OwlCyberSecurity - MANAGER
Edit File: backend_bases.cpython-38.pyc
U ��]O� � @ s� d Z ddlmZ ddlmZ ddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z ddlZddlZddlmZmZmZmZmZmZmZmZmZm Z ddl m Z ddl m Z dd l!m"Z" z4dd l#m$Z$ dd l%m&Z& e&e$�d kr�d Z'ndZ'[$W n e(k �r dZ'Y nX e�)e*�Z+dddddddddd� Z,dddddddddd� Z-dNd d �Z.d d � Z/G d d!� d!e0�Z1G d"d#� d#e0�Z2G d$d%� d%e0�Z3G d&d'� d'e0�Z4G d(d)� d)e4�Z5G d*d+� d+e4�Z6G d,d-� d-e4�Z7G d.d/� d/e4�Z8G d0d1� d1e�Z9G d2d3� d3e8�Z:G d4d5� d5e4�Z;G d6d7� d7e8�Z<d8d9� Z=G d:d;� d;e0�Z>dOd<d=�Z?dPd>d?�Z@G d@dA� dAeA�ZBG dBdC� dCe0�ZCejDZDG dDdE� dEe0�ZEG dFdG� dGe0�ZFG dHdI� dIe0�ZGG dJdK� dKe0�ZHG dLdM� dMeH�ZIdS )Qab Abstract base classes define the primitives that renderers and graphics contexts must implement to serve as a matplotlib backend :class:`RendererBase` An abstract base class to handle drawing/rendering operations. :class:`FigureCanvasBase` The abstraction layer that separates the :class:`matplotlib.figure.Figure` from the backend specific details like a user interface drawing area :class:`GraphicsContextBase` An abstract base class that provides color, line styles, etc... :class:`Event` The base class for all of the matplotlib event handling. Derived classes such as :class:`KeyEvent` and :class:`MouseEvent` store the meta data like keys and buttons pressed, x and y locations in pixel and :class:`~matplotlib.axes.Axes` coordinates. :class:`ShowBase` The base class for the Show class of each interactive backend; the 'show' callable is then set to Show.__call__, inherited from ShowBase. :class:`ToolContainerBase` The base class for the Toolbar class of each interactive backend. :class:`StatusbarBase` The base class for the messaging area. � )�contextmanager)�IntEnumN)�WeakKeyDictionary) � backend_tools�cbook�colors�textpath� tight_bbox� transforms�widgets� get_backend�is_interactive�rcParams)�Gcf)�Affine2D)�Path)�PILLOW_VERSION)� LooseVersionz3.4TFZ PostscriptzEncapsulated PostscriptzPortable Document FormatzPGF code for LaTeXzPortable Network GraphicszRaw RGBA bitmapzScalable Vector Graphics) ZpsZepsZpdfZpgfZpng�rawZrgbaZsvgZsvgzz matplotlib.backends.backend_psz matplotlib.backends.backend_pdfz matplotlib.backends.backend_pgf� matplotlib.backends.backend_aggz matplotlib.backends.backend_svgc C s |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, optional Description of the file type. Defaults to an empty string N� )�_default_backends�_default_filetypes)�formatZbackend� description� r �:/usr/lib/python3/dist-packages/matplotlib/backend_bases.py�register_backend_ s r c C s6 | t kr dS t | }t|t�r2t�|�j}|t | < |S )zv Return the registered default canvas for given file format. Handles deferred import of required backend. N)r � isinstance�str� importlib� import_module� FigureCanvas)r Z backend_classr r r �get_registered_canvas_classt s r# c @ s" e Zd ZdZdd� ZdFdd�Zdd� ZdGd d �ZdHd d �Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � ZdId d �Zd d � Zd!d"� ZdJd$d%�ZdKd'd(�Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Zd5d6� Z d7d8� Z e j d9d:d;�d<d=� �Z d>d?� Z!d@dA� Z"dBdC� Z#dDdE� Z$dS )L� 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` c C s d | _ t�� | _d S �N)� _texmanagerr Z TextToPath� _text2path��selfr r r �__init__� s zRendererBase.__init__Nc C s dS )zz Open a grouping element with label *s* and *gid* (if set) as id. Only used by the SVG renderer. Nr )r) �s�gidr r r � open_group� s zRendererBase.open_groupc C s dS )za Close a grouping element with label *s* Only used by the SVG renderer. Nr �r) r+ r r r � close_group� s zRendererBase.close_groupc C s t �dS )zk Draws a :class:`~matplotlib.path.Path` instance using the given affine transform. N��NotImplementedError)r) �gc�path� transform�rgbFacer r r � draw_path� s zRendererBase.draw_pathc C sT |j |dd�D ]@\}}t|�r|dd� \} } | �|||t�� �| | � |� qdS )a3 Draws 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)Zsimplify���N)Z iter_segments�lenr6 r r � translate) r) r2 Z marker_pathZ marker_transr3 �transr5 Zvertices�codes�x�yr r r � draw_markers� s ��zRendererBase.draw_markersc C s| dd� | � |||�D �}| �||||||||| | | | | � D ]<\}}}}}|\}}t�|�� ��||�}| �||||� q:dS )a� Draws 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. 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. c S s g | ]\}}|t �|�f�qS r )r r )�.0r3 r4 r r r � <listcomp>� s �z5RendererBase.draw_path_collection.<locals>.<listcomp>N)�_iter_collection_raw_paths�_iter_collectionr r Z get_matrixr9 r6 )r) r2 �master_transform�paths�all_transforms�offsets� offsetTrans� facecolors� edgecolors� linewidths� linestyles� antialiaseds�urls�offset_position�path_ids�xo�yo�path_id�gc0r5 r3 r4 r r r �draw_path_collection� s< �� �� �z!RendererBase.draw_path_collectionc C s^ ddl m} | �|||�} | dkr&|} t�|�� gt�} | �||| g |||| | g | gdgd� S )z� This provides a fallback implementation of :meth:`draw_quad_mesh` that generates paths and then calls :meth:`draw_path_collection`. r )�QuadMeshNZscreen)Zmatplotlib.collectionsrU Zconvert_mesh_to_paths�npZarray� get_linewidth�floatrT )r) r2 rC Z meshWidthZ meshHeightZ coordinatesrF rG rH Z antialiasedrI rU rD rJ r r r �draw_quad_mesh� s0 � �zRendererBase.draw_quad_meshc C s t �dS )a� Draw a Gouraud-shaded triangle. Parameters ---------- 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. Nr0 )r) r2 �pointsr r4 r r r �draw_gouraud_triangle s z"RendererBase.draw_gouraud_trianglec C s0 |� � }t||�D ]\}}| �||||� qdS )a� Draws 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)�frozen�zipr[ )r) r2 Ztriangles_arrayZ colors_arrayr4 Ztri�colr r r �draw_gouraud_triangles s z#RendererBase.draw_gouraud_trianglesc c sn t |�}t |�}t||�}|dkr&dS t�� }t|�D ]2}||| } |rZt||| �}| || fV q6dS )aJ This is a helper method (along with :meth:`_iter_collection`) to make it easier to write a space-efficient :meth:`draw_path_collection` implementation in a backend. 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. r N)r8 �maxr ZIdentityTransform�ranger ) r) rC rD rE �Npaths� Ntransforms�Nr4 �ir3 r r r rA 2 s z'RendererBase._iter_collection_raw_pathsc C s` t |�}|dks0t |�t |� kr,dkr4n ndS t|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 � )r8 r` ) r) rD rE rF rH rI rb Z Npath_idsrd r r r � _iter_collection_uses_per_pathQ s (z+RendererBase._iter_collection_uses_per_pathc # c s^ t |�}t |�}t |�}t||�}t |�}t |�}t | �}t | �}t | �}t | �}|dkrb|dksj|dkrndS |r||�|�}| �� }|�|� |dkr�d}|dkr�|�d� d\}} t|�D �]�} || | } |�rB|| | \}} | dk�rB|�r t|| | �| } n|} | �|| f�\}} | �d�\} }!| | }|!| } t � |�r�t � | ��sZq�|�rl|| | }|�r�|�r�|�| | | � |�r�|j | | | � || | }"t |"�dk�r�|"d dk�r�|�d� n |� |"� n |� |"� |dk �rt |�dk�r|d dk�rd}|� | | | � |�r@|�| | | � || | ||fV q�|�� dS )a This is a helper method (along with :meth:`_iter_collection_raw_paths`) to make it easier to write a space-efficient :meth:`draw_path_collection` implementation in a backend. 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. r N� )r r �data� � )r8 r` r4 �new_gc�copy_properties� set_linewidthra r �transform_pointrV Zisfinite� set_dashes�set_foreground�set_antialiased�set_url�restore)#r) r2 rC rE rO rF rG rH rI rJ rK rL rM rN rc rb ZNoffsetsrd Z NfacecolorsZ NedgecolorsZ NlinewidthsZ NlinestylesZNaaZNurlsZtoffsetsrS r5 rP rQ re rR r4 ZxpZyp�fgr r r rB b sv �� z RendererBase._iter_collectionc C s dS )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. � �?r r( r r r �get_image_magnification� s z$RendererBase.get_image_magnificationc C s t �dS )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 *may* be passed to :meth:`draw_image`. It takes the form of a :class:`~matplotlib.transforms.Affine2DBase` instance. 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`). Nr0 )r) r2 r< r= Zimr4 r r r � draw_image� s zRendererBase.draw_imagec C s dS )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( r r r �option_image_nocomposite� s z%RendererBase.option_image_nocompositec C s dS )z� Return whether arbitrary affine transformations in :meth:`draw_image` are supported (True for most vector backends). Fr r( r r r �option_scale_image� s z RendererBase.option_scale_image�TeX!c C s | j ||||||dd� dS )z �TeX��ismathN��_draw_text_as_path� r) r2 r< r= r+ �prop�angler~ Zmtextr r r �draw_tex� s zRendererBase.draw_texFc C s | � |||||||� dS )a Draw the text instance. Parameters ---------- gc : `GraphicsContextBase` The graphics context. x : scalar The x location of the text in display coords. y : scalar The y location of the text baseline in display coords. s : str The text string. prop : `matplotlib.font_manager.FontProperties` The font properties. angle : scalar The rotation angle in degrees. mtext : `matplotlib.text.Text` The original text object to be rendered. Notes ----- **backend implementers note** 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. Nr r� r r r � draw_text s #zRendererBase.draw_textc C s� | j }| �|�� �}|j|||d�\} } t| | �} t�|�}| �� rxt� � ||j ||j �} | � |�� || j | �} n,t� � ||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_pixels�get_size_in_pointsZ get_text_pathr rV Zdeg2rad�flipyr �scaleZ FONT_SCALE�rotater9 �height) r) r< r= r+ r� r� r~ Z text2path�fontsizeZvertsr; r3 r4 r r r �_get_text_path_transform' s ��z%RendererBase._get_text_path_transformc C s@ | � ||||||�\}} |�� } |�d� | j||| | d� dS )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 matplotlib usetex mode. ismath : bool or "TeX" If True, use mathtext parser. If "TeX", use *usetex* mode. rh )r5 N)r� �get_rgbrn r6 ) r) r2 r< r= r+ r� r� r~ r3 r4 Zcolorr r r r� F s � z RendererBase._draw_text_as_pathc C s� |dkr:| j �� }|�� }|j||| d�\}}}|||fS | �d�} |rf| j j�|| |�} | dd� S | j �� } | j �|�} |�� } | � | | � | j |d| d� | � � \}}| � � }|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 :class:`~matplotlib.font_manager.FontProperties` *prop* r| )�renderer�H r rk rh )�flagsg P@) r' �get_texmanagerr� � get_text_width_height_descentr� Zmathtext_parser�parseZ_get_hinting_flagZ _get_fontZset_sizeZset_text�get_width_heightZ get_descent)r) r+ r� r~ Z texmanagerr� �w�h�d�dpiZdimsr� Zfont�sizer r r r� [ s0 � z*RendererBase.get_text_width_height_descentc C s dS )z� Return whether y values increase from top to bottom. Note that this only affects drawing of texts and images. Tr r( r r r r� { s zRendererBase.flipyc C s dS )z5Return the canvas width and height in display coords.)rf rf r r( r r r �get_canvas_width_height� s z$RendererBase.get_canvas_width_heightc C s$ | j dkr ddlm} |� | _ | j S )z"Return the `.TexManager` instance.Nr )� TexManager)r& Zmatplotlib.texmanagerr� )r) r� r r r r� � s zRendererBase.get_texmanagerc C s t � S )z.Return an instance of a `GraphicsContextBase`.)�GraphicsContextBaser( r r r rl � s zRendererBase.new_gcc C s |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.0 * dpi/72.0 Parameters ---------- points : scalar or array_like a float or a numpy array of float Returns ------- Points converted to pixels r )r) rZ r r r r� � s z RendererBase.points_to_pixels�3.1zcbook.strip_math)Z alternativec C s t �|�S r% )r � strip_mathr. r r r r� � s zRendererBase.strip_mathc C s dS )zV Switch to the raster renderer. Used by `MixedModeRenderer`. Nr r( r r r �start_rasterizing� s z RendererBase.start_rasterizingc C s dS )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( r r r �stop_rasterizing� s z RendererBase.stop_rasterizingc C s dS )z� Switch to a temporary renderer for image filtering effects. Currently only supported by the agg renderer. Nr r( r r r � start_filter� s zRendererBase.start_filterc C s dS )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_funcr r r � stop_filter� s zRendererBase.stop_filter)N)N)N)N)r{ N)FN)%�__name__� __module__� __qualname__�__doc__r* r- r/ r6 r> rT rY r[ r_ rA rg rB rw rx ry rz r� r� r� r� r� r� r� r� rl r� r Z deprecatedr� r� r� r� r� r r r r r$ � sD � !' a ! % r$ c @ s6 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� ZdMd/d0�Zd1d2� Zd3d4� Z d5d6� Z d7d8� Z d9d:� Z d;d<� Z d=d>� Z!dNd@dA�Z"dBdC� Z#dDdE� Z$dFdG� Z%dHdI� Z&dOdKdL�Z'dJS )Pr� z=An abstract base class that provides color, line styles, etc.c C s~ d| _ d| _d| _d| _d | _d | _d| _d| _d| _d| _ d| _ d | _ t � td �| _td | _d | _d | _d | _d | _d S ) Nrv Frf �butt�NN�roundZsolid)rh rh rh rv z hatch.colorzhatch.linewidth)�_alpha� _forced_alpha� _antialiased� _capstyle� _cliprect� _clippath�_dashes� _joinstyle� _linestyle� _linewidth�_rgb�_hatchr �to_rgbar � _hatch_color�_hatch_linewidth�_url�_gid�_snap�_sketchr( r r r r* � s$ z GraphicsContextBase.__init__c C s� |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 selfN)r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� )r) r2 r r r rm � s$ z#GraphicsContextBase.copy_propertiesc C s dS )z� Restore the graphics context from the stack - needed only for backends that save graphics contexts on a stack. Nr r( r r r rt � s zGraphicsContextBase.restorec C s | j S )zc Return the alpha value used for blending - not supported on all backends. )r� r( r r r � get_alpha� s z GraphicsContextBase.get_alphac C s | j S )zAReturn whether the object should try to do antialiased rendering.)r� r( r r r �get_antialiased s z#GraphicsContextBase.get_antialiasedc C s | j S )zU Return the capstyle as a string in ('butt', 'round', 'projecting'). )r� r( r r r � get_capstyle s z GraphicsContextBase.get_capstylec C s | j S )zX Return the clip rectangle as a `~matplotlib.transforms.Bbox` instance. �r� r( r r r �get_clip_rectangle s z&GraphicsContextBase.get_clip_rectanglec C s | j dk r| j �� S dS )z� Return the clip path in the form (path, transform), where path is a :class:`~matplotlib.path.Path` instance, and transform is an affine transform to apply to the path before clipping. Nr� )r� Z get_transformed_path_and_affiner( r r r � get_clip_path s z!GraphicsContextBase.get_clip_pathc C s | j S )aO Return the dash information as an offset dashlist tuple. The dash list is a even size list that gives the ink on, ink off in pixels. See p107 of to PostScript `BLUEBOOK <https://www-cdf.fnal.gov/offline/PostScript/BLUEBOOK.PDF>`_ for more info. Default value is None )r� r( r r r � get_dashes s z GraphicsContextBase.get_dashesc C s | j S )z� Return whether the value given by get_alpha() should be used to override any other alpha-channel values. )r� r( r r r �get_forced_alpha- s z$GraphicsContextBase.get_forced_alphac C s | j S )zAReturn the line join style as one of ('miter', 'round', 'bevel').)r� r( r r r � get_joinstyle4 s z!GraphicsContextBase.get_joinstylec C s | j S )z Return the line width in points.)r� r( r r r rW 8 s z!GraphicsContextBase.get_linewidthc C s | j S )z0Return a tuple of three or four floats from 0-1.)r� r( r r r r� < s zGraphicsContextBase.get_rgbc C s | j S )z+Return a url if one is set, None otherwise.�r� r( r r r �get_url@ s zGraphicsContextBase.get_urlc C s | j S )z;Return the object identifier if one is set, None otherwise.�r� r( r r r �get_gidD s zGraphicsContextBase.get_gidc C s | j S )a Returns 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( r r r �get_snapH s z GraphicsContextBase.get_snapc C s6 |dk r|| _ d| _n d| _ d| _| j| jdd� dS )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. NTrv F)�isRGBA)r� r� rq r� )r) Zalphar r r � set_alphaS s z GraphicsContextBase.set_alphac C s t t|��| _dS )z>Set whether object should be drawn with antialiased rendering.N)�int�boolr� )r) �br r r rr d s z#GraphicsContextBase.set_antialiasedc C s |dkr|| _ n td| ��dS )z>Set the capstyle to be one of ('butt', 'round', 'projecting').)r� r� Z projectingz!Unrecognized cap style. Found %sN)r� � ValueError)r) Zcsr r r � set_capstylei s z GraphicsContextBase.set_capstylec C s || _ dS )zT Set the clip rectangle with sequence (left, bottom, width, height) Nr� )r) Z rectangler r r �set_clip_rectanglep s z&GraphicsContextBase.set_clip_rectanglec C s& |dk r t |tj�s td��|| _dS )z� Set the clip path and transformation. Path should be a :class:`~matplotlib.transforms.TransformedPath` instance. Nz?Path should be a matplotlib.transforms.TransformedPath instance)r r ZTransformedPathr� r� )r) r3 r r r � set_clip_pathv s �z!GraphicsContextBase.set_clip_pathc C s6 |dk r(t �|�}t �|dk �r(td��||f| _dS )a$ Set the dash style for the gc. Parameters ---------- dash_offset : float is the offset (usually 0). dash_list : array_like specifies the on-off sequence as points. ``(None, None)`` specifies a solid line Nrh z,All values in the dash list must be positive)rV Zasarray�anyr� r� )r) Z dash_offsetZ dash_listZdlr r r rp � s �z GraphicsContextBase.set_dashesFc C sV | j r"|r"|dd� | jf | _n0| j r:t�|| j�| _n|rF|| _n t�|�| _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. Nrk )r� r� r� r r� )r) ru r� r r r rq � s z"GraphicsContextBase.set_foregroundc C s |dkr|| _ n td| ��dS )z<Set the join style to be one of ('miter', 'round', 'bevel').)Zmiterr� Zbevelz"Unrecognized join style. Found %sN)r� r� )r) Zjsr r r � set_joinstyle� s z!GraphicsContextBase.set_joinstylec C s t |�| _dS )z Set the linewidth in points.N)rX r� )r) r� r r r rn � s z!GraphicsContextBase.set_linewidthc C s || _ dS )z-Set the url for links in compatible backends.Nr� )r) Zurlr r r rs � s zGraphicsContextBase.set_urlc C s || _ dS )z Set the id.Nr� )r) �idr r r �set_gid� s zGraphicsContextBase.set_gidc C s || _ dS )a Set the snap setting which may 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 Nr� )r) Zsnapr r r �set_snap� s z GraphicsContextBase.set_snapc C s || _ dS )z Set the hatch style (for fills).N�r� )r) �hatchr r r � set_hatch� s z GraphicsContextBase.set_hatchc C s | j S )z Get the current hatch style.r� r( r r r � get_hatch� s z GraphicsContextBase.get_hatch� @c C s | � � }|dkrdS t�||�S )z&Return a `Path` for the current hatch.N)r� r r� )r) Zdensityr� r r r �get_hatch_path� s z"GraphicsContextBase.get_hatch_pathc C s | j S )zGet the hatch color.�r� r( r r r �get_hatch_color� s z#GraphicsContextBase.get_hatch_colorc C s || _ dS )zSet the hatch color.Nr� )r) Z hatch_colorr r r �set_hatch_color� s z#GraphicsContextBase.set_hatch_colorc C s | j S )zGet the hatch linewidth.)r� r( r r r �get_hatch_linewidth� s z'GraphicsContextBase.get_hatch_linewidthc C s | j S )a Return the sketch parameters for the artist. Returns ------- sketch_params : tuple or `None` A 3-tuple with the following elements: * `scale`: The amplitude of the wiggle perpendicular to the source line. * `length`: The length of the wiggle along the line. * `randomness`: The scale factor by which the length is shrunken or expanded. May return `None` if no sketch parameters were set. �r� r( r r r �get_sketch_params� s z%GraphicsContextBase.get_sketch_paramsNc C s$ |dkr dn||pd|pdf| _ dS )a! Set the sketch parameters. Parameters ---------- scale : float, optional The amplitude of the wiggle perpendicular to the source line, in pixels. If scale is `None`, or not provided, no sketch filter will be provided. length : float, optional The length of the wiggle along the line, in pixels (default 128). randomness : float, optional The scale factor by which the length is shrunken or expanded (default 16). Ng `@g 0@r� )r) r� ZlengthZ randomnessr r r �set_sketch_params� s �z%GraphicsContextBase.set_sketch_params)F)r� )NNN)(r� r� r� r� r* rm rt r� r� r� r� r� r� r� r� rW r� r� r� r� r� rr r� r� r� rp rq r� rn rs r� r� r� r� r� r� r� r� r� r� r r r r r� � sJ r� c @ s� e Zd ZdZd dd�Zdd� Zd dd�Zd d � Zd d � Zd d� Z e dd� �Z e j dd� �Z e dd� �Z e j dd� �Z dd� Zdd� Zdd� Zdd � Zd d � ZdS )!� TimerBasea� A base class for providing timer events, useful for things animations. Backends need to implement a few specific methods in order to use their own timing mechanisms so that the timer events are integrated into their event loops. Mandatory functions that must be implemented: * `_timer_start`: Contains backend-specific code for starting the timer * `_timer_stop`: Contains backend-specific code for stopping the timer Optional overrides: * `_timer_set_single_shot`: Code for setting the timer to single shot operating mode, if supported by the timer object. If not, the `Timer` class itself will store the flag and the `_on_timer` method should be overridden to support such behavior. * `_timer_set_interval`: Code for setting the interval on the timer, if there is a method for doing so on the timer object. * `_on_timer`: This is the internal function that any timer object should call, which will handle the task of running all callbacks that have been set. Attributes ---------- interval : scalar The time between timer events in milliseconds. Default is 1000 ms. single_shot : bool Boolean flag indicating whether this timer should operate as single shot (run once and then stop). Defaults to `False`. callbacks : List[Tuple[callable, Tuple, Dict]] Stores list of (func, args, kwargs) tuples that will be called upon timer events. This list can be manipulated directly, or the functions `add_callback` and `remove_callback` can be used. Nc C sD |d krg | _ n|d d � | _ |d kr.d| _n|| _d| _d | _d S )Ni� F)� callbacks� _interval�_singleZ_timer)r) �intervalr� r r r r* 9 s zTimerBase.__init__c C s | � � dS )z1Need to stop timer and possibly disconnect timer.N�� _timer_stopr( r r r �__del__J s zTimerBase.__del__c C s |dk r| � |� | �� dS )z� Start the timer object. Parameters ---------- interval : int, optional Timer interval in milliseconds; overrides a previously set interval if provided. N)Z _set_interval� _timer_start�r) r� r r r �startN s zTimerBase.startc C s | � � dS )zStop the timer.Nr� r( r r r �stop\ s zTimerBase.stopc C s d S r% r r( r r r r� ` s zTimerBase._timer_startc C s d S r% r r( r r r r� c s zTimerBase._timer_stopc C s | j S r% )r� r( r r r r� f s zTimerBase.intervalc C s t |�}|| _| �� d S r% )r� r� �_timer_set_intervalr� r r r r� j s c C s | j S r% )r� r( r r r � single_shotr s zTimerBase.single_shotc C s || _ | �� d S r% )r� �_timer_set_single_shot)r) Zssr r r r� v s c O s | j �|||f� |S )z� Register *func* to be called by timer when the event fires. Any additional arguments provided will be passed to *func*. This function returns *func*, which makes it possible to use it as a decorator. )r� �append)r) �func�args�kwargsr r r � add_callback{ s zTimerBase.add_callbackc O sV |s|r(t �dd� | j�|||f� n*dd� | jD �}||krR| j�|�|�� dS )a� Remove *func* from list of callbacks. *args* and *kwargs* are optional and used to distinguish between copies of the same function registered to be called with different arguments. This behavior is deprecated. In the future, `*args, **kwargs` won't be considered anymore; to keep a specific callback removable by itself, pass it to `add_callback` as a `functools.partial` object. r� z�In a future version, Timer.remove_callback will not take *args, **kwargs anymore, but remove all callbacks where the callable matches; to keep a specific callback removable by itself, pass it to add_callback as a functools.partial object.c S s g | ] }|d �qS �r r )r? �cr r r r@ � s z-TimerBase.remove_callback.<locals>.<listcomp>N)r �warn_deprecatedr� �remove�pop�index)r) r� r� r� Zfuncsr r r �remove_callback� s �zTimerBase.remove_callbackc C s dS )z0Used to set interval on underlying timer object.Nr r( r r r r� � s z TimerBase._timer_set_intervalc C s dS )z3Used to set single shot on underlying timer object.Nr r( r r r r� � s z TimerBase._timer_set_single_shotc C sP | j D ].\}}}|||�}|dkr| j �|||f� qt| j �dkrL| �� dS )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. r N)r� r� r8 r� )r) r� r� r� Zretr r r � _on_timer� s zTimerBase._on_timer)NN)N)r� r� r� r� r* r� r� r� r� r� �propertyr� �setterr� r� r r� r� r r r r r r� s( , r� c @ s e Zd ZdZddd�ZdS )�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 Nc C s || _ || _|| _d S r% )�name�canvas�guiEvent)r) r r r r r r r* � s zEvent.__init__)N�r� r� r� r� r* r r r r r � s r c @ s e Zd ZdZdd� ZdS )� 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 :class:`Event` attributes, the following event attributes are defined: Attributes ---------- renderer : `RendererBase` the renderer for the draw event c C s t �| ||� || _d S r% )r r* r� )r) r r r� r r r r* � s zDrawEvent.__init__Nr r r r r r � s r c @ s e Zd ZdZdd� ZdS )� ResizeEventa' An event triggered by a canvas resize In addition to the :class:`Event` attributes, the following event attributes are defined: Attributes ---------- width : scalar width of the canvas in pixels height : scalar height of the canvas in pixels c C s" t �| ||� |�� \| _| _d S r% )r r* r� �widthr� )r) r r r r r r* � s zResizeEvent.__init__Nr r r r r r � s r c @ s e Zd ZdZdS )� CloseEventz,An event triggered by a figure being closed.N)r� r� r� r� r r r r r s r c @ s& e Zd ZdZdZddd�Zdd� ZdS )� LocationEventad An event that has a screen location. The following additional attributes are defined and shown with their default values. In addition to the :class:`Event` attributes, the following event attributes are defined: Attributes ---------- x : scalar x position - pixels from left of canvas y : scalar y position - pixels from bottom of canvas inaxes : bool the :class:`~matplotlib.axes.Axes` instance if mouse is over axes xdata : scalar x coord of mouse in data coords ydata : scalar y coord of mouse in data coords Nc C s� t j| |||d� |dk r"t|�n|| _|dk r8t|�n|| _d| _d| _d| _|dks`|dkrl| �� dS | j j dkr�| j �||f�| _n | j j | _| jdk r�z"| jj � � }|� ||f�\}}W n tk r� Y nX || _|| _| �� dS )z? *x*, *y* in figure coords, 0,0 = bottom, left �r N)r r* r� r< r= �inaxes�xdata�ydata�_update_enter_leaver � mouse_grabberZ transData�invertedro r� ) r) r r r< r= r r: r r r r r r* " s* zLocationEvent.__init__c C s� t jdk rlt j}|j| jkr�z |jdk r8|jj�d|� W n tk rN Y nX | jdk r�| jj�d| � n| jdk r�| jj�d| � | t _dS )z*process the figure/axes enter leave eventsN�axes_leave_event�axes_enter_event)r � lasteventr r r� �process� Exception)r) Zlastr r r r E s z!LocationEvent._update_enter_leave)N)r� r� r� r� r r* r r r r r r s #r c @ s e Zd ZdZdZdZdZdZdS )� MouseButtonrf � rk � � N)r� r� r� ZLEFTZMIDDLEZRIGHTZBACKZFORWARDr r r r r ` s r c @ s" e Zd ZdZd dd�Zdd� ZdS ) � MouseEventaI A mouse event ('button_press_event', 'button_release_event', 'scroll_event', 'motion_notify_event'). In addition to the :class:`Event` and :class:`LocationEvent` attributes, the following attributes are defined: Attributes ---------- button : {None, MouseButton.LEFT, MouseButton.MIDDLE, MouseButton.RIGHT, '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`. step : scalar 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 -------- Usage:: def on_press(event): print('you pressed', event.button, event.xdata, event.ydata) cid = fig.canvas.mpl_connect('button_press_event', on_press) Nr Fc C sH t j| ||||| d� |tj�� kr,t|�}|| _|| _|| _|| _dS )zn x, y in figure coords, 0,0 = bottom, left button pressed None, 1, 2, 3, 'up', 'down' r N) r r* r � __members__�values�button�key�step�dblclick) r) r r r< r= r# r$ r% r& r r r r r* � s zMouseEvent.__init__c C sB | j � d| j� d| j� d| j� d| j� d| j� d| j� d| j� �S )Nz: xy=(�, z ) xydata=(z ) button=z dblclick=z inaxes=)r r< r= r r r# r& r r( r r r �__str__� s zMouseEvent.__str__)NNr FN)r� r� r� r� r* r( r r r r r h s - � r c @ s e Zd ZdZddd�ZdS )� PickEventa� a pick event, fired when the user picks a location on the canvas sufficiently close to an artist. Attrs: all the :class:`Event` attributes plus Attributes ---------- mouseevent : `MouseEvent` the mouse event that generated the pick artist : `matplotlib.artist.Artist` the picked artist other extra class dependent attrs -- e.g., a :class:`~matplotlib.lines.Line2D` pick may define different extra attributes than a :class:`~matplotlib.collections.PatchCollection` pick event Examples -------- Usage:: 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) Nc K s, t �| |||� || _|| _| j�|� d S r% )r r* � mouseevent�artist�__dict__�update)r) r r r* r+ r r� r r r r* � s zPickEvent.__init__)Nr r r r r r) � s $ �r) c @ s e Zd ZdZddd�ZdS )�KeyEventa A key event (key press, key release). Attach additional attributes as defined in :meth:`FigureCanvasBase.mpl_connect`. In addition to the :class:`Event` and :class:`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 -------- Usage:: def on_key(event): print('you pressed', event.key, event.xdata, event.ydata) cid = fig.canvas.mpl_connect('key_press_event', on_key) r Nc C s t j| |||||d� || _d S )Nr )r r* r$ )r) r r r$ r< r= r r r r r* � s zKeyEvent.__init__)r r Nr r r r r r. � s "r. c C s& t | d�o$| jdk o$t| jdd�dkS )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)�hasattrr/ �getattr)�ipr r r �$_is_non_interactive_terminal_ipython� s ��r3 c @ s� e Zd ZdZdddddddd d d d d dddgZdZdZeZe rne ddd� e ddd� e ddd� e ddd� dd� Z e e �� d d � ��Zed d � �Zd d!� Zd"d#� Zdpd$d%�Zd&d'� Zd(d)� Zd*d+� Zdqd,d-�Zdrd.d/�Zdsd0d1�Zd2d3� Zdtd4d5�Z dud7d8�Z dvd9d:�Z dwd;d<�Z dxd=d>�Z dyd?d@�Z!dAdB� Z"dCdD� Z#dEdF� Z$dGdH� Z%dIdJ� Z&dKdL� Z'dMdN� Z(e dOdP� �Z)e dQdR� �Z*dSdT� Z+dzddV�dWdX�Z,e dYdZ� �Z-d[d\� Z.d]d^� Z/d_d`� Z0dadb� Z1dcdd� Z2dedf� Z3dgdh� Z4didj� Z5d{dldm�Z6dndo� Z7dS )|�FigureCanvasBasez� The canvas the figure renders into. Public attributes Attributes ---------- figure : `matplotlib.figure.Figure` A high-level figure instance � resize_event� draw_event�key_press_event�key_release_event�button_press_event�button_release_event� scroll_event�motion_notify_event� pick_eventZ idle_event�figure_enter_event�figure_leave_eventr r � close_eventTNZjpgr z Joint Photographic Experts GroupZjpegZtifzTagged Image File FormatZtiffc C s� | � � d| _d| _|�| � || _t�� | _t� � | _ d | _ d | _ d\| _ | _| �d| j�| _| �d| j�| _d | _d | _d| _d S )NTFr� r9 r; )�_fix_ipython_backend2gui�_is_idle_drawing� _is_saving� set_canvas�figurer ZCallbackRegistryr� r ZLockDraw� widgetlock�_button�_key�_lastx�_lasty� mpl_connect�pickZbutton_pick_idZscroll_pick_idr �toolbar)r) rE r r r r* ; s zFigureCanvasBase.__init__c C s� dt jkrd S dd l}|�� }|s&d S ddlm} t|d�rFt|d�sJd S t j| j }t|dd �}dddd d d �� |�}|r�t |�r�|� |� d S ) N�IPythonr )� pylabtoolsZ backend2guiZenable_matplotlib� required_interactive_frameworkZqt�gtk3�wxZosx)Zqt5Zqt4rQ rR Zmacosx) �sys�modulesrN Z get_ipythonZ IPython.corerO r0 r� r1 �getr3 Z enable_gui)�clsrN r2 ZptZ backend_modZrifZbackend2gui_rifr r r rA M s, � ��z)FigureCanvasBase._fix_ipython_backend2guic c s d| _ d V d| _ d S )NTF)rB r( r r r �_idle_draw_cntxh s z FigureCanvasBase._idle_draw_cntxc C s | j S )z� Returns whether the renderer is in the process of saving to a file, rather than rendering for an on-screen buffer. )rC r( r r r � is_savingn s zFigureCanvasBase.is_savingc C s | j �� s| j�|� d S r% )rF �lockedrE rL )r) r* r r r rL u s zFigureCanvasBase.pickc C s dS )z0Blit the canvas in bbox (default entire canvas).Nr )r) �bboxr r r �blity s zFigureCanvasBase.blitc C s dS )z Set the canvas size in pixels.Nr �r) r� r� r r r �resize| s zFigureCanvasBase.resizec C s" d}t || |�}| j�||� dS )z@Pass a `DrawEvent` to all functions connected to ``draw_event``.r6 N)r r� r )r) r� r+ �eventr r r r6 s zFigureCanvasBase.draw_eventc C s( d}t || �}| j�||� | �� dS )zMPass a `ResizeEvent` to all functions connected to ``resize_event``. r5 N)r r� r � draw_idle)r) r+ r^ r r r r5 � s z FigureCanvasBase.resize_eventc C sB d}z t || |d�}| j�||� W n ttfk r< Y nX dS )zKPass a `CloseEvent` to all functions connected to ``close_event``. r@ r N)r r� r � TypeError�AttributeError)r) r r+ r^ r r r r@ � s z FigureCanvasBase.close_eventc C s4 || _ d}t|| || j| j|d�}| j�||� dS )zMPass a `KeyEvent` to all functions connected to ``key_press_event``. r7 r N)rH r. rI rJ r� r �r) r$ r r+ r^ r r r r7 � s �z FigureCanvasBase.key_press_eventc C s4 d}t || || j| j|d�}| j�||� d| _dS )zX Pass a `KeyEvent` to all functions connected to ``key_release_event``. r8 r N)r. rI rJ r� r rH rb r r r r8 � s �z"FigureCanvasBase.key_release_eventc K s2 d}t || ||fd|ji|��}| j�||� dS )z� This method will be called by artists who are picked and will fire off :class:`PickEvent` callbacks registered listeners r= r N)r) r r� r )r) r* r+ r� r+ r^ r r r r= � s ��zFigureCanvasBase.pick_eventc C sH |dkrd| _ nd| _ d}t|| ||| j | j||d�}| j�||� dS )aI 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 be call all functions connected to the 'scroll_event' with a :class:`MouseEvent` instance. r ZupZdownr; )r% r N�rG r rH r� r )r) r< r= r% r r+ r* r r r r; � s �z FigureCanvasBase.scroll_eventFc C s6 || _ d}t|| |||| j||d�}| j�||� dS )aW 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 :class:`MouseEvent`. This method will be call all functions connected to the 'button_press_event' with a :class:`MouseEvent` instance. r9 )r& r Nrc )r) r< r= r# r& r r+ r* r r r r9 � s �z#FigureCanvasBase.button_press_eventc C s4 d}t || |||| j|d�}| j�||� d| _dS )a� 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 :class:`MouseEvent` instance. Parameters ---------- x : scalar the canvas coordinates where 0=left y : scalar the canvas coordinates where 0=bottom guiEvent the native UI event that generated the mpl event r: r N)r rH r� r rG )r) r< r= r# r r+ r^ r r r r: � s z%FigureCanvasBase.button_release_eventc C s> || | _ | _d}t|| ||| j| j|d�}| j�||� dS )a� 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 :class:`MouseEvent` instance. Parameters ---------- x : scalar the canvas coordinates where 0=left y : scalar the canvas coordinates where 0=bottom guiEvent the native UI event that generated the mpl event r< r N)rI rJ r rG rH r� r )r) r< r= r r+ r^ r r r r< � s �z$FigureCanvasBase.motion_notify_eventc C s& | j �dtj� dt_d\| _| _dS )z� Backend derived classes should call this function when leaving canvas Parameters ---------- guiEvent the native UI event that generated the mpl event r? Nr� )r� r r r rI rJ )r) r r r r �leave_notify_event s z#FigureCanvasBase.leave_notify_eventc C sX |dk r |\}}|| | _ | _nd}d}tjddd� td| |||�}| j�d|� dS )aL Backend derived classes should call this function when entering canvas Parameters ---------- guiEvent the native UI event that generated the mpl event xy : (float, float) the coordinate location of the pointer when the canvas is entered Nz3.0zHenter_notify_event expects a location but your backend did not pass one.)�messager> )rI rJ r r� r r� r )r) r �xyr< r= r^ r r r �enter_notify_event s �z#FigureCanvasBase.enter_notify_eventc s0 � fdd�| j �� D �}|r(t�|�}nd}|S )ae Check if a point is in an axes. Parameters ---------- xy : tuple or list (x,y) coordinates. x position - pixels from left of canvas. y position - pixels from bottom of canvas. Returns ------- axes: topmost axes containing the point, or None if no axes. c s g | ]}|j �� �r|�qS r )�patchZcontains_point�r? �a�rf r r r@ I s �z+FigureCanvasBase.inaxes.<locals>.<listcomp>N)rE �get_axesr �_topmost_artist)r) rf Z axes_list�axesr rk r r 9 s zFigureCanvasBase.inaxesc C s | j d|fkrtd��|| _ dS )z� Set the child axes which are currently 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)r � RuntimeError�r) �axr r r � grab_mouseS s zFigureCanvasBase.grab_mousec C s | j |krd| _ dS )z� Release the mouse grab held by the axes, ax. Usually called by the widgets. It is ok to call this even if you ax doesn't have the mouse grab currently. N)r rp r r r � release_mouse^ s z FigureCanvasBase.release_mousec O s dS )z.Render the :class:`~matplotlib.figure.Figure`.Nr �r) r� r� r r r �drawh s zFigureCanvasBase.drawc O s* | j s&| �� � | j||� W 5 Q R X dS )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)rB rW ru rt r r r r_ k s zFigureCanvasBase.draw_idlec C s dS )z� Draw a cursor in the event.axes if inaxes is not None. Use native GUI drawing for efficiency if possible Nr �r) r^ r r r � draw_cursor| s z FigureCanvasBase.draw_cursorc C s t | jjj�t | jjj�fS )z� Return the figure width and height in points or pixels (depending on the backend), truncated to integers )r� rE rZ r r� r( r r r r� � s z!FigureCanvasBase.get_width_heightc C s | j S )z=Return dict of savefig file formats supported by this backend)� filetypes�rV r r r �get_supported_filetypes� s z(FigureCanvasBase.get_supported_filetypesc C s: i }| j �� D ]&\}}|�|g ��|� || �� q|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'].)rx �items� setdefaultr� �sort)rV Z groupingsZextr r r r � get_supported_filetypes_grouped� s z0FigureCanvasBase.get_supported_filetypes_groupedc C sL t | d�|��r| S t|�}|r*| �|�S td�|d�t| �� �����dS )z� Return a canvas suitable for saving figures to a specified file format. If necessary, this function will switch to a registered backend that supports the format. zprint_{}z4Format {!r} is not supported (supported formats: {})r' N)r0 r r# �switch_backendsr� �join�sortedrz )r) ZfmtZ canvas_classr r r �_get_output_canvas� s ��z#FigureCanvasBase._get_output_canvas�portrait)� bbox_inchesc K sl |dkrtt |tj�r t�|�}t |t�r@tj�|�d dd� }|dksP|dkrt| �� }t |t�rt|�d�d | }|� � }| � |�} t | d| �} |dkr�t d }|dkr�t | j d| j j�}tj| d dd ���� tj| j |d ���t |dkr�t d }|dk�rt d }| j �� } | j �� } | j �|� | j �|� |dk�rFt d }|�r�|dk�r�| t�� f||||d d�|��} | j j}|�dd�}| j j||d�}|�dd�}|dk�r�t d }|�|�}t� | j || j �}||f}nd}z | |f|||||d�|��} W 5 |�r|�r|� | j �| � | j �| � | j � | � X | W 5 Q R � W 5 Q R � S Q R X W 5 Q R X dS )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 can also be a file object on image backends orientation : {'landscape', 'portrait'}, optional only currently applies to PostScript printing. dpi : scalar, optional the dots per inch to save the figure in; if None, use savefig.dpi facecolor : color or None, optional the facecolor of the figure; if None, defaults to savefig.facecolor edgecolor : color or None, optional the edgecolor of the figure; if None, defaults to savefig.edgecolor format : str, optional when set, forcibly set the file format to save to bbox_inches : str or `~matplotlib.transforms.Bbox`, optional Bbox in inches. Only the given portion of the figure is saved. If 'tight', try to figure out the tight bbox of the figure. If None, use savefig.bbox pad_inches : scalar, optional Amount of padding around the figure when bbox_inches is 'tight'. If None, use savefig.pad_inches bbox_extra_artists : list of `~matplotlib.artist.Artist`, optional A list of extra artists that will be considered when the tight bbox is calculated. Nrf r �.zprint_%sz savefig.dpirE Z _original_dpiT)rC �manager)r� zsavefig.facecolorzsavefig.edgecolorz savefig.bboxZtight)r� � facecolor� edgecolor� orientationZdryrun�bbox_extra_artists)r� Z pad_incheszsavefig.pad_inches)r� r� r� r� Zbbox_inches_restore) r �os�PathLike�fspathr r3 �splitext�get_default_filetype�rstrip�lowerr� r1 r rE r� r Z _setattr_cmZ get_facecolorZ get_edgecolorZ set_facecolorZ set_edgecolor�io�BytesIOZ_cachedRendererr Z get_tightbboxZpaddedr Z adjust_bbox� fixed_dpirD )r) �filenamer� r� r� r� r r� r� r Z print_methodZ origfacecolorZ origedgecolor�resultr� Z bbox_artistsZpadZ restore_bboxZ_bbox_inches_restorer r r � print_figure� s� + � ��� � � ��� z FigureCanvasBase.print_figurec C s t d S )z� Get the default savefig file format as specified in rcParam ``savefig.format``. Returned string excludes period. Overridden in backends that only support a single file type. zsavefig.format)r ry r r r r� 3 s z%FigureCanvasBase.get_default_filetypec C s t | d�r| j�� S dS )z� Get the title text of the window containing the figure. Return None if there is no window (e.g., a PS backend). r� N)r0 r� �get_window_titler( r r r r� < s z!FigureCanvasBase.get_window_titlec C s t | d�r| j�|� 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). r� N)r0 r� �set_window_title�r) �titler r r r� D s z!FigureCanvasBase.set_window_titlec C s0 | � � p d}|�dd�}| �� }|d | }|S )zl Return a string, which includes extension, suitable for use as a default filename. �image� �_r� )r� �replacer� )r) Zdefault_basenameZdefault_filetypeZdefault_filenamer r r �get_default_filenameL s z%FigureCanvasBase.get_default_filenamec C s || 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 )rE rC )r) ZFigureCanvasClassZ newCanvasr r r r W s z FigureCanvasBase.switch_backendsc C s | j �||�S )a� Connect event with string *s* to *func*. The signature of *func* is:: def func(event) where event is a :class:`matplotlib.backend_bases.Event`. The following events are recognized - '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' For the location events (button and key press/release), if the mouse is over the axes, the variable ``event.inaxes`` will be set to the :class:`~matplotlib.axes.Axes` the event occurs is over, and additionally, the variables ``event.xdata`` and ``event.ydata`` will be defined. This is the mouse location in data coords. See :class:`~matplotlib.backend_bases.KeyEvent` and :class:`~matplotlib.backend_bases.MouseEvent` for more info. Return value is a connection id that can be used with :meth:`~matplotlib.backend_bases.Event.mpl_disconnect`. Examples -------- Usage:: def on_press(event): print('you pressed', event.button, event.xdata, event.ydata) cid = canvas.mpl_connect('button_press_event', on_press) )r� Zconnect)r) r+ r� r r r rK d s .z FigureCanvasBase.mpl_connectc C s | j �|�S )z� Disconnect callback id cid Examples -------- Usage:: cid = canvas.mpl_connect('button_press_event', on_press) #...later canvas.mpl_disconnect(cid) )r� Z disconnect)r) Zcidr r r �mpl_disconnect� s z FigureCanvasBase.mpl_disconnectc O s t ||�S )a� Creates a new backend-specific subclass of :class:`backend_bases.Timer`. This is useful for getting periodic events through the backend's native event loop. Implemented only for backends with GUIs. Other Parameters ---------------- interval : scalar 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}),]) )r� rt r r r � new_timer� s zFigureCanvasBase.new_timerc C s dS )zu Flush the GUI events for the figure. Interactive backends need to reimplement this method. Nr r( r r r � flush_events� s z FigureCanvasBase.flush_eventsr c C sN |dkrt j}d}d}d| _| jrJ|| |k rJ| �� t�|� |d7 }q dS )a# Start a blocking event loop. Such an event loop is used by interactive functions, such as `ginput` and `waitforbuttonpress`, to wait for events. The event loop blocks until a callback function triggers `stop_event_loop`, or *timeout* is reached. If *timeout* is 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. r g{�G�z�?Trf N)rV �inf�_loopingr� �time�sleep)r) ZtimeoutZtimestepZcounterr r r �start_event_loop� s z!FigureCanvasBase.start_event_loopc C s d| _ dS )z�Stop the current blocking event loop. Interactive backends need to reimplement this to match `start_event_loop` FN)r� r( r r r �stop_event_loop� s z FigureCanvasBase.stop_event_loop)N)N)N)N)N)FN)N)N)N)NN)NNNr� N)r )8r� r� r� r� ZeventsZ supports_blitr� r rx �_has_pilr r* � classmethod� functools� lru_cacherA r rW rX rL r[ r] r6 r5 r@ r7 r8 r= r; r9 r: r< rd rg r rr rs ru r_ rw r� rz r~ r� r� r� r� r� r� r rK r� r� r� r� r� r r r r r4 s� ����� �� 0 r4 c C s | j dkrdS td }td }td }td }td }td }td } td } td } td } td } td }td }| j |kr�z|j�� W n tk r� Y nX | j | kr�t�|j� |dk �rV| j |kr�|�� n~| j |kr�|� � nj| j |k�r|� � nT| j |k�r"|� � |� | � n4| j |k�rB|� � |� | � n| j | k�rV|�� | jdk�rfdS dd� }| j}| j | k�r<d||jj�||jj�fk�r<||jj�}||jj�}ddddg}z&||�||f�d t|� \}}W n tk �r� Y n>X |j||�rdnddd� |j||�r*dnddd� |�� | j | k�r�d||jj�||jj�fk�r�||jj�}||jj�}ddddg}z&||�||f�d t|� \}}W n tk �r� Y n*X |j|ddd� |j|ddd� |�� �n | j | k�r�|�� }|dk�r*|�d � |jj�� nb|d k�r�z|�d� W n< tk �r~ } z t � t |�� |�d � W 5 d}~X Y nX |jj�� �nn| j |k�r*|� � }|dk�r�|� d � |jj�� nb|d k�r�z|� d� W n< tk �r } z t � t |�� |� d � W 5 d}~X Y nX |jj�� n�| j |k�rx|j�!� D ]4}| j"dk �r@| j#dk �r@|�$| ��r@|�%d � �q@n�| j �&� �r�| j d k�r�t'| j �d }|t|j�!� �k �r�t(|j�!� �D ]<\}}| j"dk �r�| j#dk �r�|�$| ��r�|�%||k� �q�dS ) az Implement the default mpl key bindings for the canvas and toolbar described at :ref:`key-event-handling` Parameters ---------- event : :class:`KeyEvent` a key press/release event canvas : :class:`FigureCanvasBase` the backend-specific canvas instance toolbar : :class:`NavigationToolbar2` the navigation cursor toolbar Nzkeymap.fullscreenz keymap.home� keymap.back�keymap.forwardz keymap.panz keymap.zoomz keymap.savez keymap.quitz keymap.gridzkeymap.grid_minorz keymap.yscalez keymap.xscalezkeymap.all_axesc S s4 t dd� | D ��rdS tdd� | D ��s,dS d S d S )Nc s s | ]}|j �� V qd S r% �Zgridline� get_visible�r? Ztickr r r � <genexpr>3 s zDkey_press_handler.<locals>._get_uniform_gridstate.<locals>.<genexpr>Tc s s | ]}|j �� V qd S r% r� r� r r r r� 5 s F)�allr� )Zticksr r r �_get_uniform_gridstate0 s z1key_press_handler.<locals>._get_uniform_gridstate�FF)TF)TT)FTrf �majorZbothr< )ZwhichZaxisr= �logZlinearT�0))r$ r r� �full_screen_togglera r Z destroy_figrE �home�back�forward�pan� _set_cursor�zoom� save_figurer �xaxisZ minorTicks�yaxisZ majorTicksr r8 r� Zgridr_ Z get_yscaleZ set_yscaler �_logZwarningr Z get_xscaleZ set_xscalerl r< r= �in_axesZ set_navigate�isdigitr� � enumerate)r^ r rM Zfullscreen_keysZ home_keysZ back_keysZ forward_keysZpan_keysZ zoom_keysZ save_keysZ quit_keysZ grid_keysZgrid_minor_keysZtoggle_yscale_keysZtoggle_xscale_keysZall_keysr� rq Zx_stateZy_state�cycler� �excZscalexrj �nre r r r �key_press_handler� s� �� � �� � ��r� c C sD |dk r@t t| j��}|td kr,|�� n|td kr@|�� dS )zH The default Matplotlib button actions for extra mouse buttons. Nr� r� )r r r# r r� r� )r^ r rM Z button_namer r r �button_press_handler� s r� c @ s e Zd ZdS )�NonGuiExceptionN)r� r� r� r r r r r� � s r� c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�FigureManagerBasea Helper class for pyplot mode, wraps everything up into a neat bundle Attributes ---------- canvas : :class:`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) c st |� _ � |_|� _d � _d � _td dkrN� j �d� j�� _� j �d� j�� _d � _ d � _ � j j j � fdd��}d S )NrM � toolmanagerr7 r9 c s" � j d kr � jd k r � j�� d S r% )r� rM r- )�figr( r r �notify_axes_change� s z6FigureManagerBase.__init__.<locals>.notify_axes_change) r r� �numZkey_press_handler_idZbutton_press_handler_idr rK � key_press� button_pressr� rM rE Zadd_axobserver)r) r r� r� r r( r r* � s$ ��zFigureManagerBase.__init__c C s t � �dS )z� For GUI backends, show the figure window and redraw. For non-GUI backends, raise an exception to be caught by :meth:`~matplotlib.figure.Figure.show`, for an optional warning. N)r� r( r r r �show� s zFigureManagerBase.showc C s d S r% r r( r r r �destroy� s zFigureManagerBase.destroyc C s d S r% r r( r r r r� � s z$FigureManagerBase.full_screen_togglec C s dS )z1"For GUI backends, resize the window (in pixels).Nr r\ r r r r] � s zFigureManagerBase.resizec C s" t d dkr t|| j| jj� dS )ze Implement the default mpl key bindings defined at :ref:`key-event-handling` rM r� N)r r� r rM rv r r r r� � s zFigureManagerBase.key_pressc C s" t d dkr t|| j| jj� dS )zP The default Matplotlib button actions for extra mouse buttons. rM r� N)r r� r rM rv r r r r� � s z FigureManagerBase.button_pressc C s dS )zvGet the title text of the window containing the figure. Return None for non-GUI (e.g., PS) backends. r� r r( r r r r� � s z"FigureManagerBase.get_window_titlec C s dS )z}Set the title text of the window containing the figure. This has no effect for non-GUI (e.g., PS) backends. Nr r� r r r r� � s z"FigureManagerBase.set_window_titleN) r� r� r� r� r* r� r� r� r] r� r� r� r� r r r r r� � s r� c @ s� e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Z d3d4� Z d5d6� Z d7d8� Z d9d:� Z d;d<� Z!d=S )>�NavigationToolbar2a% 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:`_init_toolbar` create your toolbar widget :meth:`draw_rubberband` (optional) draw the zoom to rect "rubberband" rectangle :meth:`press` (optional) whenever a mouse button is pressed, you'll be notified with the event :meth:`release` (optional) whenever a mouse button is released, you'll be notified with the event :meth:`set_message` (optional) display message :meth:`set_history_buttons` (optional) you can change the history back / forward buttons to indicate disabled / enabled state. That's it, we'll do the rest! ) )ZHomezReset original viewr� r� )ZBackzBack to previous viewr� r� )ZForwardzForward to next viewr� r� �NNNN)ZPanz)Pan axes with left mouse, zoom with rightZmover� )ZZoomzZoom to rectangleZ zoom_to_rectr� )ZSubplotszConfigure subplotsZsubplotsZconfigure_subplotsr� )ZSavezSave the figureZfilesaver� c C st || _ | |_t�� | _d | _d | _d | _d | _t j | _ | � � | j � d| j�| _g | _d | _d | _d| _| �� d S )Nr< r )r rM r ZStack� _nav_stack�_xypress�_idPress� _idRelease�_active�cursors�POINTER� _lastCursor� _init_toolbarrK � mouse_move�_idDrag� _ids_zoom� _zoom_mode�_button_pressed�mode�set_history_buttons)r) r r r r r* ? s$ �zNavigationToolbar2.__init__c C s dS )z.Display a message on toolbar or in status bar.Nr r. r r r � set_messageW s z NavigationToolbar2.set_messagec G s | j �� | �� | �� dS )z move back up the view lim stackN)r� r� r� � _update_view�r) r� r r r r� Z s zNavigationToolbar2.backc C s dS )z�Draw a rectangle rubberband to indicate zoom limits. Note that it is not guaranteed that ``x0 <= x1`` and ``y0 <= y1``. Nr )r) r^ Zx0Zy0�x1�y1r r r �draw_rubberband` s z"NavigationToolbar2.draw_rubberbandc C s dS )zRemove the rubberband.Nr r( r r r �remove_rubberbandf s z$NavigationToolbar2.remove_rubberbandc G s | j �� | �� | �� dS )z#Move forward in the view lim stack.N)r� r� r� r� r� r r r r� i s zNavigationToolbar2.forwardc G s | j �� | �� | �� dS )zRestore the original view.N)r� r� r� r� r� r r r r� o s zNavigationToolbar2.homec C s t �dS )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. Nr0 r( r r r r� u s z NavigationToolbar2._init_toolbarc C s� |j r | js.| jtjkr�| �tj� tj| _nV| jdkrZ| jtjkrZ| �tj� tj| _n*| jdkr�| jtjkr�| �tj� tj| _d S )N�ZOOM�PAN)r r� r� r� r� � set_cursorZ SELECT_REGIONZMOVErv r r r r� � s � � z NavigationToolbar2._set_cursorc s� | � � � � jrֈ j�� r�z� j�� j� j�}W n ttfk rH Y q�X � fdd�� jjD �}|r�t � |�}|� jj k r�|� � �}|d k r�|� |�}|d k r�|d | }t| j�r�| �d| j|f � q�| �|� n | �| j� d S )Nc s& g | ] }|� � �d r|�� r|�qS r� )�containsr� ri �r^ r r r@ � s �z1NavigationToolbar2.mouse_move.<locals>.<listcomp>r� z%s, %s)r� r � get_navigateZ format_coordr r r� � OverflowErrorZ_mouseover_setr rm rh Zget_cursor_dataZformat_cursor_datar8 r� r� )r) r^ r+ Zartistsrj ri Zdata_strr r� r r� � s& z NavigationToolbar2.mouse_movec G s� | j dkrd| _ nd| _ | jdk r8| j�| j�| _d| _| jdk rX| j�| j�| _d| _| j r�| j�d| j�| _| j�d| j�| _d| _| j� | � n| jj � | � | jj � � D ]}|� | j � q�| �| j� dS )zAActivate the pan/zoom tool. pan with left button, zoom with rightr� Nr r9 r: zpan/zoom)r� r� r r� r� r� rK � press_pan� release_panrF �releaserE rl �set_navigate_moder� �r) r� rj r r r r� � s0 � �zNavigationToolbar2.panc C s dS )z*Called whenever a mouse button is pressed.Nr rv r r r �press� s zNavigationToolbar2.pressc C s� |j dkrd| _n |j dkr$d| _n d| _dS | �� dkrB| �� |j|j }}g | _t| jj � � �D ]r\}}|dk rf|dk rf|� |�rf|� � rf|� � rf|�|||j � | j�||f� | j�| j� | j�d| j�| _qf| �|� dS )z1Callback for mouse button press in pan/zoom mode.rf rk Nr< )r# r� r� � push_currentr< r= r� r� r rE rl r� r� Zcan_panZ start_panr� r� r� rK �drag_panr� )r) r^ r< r= re rj r r r r� � s. ���z NavigationToolbar2.press_panc C sP | j g krJ| j D ]}| j�|� q| �|� | �� d| _d| _g | _ dS |jdkr\d| _n |jdkrnd| _n d| _dS | �� dkr�| � � |j |j }}g | _t | jj �� �D ]L\}}|dk r�|dk r�|�|�r�|�� r�|�� r�| j�|||||�� f� q�| j�d| j�}| j�d| j�}| j�d| j�} ||| f| _ |j| _| �|� dS )z5Callback for mouse button press in zoom to rect mode.Nrf rk r< r7 r8 )r� r r� r� ru r� r� r# r� r� r< r= r� rE rl r� r� Zcan_zoomr� � _get_viewrK � drag_zoom�_switch_on_zoom_mode�_switch_off_zoom_moder$ r� r� ) r) r^ �zoom_idr< r= re rj Zid1Zid2Zid3r r r � press_zoom� sH �� �� z NavigationToolbar2.press_zoomc C s |j | _| �|� d S r% )r$ r� r� rv r r r r " s z'NavigationToolbar2._switch_on_zoom_modec C s d | _ | �|� d S r% )r� r� rv r r r r & s z(NavigationToolbar2._switch_off_zoom_modec C s, | j �tdd� | jjjD ��� | �� dS )z9Push the current view limits and position onto the stack.c S s0 i | ](}||� � |�d ��� |�� �� ff�qS )T)r� Z get_positionr\ )r? rq r r r � <dictcomp>. s � ��z3NavigationToolbar2.push_current.<locals>.<dictcomp>N)r� �pushr r rE rn r� r( r r r r� * s ���z NavigationToolbar2.push_currentc C s dS )z"Callback for mouse button release.Nr rv r r r r� 5 s zNavigationToolbar2.releasec C sz | j dkrdS | j�| j� | j�d| j�| _| jD ]\}}|�� q4| jsPdS g | _d| _ | �� | � |� | � � dS )z3Callback for mouse button release in pan/zoom mode.Nr< ) r� r r� r� rK r� r� Zend_panr� r� ru �r) r^ rj �indr r r r� 8 s � z NavigationToolbar2.release_panc C s6 | j D ] \}}|�| j|j|j|j� q| j�� dS )z'Callback for dragging in pan/zoom mode.N)r� r� r� r$ r< r= r r_ r r r r r� J s zNavigationToolbar2.drag_panc C s� | j r�|j|j }}| j d \}}}}}t�||g||gg|jj|jj�\\} } \} } | jdkrn|jj \} } n| jdkr�|jj \} } | � || | | | � dS )z#Callback for dragging in zoom mode.r r< r= N) r� r< r= rV ZcliprZ �minr` r� Z intervalyZ intervalxr� ) r) r^ r< r= �lastx�lastyrj r �viewr� r� Zx2Zy2r r r r R s � z NavigationToolbar2.drag_zoomc C sf | j D ]}| j�|� qg | _ | �� | js0dS g }| jD ]�}|j|j }}|\}}} } } t|| �dk rt| jdks�t|| �dk r�| jdkr�d| _| � |� | � � dS d\} } |r�|D ],}| � � � | |�r�d} | � � � | |�r�d} q�|�| � | jdk�rd}n| jd kr:d }nq:| �||||f|| j| | � q:| � � d| _d| _d| _| �� | � |� dS ) z7Callback for mouse button release in zoom to rect mode.N� r= r< r� Trf �inrk �out)r� r r� r� r� r< r= �absr� r� ru Zget_shared_x_axesZjoinedZget_shared_y_axesr� r� Z_set_view_from_bboxr� )r) r^ r Zlast_aZ cur_xypressr< r= r r rj r r ZtwinxZtwinyZla� directionr r r � release_zoom_ sV �� �z NavigationToolbar2.release_zoomc C s� | j j�� D ]z}t|dd�}t|dd�}g }|dk rP|�|�� � |�|�� � |dk rt|�|�� � |�|�� � |D ] }|�� qxq | j �� dS )z)Redraw the canvases, update the locators.r� Nr� ) r rE rl r1 r� Zget_major_locatorZget_minor_locatorZrefreshr_ )r) rj r� r� ZlocatorsZlocr r r ru � s zNavigationToolbar2.drawc C sf | � � }|dkrdS t|�� �}|D ]2\}\}\}}|�|� |�|d� |�|d� q$| j�� dS )z`Update the viewlim and position from the view and position stack for each axes. NZoriginalZactive)r� �listr{ Z _set_viewZ _set_positionr r_ )r) Znav_infor{ rq r Zpos_origZ pos_activer r r r� � s z NavigationToolbar2._update_viewc G s t �dS )zSave the current figure.Nr0 r� r r r r� � s z NavigationToolbar2.save_figurec C s dS )aC 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) Zcursorr r r r� � s z NavigationToolbar2.set_cursorc C s | j �� | �� dS )zReset the axes stack.N)r� �clearr� r( r r r r- � s zNavigationToolbar2.updatec G s� | j dkrd| _ nd| _ | jdk r8| j�| j�| _d| _| jdk rX| j�| j�| _d| _| j r�| j�d| j�| _| j�d| j�| _d| _| j� | � n| jj � | � | jj � � D ]}|� | j � q�| �| j� dS )zActivate zoom to rect mode.r� Nr r9 r: z zoom rect)r� r� r r� r� r� rK r r rF r� rE rl r� r� r� r r r r� � s, ��zNavigationToolbar2.zoomc C s dS )z*Enable or disable the back/forward button.Nr r( r r r r� � s z&NavigationToolbar2.set_history_buttonsN)"r� r� r� r� Z toolitemsr* r� r� r� r� r� r� r� r� r� r� r� r� r r r r� r� r� r� r r ru r� r� r� r- r� r� r r r r r� s> / , 7 r� c @ s^ e Zd ZdZdZdd� Zdd� Zddd �Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )�ToolContainerBasez� Base class for all tool containers, e.g. toolbars. Attributes ---------- toolmanager : `ToolManager` The tools with which this `ToolContainer` wants to communicate. z.pngc C s || _ | j �d| j� d S )NZtool_removed_event)r� �toolmanager_connect�_remove_tool_cbk�r) r� r r r r* � s �zToolContainerBase.__init__c C s | � |jj|jj� dS )zc Captures the 'tool_trigger_[name]' This only gets used for toggled tools N)�toggle_toolitem�toolr �toggledrv r r r �_tool_toggled_cbk s z#ToolContainerBase._tool_toggled_cbk���c C sr | j �|�}| �|j�}t|dd�dk }| �|j||||j|� |rn| j �d|j | j � |j rn| � |jd� dS )ae Adds 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 (optional) The position within the group to place this tool. Defaults to end. r Nztool_trigger_%sT) r� Zget_tool�_get_image_filenamer� r1 � add_toolitemr r r r r r )r) r �group�positionr� �toggler r r �add_tool s ��zToolContainerBase.add_toolc C s | � |jj� dS )z>Captures the 'tool_removed_event' signal and removes the tool.N)�remove_toolitemr r rv r r r r # s z"ToolContainerBase._remove_tool_cbkc C sh |sdS t j�td d�}||| j t j�||�t j�||�| j f}|D ]}t j�|�rJ| S qJdS )z!Find the image based on its name.N�datapathZimages)r� r3 r� r �_icon_extension�isfile)r) r� ZbasedirZpossible_images�fnamer r r r ' s � z%ToolContainerBase._get_image_filenamec C s | j j|| d� dS )z� Trigger the tool Parameters ---------- name : string Name (id) of the tool triggered from within the container )ZsenderN)r� � trigger_tool�r) r r r r r) 7 s z ToolContainerBase.trigger_toolc C s t �dS )a� Add a toolitem to the container This method must get implemented per backend The callback associated with the button click event, must be **EXACTLY** `self.trigger_tool(name)` Parameters ---------- name : string Name of the tool to add, this gets used as the tool's ID and as the default label of the buttons group : String Name of the group that this tool belongs to position : Int Position of the tool within its group, if -1 it goes at the End image_file : String Filename of the image for the button or `None` description : String Description of the tool, used for the tooltips toggle : Bool * `True` : The button is a toggle (change the pressed/unpressed state between consecutive clicks) * `False` : The button is a normal button (returns to unpressed state after release) Nr0 )r) r r r! r� r r" r r r r B s z ToolContainerBase.add_toolitemc C s t �dS )z� Toggle the toolitem without firing event Parameters ---------- name : String Id of the tool to toggle toggled : bool Whether to set this tool as toggled or not. Nr0 )r) r r r r r r ` s z!ToolContainerBase.toggle_toolitemc C s t �dS )a Remove a toolitem from the `ToolContainer` This method must get implemented per backend Called when `ToolManager` emits a `tool_removed_event` Parameters ---------- name : string Name of the tool to remove Nr0 r* r r r r$ m s z!ToolContainerBase.remove_toolitemN)r )r� r� r� r� r& r* r r# r r r) r r r$ r r r r r � s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � StatusbarBasez Base class for the statusbarc C s || _ | j �d| j� d S )NZtool_message_event)r� r � _message_cbkr r r r r* s �zStatusbarBase.__init__c C s | � |j� dS )z5Captures the 'tool_message_event' and set the messageN)r� re rv r r r r, � s zStatusbarBase._message_cbkc C s dS )z� Display a message on toolbar or in status bar Parameters ---------- s : str Message text Nr r. r r r r� � s zStatusbarBase.set_messageN)r� r� r� r� r* r, r� r r r r r+ } s r+ c @ sn e Zd ZdZdZdZeZdZdZ e dd� �Z e dd� �Z e dd� �Z e e�d d �dd d ���Zed d� �ZdS )�_BackendN�unknownc O s. ddl m} |�d|�}|||�}| �||�S )z.Create a new figure manager instance. r )�FigureZ FigureClass)Zmatplotlib.figurer/ r � new_figure_manager_given_figure)rV r� r� r� r/ Zfig_clsr� r r r �new_figure_manager� s z_Backend.new_figure_managerc C s | � |�}| �||�}|S )zCCreate a new figure manager instance for the given figure. )r" � FigureManager)rV r� rE r r� r r r r0 � s z(_Backend.new_figure_manager_given_figurec C s* | j d k r&t� r&t�� }|r&| � |� d S r% )�trigger_manager_drawr r Z get_active)rV r� r r r �draw_if_interactive� s z _Backend.draw_if_interactiver� �blockc C s� t �� }|sdS |D ]}|jj�� q| jdkr4dS |dkr�ddlm} z|jj }W n t k rn d}Y nX | o|t � }t � dkr�d}|r�| �� dS )z� Show all figures. `show` blocks by calling `mainloop` if *block* is ``True``, or if it is ``None`` and we are neither in IPython's ``%pylab`` mode, nor in `interactive` mode. Nr )�pyplotFZWebAggT) r Zget_all_fig_managersr rE r� �mainloop� matplotlibr6 Z _needmainra r r )rV r5 Zmanagersr� r6 Z ipython_pylabr r r r� � s$ z _Backend.showc sP dD ] }t tj� j |t� |�� qG � fdd�dt�}t tj� j d|� � S )N)rP �backend_versionr" r2 r1 r0 r4 r� c s e Zd Z� fdd�ZdS )z _Backend.export.<locals>.Showc s � � � S r% )r7 r( ry r r r7 s z&_Backend.export.<locals>.Show.mainloopN)r� r� r� r7 r ry r r �Show� s r: )�setattrrS rT r� r1 �ShowBase)rV r r: r ry r �export� s z_Backend.export)N)r� r� r� rP r9 r" r� r2 r3 r7 r� r1 r0 r4 r Z_make_keyword_onlyr� � staticmethodr= r r r r r- � s" #r- c @ s e Zd ZdZddd�ZdS )r< zu Simple base class to generate a show() callable in backends. Subclass must override mainloop() method. Nc C s | j |d�S )N)r5 )r� )r) r5 r r r �__call__ s zShowBase.__call__)N)r� r� r� r� r? r r r r r< s r< )N)N)N)Jr� � contextlibr �enumr r� r r� Zloggingr� rS r� �weakrefr ZnumpyrV r8 Zmplr Ztoolsr r r r r r r r r Zmatplotlib._pylab_helpersr Zmatplotlib.transformsr Zmatplotlib.pathr ZPILr Zdistutils.versionr r� � ImportErrorZ getLoggerr� r� r r r r# �objectr$ r� r� r r r r r r r r) r. r3 r4 r� r� r r� r� r� r� r r+ r- r< r r r r �<module> s� " 0 �� M C , \C,( _ ( b l s