コード例 #1
0
    def __activate_set_data_cb(self, column, cell, model, tree_iter, data):

        # DOUBT: Currently I'm showing the a green icon when the font is active
        # and a red icon when its deactivated so I'm using the this cell as a
        # status indicator rather than a button with when shows a green tick
        # sign means the cell will be activated if the button is clicked -
        # is this setting correct?

        # FIXME: add tooltips here to that the user what icons mean what

        is_activated = model[tree_iter][ListModel.COLUMN_ACTIVATE]

        if is_activated == 1:
            loader = GdkPixbuf.PixbufLoader()
            loader.write(localIcon.activate.encode())
            loader.close()
            cell.props.pixbuf = loader.get_pixbuf()

        elif is_activated == 0:
            loader = GdkPixbuf.PixbufLoader()
            loader.write(localIcon.deactivate.encode())
            loader.close()
            cell.props.pixbuf = loader.get_pixbuf()

        else:
            loader = GdkPixbuf.PixbufLoader()
            loader.write(localIcon.lock.encode())
            loader.close()
            cell.props.pixbuf = loader.get_pixbuf()
コード例 #2
0
 def __favorite_set_data_cb(self, column, cell, model, tree_iter, data):
     font_name = model[tree_iter][ListModel.COLUMN_FONT_NAME]
     favorite = font_name in fav_fonts
     if favorite:
         loader = GdkPixbuf.PixbufLoader()
         loader.write(svg_active.encode())
         loader.close()
         cell.props.pixbuf = loader.get_pixbuf()
     else:
         loader = GdkPixbuf.PixbufLoader()
         loader.write(svg_inactive.encode())
         loader.close()
         cell.props.pixbuf = loader.get_pixbuf()
コード例 #3
0
def pixbuf_from_data(data, size=None, keep_ratio=True, upscale=False):
    """
        Generates a pixbuf from arbitrary image data

        :param data: The raw image data
        :type data: byte
        :param size: Size to scale to; if not specified,
            the image will render to its native size
        :type size: tuple of int
        :param keep_ratio: Whether to keep the original
            image ratio on resizing operations
        :type keep_ratio: bool
        :param upscale: Whether to upscale if the requested
            size exceeds the native size
        :type upscale: bool

        :returns: the generated pixbuf
        :rtype: :class:`GdkPixbuf.Pixbuf` or None
    """
    if not data:
        return None

    pixbuf = None
    loader = GdkPixbuf.PixbufLoader()

    if size is not None:

        def on_size_prepared(loader, width, height):
            """
                Keeps the ratio if requested
            """
            if keep_ratio:
                scale = min(size[0] / float(width), size[1] / float(height))

                if scale > 1.0 and upscale:
                    width = int(width * scale)
                    height = int(height * scale)
                elif scale <= 1.0:
                    width = int(width * scale)
                    height = int(height * scale)
            else:
                if upscale:
                    width, height = size
                else:
                    width = height = max(width, height)

            loader.set_size(width, height)

        loader.connect('size-prepared', on_size_prepared)

    try:
        loader.write(data)
        loader.close()
    except GLib.GError as e:
        logger.warning(
            'Failed to get pixbuf from data: {error}'.format(error=e.message))
    else:
        pixbuf = loader.get_pixbuf()

    return pixbuf
コード例 #4
0
ファイル: engine.py プロジェクト: Codified-Vexing/Perphona
    def show(self):
        # Only load the pictures if it hasn't already. Ie.: the number of pics in metadata is different from those loaded.

        if not hasattr(self.raw_meta, 'pictures'):
            return False

        if len(self.raw_meta.pictures) != len(self.meta["pics"]):
            art_type = [
                "Other", "File Icon", "Alternate File Icon", "Front Cover",
                "Back Cover", "Leaflet Page", "Media Label", "Lead Author",
                "Author", "Conductor", "Band", "Composer", "Lyrics Writer",
                "Recording Location", "During Perfomance", "Screen Capture",
                "Fish", "Band Logo", "Publisher Logo"
            ]

            if len(self.raw_meta.pictures) >= 1:
                for each in self.raw_meta.pictures:
                    pixloader = gpix.PixbufLoader()
                    pixloader.write(each.data)
                    pixloader.close()
                    self.meta["pics"][art_type[
                        each.type]] = pixloader.get_pixbuf()
                    if each.type in (3, 2,
                                     1) or self.meta["thumbnail"] == None:
                        self.meta["thumbnail"] = pixloader.get_pixbuf(
                        ).scale_simple(30, 30, gpix.InterpType.BILINEAR)
