handle jpg/jpeg in the qtconsole.

This try to handle both image/jpeg image/jpg mimetype that arrives in
the qtconsole, when QImage support It,
note that image/jpg should never append, but is still supported.

It does not allows the export as html/jpeg. The jpeg will be converted
to png at save time.

IPython/frontend/qt/console/rich_ipython_widget.py

@@ -1,256 +1,301
+#-----------------------------------------------------------------------------
+# Copyright (c) 2010-2012, IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
 # Standard libary imports.
 from base64 import decodestring
 import os
 import re
 
 # System libary imports.
 from IPython.external.qt import QtCore, QtGui
 
 # Local imports
 from IPython.frontend.qt.svg import save_svg, svg_to_clipboard, svg_to_image
 from ipython_widget import IPythonWidget
 
 
 class RichIPythonWidget(IPythonWidget):
     """ An IPythonWidget that supports rich text, including lists, images, and
         tables. Note that raw performance will be reduced compared to the plain
         text version.
     """
 
     # RichIPythonWidget protected class variables.
     _payload_source_plot = 'IPython.zmq.pylab.backend_payload.add_plot_payload'
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
 
     def __init__(self, *args, **kw):
         """ Create a RichIPythonWidget.
         """
         kw['kind'] = 'rich'
         super(RichIPythonWidget, self).__init__(*args, **kw)
 
         # Configure the ConsoleWidget HTML exporter for our formats.
         self._html_exporter.image_tag = self._get_image_tag
 
         # Dictionary for resolving document resource names to SVG data.
         self._name_to_svg_map = {}
 
+        # Do we support jpg ?
+        # it seems that sometime jpg support is a plugin of QT, so try to assume
+        # it is not always supported.
+        self._supported_format = map(str,QtGui.QImageReader.supportedImageFormats())
+        self._jpg_supported = 'jpeg' in self._supported_format
+
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _context_menu_make(self, pos):
         """ Reimplemented to return a custom context menu for images.
         """
         format = self._control.cursorForPosition(pos).charFormat()
         name = format.stringProperty(QtGui.QTextFormat.ImageName)
         if name:
             menu = QtGui.QMenu()
 
             menu.addAction('Copy Image', lambda: self._copy_image(name))
             menu.addAction('Save Image As...', lambda: self._save_image(name))
             menu.addSeparator()
 
             svg = self._name_to_svg_map.get(name, None)
             if svg is not None:
                 menu.addSeparator()
                 menu.addAction('Copy SVG', lambda: svg_to_clipboard(svg))
                 menu.addAction('Save SVG As...',
                                lambda: save_svg(svg, self._control))
         else:
             menu = super(RichIPythonWidget, self)._context_menu_make(pos)
         return menu
 
     #---------------------------------------------------------------------------
     # 'BaseFrontendMixin' abstract interface
     #---------------------------------------------------------------------------
 
     def _handle_pyout(self, msg):
         """ Overridden to handle rich data types, like SVG.
         """
+        def pre_image_append():
+            self.log.debug("pyout: %s", msg.get('content', ''))
+            self._append_plain_text(self.output_sep, True)
+            self._append_html(self._make_out_prompt(prompt_number), True)
+            # This helps the output to look nice.
+            self._append_plain_text('\n', True)
+
         if not self._hidden and self._is_from_this_session(msg):
             content = msg['content']
             prompt_number = content['execution_count']
             data = content['data']
             if data.has_key('image/svg+xml'):
-                self.log.debug("pyout: %s", msg.get('content', ''))
-                self._append_plain_text(self.output_sep, True)
-                self._append_html(self._make_out_prompt(prompt_number), True)
+                pre_image_append()
                 self._append_svg(data['image/svg+xml'], True)
                 self._append_html(self.output_sep2, True)
             elif data.has_key('image/png'):
-                self.log.debug("pyout: %s", msg.get('content', ''))
-                self._append_plain_text(self.output_sep, True)
-                self._append_html(self._make_out_prompt(prompt_number), True)
-                # This helps the output to look nice.
-                self._append_plain_text('\n', True)
+                pre_image_append()
                 self._append_png(decodestring(data['image/png'].encode('ascii')), True)
                 self._append_html(self.output_sep2, True)
