| Server IP : 35.80.110.71 / Your IP : 216.73.216.170 Web Server : Apache/2.4.58 (Ubuntu) System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64 User : ubuntu ( 1000) PHP Version : 8.3.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/matplotlib/backends/__pycache__/ |
Upload File : |
�
G8�cT � � � d Z ddlmZ ddlmZ ddlmZmZmZm Z ddl
m Z G d� de � Z G d� d e� Z
d
d �d �Z G d
� de� Z G d� de� ZeZeZy
)a�
A fully functional, do-nothing backend intended as a template for backend
writers. It is fully functional in that you can select it as a backend e.g.
with ::
import matplotlib
matplotlib.use("template")
and your program will (should!) run without error, though no output is
produced. This provides a starting point for backend writers; you can
selectively implement drawing methods (`~.RendererTemplate.draw_path`,
`~.RendererTemplate.draw_image`, etc.) and slowly see your figure come to life
instead having to have a full blown implementation before getting any results.
Copy this file to a directory outside of the Matplotlib source tree, somewhere
where Python can import it (by adding the directory to your ``sys.path`` or by
packaging it as a normal Python package); if the backend is importable as
``import my.backend`` you can then select it using ::
import matplotlib
matplotlib.use("module://my.backend")
If your backend implements support for saving figures (i.e. has a `print_xyz`
method), you can register it as the default handler for a given file type::
from matplotlib.backend_bases import register_backend
register_backend('xyz', 'my_backend', 'XYZ File Format')
...
plt.savefig("figure.xyz")
� )�_api)�Gcf)�FigureCanvasBase�FigureManagerBase�GraphicsContextBase� RendererBase)�Figurec �V � � e Zd ZdZ� fd�Zd d�Zd� Zd d�Zd� Zd� Z d� Z
d � Z d
� Z � xZ
S )
�RendererTemplatez�
The renderer handles drawing/rendering operations.
This is a minimal do-nothing class that can be used to get started when
writing a new backend. Refer to `.backend_bases.RendererBase` for
documentation of the methods.
c �0 �� t �| � � || _ y �N)�super�__init__�dpi)�selfr � __class__s ��F/usr/lib/python3/dist-packages/matplotlib/backends/backend_template.pyr zRendererTemplate.__init__0 s �� �
������� c � � y r
� )r �gc�path� transform�rgbFaces r � draw_pathzRendererTemplate.draw_path4 � � � r c � � y r
r )r r �x�y�ims r �
draw_imagezRendererTemplate.draw_imageO r r c � � y r
r ) r r r r �s�prop�angle�ismath�mtexts r � draw_textzRendererTemplate.draw_textR r r c � � y)NTr �r s r �flipyzRendererTemplate.flipyU s � �r c � � y)N)�d r- r r* s r �get_canvas_width_heightz(RendererTemplate.get_canvas_width_heightY s � �r c � � y)N)� r0 r0 r )r r# r$ r& s r � get_text_width_height_descentz.RendererTemplate.get_text_width_height_descent] s � �r c � � t � S r
)�GraphicsContextTemplater* s r �new_gczRendererTemplate.new_gc` s � �&�(�(r c � � |S r
r )r �pointss r �points_to_pixelsz!RendererTemplate.points_to_pixelsd s � ��
r r
)FN)�__name__�
__module__� __qualname__�__doc__r r r! r( r+ r. r1 r4 r7 �
__classcell__)r s @r r r ' s5 �� ���
�6
�
����)�r r c � � e Zd ZdZy)r3 a�
The graphics context provides the color, line styles, etc. See the cairo
and postscript backends for examples of mapping the graphics context
attributes (cap styles, join styles, line widths, colors) to a particular
backend. In cairo this is done by wrapping a cairo.Context object and
forwarding the appropriate calls to it using a dictionary mapping styles
to gdk constants. In Postscript, all the work is done by the renderer,
mapping line styles to postscript calls.
If it's more appropriate to do the mapping at the renderer level (as in
the postscript backend), you don't need to override any of the GC methods.
If it's more appropriate to wrap an instance (as in the cairo backend) and
do the mapping here, you'll need to override several of the setter
methods.
The base GraphicsContext stores colors as a RGB tuple on the unit
interval, e.g., (0.5, 0.0, 1.0). You may need to map this to colors
appropriate for your backend.
N�r8 r9 r: r; r r r r3 r3 m s � �r r3 N)�blockc �6 � t j � D ] }� y)z�
For image backends - is not required.
For GUI backends - show() is usually the last line of a pyplot script and
tells the backend that it is time to draw. In interactive mode, this
should do nothing.
N)r �get_all_fig_managers)r? �managers r �showrC � s � � �+�+�-�
�� �
r c � � e Zd ZdZy)�FigureManagerTemplatez�
Helper class for pyplot mode, wraps everything up into a neat bundle.
For non-interactive backends, the base class is sufficient.
Nr> r r r rE rE � s � �r rE c �v � e Zd ZdZeZd� Zi ej �ddi�Z e j dd� d� � Z d� Z y )
�FigureCanvasTemplatea1
The canvas the figure renders into. Calls the draw and print fig
methods, creates the renderers, etc.
Note: GUI templates will want to connect events for button presses,
mouse movements and key presses to functions that call the base
class methods button_press_event, button_release_event,
motion_notify_event, key_press_event, and key_release_event. See the
implementations of the interactive backends for examples.
Attributes
----------
figure : `matplotlib.figure.Figure`
A high-level Figure instance
c �x � t | j j � }| j j |� y)aE
Draw the figure using the renderer.
It is important that this method actually walk the artist tree
even if not output is produced because this will trigger
deferred work (like computing limits auto-limits and tick
values) that users may want access to before saving to disk.
N)r �figurer �draw)r �renderers r rJ zFigureCanvasTemplate.draw� s( � � $�D�K�K�O�O�4�� � � ����"r �foozMy magic Foo formatz3.5�argsc �$ � | j � y)a{
Write out format foo.
This method is normally called via `.Figure.savefig` and
`.FigureCanvasBase.print_figure`, which take care of setting the figure
facecolor, edgecolor, and dpi to the desired output values, and will
restore them to the original values. Therefore, `print_foo` does not
need to handle these settings.
N)rJ )r �filenamerM �kwargss r � print_fooz FigureCanvasTemplate.print_foo� s
� �
� � � r c � � y)NrL r r* s r �get_default_filetypez)FigureCanvasTemplate.get_default_filetype� s � �r N)
r8 r9 r: r; rE �
manager_classrJ r � filetypesr �delete_parameterrQ rS r r r rG rG � sU � ��& *�M�
#�" M�#�-�-�L�u�6K�L�I��T���5�&�)�
� *�
�r rG )r; �
matplotlibr �matplotlib._pylab_helpersr �matplotlib.backend_basesr r r r �matplotlib.figurer r r3 rC rE rG � FigureCanvas�
FigureManagerr r r �<module>r] sl �� �> � )�M� M� $�?�|� ?�L� 1� �< �
�� -� �7�+� 7�@ $� �%�
r