"""

Common code for GTK3 and GTK4 backends.

"""

import logging

import sys

import matplotlib as mpl

from matplotlib import _api, backend_tools, cbook

from matplotlib._pylab_helpers import Gcf

from matplotlib.backend_bases import (

_Backend, FigureCanvasBase, FigureManagerBase, NavigationToolbar2,

TimerBase)

from matplotlib.backend_tools import Cursors

import gi

# The GTK3/GTK4 backends will have already called `gi.require_version` to set

# the desired GTK.

from gi.repository import Gdk, Gio, GLib, Gtk

try:

gi.require_foreign("cairo")

except ImportError as e:

raise ImportError("Gtk-based backends require cairo") from e

_log = logging.getLogger(__name__)

_application = None # Placeholder

def _shutdown_application(app):

# The application might prematurely shut down if Ctrl-C'd out of IPython,

# so close all windows.

for win in app.get_windows():

win.close()

# The PyGObject wrapper incorrectly thinks that None is not allowed, or we

# would call this:

# Gio.Application.set_default(None)

# Instead, we set this property and ignore default applications with it:

app._created_by_matplotlib = True

global _application

_application = None

def _create_application():

global _application

if _application is None:

app = Gio.Application.get_default()

if app is None or getattr(app, '_created_by_matplotlib', False):

# display_is_valid returns False only if on Linux and neither X11

# nor Wayland display can be opened.

if not mpl._c_internal_utils.display_is_valid():

raise RuntimeError('Invalid DISPLAY variable')

_application = Gtk.Application.new('org.matplotlib.Matplotlib3',

Gio.ApplicationFlags.NON_UNIQUE)

# The activate signal must be connected, but we don't care for

# handling it, since we don't do any remote processing.

_application.connect('activate', lambda *args, **kwargs: None)

_application.connect('shutdown', _shutdown_application)

_application.register()

cbook._setup_new_guiapp()

else:

_application = app

return _application

def mpl_to_gtk_cursor_name(mpl_cursor):

return _api.getitem_checked({

Cursors.MOVE: "move",

Cursors.HAND: "pointer",

Cursors.POINTER: "default",

Cursors.SELECT_REGION: "crosshair",

Cursors.WAIT: "wait",

Cursors.RESIZE_HORIZONTAL: "ew-resize",

Cursors.RESIZE_VERTICAL: "ns-resize",

}, cursor=mpl_cursor)

class TimerGTK(TimerBase):

"""Subclass of `.TimerBase` using GTK timer events."""

def __init__(self, *args, **kwargs):

self._timer = None

super().__init__(*args, **kwargs)

def _timer_start(self):

# Need to stop it, otherwise we potentially leak a timer id that will

# never be stopped.

self._timer_stop()

self._timer = GLib.timeout_add(self._interval, self._on_timer)

def _timer_stop(self):

if self._timer is not None:

GLib.source_remove(self._timer)

self._timer = None

def _timer_set_interval(self):

# Only stop and restart it if the timer has already been started.

if self._timer is not None:

self._timer_stop()

self._timer_start()

def _on_timer(self):

super()._on_timer()

# Gtk timeout_add() requires that the callback returns True if it

# is to be called again.

if self.callbacks and not self._single:

return True

else:

self._timer = None

return False

class _FigureCanvasGTK(FigureCanvasBase):

_timer_cls = TimerGTK

class _FigureManagerGTK(FigureManagerBase):

"""

Attributes

----------

canvas : `FigureCanvas`

The FigureCanvas instance

num : int or str

The Figure number

toolbar : Gtk.Toolbar or Gtk.Box

The toolbar

vbox : Gtk.VBox

The Gtk.VBox containing the canvas and toolbar

window : Gtk.Window

The Gtk.Window

"""

def __init__(self, canvas, num):

self._gtk_ver = gtk_ver = Gtk.get_major_version()

app = _create_application()

self.window = Gtk.Window()

app.add_window(self.window)

super().__init__(canvas, num)

if gtk_ver == 3:

icon_ext = "png" if sys.platform == "win32" else "svg"

self.window.set_icon_from_file(

str(cbook._get_data_path(f"images/matplotlib.{icon_ext}")))

self.vbox = Gtk.Box()

self.vbox.set_property("orientation", Gtk.Orientation.VERTICAL)

if gtk_ver == 3:

self.window.add(self.vbox)

self.vbox.show()

self.canvas.show()

self.vbox.pack_start(self.canvas, True, True, 0)

elif gtk_ver == 4:

self.window.set_child(self.vbox)

self.vbox.prepend(self.canvas)

# calculate size for window

w, h = self.canvas.get_width_height()

if self.toolbar is not None:

if gtk_ver == 3:

self.toolbar.show()

self.vbox.pack_end(self.toolbar, False, False, 0)

elif gtk_ver == 4:

sw = Gtk.ScrolledWindow(vscrollbar_policy=Gtk.PolicyType.NEVER)

sw.set_child(self.toolbar)

self.vbox.append(sw)

min_size, nat_size = self.toolbar.get_preferred_size()