+            elif data.has_key('image/jpeg') and self._jpg_supported:
+                pre_image_append()
+                self._append_jpg(decodestring(data['image/jpeg'].encode('ascii')), True)
+                self._append_html(self.output_sep2, True)
+            # image/jpg should be an invalid mimetype, but python mimetype package
+            # handel it.
+            elif data.has_key('image/jpg') and self._jpg_supported:
+                pre_image_append()
+                self._append_jpg(decodestring(data['image/jpg'].encode('ascii')), True)
+                self._append_html(self.output_sep2, True)
             else:
                 # Default back to the plain text representation.
                 return super(RichIPythonWidget, self)._handle_pyout(msg)
 
     def _handle_display_data(self, msg):
         """ Overridden to handle rich data types, like SVG.
         """
         if not self._hidden and self._is_from_this_session(msg):
             source = msg['content']['source']
             data = msg['content']['data']
             metadata = msg['content']['metadata']
             # Try to use the svg or html representations.
             # FIXME: Is this the right ordering of things to try?
             if data.has_key('image/svg+xml'):
                 self.log.debug("display: %s", msg.get('content', ''))
                 svg = data['image/svg+xml']
                 self._append_svg(svg, True)
             elif data.has_key('image/png'):
                 self.log.debug("display: %s", msg.get('content', ''))
                 # PNG data is base64 encoded as it passes over the network
                 # in a JSON structure so we decode it.
                 png = decodestring(data['image/png'].encode('ascii'))
                 self._append_png(png, True)
+            elif data.has_key('image/jpeg') and self._jpg_supported:
+                self.log.debug("display: %s", msg.get('content', ''))
+                jpg = decodestring(data['image/jpeg'].encode('ascii'))
+                self._append_jpg(jpg, True)
+            elif data.has_key('image/jpg') and self._jpg_supported:
+                self.log.debug("display: %s", msg.get('content', ''))
+                jpg = decodestring(data['image/jpg'].encode('ascii'))
+                self._append_jpg(jpg, True)
             else:
                 # Default back to the plain text representation.
                 return super(RichIPythonWidget, self)._handle_display_data(msg)
 
     #---------------------------------------------------------------------------
     # 'RichIPythonWidget' protected interface
     #---------------------------------------------------------------------------
 
+    def _append_jpg(self, jpg, before_prompt=False):
+        """ Append raw JPG data to the widget."""
+        self._append_custom(self._insert_jpg, jpg, before_prompt)
+
     def _append_png(self, png, before_prompt=False):
         """ Append raw PNG data to the widget.
         """
         self._append_custom(self._insert_png, png, before_prompt)
 
     def _append_svg(self, svg, before_prompt=False):
         """ Append raw SVG data to the widget.
         """
         self._append_custom(self._insert_svg, svg, before_prompt)
 
     def _add_image(self, image):
         """ Adds the specified QImage to the document and returns a
             QTextImageFormat that references it.
         """
         document = self._control.document()
         name = str(image.cacheKey())
         document.addResource(QtGui.QTextDocument.ImageResource,
                              QtCore.QUrl(name), image)
         format = QtGui.QTextImageFormat()
         format.setName(name)
         return format
 
     def _copy_image(self, name):
         """ Copies the ImageResource with 'name' to the clipboard.
         """
         image = self._get_image(name)
         QtGui.QApplication.clipboard().setImage(image)
 
     def _get_image(self, name):
         """ Returns the QImage stored as the ImageResource with 'name'.
         """
         document = self._control.document()
         image = document.resource(QtGui.QTextDocument.ImageResource,
                                   QtCore.QUrl(name))
         return image
 
     def _get_image_tag(self, match, path = None, format = "png"):
         """ Return (X)HTML mark-up for the image-tag given by match.
 
         Parameters
         ----------
         match : re.SRE_Match
             A match to an HTML image tag as exported by Qt, with
             match.group("Name") containing the matched image ID.
 
         path : string|None, optional [default None]
             If not None, specifies a path to which supporting files may be
             written (e.g., for linked images).  If None, all images are to be
             included inline.
 
-        format : "png"|"svg", optional [default "png"]
+        format : "png"|"svg"|"jpg", optional [default "png"]
             Format for returned or referenced images.
         """
