@@ -820,8 +820,6 @@ def __init__(self, locator, tz=None, formats=None, offset_formats=None,
         """
         self._locator = locator
         self._tz = tz
-        self._oldticks = np.array([])
-        self._oldlabels = None
         self.defaultfmt = '%Y'
         # there are 6 levels with each level getting a specific format
         # 0: mostly years,  1: months,  2: days,
@@ -869,95 +867,76 @@ def __init__(self, locator, tz=None, formats=None, offset_formats=None,
                                    '%Y-%b-%d',
                                    '%Y-%b-%d %H:%M']
         self.offset_string = ''
-        self._formatter = DateFormatter(self.defaultfmt, self._tz)
         self.show_offset = show_offset
 
     def __call__(self, x, pos=None):
-        if hasattr(self._locator, '_get_unit'):
-            locator_unit_scale = float(self._locator._get_unit())
-        else:
-            locator_unit_scale = 1.0
-        ticks = self._locator()
-        if pos is not None:
-            if not np.array_equal(ticks, self._oldticks):
-
-                offset_fmt = ''
-                fmt = self.defaultfmt
-                self._formatter = DateFormatter(fmt, self._tz)
-                tickdatetime = [num2date(tick) for tick in ticks]
-                tickdate = np.array([tdt.timetuple()[:6]
-                                     for tdt in tickdatetime])
-
-                # basic algorithm:
-                # 1) only display a part of the date if it changes over the
-                #    ticks.
-                # 2) don't display the smaller part of the date if:
-                #    it is always the same or if it is the start of the
-                #    year, month, day etc.
-                # fmt for most ticks at this level
-                fmts = self.formats
-                # format beginnings of days, months, years, etc...
-                zerofmts = self.zero_formats
-                # offset fmt are for the offset in the upper left of the
-                # or lower right of the axis.
-                offsetfmts = self.offset_formats
-
-                # determine the level we will label at:
-                # mostly 0: years,  1: months,  2: days,
-                # 3: hours, 4: minutes, 5: seconds, 6: microseconds
-                for level in range(5, -1, -1):
-                    if len(np.unique(tickdate[:, level])) > 1:
-                        break
-
-                # level is the basic level we will label at.
-                # now loop through and decide the actual ticklabels
-                zerovals = [0, 1, 1, 0, 0, 0, 0]
-                ticknew = ['']*len(tickdate)
-                for nn in range(len(tickdate)):
-                    if level < 5:
-                        if tickdate[nn][level] == zerovals[level]:
-                            fmt = zerofmts[level]
-                        else:
-                            fmt = fmts[level]
-                    else:
-                        # special handling for seconds + microseconds
-                        if (tickdatetime[nn].second == 0 and
-                                tickdatetime[nn].microsecond == 0):
-                            fmt = zerofmts[level]
-                        else:
-                            fmt = fmts[level]
-                    ticknew[nn] = tickdatetime[nn].strftime(fmt)
-
-                # special handling of seconds and microseconds:
-                # strip extra zeros and decimal if possible...
-                # this is complicated by two factors.  1) we have some
-                # level-4 strings here (i.e. 03:00, '0.50000', '1.000')
-                # 2) we would like to have the same number of decimals for
-                # each string (i.e. 0.5 and 1.0).
-                if level >= 5:
-                    trailing_zeros = min(
-                        (len(s) - len(s.rstrip('0')) for s in ticknew
-                                if '.' in s),
-                        default=None)
-                    if trailing_zeros:
-                        for nn in range(len(ticknew)):
-                            if '.' in ticknew[nn]:
-                                ticknew[nn] = \
-                                    ticknew[nn][:-trailing_zeros].rstrip('.')
-
-                result = ticknew[pos]
-                self._oldticks = ticks
-                self._oldlabels = ticknew
-
-                # set the offset string:
-                if self.show_offset:
-                    self.offset_string = tickdatetime[-1].strftime(
-                                           offsetfmts[level])
-
-            result = self._oldlabels[pos]
-        else:
-            result = self._formatter(x, pos)
-        return result
+        formatter = DateFormatter(self.defaultfmt, self._tz)
+        return formatter(x, pos=pos)
+
+    def format_ticks(self, values):
+        if not self.show_offset:
+            formatter = DateFormatter(self.defaultfmt, self._tz)
+            return [formatter(x, i) for i, x in enumerate(values)]
+
+        tickdatetime = [num2date(value) for value in values]
+        tickdate = np.array([tdt.timetuple()[:6] for tdt in tickdatetime])
+
+        # basic algorithm:
+        # 1) only display a part of the date if it changes over the ticks.
+        # 2) don't display the smaller part of the date if:
+        #    it is always the same or if it is the start of the
+        #    year, month, day etc.
+        # fmt for most ticks at this level
+        fmts = self.formats
+        # format beginnings of days, months, years, etc...
+        zerofmts = self.zero_formats
+        # offset fmt are for the offset in the upper left of the
+        # or lower right of the axis.
+        offsetfmts = self.offset_formats
+
+        # determine the level we will label at:
+        # mostly 0: years,  1: months,  2: days,
+        # 3: hours, 4: minutes, 5: seconds, 6: microseconds
+        for level in range(5, -1, -1):
+            if len(np.unique(tickdate[:, level])) > 1:
+                break
+
+        # level is the basic level we will label at.
+        # now loop through and decide the actual ticklabels
+        zerovals = [0, 1, 1, 0, 0, 0, 0]
+        labels = [''] * len(tickdate)
+        for nn in range(len(tickdate)):
+            if level < 5:
+                if tickdate[nn][level] == zerovals[level]:
+                    fmt = zerofmts[level]
+                else:
+                    fmt = fmts[level]
+            else:
+                # special handling for seconds + microseconds
+                if (tickdatetime[nn].second == tickdatetime[nn].microsecond
+                        == 0):
+                    fmt = zerofmts[level]
+                else:
+                    fmt = fmts[level]
+            labels[nn] = tickdatetime[nn].strftime(fmt)
+
+        # special handling of seconds and microseconds:
+        # strip extra zeros and decimal if possible.
+        # this is complicated by two factors.  1) we have some level-4 strings
+        # here (i.e. 03:00, '0.50000', '1.000') 2) we would like to have the
+        # same number of decimals for each string (i.e. 0.5 and 1.0).
+        if level >= 5:
+            trailing_zeros = min(
+                (len(s) - len(s.rstrip('0')) for s in labels if '.' in s),
+                default=None)
+            if trailing_zeros:
+                for nn in range(len(labels)):
+                    if '.' in labels[nn]:
+                        labels[nn] = labels[nn][:-trailing_zeros].rstrip('.')
+
+        # set the offset string:
+        self.offset_string = tickdatetime[-1].strftime(offsetfmts[level])
+        return labels
 
     def get_offset(self):
         return self.offset_string
@@ -2064,7 +2043,7 @@ class ConciseDateConverter(DateConverter):
     """
 
     def __init__(self, formats=None, zero_formats=None, offset_formats=None,
-                show_offset=True):
+                 show_offset=True):
         self._formats = formats
         self._zero_formats = zero_formats
         self._offset_formats = offset_formats