h += nat_size.height

self.window.set_default_size(w, h)

self._destroying = False

self.window.connect("destroy", lambda *args: Gcf.destroy(self))

self.window.connect({3: "delete_event", 4: "close-request"}[gtk_ver],

lambda *args: Gcf.destroy(self))

if mpl.is_interactive():

self.window.show()

self.canvas.draw_idle()

self.canvas.grab_focus()

def destroy(self, *args):

if self._destroying:

# Otherwise, this can be called twice when the user presses 'q',

# which calls Gcf.destroy(self), then this destroy(), then triggers

# Gcf.destroy(self) once again via

# `connect("destroy", lambda *args: Gcf.destroy(self))`.

return

self._destroying = True

self.window.destroy()

self.canvas.destroy()

super().destroy()

@classmethod

def start_main_loop(cls):

global _application

if _application is None:

return

try:

_application.run() # Quits when all added windows close.

except KeyboardInterrupt:

# Ensure all windows can process their close event from

# _shutdown_application.

context = GLib.MainContext.default()

while context.pending():

context.iteration(True)

raise

finally:

# Running after quit is undefined, so create a new one next time.

_application = None

def show(self):

# show the figure window

self.window.show()

self.canvas.draw()

if mpl.rcParams["figure.raise_window"]:

meth_name = {3: "get_window", 4: "get_surface"}[self._gtk_ver]

if getattr(self.window, meth_name)():

self.window.present()

else:

# If this is called by a callback early during init,

# self.window (a GtkWindow) may not have an associated

# low-level GdkWindow (on GTK3) or GdkSurface (on GTK4) yet,

# and present() would crash.

_api.warn_external("Cannot raise window yet to be setup")

def full_screen_toggle(self):

is_fullscreen = {

3: lambda w: (w.get_window().get_state()

& Gdk.WindowState.FULLSCREEN),

4: lambda w: w.is_fullscreen(),

}[self._gtk_ver]

if is_fullscreen(self.window):

self.window.unfullscreen()

else:

self.window.fullscreen()

def get_window_title(self):

return self.window.get_title()

def set_window_title(self, title):

self.window.set_title(title)

def resize(self, width, height):

width = int(width / self.canvas.device_pixel_ratio)

height = int(height / self.canvas.device_pixel_ratio)

if self.toolbar:

min_size, nat_size = self.toolbar.get_preferred_size()

height += nat_size.height

canvas_size = self.canvas.get_allocation()

if self._gtk_ver >= 4 or canvas_size.width == canvas_size.height == 1:

# A canvas size of (1, 1) cannot exist in most cases, because

# window decorations would prevent such a small window. This call

# must be before the window has been mapped and widgets have been

# sized, so just change the window's starting size.

self.window.set_default_size(width, height)

else:

self.window.resize(width, height)

class _NavigationToolbar2GTK(NavigationToolbar2):

# Must be implemented in GTK3/GTK4 backends:

# * __init__

# * save_figure

def set_message(self, s):

escaped = GLib.markup_escape_text(s)

self.message.set_markup(f'<small>{escaped}</small>')

def draw_rubberband(self, event, x0, y0, x1, y1):

height = self.canvas.figure.bbox.height

y1 = height - y1

y0 = height - y0

rect = [int(val) for val in (x0, y0, x1 - x0, y1 - y0)]

self.canvas._draw_rubberband(rect)

def remove_rubberband(self):

self.canvas._draw_rubberband(None)

def _update_buttons_checked(self):

for name, active in [("Pan", "PAN"), ("Zoom", "ZOOM")]:

button = self._gtk_ids.get(name)

if button:

with button.handler_block(button._signal_handler):

button.set_active(self.mode.name == active)

def pan(self, *args):

super().pan(*args)

self._update_buttons_checked()

def zoom(self, *args):

super().zoom(*args)

self._update_buttons_checked()

def set_history_buttons(self):

can_backward = self._nav_stack._pos > 0

can_forward = self._nav_stack._pos < len(self._nav_stack) - 1

if 'Back' in self._gtk_ids:

self._gtk_ids['Back'].set_sensitive(can_backward)

if 'Forward' in self._gtk_ids:

self._gtk_ids['Forward'].set_sensitive(can_forward)

class RubberbandGTK(backend_tools.RubberbandBase):

def draw_rubberband(self, x0, y0, x1, y1):

_NavigationToolbar2GTK.draw_rubberband(

self._make_classic_style_pseudo_toolbar(), None, x0, y0, x1, y1)

def remove_rubberband(self):

_NavigationToolbar2GTK.remove_rubberband(

self._make_classic_style_pseudo_toolbar())

class ConfigureSubplotsGTK(backend_tools.ConfigureSubplotsBase):

def trigger(self, *args):

_NavigationToolbar2GTK.configure_subplots(self, None)

class _BackendGTK(_Backend):

backend_version = "{}.{}.{}".format(

Gtk.get_major_version(),

Gtk.get_minor_version(),

Gtk.get_micro_version(),

)

mainloop = _FigureManagerGTK.start_main_loop