applied patch 1222180

jdh2358 · jdh2358 · commit c3b87ffc0ff7 · 2005-06-16T21:10:10.000Z
svn path=/trunk/matplotlib/; revision=1478
diff --git a/CHANGELOG b/CHANGELOG
@@ -1,5 +1,9 @@
 New entries should be added at the top
 
+2005-06-16 Applied David Cooke's subplot make_key patch
+========================================================
+2005-06-15 0.82 released
+
 2005-06-15 Added subplot config tool to GTK* backends -- note you must
            now import the NavigationToolbar2 from your backend of
            choice rather than from backend_gtk because it needs to
diff --git a/lib/matplotlib/axes.py b/lib/matplotlib/axes.py
@@ -353,8 +353,7 @@ def __init__(self, fig, rect,
         # a mapping from artists to 1 -- would use a set but we are
         # python2.2 compliant
         self.animated = {}  
-        self._lastRenderer = None
-
+        self._cachedRenderer = None
         self.set_navigate(True)
         if len(kwargs): setp(self, **kwargs)
         
@@ -1324,7 +1323,25 @@ def csd(self, x, y, NFFT=256, Fs=2, detrend=detrend_none,
 
         return pxy, freqs
 
-    def draw(self, renderer):
+    def draw_artist(self, a):
+        """
+        This method can only be used after an initial draw which
+        caches the renderer.  It is used to efficiently update Axes
+        data (axis ticks, labels, etc are not updated)        
+        """
+        assert self._cachedRenderer is not None
+        a.draw(self._cachedRenderer)
+
+    def redraw_in_frame(self):
+        """
+        This method can only be used after an initial draw which
+        caches the renderer.  It is used to efficiently update Axes
+        data (axis ticks, labels, etc are not updated)        
+        """
+        assert self._cachedRenderer is not None
+        self.draw(self._cachedRenderer, inframe=True)
+        
+    def draw(self, renderer, inframe=False):
         "Draw everything (plot lines, axes, labels)"
         if not self.get_visible(): return
         renderer.open_group('axes')
@@ -1357,7 +1374,7 @@ def draw(self, renderer):
             oy = self.figure.bbox.height()-(b+h)
             renderer.draw_image(ox, oy, im, origin, self.bbox)
 
-        if self.axison:
+        if self.axison and not inframe:
             self.xaxis.draw(renderer)
             self.yaxis.draw(renderer)
 
@@ -1395,11 +1412,10 @@ def draw(self, renderer):
         self.transAxes.thaw()  # release the lazy objects
         renderer.close_group('axes')
 
-        if len(self.animated):
-            self._lastRenderer = renderer
-            renderer.cache()
+        self._cachedRenderer = renderer
 
-    def draw_animate(self):
+    def __draw_animate(self):
+        # ignore for now; broken
         if self._lastRenderer is None:
             raise RuntimeError('You must first call ax.draw()')
         dsu = [(a.zorder, a) for a in self.animated.keys()]
diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
@@ -16,20 +16,6 @@ class RendererBase:
     """An abstract base class to handle drawing/rendering operations
     """
 
-    def cache(self):
-        """
-        save a copy of the canvas, to be used in conjunction with blit
-        in support of animation
-        """
-        pass
-
-    def blit(self):
-        """
-        blit the cached copy of the canvas, to be used in conjunction
-        with blit in support of animation
-        """
-        pass
-
     
     def open_group(self, s):
         """open a grouping element with label s
@@ -713,6 +699,12 @@ def __init__(self, figure):
 
 
 
+    def blit(self, bbox=None):
+        """
+        blit the canvas in bbox (default entire canvas)
+        """
+        pass
+
     def key_press_event(self, key, guiEvent=None):
         self._key = key
         event = KeyEvent('key_press_event', self, key, self._lastx, self._lasty, guiEvent=guiEvent)        
diff --git a/lib/matplotlib/backends/backend_agg.py b/lib/matplotlib/backends/backend_agg.py
@@ -120,6 +120,11 @@ def __init__(self, width, height, dpi):
         self.draw_line_collection = self._renderer.draw_line_collection
         self.draw_poly_collection = self._renderer.draw_poly_collection
         self.draw_regpoly_collection = self._renderer.draw_regpoly_collection
+
+        self.copy_from_bbox = self._renderer.copy_from_bbox
+        self.restore_region = self._renderer.restore_region        
+        
+
         self.cache = self._renderer.cache
         self.blit = self._renderer.blit
         self.texmanager = TexManager()
@@ -359,6 +364,14 @@ class FigureCanvasAgg(FigureCanvasBase):
       figure - A Figure instance
     """    
 
+    def copy_from_bbox(self, bbox):
+        renderer = self.get_renderer()
+        return renderer.copy_from_bbox(bbox)
+
+    def restore_region(self, region):
+        renderer = self.get_renderer()
+        return renderer.restore_region(region)
+        
     def draw(self):
         """
         Draw the figure using the renderer
diff --git a/lib/matplotlib/backends/backend_gtkagg.py b/lib/matplotlib/backends/backend_gtkagg.py
@@ -89,10 +89,10 @@ def _render_figure(self, width, height):
                                            self._pixmap_height)
 
         FigureCanvasAgg.draw(self)
-        agg_to_gtk_drawable(self._pixmap, self.renderer._renderer)
+        agg_to_gtk_drawable(self._pixmap, self.renderer._renderer, None)
 
-    def blit(self):
-        agg_to_gtk_drawable(self._pixmap, self.renderer._renderer)
+    def blit(self, bbox=None):
+        agg_to_gtk_drawable(self._pixmap, self.renderer._renderer, bbox)
         self.window.set_back_pixmap (self._pixmap, False)
         self.window.clear()  # draw pixmap as the gdk.Window's bg
         self._draw_pixmap = False
diff --git a/lib/matplotlib/figure.py b/lib/matplotlib/figure.py
@@ -150,6 +150,8 @@ def __init__(self,
 
         self.clf()
 
+        self._cachedRenderer = None
+        
     def set_canvas(self, canvas):
         """\
 Set the canvas the contains the figure
@@ -336,16 +338,20 @@ def fixitems(items):
             # to tuples for the kyey
             ret = []
             for k, v in items:
-                if iterable(v): v = tuple(v)                
+                if iterable(v): v = tuple(v)
                 ret.append((k,v))
-            return ret
+            return tuple(ret)
+
+        def fixlist(args):
+            ret = []
+            for a in args:
+                if iterable(a): a = tuple(a)
+                ret.append(a)
+            return tuple(ret)
 
-        if iterable(args[0]):
-            key = tuple(args[0]), tuple( fixitems(kwargs.items()))
-        else:		
-            key = args[0], tuple(fixitems( kwargs.items()))
+        key = fixlist(args), fixitems(kwargs.items())
         return key
-        
+
     def add_axes(self, *args, **kwargs):
         """
 Add an a axes with axes rect [left, bottom, width, height] where all
@@ -506,6 +512,13 @@ def draw(self, renderer):
         self.transFigure.thaw()  # release the lazy objects
         renderer.close_group('figure')
 
+        self._cachedRenderer = renderer
+
+    def draw_artist(self, a):
+        'draw artist only -- this is available only after the figure is drawn'
+        assert self._cachedRenderer is not None
+        a.draw(self._cachedRenderer)
+            
     def get_axes(self):
         return self.axes
 
diff --git a/lib/matplotlib/image.py b/lib/matplotlib/image.py
@@ -189,7 +189,6 @@ def make_image(self, flipy):
         return im
     
     def draw(self, renderer, *args, **kwargs):
-
         if not self.get_visible(): return 
         isUpper = self.origin=='upper'
         flipy = renderer.flipy()
diff --git a/lib/matplotlib/pylab.py b/lib/matplotlib/pylab.py
@@ -803,7 +803,8 @@ def figure(num=None, # autoincrement if None, else integer from 1-N
         figManager = new_figure_manager(num, figsize, dpi, facecolor, edgecolor, frameon)
         _pylab_helpers.Gcf.set_active(figManager)
         figManager.canvas.figure.number = num
-        
+
+    draw_if_interactive()
     return figManager.canvas.figure
 
 def gca(**kwargs):
diff --git a/lib/matplotlib/text.py b/lib/matplotlib/text.py
@@ -276,10 +276,10 @@ def set_bbox(self, rectprops):
         self._bbox = rectprops
 
     def draw(self, renderer):
-        if not self.get_visible(): return 
-        if self._text=='': return
         if renderer is not None:
             self._renderer = renderer
+        if not self.get_visible(): return 
+        if self._text=='': return
 
         gc = renderer.new_gc()
         gc.set_foreground(self._color)
diff --git a/lib/matplotlib/widgets.py b/lib/matplotlib/widgets.py
@@ -135,13 +135,15 @@ def __init__(self, ax, label, valmin, valmax, valinit=0.5, valfmt='%1.2f',
         """
         Create a slider from valmin to valmax in axes ax;
 
-        label is the slider label valinit is the slider initial position
+        valinit -  the slider initial position
 
-        valfmt is used to format the slider value
+        label - the slider label 
 
-        closedmin and closedmax indicated whether the slider interval is closed
+        valfmt - used to format the slider value
 
-        slidermin and slidermax can be used to contrain the value of
+        closedmin and closedmax - indicate whether the slider interval is closed
+
+        slidermin and slidermax - be used to contrain the value of
           this slider to the values of other sliders.
           """
         self.ax = ax
diff --git a/setupext.py b/setupext.py
@@ -115,7 +115,9 @@ def add_agg_flags(module):
     module.libraries.append('png')
     module.libraries.append('z')
     add_base_flags(module)
-    module.include_dirs.extend(['src','%s/include'%AGG_VERSION, '.'])
+    module.include_dirs.extend(['src','swig', '%s/include'%AGG_VERSION, '.'])
+    
+
 
     # put these later for correct link order
     module.libraries.extend(['stdc++', 'm'])
@@ -351,7 +353,7 @@ def build_ft2font(ext_modules, packages):
 def build_gtkagg(ext_modules, packages, numerix):
     global BUILT_GTKAGG
     if BUILT_GTKAGG: return # only build it if you you haven't already
-    deps = ['src/_gtkagg.cpp', 'src/mplutils.cpp']
+    deps = ['src/_gtkagg.cpp', 'src/mplutils.cpp', 'src/_transforms.cpp']
     deps.extend(glob.glob('CXX/*.cxx'))
     deps.extend(glob.glob('CXX/*.c'))
 
diff --git a/src/_backend_agg.cpp b/src/_backend_agg.cpp
@@ -8,6 +8,7 @@
 #include <stdexcept>
 #include <png.h>
 
+
 #include "agg_conv_transform.h"
 #include "agg_conv_curve.h"
 #include "agg_scanline_storage_aa.h"
@@ -602,6 +603,84 @@ RendererAgg::draw_line_collection(const Py::Tuple& args) {
 }
 
 
+
+Py::Object
+RendererAgg::copy_from_bbox(const Py::Tuple& args) {
+  //copy region in bbox to buffer and return swig/agg buffer object
+  args.verify_length(1);
+   
+
+  agg::rect r = bbox_to_rect(args[0]);
+  r.x1 -=5;
+  r.y1 -=5;
+  r.x2 +=5;
+  r.y2 +=5;
+  
+  int boxwidth = r.x2-r.x1;
+  int boxheight = r.y2-r.y1;
+  int boxstride = boxwidth*4;
+  agg::buffer buf(boxwidth, boxheight, boxstride, false);
+  if (buf.data ==NULL) {
+    throw Py::MemoryError("RendererAgg::copy_from_bbox could not allocate memory for buffer");
+  }
+    
+  agg::rendering_buffer rbuf;
+  rbuf.attach(buf.data, boxwidth, boxheight, boxstride);
+
+  pixfmt pf(rbuf);
+  renderer_base rb(pf);
+  rb.clear(agg::rgba(1, 0, 0)); //todo remove me
+  rb.copy_from(*renderingBuffer, &r, -r.x1, -r.y1);
+  Region* reg = new Region(buf, r);
+
+  return Py::asObject(reg);
+  
+  
+  
+}
+
+Py::Object
+RendererAgg::restore_region(const Py::Tuple& args) {
+  //copy Region to buffer
+  args.verify_length(1);
+  Region* region  = static_cast<Region*>(args[0].ptr());
+  
+  if (region->aggbuf.data==NULL) 
+    throw Py::ValueError("Cannot restore_region frm NULL data");
+
+    
+  agg::rendering_buffer rbuf;
+  rbuf.attach(region->aggbuf.data, 
+	      region->aggbuf.width, 
+	      region->aggbuf.height, 
+	      region->aggbuf.stride);
+
+  rendererBase->copy_from(rbuf, 0, region->rect.x1, region->rect.y1);
+
+  return Py::Object();
+  
+  
+  
+}
+
+
+agg::rect_base<int>
+RendererAgg::bbox_to_rect(const Py::Object& o) {
+  //return the agg::rect for bbox, flipping y
+
+  Bbox* clipbox = static_cast<Bbox*>(o.ptr());
+  double l = clipbox->ll_api()->x_api()->val() ; 
+  double b = clipbox->ll_api()->y_api()->val();
+  double r = clipbox->ur_api()->x_api()->val() ; 
+  double t = clipbox->ur_api()->y_api()->val() ; ;       
+  
+  agg::rect<int> rect( (int)l, height-(int)t, (int)r, height-(int)b ) ;
+  if (!rect.is_valid())
+    throw Py::ValueError("Invalid rectangle in bbox_to_rect");
+  return rect;
+  
+}
+
 void
 RendererAgg::set_clip_from_bbox(const Py::Object& o) {
   if (o.ptr() != Py_None) {  //using clip
@@ -1941,6 +2020,11 @@ void RendererAgg::init_type()
 		     "cache()"); 
   add_varargs_method("blit", &RendererAgg::blit, 
 		     "blit()"); 
+  add_varargs_method("copy_from_bbox", &RendererAgg::copy_from_bbox, 
+		     "copy_from_bbox(bbox)"); 
+
+  add_varargs_method("restore_region", &RendererAgg::restore_region, 
+		     "restore_region(region)"); 
 
   
 }
diff --git a/src/_backend_agg.h b/src/_backend_agg.h
diff --git a/src/_gtkagg.cpp b/src/_gtkagg.cpp
diff --git a/swig/agg_buffer.h b/swig/agg_buffer.h
