Toolbars keep history if axes change

KevKeating · KevKeating · commit 08219c232d1c · 2015-10-02T12:28:59.000-04:00
diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
@@ -2734,6 +2734,7 @@ def __init__(self, canvas):
         self._idRelease = None
         self._active = None
         self._lastCursor = None
+        self._home_views = {}
         self._init_toolbar()
         self._idDrag = self.canvas.mpl_connect(
             'motion_notify_event', self.mouse_move)
@@ -2753,6 +2754,7 @@ def set_message(self, s):
 
     def back(self, *args):
         """move back up the view lim stack"""
+        self._update_home_views()
         self._views.back()
         self._positions.back()
         self.set_history_buttons()
@@ -2771,13 +2773,15 @@ def remove_rubberband(self):
 
     def forward(self, *args):
         """Move forward in the view lim stack"""
+        self._update_home_views()
         self._views.forward()
         self._positions.forward()
         self.set_history_buttons()
         self._update_view()
 
     def home(self, *args):
         """Restore the original view"""
+        self._update_home_views()
         self._views.home()
         self._positions.home()
         self.set_history_buttons()
@@ -2968,19 +2972,48 @@ def _switch_off_zoom_mode(self, event):
         self.mouse_move(event)
 
     def push_current(self):
-        """push the current view limits and position onto the stack"""
-        views = []
-        pos = []
+        """
+        Push the current view limits and position onto their respective stacks
+        """
+
+        views = {}
+        pos = {}
         for a in self.canvas.figure.get_axes():
-            views.append(a._get_view())
-            # Store both the original and modified positions
-            pos.append((
-                a.get_position(True).frozen(),
-                a.get_position().frozen()))
+            views[a] = a._get_view()
+            pos[a] = self._axes_pos(a)
         self._views.push(views)
         self._positions.push(pos)
+        self._update_home_views()
         self.set_history_buttons()
 
+    def _axes_pos(self, ax):
+        """
+        Return the original and modified positions for the specified axes
+
+        Parameters
+        ----------
+        ax : (matplotlib.axes.AxesSubplot)
+            The axes to get the positions for
+
+        Returns
+        -------
+        limits : (tuple)
+            A tuple of the original and modified positions
+        """
+
+        return (ax.get_position(True).frozen(),
+                ax.get_position().frozen())
+
+    def _update_home_views(self):
+        """
+        Make sure that self._home_views has an entry for all axes present in the
+        figure
+        """
+
+        for a in self.canvas.figure.get_axes():
+            if a not in self._home_views:
+                self._home_views[a] = a._get_view()
+
     def release(self, event):
         """this will be called whenever mouse button is released"""
         pass
@@ -3106,8 +3139,11 @@ def draw(self):
         self.canvas.draw_idle()
 
     def _update_view(self):
-        """Update the viewlim and position from the view and
-        position stack for each axes
+        """
+        Update the view limits and position for each axes from the current stack
+        position.  If any axes are present in the figure that aren't in the
+        current stack position, use the home view limits for those axes and
+        don't update *any* positions.
         """
 
         views = self._views()
@@ -3116,11 +3152,19 @@ def _update_view(self):
         pos = self._positions()
         if pos is None:
             return
-        for i, a in enumerate(self.canvas.figure.get_axes()):
-            a._set_view(views[i])
-            # Restore both the original and modified positions
-            a.set_position(pos[i][0], 'original')
-            a.set_position(pos[i][1], 'active')
+        all_axes = self.canvas.figure.get_axes()
+        for a in all_axes:
+            if a in views:
+                cur_view = views[a]
+            else:
+                cur_view = self._home_views[a]
+            a._set_view(cur_view)
+
+        if set(all_axes).issubset(pos.keys()):
+            for a in all_axes:
+                # Restore both the original and modified positions
+                a.set_position(pos[a][0], 'original')
+                a.set_position(pos[a][1], 'active')
 
         self.canvas.draw_idle()
 
@@ -3137,6 +3181,7 @@ def set_cursor(self, cursor):
 
     def update(self):
         """Reset the axes stack"""
+        self._home_views.clear()
         self._views.clear()
         self._positions.clear()
         self.set_history_buttons()
diff --git a/lib/matplotlib/backend_tools.py b/lib/matplotlib/backend_tools.py
@@ -445,29 +445,24 @@ class ToolViewsPositions(ToolBase):
     def __init__(self, *args, **kwargs):
         self.views = WeakKeyDictionary()
         self.positions = WeakKeyDictionary()
+        self.home_views = WeakKeyDictionary()
         ToolBase.__init__(self, *args, **kwargs)
 
     def add_figure(self):
         """Add the current figure to the stack of views and positions"""
         if self.figure not in self.views:
             self.views[self.figure] = cbook.Stack()
             self.positions[self.figure] = cbook.Stack()
+            self.home_views[self.figure] = WeakKeyDictionary()
             # Define Home
             self.push_current()
-            # Adding the clear method as axobserver, removes this burden from
-            # the backend
-            self.figure.add_axobserver(self.clear)
-
-    def clear(self, figure):
-        """Reset the axes stack"""
-        if figure in self.views:
-            self.views[figure].clear()
-            self.positions[figure].clear()
 
     def update_view(self):
         """