コード例 #5
0
 def get_pixbuf_from_buffer(self, image_buffer):
     """Buffer To Pixbuf"""
     pixbuf_loader = GdkPixbuf.PixbufLoader()
     pixbuf_loader.write(image_buffer)
     pixbuf_loader.close()
     pixbuf = pixbuf_loader.get_pixbuf()
     return pixbuf
コード例 #6
0
def _data2pixbuf(data, width=None, height=None):
    loader = GdkPixbuf.PixbufLoader()
    if width and height:
        loader.set_size(width, height)
    loader.write(data)
    loader.close()
    return loader.get_pixbuf()
コード例 #7
0
    def __init__(self):
        Gtk.Window.__init__(self, title="CellRendererPixbuf Example")

        self.set_default_size(200, 200)

        self.liststore = Gtk.ListStore(str, str)
        self.liststore.append(["New", "document-new"])
        self.liststore.append(["Open", "document-open"])
        self.liststore.append(["Save", "document-save"])

        treeview = Gtk.TreeView(model=self.liststore)

        renderer_text = Gtk.CellRendererText()
        column_text = Gtk.TreeViewColumn("Text", renderer_text, text=0)
        treeview.append_column(column_text)

        renderer_pixbuf = Gtk.CellRendererPixbuf()

        loader = GdkPixbuf.PixbufLoader()
        loader.write(svg.encode())
        loader.close()
        renderer_pixbuf.props.pixbuf = loader.get_pixbuf()
        column_pixbuf = Gtk.TreeViewColumn("Image", renderer_pixbuf)
        treeview.append_column(column_pixbuf)

        self.add(treeview)
コード例 #8
0
def load_from_stream(fp, progress=None):
    """Load a pixbuf from an open file-like object

    :param fp: file-like object opened for reading
    :param progress: Provides UI feedback. Must be sized (expected bytes).
    :type progress: lib.feedback.Progress or None
    :rtype: GdkPixbuf.Pixbuf
    :returns: the loaded pixbuf

    >>> with open("pixmaps/mypaint_logo.png", "rb") as fp:
    ...     p = load_from_stream(fp)
    >>> isinstance(p, GdkPixbuf.Pixbuf)
    True

    If a progress feedback object is specified, its `items` field must
    have been pre-filled with the number of bytes expected before
    fp.read() returns an empty string.

    """
    if progress and (progress.items is None):
        raise ValueError("progress argument must be sized if specified")

    loader = GdkPixbuf.PixbufLoader()
    while True:
        buf = fp.read(LOAD_CHUNK_SIZE)
        if buf == '':
            break
        loader.write(buf)
        if progress is not None:
            progress += len(buf)
    loader.close()
    return loader.get_pixbuf()
コード例 #9
0
ファイル: gtkgui_helpers.py プロジェクト: shubham2110/gajim1
def get_pixbuf_from_data(file_data):
    """
    Get image data and returns GdkPixbuf.Pixbuf
    """
    pixbufloader = GdkPixbuf.PixbufLoader()
    try:
        pixbufloader.write(file_data)
        pixbufloader.close()
        pixbuf = pixbufloader.get_pixbuf()
    except GLib.GError:
        pixbufloader.close()

        log.warning('loading avatar using pixbufloader failed, trying to '
                    'convert avatar image using pillow')
        try:
            avatar = Image.open(BytesIO(file_data)).convert("RGBA")
            array = GLib.Bytes.new(avatar.tobytes())
            width, height = avatar.size
            pixbuf = GdkPixbuf.Pixbuf.new_from_bytes(array,
                                                     GdkPixbuf.Colorspace.RGB,
                                                     True, 8, width, height,
                                                     width * 4)
        except Exception:
            log.warning(
                'Could not use pillow to convert avatar image, '
                'image cannot be displayed',
                exc_info=True)
            return

    return pixbuf
