feat: add various system and theme icons, configuration files, and support assets

squashfs-root/usr/lib/python3/dist-packages/pygtkcompat/__init__.py

@@ -0,0 +1,20 @@
+
+# pyflakes.ignore
+from .pygtkcompat import (enable,
+                          enable_gtk,
+                          enable_vte,
+                          enable_poppler,
+                          enable_webkit,
+                          enable_gudev,
+                          enable_gst,
+                          enable_goocanvas)
+
+
+__all__ = ['enable',
+           'enable_gtk',
+           'enable_vte',
+           'enable_poppler',
+           'enable_webkit',
+           'enable_gudev',
+           'enable_gst',
+           'enable_goocanvas']

squashfs-root/usr/lib/python3/dist-packages/pygtkcompat/generictreemodel.py

@@ -0,0 +1,426 @@
+# -*- Mode: Python; py-indent-offset: 4 -*-
+# generictreemodel - GenericTreeModel implementation for pygtk compatibility.
+# Copyright (C) 2013 Simon Feltman
+#
+#   generictreemodel.py: GenericTreeModel implementation for pygtk compatibility
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, see <http://www.gnu.org/licenses/>.
+
+
+# System
+import sys
+import random
+import collections
+import ctypes
+import platform
+import warnings
+
+# GObject
+import gi
+from gi.repository import GObject
+from gi.repository import Gtk
+
+
+class _CTreeIter(ctypes.Structure):
+    _fields_ = [('stamp', ctypes.c_int),
+                ('user_data', ctypes.c_void_p),
+                ('user_data2', ctypes.c_void_p),
+                ('user_data3', ctypes.c_void_p)]
+
+    @classmethod
+    def from_iter(cls, iter):
+        offset = sys.getsizeof(object())  # size of PyObject_HEAD
+        return ctypes.POINTER(cls).from_address(id(iter) + offset)
+
+
+if platform.python_implementation() == "PyPy":
+    def _get_user_data_as_pyobject(iter):
+        raise NotImplementedError("Not yet supported under PyPy")
+else:
+    def _get_user_data_as_pyobject(iter):
+        citer = _CTreeIter.from_iter(iter)
+        return ctypes.cast(citer.contents.user_data, ctypes.py_object).value
+
+
+def handle_exception(default_return):
+    """Returns a function which can act as a decorator for wrapping exceptions and
+    returning "default_return" upon an exception being thrown.
+
+    This is used to wrap Gtk.TreeModel "do_" method implementations so we can return
+    a proper value from the override upon an exception occurring with client code
+    implemented by the "on_" methods.
+    """
+    def decorator(func):
+        def wrapped_func(*args, **kargs):
+            try:
+                return func(*args, **kargs)
+            except:
+                # Use excepthook directly to avoid any printing to the screen
+                # if someone installed an except hook.
+                sys.excepthook(*sys.exc_info())
+            return default_return
+        return wrapped_func
+    return decorator
+
+
+class GenericTreeModel(GObject.GObject, Gtk.TreeModel):
+    """A base implementation of a Gtk.TreeModel for python.
+
+    The GenericTreeModel eases implementing the Gtk.TreeModel interface in Python.
+    The class can be subclassed to provide a TreeModel implementation which works
+    directly with Python objects instead of iterators.
+
+    All of the on_* methods should be overridden by subclasses to provide the
+    underlying implementation a way to access custom model data. For the purposes of
+    this API, all custom model data supplied or handed back through the overridable
+    API will use the argument names: node, parent, and child in regards to user data
+    python objects.
+
+    The create_tree_iter, set_user_data, invalidate_iters, iter_is_valid methods are
+    available to help manage Gtk.TreeIter objects and their Python object references.
+
+    GenericTreeModel manages a pool of user data nodes that have been used with iters.
+    This pool stores a references to user data nodes as a dictionary value with the
+    key being the integer id of the data. This id is what the Gtk.TreeIter objects
+    use to reference data in the pool.
+    References will be removed from the pool when the model is deleted or explicitly
+    by using the optional "node" argument to the "row_deleted" method when notifying
+    the model of row deletion.
+    """
+
+    leak_references = GObject.Property(default=True, type=bool,
+                                       blurb="If True, strong references to user data attached to iters are "
+                                       "stored in a dictionary pool (default). Otherwise the user data is "
+                                       "stored as a raw pointer to a python object without a reference.")
+
+    #
+    # Methods
+    #
+    def __init__(self):
+        """Initialize. Make sure to call this from derived classes if overridden."""
+        warnings.warn("pygtkcompat is deprecated, see https://gnome.pages.gitlab.gnome.org/pygobject for migration instructions", gi.PyGIDeprecationWarning)
+        super(GenericTreeModel, self).__init__()
+        self.stamp = 0
+
+        #: Dictionary of (id(user_data): user_data), used when leak-refernces=False
+        self._held_refs = dict()
+
+        # Set initial stamp
+        self.invalidate_iters()
+
+    def iter_depth_first(self):
+        """Depth-first iteration of the entire TreeModel yielding the python nodes."""
+        stack = collections.deque([None])
+        while stack:
+            it = stack.popleft()
+            if it is not None:
+                yield self.get_user_data(it)
+            children = [self.iter_nth_child(it, i) for i in range(self.iter_n_children(it))]
+            stack.extendleft(reversed(children))
+
+    def invalidate_iter(self, iter):
+        """Clear user data and its reference from the iter and this model."""
+        iter.stamp = 0
+        if iter.user_data:
+            if iter.user_data in self._held_refs:
+                del self._held_refs[iter.user_data]
+            iter.user_data = None
+
+    def invalidate_iters(self):
+        """
+        This method invalidates all TreeIter objects associated with this custom tree model
+        and frees their locally pooled references.
+        """
+        self.stamp = random.randint(-2147483648, 2147483647)
+        self._held_refs.clear()
+
+    def iter_is_valid(self, iter):
+        """
+        :Returns:
+            True if the gtk.TreeIter specified by iter is valid for the custom tree model.
+        """
+        return iter.stamp == self.stamp
+
+    def get_user_data(self, iter):
+        """Get the user_data associated with the given TreeIter.
+
+        GenericTreeModel stores arbitrary Python objects mapped to instances of Gtk.TreeIter.
+        This method allows to retrieve the Python object held by the given iterator.
+        """
+        if self.leak_references:
+            return self._held_refs[iter.user_data]
+        else:
+            return _get_user_data_as_pyobject(iter)
+
+    def set_user_data(self, iter, user_data):
+        """Applies user_data and stamp to the given iter.
+
+        If the models "leak_references" property is set, a reference to the
+        user_data is stored with the model to ensure we don't run into bad
+        memory problems with the TreeIter.
+        """
+        iter.user_data = id(user_data)
+
+        if user_data is None:
+            self.invalidate_iter(iter)
+        else:
+            iter.stamp = self.stamp
+            if self.leak_references:
+                self._held_refs[iter.user_data] = user_data
+
+    def create_tree_iter(self, user_data):
+        """Create a Gtk.TreeIter instance with the given user_data specific for this model.
+
+        Use this method to create Gtk.TreeIter instance instead of directly calling
+        Gtk.Treeiter(), this will ensure proper reference managment of wrapped used_data.
+        """
+        iter = Gtk.TreeIter()
+        self.set_user_data(iter, user_data)
+        return iter
+
+    def _create_tree_iter(self, data):
+        """Internal creation of a (bool, TreeIter) pair for returning directly
+        back to the view interfacing with this model."""
+        if data is None:
+            return (False, None)
+        else:
+            it = self.create_tree_iter(data)
+            return (True, it)
+
+    def row_deleted(self, path, node=None):
+        """Notify the model a row has been deleted.
+
+        Use the node parameter to ensure the user_data reference associated
+        with the path is properly freed by this model.
+
+        :Parameters:
+            path : Gtk.TreePath
+                Path to the row that has been deleted.
+            node : object
+                Python object used as the node returned from "on_get_iter". This is
+                optional but ensures the model will not leak references to this object.
+        """
+        super(GenericTreeModel, self).row_deleted(path)
+        node_id = id(node)
+        if node_id in self._held_refs:
+            del self._held_refs[node_id]
+
+    #
+    # GtkTreeModel Interface Implementation
+    #
+    @handle_exception(0)
+    def do_get_flags(self):
+        """Internal method."""
+        return self.on_get_flags()
+
+    @handle_exception(0)
+    def do_get_n_columns(self):
+        """Internal method."""
+        return self.on_get_n_columns()
+
+    @handle_exception(GObject.TYPE_INVALID)
+    def do_get_column_type(self, index):
+        """Internal method."""
+        return self.on_get_column_type(index)
+
+    @handle_exception((False, None))
+    def do_get_iter(self, path):
+        """Internal method."""
+        return self._create_tree_iter(self.on_get_iter(path))
+
+    @handle_exception(False)
+    def do_iter_next(self, iter):
+        """Internal method."""
+        if iter is None:
+            next_data = self.on_iter_next(None)
+        else:
+            next_data = self.on_iter_next(self.get_user_data(iter))
+
+        self.set_user_data(iter, next_data)
+        return next_data is not None
+
+    @handle_exception(None)
+    def do_get_path(self, iter):
+        """Internal method."""
+        path = self.on_get_path(self.get_user_data(iter))
+        if path is None:
+            return None
+        else:
+            return Gtk.TreePath(path)
+
+    @handle_exception(None)
+    def do_get_value(self, iter, column):
+        """Internal method."""
+        return self.on_get_value(self.get_user_data(iter), column)
+
+    @handle_exception((False, None))
+    def do_iter_children(self, parent):
+        """Internal method."""
+        data = self.get_user_data(parent) if parent else None
+        return self._create_tree_iter(self.on_iter_children(data))
+
+    @handle_exception(False)
+    def do_iter_has_child(self, parent):
+        """Internal method."""
+        return self.on_iter_has_child(self.get_user_data(parent))
+
+    @handle_exception(0)
+    def do_iter_n_children(self, iter):
+        """Internal method."""
+        if iter is None:
+            return self.on_iter_n_children(None)
+        return self.on_iter_n_children(self.get_user_data(iter))
+
+    @handle_exception((False, None))
+    def do_iter_nth_child(self, parent, n):
+        """Internal method."""
+        if parent is None:
+            data = self.on_iter_nth_child(None, n)
+        else:
+            data = self.on_iter_nth_child(self.get_user_data(parent), n)
+        return self._create_tree_iter(data)
+
+    @handle_exception((False, None))
+    def do_iter_parent(self, child):
+        """Internal method."""
+        return self._create_tree_iter(self.on_iter_parent(self.get_user_data(child)))
+
+    @handle_exception(None)
+    def do_ref_node(self, iter):
+        self.on_ref_node(self.get_user_data(iter))
+
+    @handle_exception(None)
+    def do_unref_node(self, iter):
+        self.on_unref_node(self.get_user_data(iter))
+
+    #
+    # Python Subclass Overridables
+    #
+    def on_get_flags(self):
+        """Overridable.
+
+        :Returns Gtk.TreeModelFlags:
+            The flags for this model. See: Gtk.TreeModelFlags
+        """
+        raise NotImplementedError
+
+    def on_get_n_columns(self):
+        """Overridable.
+
+        :Returns:
+            The number of columns for this model.
+        """
+        raise NotImplementedError
+
+    def on_get_column_type(self, index):
+        """Overridable.
+
+        :Returns:
+            The column type for the given index.
+        """
+        raise NotImplementedError
+
+    def on_get_iter(self, path):
+        """Overridable.
+
+        :Returns:
+            A python object (node) for the given TreePath.
+        """
+        raise NotImplementedError
+
+    def on_iter_next(self, node):
+        """Overridable.
+
+        :Parameters:
+            node : object
+                Node at current level.
+
+        :Returns:
+            A python object (node) following the given node at the current level.
+        """
+        raise NotImplementedError
+
+    def on_get_path(self, node):
+        """Overridable.
+
+        :Returns:
+            A TreePath for the given node.
+        """
+        raise NotImplementedError
+
+    def on_get_value(self, node, column):
+        """Overridable.
+
+        :Parameters:
+            node : object
+            column : int
+                Column index to get the value from.
+
+        :Returns:
+            The value of the column for the given node."""
+        raise NotImplementedError
+
+    def on_iter_children(self, parent):
+        """Overridable.
+
+        :Returns:
+            The first child of parent or None if parent has no children.
+            If parent is None, return the first node of the model.
+        """
+        raise NotImplementedError
+
+    def on_iter_has_child(self, node):
+        """Overridable.
+
+        :Returns:
+            True if the given node has children.
+        """
+        raise NotImplementedError
+
+    def on_iter_n_children(self, node):
+        """Overridable.
+
+        :Returns:
+            The number of children for the given node. If node is None,
+            return the number of top level nodes.
+        """
+        raise NotImplementedError
+
+    def on_iter_nth_child(self, parent, n):
+        """Overridable.
+
+        :Parameters:
+            parent : object
+            n : int
+                Index of child within parent.
+
+        :Returns:
+            The child for the given parent index starting at 0. If parent None,
+            return the top level node corresponding to "n".
+            If "n" is larger then available nodes, return None.
+        """
+        raise NotImplementedError
+
+    def on_iter_parent(self, child):
+        """Overridable.
+
+        :Returns:
+            The parent node of child or None if child is a top level node."""
+        raise NotImplementedError
+
+    def on_ref_node(self, node):
+        pass
+
+    def on_unref_node(self, node):
+        pass