-        Update the viewlim and position from the view and
-        position stack for each axes
+        Update the view limits and position for each axes from the current
+        stack position. If any axes are present in the figure that aren't in
+        the current stack position, use the home view limits for those axes and
+        don't update *any* positions.
         """
 
         views = self.views[self.figure]()
@@ -476,27 +471,64 @@ def update_view(self):
         pos = self.positions[self.figure]()
         if pos is None:
             return
-        for i, a in enumerate(self.figure.get_axes()):
-            a._set_view(views[i])
-            # Restore both the original and modified positions
-            a.set_position(pos[i][0], 'original')
-            a.set_position(pos[i][1], 'active')
+        home_views = self.home_views[self.figure]
+        all_axes = self.figure.get_axes()
+        for a in all_axes:
+            if a in views:
+                cur_view = views[a]
+            else:
+                cur_view = home_views[a]
+            a._set_view(cur_view)
+
+        if set(all_axes).issubset(pos.keys()):
+            for a in all_axes:
+                # Restore both the original and modified positions
+                a.set_position(pos[a][0], 'original')
+                a.set_position(pos[a][1], 'active')
 
         self.figure.canvas.draw_idle()
 
     def push_current(self):
-        """push the current view limits and position onto the stack"""
+        """
+        Push the current view limits and position onto their respective stacks
+        """
 
-        views = []
-        pos = []
+        views = WeakKeyDictionary()
+        pos = WeakKeyDictionary()
         for a in self.figure.get_axes():
-            views.append(a._get_view())
-            # Store both the original and modified positions
-            pos.append((
-                a.get_position(True).frozen(),
-                a.get_position().frozen()))
+            views[a] = a._get_view()
+            pos[a] = self._axes_pos(a)
         self.views[self.figure].push(views)
         self.positions[self.figure].push(pos)
+        self.update_home_views()
+
+    def _axes_pos(self, ax):
+        """
+        Return the original and modified positions for the specified axes
+
+        Parameters
+        ----------
+        ax : (matplotlib.axes.AxesSubplot)
+        The axes to get the positions for
+
+        Returns
+        -------
+        limits : (tuple)
+        A tuple of the original and modified positions
+        """
+
+        return (ax.get_position(True).frozen(),
+                ax.get_position().frozen())
+
+    def update_home_views(self):
+        """
+        Make sure that self.home_views has an entry for all axes present in the
+        figure
+        """
+
+        for a in self.figure.get_axes():
+            if a not in self.home_views[self.figure]:
+                self.home_views[self.figure][a] = a._get_view()
 
     def refresh_locators(self):
         """Redraw the canvases, update the locators"""
@@ -542,6 +574,7 @@ class ViewsPositionsBase(ToolBase):
 
     def trigger(self, sender, event, data=None):
         self.toolmanager.get_tool(_views_positions).add_figure()
+        self.toolmanager.get_tool(_views_positions).update_home_views()
         getattr(self.toolmanager.get_tool(_views_positions),
                 self._on_trigger)()
         self.toolmanager.get_tool(_views_positions).update_view()
diff --git a/lib/matplotlib/backends/backend_gtk.py b/lib/matplotlib/backends/backend_gtk.py
@@ -586,11 +586,6 @@ def destroy(*args):
             self.window.show()
             self.canvas.draw_idle()
 
-        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 destroy(self, *args):
diff --git a/lib/matplotlib/backends/backend_gtk3.py b/lib/matplotlib/backends/backend_gtk3.py
@@ -450,14 +450,6 @@ def destroy(*args):
             self.window.show()
             self.canvas.draw_idle()
 
-        def notify_axes_change(fig):
-            'this will be called whenever the current axes is changed'
-            if self.toolmanager is not None:
-                pass
-            elif self.toolbar is not None:
-                self.toolbar.update()
-        self.canvas.figure.add_axobserver(notify_axes_change)
-
         self.canvas.grab_focus()
 
     def destroy(self, *args):
diff --git a/lib/matplotlib/backends/backend_macosx.py b/lib/matplotlib/backends/backend_macosx.py
@@ -388,11 +388,6 @@ def __init__(self, canvas, num):
         if self.toolbar is not None:
             self.toolbar.update()
 
-        def notify_axes_change(fig):
-            'this will be called whenever the current axes is changed'
-            if self.toolbar != None: self.toolbar.update()
-        self.canvas.figure.add_axobserver(notify_axes_change)
-
         if matplotlib.is_interactive():
             self.show()
             self.canvas.draw_idle()
diff --git a/lib/matplotlib/backends/backend_qt5.py b/lib/matplotlib/backends/backend_qt5.py
@@ -485,12 +485,6 @@ def __init__(self, canvas, num):
             self.window.show()
             self.canvas.draw_idle()
 
-        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)
-
     @QtCore.Slot()
     def _show_message(self, s):
         self.statusbar_label.setText(s)
diff --git a/lib/matplotlib/backends/backend_tkagg.py b/lib/matplotlib/backends/backend_tkagg.py
@@ -551,14 +551,6 @@ def __init__(self, canvas, num, window):
 
         self._shown = False
 
-        def notify_axes_change(fig):
-            'this will be called whenever the current axes is changed'
-            if self.toolmanager is not None:
-                pass
-            elif self.toolbar is not None:
-                self.toolbar.update()
-        self.canvas.figure.add_axobserver(notify_axes_change)
-
     def _get_toolbar(self):
         if matplotlib.rcParams['toolbar'] == 'toolbar2':
             toolbar = NavigationToolbar2TkAgg(self.canvas, self.window)
diff --git a/lib/matplotlib/backends/backend_wx.py b/lib/matplotlib/backends/backend_wx.py
@@ -1363,12 +1363,6 @@ def __init__(self, canvas, num, frame):
         self.tb = frame.GetToolBar()
         self.toolbar = self.tb  # consistent with other backends
 
-        def notify_axes_change(fig):
-            'this will be called whenever the current axes is changed'
-            if self.tb is not None:
-                self.tb.update()
-        self.canvas.figure.add_axobserver(notify_axes_change)
-
     def show(self):
         self.frame.Show()
 
