Refactor pass 1. Refactoring Gcf out of specific backend (backend_gtk3.py)

OceanWolf · OceanWolf · commit 00a2252f7f43 · 2015-02-22T00:14:36.000+01:00
diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
@@ -40,6 +40,7 @@
 import io
 
 import numpy as np
+import matplotlib # temporary )assuming we refactor where marked below)
 import matplotlib.cbook as cbook
 import matplotlib.colors as colors
 import matplotlib.transforms as transforms
@@ -2534,6 +2535,165 @@ def key_press_handler(event, canvas, toolbar=None):
 class NonGuiException(Exception):
     pass
 
+class WindowEvent(object):
+    def __init__(self, name, window):
+        self.name = name
+        self.window = window
+
+class WindowBase(object):
+    def __init__(self, title):
+        self._callbacks = cbook.CallbackRegistry()
+
+    def mpl_connect(self, s, func):
+        return self._callbacks.connect(s, func)
+
+    def mpl_disconnect(self, cid):
+        return self._callbacks.disconnect(cid)
+
+    def show(self):
+        """
+        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.
+        """
+        raise NonGuiException()
+
+    def destroy(self):
+        pass
+
+    def set_fullscreen(self, fullscreen):
+        pass
+
+    def resize(self, w, h):
+        """"For gui backends, resize the window (in pixels)."""
+        pass
+
+    def get_window_title(self):
+        """
+        Get the title text of the window containing the figure.
+        Return None for non-GUI backends (e.g., a PS backend).
+        """
+        return 'image'
+
+    def set_window_title(self, title):
+        """
+        Set the title text of the window containing the figure.  Note that
+        this has no effect for non-GUI backends (e.g., a PS backend).
+        """
+        pass
+
+    def add_element_to_window(self, element, expand, fill, padding, from_start=False):
+        """ Adds a gui widget to the window.
+        This has no effect for non-GUI backends
+        """
+        pass
+
+    def terminate_backend(self):
+        """Method to terminate the usage of the backend
+        """
+        # TODO refactor me out on second pass
+        pass
+
+    def destroy_event(self, *args):
+        s = 'window_destroy_event'
+        event = WindowEvent(s, self)
+        self._callbacks.process(s, event)
+
+
+class FigureManager(object):
+    def __init__(self, canvas, num, classes):
+        self._classes = classes
+        self.canvas = canvas
+        canvas.manager = self
+        self.num = num
+
+        self.key_press_handler_id = self.canvas.mpl_connect('key_press_event',
+                                                            self.key_press)
+
+        self.window = classes['Window']('Figure %d' % num)
+        self.window.mpl_connect('window_destroy_event', self._destroy)
+
+        w = int(self.canvas.figure.bbox.width)
+        h = int(self.canvas.figure.bbox.height)
+
+        self.window.add_element_to_window(self.canvas, True, True, 0, True)
+
+        self.toolbar = self._get_toolbar(canvas)
+        if self.toolbar is not None:
+            h += self.window.add_element_to_window(self.toolbar, False, False, 0)
+
+        self.window.set_default_size(w,h)
+
+        # Refactor this?  If so, delete import matplotlib from above.
+        if matplotlib.is_interactive():
+            self.window.show()
+
+        def notify_axes_change(fig):
+            'this will be called whenever the current axes is changed'
+            if self.toolbar is not None: self.toolbar.update()
+        self.canvas.figure.add_axobserver(notify_axes_change)
+
+        self.canvas.grab_focus()
+
+    def key_press(self, event):
+        """
+        Implement the default mpl key bindings defined at
+        :ref:`key-event-handling`
+        """
+        key_press_handler(event, self.canvas, self.canvas.toolbar)
+
+    def _destroy(self, event):
+        Gcf.destroy(self.num) # TODO refactor me out of here on second pass!
+
+    def destroy(self, *args):
+        self.window.destroy()
+        self.canvas.destroy()
+        if self.toolbar:
+            self.toolbar.destroy()
+
+        # TODO refactor out on second pass
+        if Gcf.get_num_fig_managers()==0 and not matplotlib.is_interactive():
+            self.window.terminate_backend()
+
+    def show(self):
+        self.window.show()
+
+    def full_screen_toggle(self):
+        self._full_screen_flag = not self._full_screen_flag
+        self.window.set_fullscreen(self._full_screen_flag)
+
+    def resize(self, w, h):
+        self.window.resize(w,h)
+
+    def get_window_title(self):
+        """
+        Get the title text of the window containing the figure.
+        Return None for non-GUI backends (e.g., a PS backend).
+        """
+        return self.window.get_window_title()
+
+    def set_window_title(self, title):
+        """
+        Set the title text of the window containing the figure.  Note that
+        this has no effect for non-GUI backends (e.g., a PS backend).
+        """
+        self.window.set_window_title(title)
+
+    def show_popup(self, msg):
+        """
+        Display message in a popup -- GUI only
+        """
+        pass
+
+    def _get_toolbar(self, canvas):
+        # must be inited after the window, drawingArea and figure
+        # attrs are set
+        if rcParams['toolbar'] == 'toolbar2':
+            toolbar = self._classes['Toolbar2'](canvas, self.window)
+        else:
+            toolbar = None
+        return toolbar
 
 class FigureManagerBase(object):
     """
diff --git a/lib/matplotlib/backends/backend_gtk3.py b/lib/matplotlib/backends/backend_gtk3.py
@@ -29,7 +29,7 @@ def fn_name(): return sys._getframe(1).f_code.co_name
 import matplotlib
 from matplotlib._pylab_helpers import Gcf
 from matplotlib.backend_bases import RendererBase, GraphicsContextBase, \
-     FigureManagerBase, FigureCanvasBase, NavigationToolbar2, cursors, TimerBase
+     FigureManagerBase, FigureCanvasBase, NavigationToolbar2, cursors, TimerBase, WindowBase
 from matplotlib.backend_bases import ShowBase
 
 from matplotlib.cbook import is_string_like, is_writable_file_like
@@ -374,6 +374,85 @@ def stop_event_loop(self):
         FigureCanvasBase.stop_event_loop_default(self)
     stop_event_loop.__doc__=FigureCanvasBase.stop_event_loop_default.__doc__
 
+class WindowGTK3(WindowBase):
+    def __init__(self, title):
+        WindowBase.__init__(self, title)
+        self.window = Gtk.Window()
+        self.set_window_title(title)
+
+        try:
+            self.window.set_icon_from_file(window_icon)
+        except (SystemExit, KeyboardInterrupt):
+            # re-raise exit type Exceptions
+            raise
+        except:
+            # some versions of gtk throw a glib.GError but not
+            # all, so I am not sure how to catch it.  I am unhappy
+            # doing a blanket catch here, but am not sure what a
+            # better way is - JDH
+            verbose.report('Could not load matplotlib icon: %s' % sys.exc_info()[1])
+
+        self.vbox = Gtk.Box()
+        self.vbox.set_property('orientation', Gtk.Orientation.VERTICAL)
+        self.window.add(self.vbox)
+        self.vbox.show()
+
+        self.window.connect('destroy', self.destroy_event) # TODO create in base
+        self.window.connect('delete_event', self.destroy_event)
+
+    def add_element_to_window(self, element, expand, fill, padding, from_start=False):
+        element.show()
+        if from_start:
+            self.vbox.pack_start(element, expand, fill, padding)
+        else:
+            self.vbox.pack_end(element, False, False, 0)
+        size_request = element.size_request()
+        return size_request.height
+
+    def set_default_size(self, width, height):
+        self.window.set_default_size(width, height)
+
+    def show(self):
+        # show the figure window
+        self.window.show()
+
+    def destroy(self):
+        self.vbox.destroy()
+        self.window.destroy()
+
+    # TODO refactor out on second pass.
+    def terminate_backend(self):
+        if Gtk.main_level() >= 1:
+            Gtk.main_quit()
+
+    def set_fullscreen(self, fullscreen):
+        if fullscreen:
+            self.window.fullscreen()
+        else:
+            self.window.unfullscreen()
+
+    def _get_toolbar(self, canvas):
+        # must be inited after the window, drawingArea and figure
+        # attrs are set
+        if rcParams['toolbar'] == 'toolbar2':
+            toolbar = NavigationToolbar2GTK3 (canvas, self.window)
+        else:
+            toolbar = None
+        return toolbar
+
+    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):
+        'set the canvas size in pixels'
+        #_, _, cw, ch = self.canvas.allocation
+        #_, _, ww, wh = self.window.allocation
+        #self.window.resize (width-cw+ww, height-ch+wh)
+        self.window.resize(width, height)
+
 
 class FigureManagerGTK3(FigureManagerBase):
     """