コード例 #10
0
ファイル: event_stream.py プロジェクト: Lyude/gtk-pushbullet
    def __init__(self, push, pushbullet):
        self.pushbullet = pushbullet
        self.notification = Notify.Notification.new(push["title"], push["body"])

        self.notification_id  = push["notification_id"]
        self.package_name     = push["package_name"]
        self.source_user_iden = push["source_user_iden"]

        if "notification_tag" in push:
            self.notification_tag = push["notification_tag"]
        else:
            self.notification_tag = None

        if push["icon"] is not None:
            pbl = GdkPixbuf.PixbufLoader()
            pbl.write(bytes(b64decode(push["icon"])))
            pbl.close()

            self.notification.set_icon_from_pixbuf(pbl.get_pixbuf())

        if push["dismissible"] == True:
            self.__dismiss_cb_id = self.notification.connect_after("closed", self.__dismiss_cb)

        self.notification.set_timeout(0)
        self.notification.set_urgency(Notify.Urgency.LOW)
        self.notification.show()
コード例 #11
0
 def run(self):
     try:
         response = requests.get(self.url)
         if response.status_code == 200:
             loader = GdkPixbuf.PixbufLoader()
             loader.write(response.content)
             loader.close()
             pixbuf = loader.get_pixbuf()
             height = pixbuf.get_height() * self.scale / 100.0
             width = pixbuf.get_width() * self.scale / 100.0
             scaled_buf = pixbuf.scale_simple(
                 width, height, GdkPixbuf.InterpType.BILINEAR)
             if scaled_buf:
                 surface = cairo.ImageSurface(
                     cairo.FORMAT_ARGB32,
                     scaled_buf.get_width(),
                     scaled_buf.get_height())
                 context = cairo.Context(surface)
                 Gdk.cairo_set_source_pixbuf(context, scaled_buf, 0, 0)
                 context.paint()
                 self.emit('downloaded', True, surface, width, height)
                 return
     except Exception as e:
         print(e)
     self.emit('downloaded', False, None, -1, -1)
     return
コード例 #12
0
ファイル: geticon.py プロジェクト: anilcorekci/Oynatici
    def get_pixbuf(self, image, shape="cover"):
        """get_pixbuf _ dosya yolu , maske
        PIL ile maske ile yeni bir pixbuf gönder"""

        iconPath = image
        highlight = Image.open('simgeler/%s.png' % shape)
        mask = Image.open('simgeler/%s-mask.png' % shape)
        icon = Image.open(iconPath).convert('RGBA')  #.rotate(-6)
        button = Image.new('RGBA', mask.size)
        icon = ImageOps.fit(icon,
                            highlight.size,
                            method=Image.ANTIALIAS,
                            centering=(0.5, 0))
        helper = button.copy()
        helper.paste(icon, mask=mask)
        button.paste((255, 255, 255), mask=mask)
        icon = icon.convert('RGB')
        button.paste(icon, mask=helper)
        overlay = highlight.copy().convert('RGB')
        button.paste(overlay, mask=highlight)
        file1 = StringIO.StringIO()
        button.save(file1, "png")
        contents = file1.getvalue()
        file1.close()
        loader = gdkpixbuf.PixbufLoader()
        loader.set_size(80, 80)
        loader.write(contents)
        pixbuf = loader.get_pixbuf()

        loader.close()
        return pixbuf
コード例 #13
0
ファイル: tagger.py プロジェクト: Tubbz-alt/gnome-tagger
    def set_package_info(self, name, summary, tags, icon_url):
        """ Set the package information into the GUI.
        """
        self.pkgname = name

        image = self.builder.get_object('image_pkg')
        try:
            response = urllib2.urlopen(icon_url)
        except:
            response = urllib2.urlopen('https://apps.fedoraproject.org/'
                                       'packages/images/icons/'
                                       'package_128x128.png')
        loader = GdkPixbuf.PixbufLoader()
        loader.write(response.read())
        image.set_from_pixbuf(loader.get_pixbuf())
        loader.close()

        label = self.builder.get_object('label_pkg')
        label.set_text('<b>%s</b>\n%s' % (name, summary or ''))
        label.set_use_markup(True)

        treeview = self.builder.get_object('treeview1')
        liststore = Gtk.ListStore(str)
        for tag in tags:
            liststore.append([tag])
        treeview.set_model(liststore)
コード例 #14
0
 def specDone(self, fd, x):
     with os.fdopen(fd, "rb") as spec:
         loader = GdkPixbuf.PixbufLoader()
         loader.write(spec.read())
         loader.close()
         self.spec_image.set_from_pixbuf(loader.get_pixbuf())
         self.spec_image.show()
