def _print_image(self, filename, format):
        if self.flags() & gtk.REALIZED == 0:
            # for self.window(for pixmap) and has a side effect of altering
            # figure width,height (via configure-event?)
            gtk.DrawingArea.realize(self)

        width, height = self.get_width_height()
        pixmap = gdk.Pixmap (self.window, width, height)
        self._renderer.set_pixmap (pixmap)
        self._render_figure(pixmap, width, height)

        # jpg colors don't match the display very well, png colors match
        # better
        pixbuf = gdk.Pixbuf(gdk.COLORSPACE_RGB, 0, 8, width, height)
        pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(),
                                     0, 0, 0, 0, width, height)

        if is_string_like(filename):
            try:
                pixbuf.save(filename, format)
            except gobject.GError as exc:
                error_msg_gtk('Save figure failure:\n%s' % (exc,), parent=self)
        elif is_writable_file_like(filename):
            if hasattr(pixbuf, 'save_to_callback'):
                def save_callback(buf, data=None):
                    data.write(buf)
                try:
                    pixbuf.save_to_callback(save_callback, format, user_data=filename)
                except gobject.GError as exc:
                    error_msg_gtk('Save figure failure:\n%s' % (exc,), parent=self)
            else:
                raise ValueError("Saving to a Python file-like object is only supported by PyGTK >= 2.8")
        else:
            raise ValueError("filename must be a path or a file-like object")

 def print_svg(self, filename, *args, **kwargs):
     if is_string_like(filename):
         fh_to_close = svgwriter = codecs.open(filename, "w", "utf-8")
     elif is_writable_file_like(filename):
         svgwriter = codecs.EncodedFile(filename, "utf-8")
         fh_to_close = None
     else:
         raise ValueError("filename must be a path or a file-like object")
     return self._print_svg(filename, svgwriter, fh_to_close)

 def print_svgz(self, filename, *args, **kwargs):
     if is_string_like(filename):
         fh_to_close = gzipwriter = gzip.GzipFile(filename, 'w')
         svgwriter = io.TextIOWrapper(gzipwriter, 'utf-8')
     elif is_writable_file_like(filename):
         fh_to_close = gzipwriter = gzip.GzipFile(fileobj=filename, mode='w')
         svgwriter = io.TextIOWrapper(gzipwriter, 'utf-8')
     else:
         raise ValueError("filename must be a path or a file-like object")
     return self._print_svg(filename, svgwriter, fh_to_close)

 def print_svgz(self, filename, *args, **kwargs):
     if is_string_like(filename):
         gzipwriter = gzip.GzipFile(filename, "w")
         fh_to_close = svgwriter = codecs.EncodedFile(gzipwriter, "utf-8")
     elif is_writable_file_like(filename):
         fh_to_close = gzipwriter = gzip.GzipFile(fileobj=filename, mode="w")
         svgwriter = codecs.EncodedFile(gzipwriter, "utf-8")
     else:
         raise ValueError("filename must be a path or a file-like object")
     return self._print_svg(filename, svgwriter, fh_to_close)

 def print_png(self, fname_or_fh, *args, **kwargs):
     """
     Use LaTeX to compile a pgf figure to pdf and convert it to png.
     """
     if is_string_like(fname_or_fh):
         with open(fname_or_fh, "wb") as fh:
             self._print_png_to_fh(fh)
     elif is_writable_file_like(fname_or_fh):
         self._print_png_to_fh(fname_or_fh)
     else:
         raise ValueError("filename must be a path or a file-like object")

 def print_pdf(self, fname_or_fh, *args, **kwargs):
     """
     Use LaTeX to compile a Pgf generated figure to PDF.
     """
     # figure out where the pdf is to be written to
     if is_string_like(fname_or_fh):
         with open(fname_or_fh, "wb") as fh:
             self._print_pdf_to_fh(fh)
     elif is_writable_file_like(fname_or_fh):
         self._print_pdf_to_fh(fname_or_fh)
     else:
         raise ValueError("filename must be a path or a file-like object")

 def print_svg(self, filename, *args, **kwargs):
     if is_string_like(filename):
         fh_to_close = svgwriter = io.open(filename, "w", encoding="utf-8")
     elif is_writable_file_like(filename):
         if not isinstance(filename, io.TextIOBase):
             if sys.version_info[0] >= 3:
                 svgwriter = io.TextIOWrapper(filename, "utf-8")
             else:
                 svgwriter = codecs.getwriter("utf-8")(filename)
         fh_to_close = None
     else:
         raise ValueError("filename must be a path or a file-like object")
     return self._print_svg(filename, svgwriter, fh_to_close, **kwargs)

    def print_png(self, fname_or_fh, *args, **kwargs):
        """
        Use LaTeX to compile a pgf figure to pdf and convert it to png.
        """
        if kwargs.get("dryrun", False):
            self._print_pgf_to_fh(None, *args, **kwargs)
            return

        if isinstance(fname_or_fh, six.string_types):
            with open(fname_or_fh, "wb") as fh:
                self._print_png_to_fh(fh, *args, **kwargs)
        elif is_writable_file_like(fname_or_fh):
            self._print_png_to_fh(fname_or_fh, *args, **kwargs)
        else:
            raise ValueError("filename must be a path or a file-like object")

 def print_svg(self, filename, *args, **kwargs):
     if is_string_like(filename):
         fh_to_close = svgwriter = io.open(filename, 'w', encoding='utf-8')
     elif is_writable_file_like(filename):
         if not isinstance(filename, io.TextIOBase):
             if six.PY3:
                 svgwriter = io.TextIOWrapper(filename, 'utf-8')
             else:
                 svgwriter = codecs.getwriter('utf-8')(filename)
         else:
             svgwriter = filename
         fh_to_close = None
     else:
         raise ValueError("filename must be a path or a file-like object")
     return self._print_svg(filename, svgwriter, fh_to_close, **kwargs)

 def print_ipe(self, filename, *args, **kwargs):
     if isinstance(filename, string_types):
         fh_to_close = ipewriter = io.open(filename, 'w', encoding='utf-8')
     elif is_writable_file_like(filename):
         if not isinstance(filename, io.TextIOBase):
             if sys.version_info[0] >= 3:
                 ipewriter = io.TextIOWrapper(filename, 'utf-8')
             else:
                 ipewriter = codecs.getwriter('utf-8')(filename)
         else:
             ipewriter = filename
         fh_to_close = None
     else:
         raise ValueError("filename must be a path or a file-like object")
     return self._print_ipe(filename, ipewriter, fh_to_close, **kwargs)

    def print_pgf(self, fname_or_fh, *args, **kwargs):
        """
        Output pgf commands for drawing the figure so it can be included and
        rendered in latex documents.
        """
        if kwargs.get("dryrun", False): return

        # figure out where the pgf is to be written to
        if is_string_like(fname_or_fh):
            with codecs.open(fname_or_fh, "w", encoding="utf-8") as fh:
                self._print_pgf_to_fh(fh)
        elif is_writable_file_like(fname_or_fh):
            raise ValueError("saving pgf to a stream is not supported, " + \
            "consider using the pdf option of the pgf-backend")
        else:
            raise ValueError("filename must be a path")

    def print_pdf(self, fname_or_fh, *args, **kwargs):
        """
        Use LaTeX to compile a Pgf generated figure to PDF.
        """
        if kwargs.get("dryrun", False):
            self._print_pgf_to_fh(None, *args, **kwargs)
            return

        # figure out where the pdf is to be written to
        if isinstance(fname_or_fh, six.string_types):
            with open(fname_or_fh, "wb") as fh:
                self._print_pdf_to_fh(fh, *args, **kwargs)
        elif is_writable_file_like(fname_or_fh):
            self._print_pdf_to_fh(fname_or_fh, *args, **kwargs)
        else:
            raise ValueError("filename must be a path or a file-like object")

    def print_pgf(self, fname_or_fh, *args, **kwargs):
        """
        Output pgf commands for drawing the figure so it can be included and
        rendered in latex documents.
        """
        if kwargs.get("dryrun", False):
            self._print_pgf_to_fh(None, *args, **kwargs)
            return

        # figure out where the pgf is to be written to
        if is_string_like(fname_or_fh):
            with codecs.open(fname_or_fh, "w", encoding="utf-8") as fh:
                self._print_pgf_to_fh(fh, *args, **kwargs)
        elif is_writable_file_like(fname_or_fh):
            fh = codecs.getwriter("utf-8")(fname_or_fh)
            self._print_pgf_to_fh(fh, *args, **kwargs)
        else:
            raise ValueError("filename must be a path")

    def _print_image(self, filename, format, *args, **kwargs):
        if self.flags() & gtk.REALIZED == 0:
            # for self.window(for pixmap) and has a side effect of altering
            # figure width,height (via configure-event?)
            gtk.DrawingArea.realize(self)

        width, height = self.get_width_height()
        pixmap = gdk.Pixmap(self.window, width, height)
        self._renderer.set_pixmap(pixmap)
        self._render_figure(pixmap, width, height)

        # jpg colors don't match the display very well, png colors match
        # better
        pixbuf = gdk.Pixbuf(gdk.COLORSPACE_RGB, 0, 8, width, height)
        pixbuf.get_from_drawable(pixmap, pixmap.get_colormap(), 0, 0, 0, 0, width, height)

        # set the default quality, if we are writing a JPEG.
        # http://www.pygtk.org/docs/pygtk/class-gdkpixbuf.html#method-gdkpixbuf--save
        options = cbook.restrict_dict(kwargs, ["quality"])
        if format in ["jpg", "jpeg"]:
            if "quality" not in options:
                options["quality"] = rcParams["savefig.jpeg_quality"]

            options["quality"] = str(options["quality"])

        if is_string_like(filename):
            try:
                pixbuf.save(filename, format, options=options)
            except gobject.GError as exc:
                error_msg_gtk("Save figure failure:\n%s" % (exc,), parent=self)
        elif is_writable_file_like(filename):
            if hasattr(pixbuf, "save_to_callback"):

                def save_callback(buf, data=None):
                    data.write(buf)

                try:
                    pixbuf.save_to_callback(save_callback, format, user_data=filename, options=options)
                except gobject.GError as exc:
                    error_msg_gtk("Save figure failure:\n%s" % (exc,), parent=self)
            else:
                raise ValueError("Saving to a Python file-like object is only supported by PyGTK >= 2.8")
        else:
            raise ValueError("filename must be a path or a file-like object")

    def print_pgf(self, fname_or_fh, *args, **kwargs):
        """
        Output pgf commands for drawing the figure so it can be included and
        rendered in latex documents.
        """
        if kwargs.get("dryrun", False):
            self._print_pgf_to_fh(None, *args, **kwargs)
            return

        # figure out where the pgf is to be written to
        if is_string_like(fname_or_fh):
            with codecs.open(fname_or_fh, "w", encoding="utf-8") as fh:
                self._print_pgf_to_fh(fh, *args, **kwargs)
        elif is_writable_file_like(fname_or_fh):
            if not os.path.exists(fname_or_fh.name):
                warnings.warn("streamed pgf-code does not support raster "
                              "graphics, consider using the pgf-to-pdf option",
                              UserWarning)
            self._print_pgf_to_fh(fname_or_fh, *args, **kwargs)
        else:
            raise ValueError("filename must be a path")

    def _print_figure(self, outfile, format, dpi=72, facecolor='w', edgecolor='w',
                      orientation='portrait', isLandscape=False, papertype=None):
        """
        Render the figure to hardcopy.  Set the figure patch face and
        edge colors.  This is useful because some of the GUIs have a
        gray figure face color background and you'll probably want to
        override this on hardcopy

        If outfile is a string, it is interpreted as a file name.
        If the extension matches .ep* write encapsulated postscript,
        otherwise write a stand-alone PostScript file.

        If outfile is a file object, a stand-alone PostScript file is
        written into this file object.
        """
        isEPSF = format == 'eps'
        passed_in_file_object = False
        if is_string_like(outfile):
            title = outfile
            tmpfile = os.path.join(gettempdir(), md5(outfile).hexdigest())
        elif is_writable_file_like(outfile):
            title = None
            tmpfile = os.path.join(gettempdir(), md5(str(hash(outfile))).hexdigest())
            passed_in_file_object = True
        else:
            raise ValueError("outfile must be a path or a file-like object")
        fh = file(tmpfile, 'w')

        # find the appropriate papertype
        width, height = self.figure.get_size_inches()
        if papertype == 'auto':
            if isLandscape: papertype = _get_papertype(height, width)
            else: papertype = _get_papertype(width, height)

        if isLandscape: paperHeight, paperWidth = papersize[papertype]
        else: paperWidth, paperHeight = papersize[papertype]

        if rcParams['ps.usedistiller'] and not papertype == 'auto':
            # distillers will improperly clip eps files if the pagesize is
            # too small
            if width>paperWidth or height>paperHeight:
                if isLandscape:
                    papertype = _get_papertype(height, width)
                    paperHeight, paperWidth = papersize[papertype]
                else:
                    papertype = _get_papertype(width, height)
                    paperWidth, paperHeight = papersize[papertype]

        # center the figure on the paper
        xo = 72*0.5*(paperWidth - width)
        yo = 72*0.5*(paperHeight - height)

        l, b, w, h = self.figure.bbox.bounds
        llx = xo
        lly = yo
        urx = llx + w
        ury = lly + h
        rotation = 0
        if isLandscape:
            llx, lly, urx, ury = lly, llx, ury, urx
            xo, yo = 72*paperHeight - yo, xo
            rotation = 90
        bbox = (llx, lly, urx, ury)

        # generate PostScript code for the figure and store it in a string
        origfacecolor = self.figure.get_facecolor()
        origedgecolor = self.figure.get_edgecolor()
        self.figure.set_facecolor(facecolor)
        self.figure.set_edgecolor(edgecolor)

        self._pswriter = StringIO()
        renderer = RendererPS(width, height, self._pswriter, imagedpi=dpi)
        self.figure.draw(renderer)

        self.figure.set_facecolor(origfacecolor)
        self.figure.set_edgecolor(origedgecolor)

        # write the PostScript headers
        if isEPSF: print >>fh, "%!PS-Adobe-3.0 EPSF-3.0"
        else: print >>fh, "%!PS-Adobe-3.0"
        if title: print >>fh, "%%Title: "+title
        print >>fh, ("%%Creator: matplotlib version "
                     +__version__+", http://matplotlib.sourceforge.net/")
        print >>fh, "%%CreationDate: "+time.ctime(time.time())
        print >>fh, "%%Orientation: " + orientation
        if not isEPSF: print >>fh, "%%DocumentPaperSizes: "+papertype
        print >>fh, "%%%%BoundingBox: %d %d %d %d" % bbox
        if not isEPSF: print >>fh, "%%Pages: 1"
        print >>fh, "%%EndComments"

        Ndict = len(psDefs)
        print >>fh, "%%BeginProlog"
        if not rcParams['ps.useafm']:
            Ndict += len(renderer.used_characters)
        print >>fh, "/mpldict %d dict def"%Ndict
        print >>fh, "mpldict begin"
        for d in psDefs:
            d=d.strip()
            for l in d.split('\n'):
                print >>fh, l.strip()
#.........这里部分代码省略.........