@@ -887,3 +966,4 @@ def error_msg_gtk(msg, parent=None):
 
 FigureCanvas = FigureCanvasGTK3
 FigureManager = FigureManagerGTK3
+Window = WindowGTK3
diff --git a/lib/matplotlib/backends/backend_gtk3cairo.py b/lib/matplotlib/backends/backend_gtk3cairo.py
@@ -7,6 +7,7 @@
 from . import backend_cairo
 from .backend_cairo import cairo, HAS_CAIRO_CFFI
 from matplotlib.figure import Figure
+from matplotlib.backend_bases import FigureManager
 
 class RendererGTK3Cairo(backend_cairo.RendererCairo):
     def set_context(self, ctx):
@@ -51,7 +52,6 @@ def on_draw_event(self, widget, ctx):
 class FigureManagerGTK3Cairo(backend_gtk3.FigureManagerGTK3):
     pass
 
-
 def new_figure_manager(num, *args, **kwargs):
     """
     Create a new figure manager instance
@@ -66,10 +66,10 @@ def new_figure_manager_given_figure(num, figure):
     Create a new figure manager instance for the given figure.
     """
     canvas = FigureCanvasGTK3Cairo(figure)
-    manager = FigureManagerGTK3Cairo(canvas, num)
+    manager = FigureManager(canvas, num, classes)
     return manager
 
-
+classes = {'Window': backend_gtk3.WindowGTK3,
+            'Toolbar2': backend_gtk3.NavigationToolbar2GTK3}
 FigureCanvas = FigureCanvasGTK3Cairo
-FigureManager = FigureManagerGTK3Cairo
 show = backend_gtk3.show