コード例 #15
0
    def create_preview(self, object_id):
        jobject = datastore.get(object_id)

        if 'preview' in jobject.metadata:
            preview = jobject.metadata['preview']
            if preview is None or preview == '' or preview == 'None':
                if jobject.metadata['mime_type'] .startswith('image/') and \
                    jobject.metadata['mime_type'] != 'image/vnd.djvu':
                    filename = jobject.get_file_path()
                    self.show_image(filename)
                    return
                if jobject.metadata['mime_type'] == 'application/x-cbz':
                    filename = jobject.get_file_path()
                    fname = self.extract_image(filename)
                    self.show_image(fname)
                    os.remove(fname)
                    return
                self.show_image('xoimage.jpg')
                return

        if 'preview' in jobject.metadata and \
                len(jobject.metadata['preview']) > 4:
            preview_data = jobject.metadata['preview']
            loader = GdkPixbuf.PixbufLoader()
            loader.write(preview_data)
            scaled_buf = loader.get_pixbuf()
            loader.close()
            self.image.set_from_pixbuf(scaled_buf)
            self.image.show()
        else:
            self.image.clear()
            self.image.show()
コード例 #16
0
    def test(format_, data, gdi=False, skip_filename_load=False):
        print(format_)
        loader = GdkPixbuf.PixbufLoader()
        loader.write(data)
        loader.close()
        assert loader.get_format().get_name() == format_
        assert loader.get_pixbuf()
        # this is the only place I found where the gdi info leaks in the api
        assert ("Gdip" in loader.get_animation().__gtype__.name) == gdi

        if not skip_filename_load:
            # add some unicode to test if filenames are handled properly
            fd, fn = tempfile.mkstemp(suffix="😃ÿ")
            os.close(fd)
            try:
                with open(fn, "wb") as h:
                    h.write(data)

                f, w, h = GdkPixbuf.Pixbuf.get_file_info(fn)
                assert f.get_name() == format_

                pb = GdkPixbuf.Pixbuf.new_from_file(fn)
                assert pb
            finally:
                os.remove(fn)

        formats_tested.append(format_)
コード例 #17
0
ファイル: main.py プロジェクト: dphoyes/phototimeshift
        async def update_thumbnail(filepath):
            self.widgets.image_preview.set_opacity(0.5)

            try:
                pbl = GdkPixbuf.PixbufLoader()
                try:
                    async with self.open_thumbnail_image_of(filepath) as f:
                        while True:
                            data = await f.read(65536)
                            if len(data) == 0:
                                break
                            pbl.write(data)
                finally:
                    pbl.close()
                pixbuf = pbl.get_pixbuf()
            except Exception as e:
                self.widgets.image_preview.set_from_icon_name("gtk-missing-image", Gtk.IconSize.DIALOG)
            else:
                allocation = self.widgets.image_preview.get_parent().get_allocation()
                allocation_ratio = allocation.height/allocation.width
                image_ratio = pixbuf.props.height/pixbuf.props.width

                if image_ratio < allocation_ratio:
                    new_width = allocation.width
                    new_height = int(new_width * image_ratio)
                else:
                    new_height = allocation.height
                    new_width = int(new_height / image_ratio)

                pixbuf = pixbuf.scale_simple(new_width, new_height, GdkPixbuf.InterpType.BILINEAR)
                self.widgets.image_preview.set_from_pixbuf(pixbuf)
                self.widgets.image_preview.set_opacity(1)
コード例 #18
0
def get_thumbnail_from_file(fileobj, boundary):
    """Like get_thumbnail() but works with files that can't be reopened.

    This is needed on Windows where NamedTemporaryFile can't be reopened.

    Can raise GLib.GError or return None.
    """

    assert fileobj

    try:
        return get_thumbnail(fileobj.name, boundary)
    except GLib.GError:
        try:
            loader = GdkPixbuf.PixbufLoader()
            loader.write(fileobj.read())
            loader.close()
            fileobj.seek(0, 0)
            # can return None in case of partial data
            pixbuf = loader.get_pixbuf()
        except EnvironmentError:
            pass
        else:
            if pixbuf is not None:
                return scale(pixbuf, boundary)