squashfs-root/usr/lib/python3/dist-packages/pygtkcompat/pygtkcompat.py

@@ -0,0 +1,628 @@
+# -*- Mode: Python; py-indent-offset: 4 -*-
+# vim: tabstop=4 shiftwidth=4 expandtab
+#
+# Copyright (C) 2011-2012 Johan Dahlin <johan@gnome.org>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+# USA
+
+"""
+PyGTK compatibility layer.
+
+This modules goes a little bit longer to maintain PyGTK compatibility than
+the normal overrides system.
+
+It is recommended to not depend on this layer, but only use it as an
+intermediate step when porting your application to PyGI.
+
+Compatibility might never be 100%, but the aim is to make it possible to run
+a well behaved PyGTK application mostly unmodified on top of PyGI.
+
+"""
+
+import sys
+import warnings
+from collections import UserList
+
+import gi
+from gi.repository import GObject
+
+
+_patches = []
+_module_patches = []
+_unset = object()
+_enabled_registry = {}
+
+
+def _patch(obj, name, new_value):
+    old_value = getattr(obj, name, _unset)
+    setattr(obj, name, new_value)
+    _patches.append((obj, name, old_value))
+
+
+def _patch_module(name, new_value):
+    old_value = sys.modules.get(name, _unset)
+    sys.modules[name] = new_value
+    _module_patches.append((name, old_value))
+
+
+def _install_enums(module, dest=None, strip=''):
+    if dest is None:
+        dest = module
+    modname = dest.__name__.rsplit('.', 1)[1].upper()
+    for attr in dir(module):
+        try:
+            obj = getattr(module, attr, None)
+        except:
+            continue
+        try:
+            if issubclass(obj, GObject.GEnum):
+                for value, enum in obj.__enum_values__.items():
+                    name = enum.value_name
+                    name = name.replace(modname + '_', '')
+                    if strip and name.startswith(strip):
+                        name = name[len(strip):]
+                    _patch(dest, name, enum)
+        except TypeError:
+            continue
+        try:
+            if issubclass(obj, GObject.GFlags):
+                for value, flag in obj.__flags_values__.items():
+                    try:
+                        name = flag.value_names[-1].replace(modname + '_', '')
+                    except IndexError:
+                        # FIXME: this happens for some large flags which do not
+                        # fit into a long on 32 bit systems
+                        continue
+                    _patch(dest, name, flag)
+        except TypeError:
+            continue
+
+
+def _check_enabled(name, version=None):
+    """Returns True in case it is already enabled"""
+
+    if name in _enabled_registry:
+        enabled_version = _enabled_registry[name]
+        if enabled_version != version:
+            raise ValueError(
+                "%r already enabled with different version (%r)" % (
+                    name, enabled_version))
+        return True
+    else:
+        _enabled_registry[name] = version
+        return False
+
+
+def enable():
+    warnings.warn("pygtkcompat is deprecated, see https://gnome.pages.gitlab.gnome.org/pygobject for migration instructions", gi.PyGIDeprecationWarning)
+
+    if _check_enabled(""):
+        return
+
+    # gobject
+    from gi.repository import GLib
+    _patch_module('glib', GLib)
+
+    # gobject
+    from gi.repository import GObject
+    _patch_module('gobject', GObject)
+    from gi import _propertyhelper
+    _patch_module('gobject.propertyhelper', _propertyhelper)
+
+    # gio
+    from gi.repository import Gio
+    _patch_module('gio', Gio)
+
+
+def _disable_all():
+    """Reverse all effects of the enable_xxx() calls except for
+    require_version() calls and imports.
+    """
+
+    _enabled_registry.clear()
+
+    for obj, name, old_value in reversed(_patches):
+        if old_value is _unset:
+            delattr(obj, name)
+        else:
+            # try if deleting is enough (for override proxies)
+            delattr(obj, name)
+            if getattr(obj, name, _unset) is not old_value:
+                setattr(obj, name, old_value)
+    del _patches[:]
+
+    for name, old_value in reversed(_module_patches):
+        if old_value is _unset:
+            del sys.modules[name]
+        else:
+            sys.modules[name] = old_value
+    del _module_patches[:]
+
+
+def enable_gtk(version='3.0'):
+    if _check_enabled("gtk", version):
+        return
+
+    if version == "4.0":
+        raise ValueError("version 4.0 not supported")
+
+    # atk
+    gi.require_version('Atk', '1.0')
+    from gi.repository import Atk
+    _patch_module('atk', Atk)
+    _install_enums(Atk)
+
+    # pango
+    gi.require_version('Pango', '1.0')
+    from gi.repository import Pango
+    _patch_module('pango', Pango)
+    _install_enums(Pango)
+
+    # pangocairo
+    gi.require_version('PangoCairo', '1.0')
+    from gi.repository import PangoCairo
+    _patch_module('pangocairo', PangoCairo)
+
+    # gdk
+    gi.require_version('Gdk', version)
+    gi.require_version('GdkPixbuf', '2.0')
+    from gi.repository import Gdk
+    from gi.repository import GdkPixbuf
+    _patch_module('gtk.gdk', Gdk)
+    _install_enums(Gdk)
+    _install_enums(GdkPixbuf, dest=Gdk)
+    _patch(Gdk, "_2BUTTON_PRESS", 5)
+    _patch(Gdk, "BUTTON_PRESS", 4)
+
+    _patch(Gdk, "screen_get_default", Gdk.Screen.get_default)
+    _patch(Gdk, "Pixbuf", GdkPixbuf.Pixbuf)
+    _patch(Gdk, "PixbufLoader", GdkPixbuf.PixbufLoader.new_with_type)
+    _patch(Gdk, "pixbuf_new_from_data", GdkPixbuf.Pixbuf.new_from_data)
+    _patch(Gdk, "pixbuf_new_from_file", GdkPixbuf.Pixbuf.new_from_file)
+    _patch(Gdk, "pixbuf_new_from_file_at_scale", GdkPixbuf.Pixbuf.new_from_file_at_scale)
+    _patch(Gdk, "pixbuf_new_from_file_at_size", GdkPixbuf.Pixbuf.new_from_file_at_size)
+    _patch(Gdk, "pixbuf_new_from_inline", GdkPixbuf.Pixbuf.new_from_inline)
+    _patch(Gdk, "pixbuf_new_from_stream", GdkPixbuf.Pixbuf.new_from_stream)
+    _patch(Gdk, "pixbuf_new_from_stream_at_scale", GdkPixbuf.Pixbuf.new_from_stream_at_scale)
+    _patch(Gdk, "pixbuf_new_from_xpm_data", GdkPixbuf.Pixbuf.new_from_xpm_data)
+    _patch(Gdk, "pixbuf_get_file_info", GdkPixbuf.Pixbuf.get_file_info)
+
+    orig_get_formats = GdkPixbuf.Pixbuf.get_formats
+
+    def get_formats():
+        formats = orig_get_formats()
+        result = []
+
+        def make_dict(format_):
+            result = {}
+            result['description'] = format_.get_description()
+            result['name'] = format_.get_name()
+            result['mime_types'] = format_.get_mime_types()
+            result['extensions'] = format_.get_extensions()
+            return result
+
+        for format_ in formats:
+            result.append(make_dict(format_))
+        return result
+
+    _patch(Gdk, "pixbuf_get_formats", get_formats)
+
+    orig_get_origin = Gdk.Window.get_origin
+
+    def get_origin(self):
+        return orig_get_origin(self)[1:]
+    _patch(Gdk.Window, "get_origin", get_origin)
+
+    _patch(Gdk, "screen_width", Gdk.Screen.width)
+    _patch(Gdk, "screen_height", Gdk.Screen.height)
+
+    orig_gdk_window_get_geometry = Gdk.Window.get_geometry
+
+    def gdk_window_get_geometry(window):
+        return orig_gdk_window_get_geometry(window) + (window.get_visual().get_best_depth(),)
+    _patch(Gdk.Window, "get_geometry", gdk_window_get_geometry)
+
+    # gtk
+    gi.require_version('Gtk', version)
+    from gi.repository import Gtk
+    _patch_module('gtk', Gtk)
+    _patch(Gtk, "gdk", Gdk)
+
+    _patch(Gtk, "pygtk_version", (2, 99, 0))
+
+    _patch(Gtk, "gtk_version", (Gtk.MAJOR_VERSION,
+                                Gtk.MINOR_VERSION,
+                                Gtk.MICRO_VERSION))
+    _install_enums(Gtk)
+
+    # Action
+
+    def set_tool_item_type(menuaction, gtype):
+        warnings.warn('set_tool_item_type() is not supported',
+                      gi.PyGIDeprecationWarning, stacklevel=2)
+    _patch(Gtk.Action, "set_tool_item_type", classmethod(set_tool_item_type))
+
+    # Alignment
+
+    orig_Alignment = Gtk.Alignment
+
+    class Alignment(orig_Alignment):
+        def __init__(self, xalign=0.0, yalign=0.0, xscale=0.0, yscale=0.0):
+            orig_Alignment.__init__(self)
+            self.props.xalign = xalign
+            self.props.yalign = yalign
+            self.props.xscale = xscale
+            self.props.yscale = yscale
+
+    _patch(Gtk, "Alignment", Alignment)
+
+    # Box
+
+    orig_pack_end = Gtk.Box.pack_end
+
+    def pack_end(self, child, expand=True, fill=True, padding=0):
+        orig_pack_end(self, child, expand, fill, padding)
+    _patch(Gtk.Box, "pack_end", pack_end)
+
+    orig_pack_start = Gtk.Box.pack_start
+
+    def pack_start(self, child, expand=True, fill=True, padding=0):
+        orig_pack_start(self, child, expand, fill, padding)
+    _patch(Gtk.Box, "pack_start", pack_start)
+
+    # TreeViewColumn
+
+    orig_tree_view_column_pack_end = Gtk.TreeViewColumn.pack_end
+
+    def tree_view_column_pack_end(self, cell, expand=True):
+        orig_tree_view_column_pack_end(self, cell, expand)
+    _patch(Gtk.TreeViewColumn, "pack_end", tree_view_column_pack_end)
+
+    orig_tree_view_column_pack_start = Gtk.TreeViewColumn.pack_start
+
+    def tree_view_column_pack_start(self, cell, expand=True):
+        orig_tree_view_column_pack_start(self, cell, expand)
+    _patch(Gtk.TreeViewColumn, "pack_start", tree_view_column_pack_start)
+
+    # CellLayout
+
+    orig_cell_pack_end = Gtk.CellLayout.pack_end
+
+    def cell_pack_end(self, cell, expand=True):
+        orig_cell_pack_end(self, cell, expand)
+    _patch(Gtk.CellLayout, "pack_end", cell_pack_end)
+
+    orig_cell_pack_start = Gtk.CellLayout.pack_start
+
+    def cell_pack_start(self, cell, expand=True):
+        orig_cell_pack_start(self, cell, expand)
+    _patch(Gtk.CellLayout, "pack_start", cell_pack_start)
+
+    orig_set_cell_data_func = Gtk.CellLayout.set_cell_data_func
+
+    def set_cell_data_func(self, cell, func, user_data=_unset):
+        def callback(*args):
+            if args[-1] == _unset:
+                args = args[:-1]
+            return func(*args)
+        orig_set_cell_data_func(self, cell, callback, user_data)
+    _patch(Gtk.CellLayout, "set_cell_data_func", set_cell_data_func)
+
+    # CellRenderer
+
+    class GenericCellRenderer(Gtk.CellRenderer):
+        pass
+    _patch(Gtk, "GenericCellRenderer", GenericCellRenderer)
+
+    # ComboBox
+
+    orig_combo_row_separator_func = Gtk.ComboBox.set_row_separator_func
+
+    def combo_row_separator_func(self, func, user_data=_unset):
+        def callback(*args):
+            if args[-1] == _unset:
+                args = args[:-1]
+            return func(*args)
+        orig_combo_row_separator_func(self, callback, user_data)
+    _patch(Gtk.ComboBox, "set_row_separator_func", combo_row_separator_func)
+
+    # ComboBoxEntry
+
+    class ComboBoxEntry(Gtk.ComboBox):
+        def __init__(self, **kwds):
+            Gtk.ComboBox.__init__(self, has_entry=True, **kwds)
+
+        def set_text_column(self, text_column):
+            self.set_entry_text_column(text_column)
+
+        def get_text_column(self):
+            return self.get_entry_text_column()
+    _patch(Gtk, "ComboBoxEntry", ComboBoxEntry)
+
+    def combo_box_entry_new():
+        return Gtk.ComboBoxEntry()
+    _patch(Gtk, "combo_box_entry_new", combo_box_entry_new)
+
+    def combo_box_entry_new_with_model(model):
+        return Gtk.ComboBoxEntry(model=model)
+    _patch(Gtk, "combo_box_entry_new_with_model", combo_box_entry_new_with_model)
+
+    # Container
+
+    def install_child_property(container, flag, pspec):
+        warnings.warn('install_child_property() is not supported',
+                      gi.PyGIDeprecationWarning, stacklevel=2)
+    _patch(Gtk.Container, "install_child_property", classmethod(install_child_property))
+
+    def new_text():
+        combo = Gtk.ComboBox()
+        model = Gtk.ListStore(str)
+        combo.set_model(model)
+        combo.set_entry_text_column(0)
+        return combo
+    _patch(Gtk, "combo_box_new_text", new_text)
+
+    def append_text(self, text):
+        model = self.get_model()
+        model.append([text])
+    _patch(Gtk.ComboBox, "append_text", append_text)
+    _patch(Gtk, "expander_new_with_mnemonic", Gtk.Expander.new_with_mnemonic)
+    _patch(Gtk, "icon_theme_get_default", Gtk.IconTheme.get_default)
+    _patch(Gtk, "image_new_from_pixbuf", Gtk.Image.new_from_pixbuf)
+    _patch(Gtk, "image_new_from_stock", Gtk.Image.new_from_stock)
+    _patch(Gtk, "image_new_from_animation", Gtk.Image.new_from_animation)
+    _patch(Gtk, "image_new_from_icon_set", Gtk.Image.new_from_icon_set)
+    _patch(Gtk, "image_new_from_file", Gtk.Image.new_from_file)
+    _patch(Gtk, "settings_get_default", Gtk.Settings.get_default)
+    _patch(Gtk, "window_set_default_icon", Gtk.Window.set_default_icon)
+    _patch(Gtk, "clipboard_get", Gtk.Clipboard.get)
+
+    # AccelGroup
+    _patch(Gtk.AccelGroup, "connect_group", Gtk.AccelGroup.connect)
+
+    # StatusIcon
+    _patch(Gtk, "status_icon_position_menu", Gtk.StatusIcon.position_menu)
+    _patch(Gtk.StatusIcon, "set_tooltip", Gtk.StatusIcon.set_tooltip_text)
+
+    # Scale
+
+    orig_HScale = Gtk.HScale
+    orig_VScale = Gtk.VScale
+
+    class HScale(orig_HScale):
+        def __init__(self, adjustment=None):
+            orig_HScale.__init__(self, adjustment=adjustment)
+    _patch(Gtk, "HScale", HScale)
+
+    class VScale(orig_VScale):
+        def __init__(self, adjustment=None):
+            orig_VScale.__init__(self, adjustment=adjustment)
+    _patch(Gtk, "VScale", VScale)
+
+    _patch(Gtk, "stock_add", lambda items: None)
+
+    # Widget
+
+    _patch(Gtk.Widget, "window", property(fget=Gtk.Widget.get_window))
+
+    _patch(Gtk, "widget_get_default_direction", Gtk.Widget.get_default_direction)
+    orig_size_request = Gtk.Widget.size_request
+
+    def size_request(widget):
+        class SizeRequest(UserList):
+            def __init__(self, req):
+                self.height = req.height
+                self.width = req.width
+                UserList.__init__(self, [self.width, self.height])
+        return SizeRequest(orig_size_request(widget))
+    _patch(Gtk.Widget, "size_request", size_request)
+    _patch(Gtk.Widget, "hide_all", Gtk.Widget.hide)
+
+    class BaseGetter(object):
+        def __init__(self, context):
+            self.context = context
+
+        def __getitem__(self, state):
+            color = self.context.get_background_color(state)
+            return Gdk.Color(red=int(color.red * 65535),
+                             green=int(color.green * 65535),
+                             blue=int(color.blue * 65535))
+
+    class Styles(object):
+        def __init__(self, widget):
+            context = widget.get_style_context()
+            self.base = BaseGetter(context)
+            self.black = Gdk.Color(red=0, green=0, blue=0)
+
+    class StyleDescriptor(object):
+        def __get__(self, instance, class_):
+            return Styles(instance)
+    _patch(Gtk.Widget, "style", StyleDescriptor())
+
+    # TextView
+
+    orig_text_view_scroll_to_mark = Gtk.TextView.scroll_to_mark
+
+    def text_view_scroll_to_mark(self, mark, within_margin,
+                                 use_align=False, xalign=0.5, yalign=0.5):
+        return orig_text_view_scroll_to_mark(self, mark, within_margin,
+                                             use_align, xalign, yalign)
+    _patch(Gtk.TextView, "scroll_to_mark", text_view_scroll_to_mark)
+
+    # Window
+
+    orig_set_geometry_hints = Gtk.Window.set_geometry_hints
+
+    def set_geometry_hints(self, geometry_widget=None,
+                           min_width=-1, min_height=-1, max_width=-1, max_height=-1,
+                           base_width=-1, base_height=-1, width_inc=-1, height_inc=-1,
+                           min_aspect=-1.0, max_aspect=-1.0):
+
+        geometry = Gdk.Geometry()
+        geom_mask = Gdk.WindowHints(0)
+
+        if min_width >= 0 or min_height >= 0:
+            geometry.min_width = max(min_width, 0)
+            geometry.min_height = max(min_height, 0)
+            geom_mask |= Gdk.WindowHints.MIN_SIZE
+
+        if max_width >= 0 or max_height >= 0:
+            geometry.max_width = max(max_width, 0)
+            geometry.max_height = max(max_height, 0)
+            geom_mask |= Gdk.WindowHints.MAX_SIZE
+
+        if base_width >= 0 or base_height >= 0:
+            geometry.base_width = max(base_width, 0)
+            geometry.base_height = max(base_height, 0)
+            geom_mask |= Gdk.WindowHints.BASE_SIZE
+
+        if width_inc >= 0 or height_inc >= 0:
+            geometry.width_inc = max(width_inc, 0)
+            geometry.height_inc = max(height_inc, 0)
+            geom_mask |= Gdk.WindowHints.RESIZE_INC
+
+        if min_aspect >= 0.0 or max_aspect >= 0.0:
+            if min_aspect <= 0.0 or max_aspect <= 0.0:
+                raise TypeError("aspect ratios must be positive")
+
+            geometry.min_aspect = min_aspect
+            geometry.max_aspect = max_aspect
+            geom_mask |= Gdk.WindowHints.ASPECT
+
+        return orig_set_geometry_hints(self, geometry_widget, geometry, geom_mask)
+
+    _patch(Gtk.Window, "set_geometry_hints", set_geometry_hints)
+    _patch(Gtk, "window_list_toplevels", Gtk.Window.list_toplevels)
+    _patch(Gtk, "window_set_default_icon_name", Gtk.Window.set_default_icon_name)
+
+    # gtk.unixprint
+
+    class UnixPrint(object):
+        pass
+    unixprint = UnixPrint()
+    _patch_module('gtkunixprint', unixprint)
+
+    # gtk.keysyms
+
+    with warnings.catch_warnings():
+        warnings.simplefilter('ignore', category=RuntimeWarning)
+        from gi.overrides import keysyms
+
+    _patch_module('gtk.keysyms', keysyms)
+    _patch(Gtk, "keysyms", keysyms)
+
+    from . import generictreemodel
+    _patch(Gtk, "GenericTreeModel", generictreemodel.GenericTreeModel)
+
+
+def enable_vte():
+    if _check_enabled("vte"):
+        return
+
+    gi.require_version('Vte', '0.0')
+    from gi.repository import Vte
+    _patch_module('vte', Vte)
+
+
+def enable_poppler():
+    if _check_enabled("poppler"):
+        return
+
+    gi.require_version('Poppler', '0.18')
+    from gi.repository import Poppler
+    _patch_module('poppler', Poppler)
+
+    _patch(Poppler, "pypoppler_version", (1, 0, 0))
+
+
+def enable_webkit(version='1.0'):
+    if _check_enabled("webkit", version):
+        return
+
+    gi.require_version('WebKit', version)
+    from gi.repository import WebKit
+    _patch_module('webkit', WebKit)
+
+    _patch(WebKit.WebView, "get_web_inspector", WebKit.WebView.get_inspector)
+
+
+def enable_gudev():
+    if _check_enabled("gudev"):
+        return
+
+    gi.require_version('GUdev', '1.0')
+    from gi.repository import GUdev
+    _patch_module('gudev', GUdev)
+
+
+def enable_gst():
+    if _check_enabled("gst"):
+        return
+
+    gi.require_version('Gst', '0.10')
+    from gi.repository import Gst
+    _patch_module('gst', Gst)
+    _install_enums(Gst)
+
+    _patch(Gst, "registry_get_default", Gst.Registry.get_default)
+    _patch(Gst, "element_register", Gst.Element.register)
+    _patch(Gst, "element_factory_make", Gst.ElementFactory.make)
+    _patch(Gst, "caps_new_any", Gst.Caps.new_any)
+    _patch(Gst, "get_pygst_version", lambda: (0, 10, 19))
+    _patch(Gst, "get_gst_version", lambda: (0, 10, 40))
+
+    from gi.repository import GstInterfaces
+    _patch_module('gst.interfaces', GstInterfaces)
+    _install_enums(GstInterfaces)
+
+    from gi.repository import GstAudio
+    _patch_module('gst.audio', GstAudio)
+    _install_enums(GstAudio)
+
+    from gi.repository import GstVideo
+    _patch_module('gst.video', GstVideo)
+    _install_enums(GstVideo)
+
+    from gi.repository import GstBase
+    _patch_module('gst.base', GstBase)
+    _install_enums(GstBase)
+
+    _patch(Gst, "BaseTransform", GstBase.BaseTransform)
+    _patch(Gst, "BaseSink", GstBase.BaseSink)
+
+    from gi.repository import GstController
+    _patch_module('gst.controller', GstController)
+    _install_enums(GstController, dest=Gst)
+
+    from gi.repository import GstPbutils
+    _patch_module('gst.pbutils', GstPbutils)
+    _install_enums(GstPbutils)
+
+
+def enable_goocanvas():
+    if _check_enabled("goocanvas"):
+        return
+
+    gi.require_version('GooCanvas', '2.0')
+    from gi.repository import GooCanvas
+    _patch_module('goocanvas', GooCanvas)
+    _install_enums(GooCanvas, strip='GOO_CANVAS_')
+
+    _patch(GooCanvas, "ItemSimple", GooCanvas.CanvasItemSimple)
+    _patch(GooCanvas, "Item", GooCanvas.CanvasItem)
+    _patch(GooCanvas, "Image", GooCanvas.CanvasImage)
+    _patch(GooCanvas, "Group", GooCanvas.CanvasGroup)
+    _patch(GooCanvas, "Rect", GooCanvas.CanvasRect)