-        if format == "png":
+        if format in ("png","jpg"):
             try:
                 image = self._get_image(match.group("name"))
             except KeyError:
                 return "<b>Couldn't find image %s</b>" % match.group("name")
 
             if path is not None:
                 if not os.path.exists(path):
                     os.mkdir(path)
                 relpath = os.path.basename(path)
-                if image.save("%s/qt_img%s.png" % (path,match.group("name")),
+                if image.save("%s/qt_img%s.%s" % (path,match.group("name"),format),
                               "PNG"):
-                    return '<img src="%s/qt_img%s.png">' % (relpath,
-                                                            match.group("name"))
+                    return '<img src="%s/qt_img%s.%s">' % (relpath,
+                                                            match.group("name"),format)
                 else:
                     return "<b>Couldn't save image!</b>"
             else:
                 ba = QtCore.QByteArray()
                 buffer_ = QtCore.QBuffer(ba)
                 buffer_.open(QtCore.QIODevice.WriteOnly)
-                image.save(buffer_, "PNG")
+                image.save(buffer_, format.upper())
                 buffer_.close()
-                return '<img src="data:image/png;base64,\n%s\n" />' % (
-                    re.sub(r'(.{60})',r'\1\n',str(ba.toBase64())))
+                return '<img src="data:image/%s;base64,\n%s\n" />' % (
+                    format,re.sub(r'(.{60})',r'\1\n',str(ba.toBase64())))
 
         elif format == "svg":
             try:
                 svg = str(self._name_to_svg_map[match.group("name")])
             except KeyError:
                 return "<b>Couldn't find image %s</b>" % match.group("name")
 
             # Not currently checking path, because it's tricky to find a
             # cross-browser way to embed external SVG images (e.g., via
             # object or embed tags).
 
             # Chop stand-alone header from matplotlib SVG
             offset = svg.find("<svg")
             assert(offset > -1)
 
             return svg[offset:]
 
         else:
             return '<b>Unrecognized image format</b>'
 
+    def _insert_jpg(self, cursor, jpg):
+        """ Insert raw PNG data into the widget."""
+        self._insert_img(cursor, jpg, 'jpg')
+
     def _insert_png(self, cursor, png):
         """ Insert raw PNG data into the widget.
         """
+        self._insert_img(cursor, png, 'png')
+
+    def _insert_img(self, cursor, img, fmt):
+        """ insert a raw image, jpg or png """
         try:
             image = QtGui.QImage()
-            image.loadFromData(png, 'PNG')
+            image.loadFromData(img, fmt.upper())
         except ValueError:
-            self._insert_plain_text(cursor, 'Received invalid PNG data.')
+            self._insert_plain_text(cursor, 'Received invalid %s data.'%fmt)
         else:
             format = self._add_image(image)
             cursor.insertBlock()
             cursor.insertImage(format)
             cursor.insertBlock()
 
     def _insert_svg(self, cursor, svg):
         """ Insert raw SVG data into the widet.
         """
         try:
             image = svg_to_image(svg)
         except ValueError:
             self._insert_plain_text(cursor, 'Received invalid SVG data.')
         else:
             format = self._add_image(image)
             self._name_to_svg_map[format.name()] = svg
             cursor.insertBlock()
             cursor.insertImage(format)
             cursor.insertBlock()
 
     def _save_image(self, name, format='PNG'):
         """ Shows a save dialog for the ImageResource with 'name'.
         """
         dialog = QtGui.QFileDialog(self._control, 'Save Image')
         dialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
         dialog.setDefaultSuffix(format.lower())
         dialog.setNameFilter('%s file (*.%s)' % (format, format.lower()))
         if dialog.exec_():
             filename = dialog.selectedFiles()[0]
             image = self._get_image(name)
             image.save(filename, format)