コード例 #19
0
 def get_image_pixbuf(self, image=None):
     url = self.get_image_url(image)
     r = requests.get(url)
     loader = GdkPixbuf.PixbufLoader()
     loader.write(r.content)
     loader.close()
     return loader.get_pixbuf()
コード例 #20
0
            def asyncload():

                loader = GdkPixbuf.PixbufLoader()

                #these need to be stored separate from the self versions to prevent race conditions in cache
                path, name, buff = loadWithProgress(url, loadbar)
                (self.path, self.name) = (path, name)
                loader.write(buff)
                loader.close()

                #self.name=source.info().get_filename()
                #print("got filename: ", self.name)

                self.buf = loader.get_animation()
                self.iter = self.buf.get_iter()

                def finish():
                    self.media.set_from_animation(self.buf)
                    self.progressbox.remove(loadbar)
                    self.enableDrag()
                    self.generateDrag()
                    return False

                GObject.idle_add(finish)

                #flush to disk in background
                with open(path, 'wb+') as f:
                    f.write(buff)
                    imgcache[url] = path
コード例 #21
0
def bytes2pixbuf(data,
                 width=icon_size['width'],
                 height=icon_size['height'],
                 display_name=None):
    """
    converts raw bytes into a GTK PixBug

    args:
        data (bytes): raw bytes
        width (int): width of image
        height (int): height of images

    returns:
        GtkPixbuf: a GTK Pixbuf

    """
    loader = GdkPixbuf.PixbufLoader()
    loader.set_size(width, height)
    try:
        loader.write(data)
        loader.close()
    except GLib.Error as e:
        logger.error("can't process icon for {}: {}".format(
            display_name, str(e)))
    else:
        return loader.get_pixbuf()
コード例 #22
0
ファイル: game.py プロジェクト: ndefilippis/recall
def svg_str_to_pixbuf(svg_string):
    """ Load pixbuf from SVG string """
    pl = GdkPixbuf.PixbufLoader('svg')
    pl.write(svg_string)
    pl.close()
    pixbuf = pl.get_pixbuf()
    return pixbuf
コード例 #23
0
def cairo_surface_to_pixbuf(s):
    """
    Converts a Cairo surface to a Gtk Pixbuf by
    encoding it as PNG and using the PixbufLoader.
    """
    bio = io.BytesIO()
    try:
        s.write_to_png(bio)
    except:
        # Write an empty PNG file to the StringIO, so
        # in case of an error we have "something" to
        # load. This happens in PyCairo < 1.1.6, see:
        # http://webcvs.cairographics.org/pycairo/NEWS?view=markup
        # Thanks to Chris Arnold for reporting this bug
        bio.write('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4'
                  'c6QAAAAZiS0dEAP8A\n/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAA'
                  'AAd0SU1FB9cMEQkqIyxn3RkAAAAZdEVYdENv\nbW1lbnQAQ3JlYXRlZCB3a'
                  'XRoIEdJTVBXgQ4XAAAADUlEQVQI12NgYGBgAAAABQABXvMqOgAAAABJ\nRU'
                  '5ErkJggg==\n'.decode('base64'))

    pbl = GdkPixbuf.PixbufLoader()
    pbl.write(bio.getvalue())
    pbl.close()

    pixbuf = pbl.get_pixbuf()
    return pixbuf
コード例 #24
0
ファイル: utils.py プロジェクト: cemeiq/maps-activity
def get_pixbuf_from_string(str):
    pbl = GdkPixbuf.PixbufLoader()
    data = base64.b64decode(str)
    pbl.write(data)
    pbl.close()

    return pbl.get_pixbuf()
コード例 #25
0
        def get_album_art(url, tmpdir, *extra):
            try:
                with urllib.request.urlopen(url) as f:
                    image = f.read()
            except urllib.error.HTTPError:
                logging.warning('Invalid image url received')
                return (
                    None,
                    None,
                ) + extra

            file_url = None
            if tmpdir:
                try:
                    with tempfile.NamedTemporaryFile(prefix='art-',
                                                     dir=tmpdir.name,
                                                     delete=False) as f:
                        f.write(image)
                        file_url = urllib.parse.urljoin(
                            'file://', urllib.parse.quote(f.name))
                except IOError:
                    logging.warning("Failed to write art tempfile")

            with contextlib.closing(GdkPixbuf.PixbufLoader()) as loader:
                loader.set_size(ALBUM_ART_SIZE, ALBUM_ART_SIZE)
                loader.write(image)
            return (
                loader.get_pixbuf(),
                file_url,
            ) + extra
コード例 #26
0
 def load_icon_cache_zip(zip_path):
     """ Load icon cache from zipped archive
     :param zip_path: Full path of the zip archive
     :return: Dict with icon names and Gdkpixbuf object
     """
     with ZipFile(zip_path, 'r') as archive:
         icon_path = os.path.join('cv_gtk3', 'resources', 'mana')
         files = [
             path for path in archive.namelist()
             if os.path.isfile(path.startswith(icon_path))
         ]
         icons = {}
         for file in files:
             with archive.open(file) as data:
                 try:
                     loader = GdkPixbuf.PixbufLoader()
                     loader.write(data.read())
                     pixbuf = loader.get_pixbuf()
                     loader.close()
                     # Strip filename extension
                     icon_name = os.path.splitext(file)[0]
                     icons[icon_name] = pixbuf
                 except Exception as ex:
                     print(
                         'Error while loading icon file "{0}"\n{1}'.format(
                             file, ex))
         return icons
コード例 #27
0
def get_thumbnail_from_file(fileobj, boundary):
    """Like get_thumbnail() but works with files that can't be reopened.

    This is needed on Windows where NamedTemporaryFile can't be reopened.

    Returns Pixbuf or None. Thread-safe.
    """

    assert fileobj

    try:
        path = fileobj.name
        assert is_fsnative(path), path
        return get_thumbnail(path, boundary)
    except GLib.GError:
        try:
            loader = GdkPixbuf.PixbufLoader()
            loader.set_size(*boundary)
            loader.write(fileobj.read())
            loader.close()
            fileobj.seek(0, 0)
            # can return None in case of partial data
            return loader.get_pixbuf()
        except (GLib.GError, EnvironmentError):
            pass
コード例 #28
0
 def new_popup(self,
               nid,
               summary,
               body,
               actions,
               icon,
               timeout=10 * 1000,
               show_timeout=False):
     """Create a new Popup instance."""
     if len(self._notify_stack) == self.max_popups:
         oldest = self._notify_stack[0]
         oldest.hide_notification()
         self.popup_closed(oldest.nid, 4)
     image = None
     if icon and icon[0] == "png":
         img_data = icon[3]
         loader = GdkPixbuf.PixbufLoader()
         loader.write(img_data)
         loader.close()
         image = loader.get_pixbuf()
     popup = Popup(self,
                   nid,
                   summary,
                   body,
                   actions,
                   image=image,
                   timeout=timeout // 1000,
                   show_timeout=show_timeout)
     self._notify_stack.append(popup)
     self._offset += self._notify_stack[-1].h
     return popup
コード例 #29
0
def svg_str_to_pixbuf(svg_string):
    ''' Load pixbuf from SVG string '''
    pl = GdkPixbuf.PixbufLoader()
    pl.write(svg_string)
    pl.close()
    pixbuf = pl.get_pixbuf()
    return pixbuf
コード例 #30
0
def ora_thumbnail(infile, outfile, size):
    """Extracts an OpenRaster file's thumbnail to PNG, with scaling."""

    # Extract a GdkPixbuf from the OpenRaster file
    with zipfile.ZipFile(infile) as zf:
        png_data = zf.read('Thumbnails/thumbnail.png')
    loader = GdkPixbuf.PixbufLoader()
    loader.write(png_data)
    loader.close()
    pixbuf = loader.get_pixbuf()

    # Scale if needed
    orig_w = pixbuf.get_width()
    orig_h = pixbuf.get_height()
    if orig_w > size or orig_h > size:
        scale_factor = float(size) / max(orig_w, orig_h)
        new_w = int(orig_w * scale_factor)
        new_h = int(orig_h * scale_factor)
        pixbuf = pixbuf.scale_simple(
            new_w,
            new_h,
            GdkPixbuf.InterpType.BILINEAR,
        )

    # Save. The output file is a temporary one created by
    # GNOME::ThumbnailFactory, which overwrites any options we add
    # with its own Thumb::MTime and Thumb::URI.
    pixbuf.savev(outfile, "png", [], [])