@scrypted/server 0.0.137 → 0.0.141

package/.venv/lib/python3.9/site-packages/pgi/overrides/Gtk.py

@@ -0,0 +1,2412 @@
+# -*- Mode: Python; py-indent-offset: 4 -*-
+# vim: tabstop=4 shiftwidth=4 expandtab
+#
+# Copyright (C) 2009 Johan Dahlin <johan@gnome.org>
+#               2010 Simon van der Linden <svdlinden@src.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
+
+import collections
+import sys
+import warnings
+
+from pgi.repository import GObject
+from pgi.overrides import override, get_introspection_module, \
+    strip_boolean_result, deprecated_init
+from pgi import PyGIDeprecationWarning
+
+if sys.version_info >= (3, 0):
+    _basestring = str
+    _callable = lambda c: hasattr(c, '__call__')
+else:
+    _basestring = basestring
+    _callable = callable
+
+Gtk = get_introspection_module('Gtk')
+
+__all__ = []
+
+if Gtk._version == '2.0':
+    warn_msg = "You have imported the Gtk 2.0 module.  Because Gtk 2.0 \
+was not designed for use with introspection some of the \
+interfaces and API will fail.  As such this is not supported \
+by the pygobject development team and we encourage you to \
+port your app to Gtk 3 or greater. PyGTK is the recomended \
+python module to use with Gtk 2.0"
+
+    warnings.warn(warn_msg, RuntimeWarning)
+
+
+class PyGTKDeprecationWarning(PyGIDeprecationWarning):
+    pass
+
+__all__.append('PyGTKDeprecationWarning')
+
+
+def _construct_target_list(targets):
+    """Create a list of TargetEntry items from a list of tuples in the form (target, flags, info)
+
+    The list can also contain existing TargetEntry items in which case the existing entry
+    is re-used in the return list.
+    """
+    target_entries = []
+    for entry in targets:
+        if not isinstance(entry, Gtk.TargetEntry):
+            entry = Gtk.TargetEntry.new(*entry)
+        target_entries.append(entry)
+    return target_entries
+
+__all__.append('_construct_target_list')
+
+
+def _extract_handler_and_args(obj_or_map, handler_name):
+    handler = None
+    if isinstance(obj_or_map, collections.Mapping):
+        handler = obj_or_map.get(handler_name, None)
+    else:
+        handler = getattr(obj_or_map, handler_name, None)
+
+    if handler is None:
+        raise AttributeError('Handler %s not found' % handler_name)
+
+    args = ()
+    if isinstance(handler, collections.Sequence):
+        if len(handler) == 0:
+            raise TypeError("Handler %s tuple can not be empty" % handler)
+        args = handler[1:]
+        handler = handler[0]
+
+    elif not _callable(handler):
+        raise TypeError('Handler %s is not a method, function or tuple' % handler)
+
+    return handler, args
+
+
+# Exposed for unit-testing.
+__all__.append('_extract_handler_and_args')
+
+
+def _builder_connect_callback(builder, gobj, signal_name, handler_name, connect_obj, flags, obj_or_map):
+    handler, args = _extract_handler_and_args(obj_or_map, handler_name)
+
+    after = flags & GObject.ConnectFlags.AFTER
+    if connect_obj is not None:
+        if after:
+            gobj.connect_object_after(signal_name, handler, connect_obj, *args)
+        else:
+            gobj.connect_object(signal_name, handler, connect_obj, *args)
+    else:
+        if after:
+            gobj.connect_after(signal_name, handler, *args)
+        else:
+            gobj.connect(signal_name, handler, *args)
+
+
+class Widget(Gtk.Widget):
+
+    translate_coordinates = strip_boolean_result(Gtk.Widget.translate_coordinates)
+    """
+    :param dest_widget: a :obj:`Gtk.Widget`
+    :type dest_widget: :obj:`Gtk.Widget`
+    :param src_x: X position relative to `self`
+    :type src_x: :obj:`int`
+    :param src_y: Y position relative to `self`
+    :type src_y: :obj:`int`
+    :returns:
+        :obj:`None` if either widget was not realized, or there
+        was no common ancestor. Otherwise a ``(dest_x, dest_y)`` tuple
+        containing the X and Y position relative to `dest_widget`.
+    :rtype: (**dest_x**: :obj:`int`, **dest_y**: :obj:`int`) or :obj:`None`
+
+    {{ docs }}
+    """
+
+    def drag_dest_set_target_list(self, target_list):
+        if (target_list is not None) and (not isinstance(target_list, Gtk.TargetList)):
+            target_list = Gtk.TargetList.new(_construct_target_list(target_list))
+        super(Widget, self).drag_dest_set_target_list(target_list)
+
+    def drag_source_set_target_list(self, target_list):
+        if (target_list is not None) and (not isinstance(target_list, Gtk.TargetList)):
+            target_list = Gtk.TargetList.new(_construct_target_list(target_list))
+        super(Widget, self).drag_source_set_target_list(target_list)
+
+    def style_get_property(self, property_name, value=None):
+        """style_get_property(property_name, value=None)
+
+        :param property_name:
+            the name of a style property
+        :type property_name: :obj:`str`
+
+        :param value:
+            Either :obj:`None` or a correctly initialized :obj:`GObject.Value`
+        :type value: :obj:`GObject.Value` or :obj:`None`
+
+        :returns: The Python value of the style property
+
+        {{ docs }}
+        """
+
+        if value is None:
+            prop = self.find_style_property(property_name)
+            if prop is None:
+                raise ValueError('Class "%s" does not contain style property "%s"' %
+                                 (self, property_name))
+            value = GObject.Value(prop.value_type)
+
+        Gtk.Widget.style_get_property(self, property_name, value)
+        return value.get_value()
+
+
+Widget = override(Widget)
+__all__.append('Widget')
+
+
+class Container(Gtk.Container, Widget):
+    def __len__(self):
+        return len(self.get_children())
+
+    def __contains__(self, child):
+        return child in self.get_children()
+
+    def __iter__(self):
+        return iter(self.get_children())
+
+    def __bool__(self):
+        return True
+
+    # alias for Python 2.x object protocol
+    __nonzero__ = __bool__
+
+    get_focus_chain = strip_boolean_result(Gtk.Container.get_focus_chain)
+    """
+    :returns:
+        A list of focusable widgets or :obj:`None` if no focus chain has
+        been explicitly set.
+
+    :rtype: [:obj:`Gtk.Widget`] or :obj:`None`
+
+    Retrieves the focus chain of the container, if one has been
+    set explicitly. If no focus chain has been explicitly
+    set, GTK+ computes the focus chain based on the positions
+    of the children. In that case returns :obj:`None`.
+    """
+
+    def child_get_property(self, child, property_name, value=None):
+        """child_get_property(child, property_name, value=None)
+
+        :param child:
+            a widget which is a child of `self`
+        :type child: :obj:`Gtk.Widget`
+
+        :param property_name:
+            the name of the property to get
+        :type property_name: :obj:`str`
+
+        :param value:
+            Either :obj:`None` or a correctly initialized :obj:`GObject.Value`
+        :type value: :obj:`GObject.Value` or :obj:`None`
+
+        :returns: The Python value of the child property
+
+        {{ docs }}
+        """
+
+        if value is None:
+            prop = self.find_child_property(property_name)
+            if prop is None:
+                raise ValueError('Class "%s" does not contain child property "%s"' %
+                                 (self, property_name))
+            value = GObject.Value(prop.value_type)
+
+        Gtk.Container.child_get_property(self, child, property_name, value)
+        return value.get_value()
+
+    def child_get(self, child, *prop_names):
+        """Returns a list of child property values for the given names."""
+
+        return [self.child_get_property(child, name) for name in prop_names]
+
+    def child_set(self, child, **kwargs):
+        """Set a child properties on the given child to key/value pairs."""
+
+        for name, value in kwargs.items():
+            name = name.replace('_', '-')
+            self.child_set_property(child, name, value)
+
+
+Container = override(Container)
+__all__.append('Container')
+
+
+class Editable(Gtk.Editable):
+
+    def insert_text(self, text, position):
+        """insert_text(self, text, position)
+
+        :param new_text:
+            the text to append
+        :type new_text: :obj:`str`
+
+        :param position:
+            location of the position text will be inserted at
+        :type position: :obj:`int`
+
+        :returns:
+            location of the position text will be inserted at
+        :rtype: :obj:`int`
+
+        Inserts `new_text` into the contents of the
+        widget, at position `position`.
+
+        Note that the position is in characters, not in bytes.
+        """
+
+        return super(Editable, self).insert_text(text, -1, position)
+
+    get_selection_bounds = strip_boolean_result(Gtk.Editable.get_selection_bounds, fail_ret=())
+    """
+    :returns:
+        An empty tuple if no area is selected or a tuple containing:
+
+        :start_pos: the starting position
+        :end_pos: the end position
+
+    :rtype: (**start_pos**: :obj:`int`, **end_pos**: :obj:`int`) or ``()``
+
+    Retrieves the selection bound of the editable. start_pos will be filled
+    with the start of the selection and `end_pos` with end. If no text was
+    selected an empty tuple will be returned.
+
+    Note that positions are specified in characters, not bytes.
+    """
+
+
+Editable = override(Editable)
+__all__.append("Editable")
+
+
+class Action(Gtk.Action):
+    __init__ = deprecated_init(Gtk.Action.__init__,
+                               arg_names=('name', 'label', 'tooltip', 'stock_id'),
+                               category=PyGTKDeprecationWarning)
+
+Action = override(Action)
+__all__.append("Action")
+
+
+class RadioAction(Gtk.RadioAction):
+    __init__ = deprecated_init(Gtk.RadioAction.__init__,
+                               arg_names=('name', 'label', 'tooltip', 'stock_id', 'value'),
+                               category=PyGTKDeprecationWarning)
+
+RadioAction = override(RadioAction)
+__all__.append("RadioAction")
+
+
+class ActionGroup(Gtk.ActionGroup):
+    __init__ = deprecated_init(Gtk.ActionGroup.__init__,
+                               arg_names=('name',),
+                               category=PyGTKDeprecationWarning)
+
+    def add_actions(self, entries, user_data=None):
+        """
+        The add_actions() method is a convenience method that creates a number
+        of gtk.Action  objects based on the information in the list of action
+        entry tuples contained in entries and adds them to the action group.
+        The entry tuples can vary in size from one to six items with the
+        following information:
+
+            * The name of the action. Must be specified.
+            * The stock id for the action. Optional with a default value of None
+              if a label is specified.
+            * The label for the action. This field should typically be marked
+              for translation, see the set_translation_domain() method. Optional
+              with a default value of None if a stock id is specified.
+            * The accelerator for the action, in the format understood by the
+              gtk.accelerator_parse() function. Optional with a default value of
+              None.
+            * The tooltip for the action. This field should typically be marked
+              for translation, see the set_translation_domain() method. Optional
+              with a default value of None.
+            * The callback function invoked when the action is activated.
+              Optional with a default value of None.
+
+        The "activate" signals of the actions are connected to the callbacks and
+        their accel paths are set to <Actions>/group-name/action-name.
+        """
+        try:
+            iter(entries)
+        except (TypeError):
+            raise TypeError('entries must be iterable')
+
+        def _process_action(name, stock_id=None, label=None, accelerator=None, tooltip=None, callback=None):
+            action = Action(name=name, label=label, tooltip=tooltip, stock_id=stock_id)
+            if callback is not None:
+                if user_data is None:
+                    action.connect('activate', callback)
+                else:
+                    action.connect('activate', callback, user_data)
+
+            self.add_action_with_accel(action, accelerator)
+
+        for e in entries:
+            # using inner function above since entries can leave out optional arguments
+            _process_action(*e)
+
+    def add_toggle_actions(self, entries, user_data=None):
+        """
+        The add_toggle_actions() method is a convenience method that creates a
+        number of gtk.ToggleAction objects based on the information in the list
+        of action entry tuples contained in entries and adds them to the action
+        group. The toggle action entry tuples can vary in size from one to seven
+        items with the following information:
+
+            * The name of the action. Must be specified.
+            * The stock id for the action. Optional with a default value of None
+              if a label is specified.
+            * The label for the action. This field should typically be marked
+              for translation, see the set_translation_domain() method. Optional
+              with a default value of None if a stock id is specified.
+            * The accelerator for the action, in the format understood by the
+              gtk.accelerator_parse() function. Optional with a default value of
+              None.
+            * The tooltip for the action. This field should typically be marked
+              for translation, see the set_translation_domain() method. Optional
+              with a default value of None.
+            * The callback function invoked when the action is activated.
+              Optional with a default value of None.
+            * A flag indicating whether the toggle action is active. Optional
+              with a default value of False.
+
+        The "activate" signals of the actions are connected to the callbacks and
+        their accel paths are set to <Actions>/group-name/action-name.
+        """
+
+        try:
+            iter(entries)
+        except (TypeError):
+            raise TypeError('entries must be iterable')
+
+        def _process_action(name, stock_id=None, label=None, accelerator=None, tooltip=None, callback=None, is_active=False):
+            action = Gtk.ToggleAction(name=name, label=label, tooltip=tooltip, stock_id=stock_id)
+            action.set_active(is_active)
+            if callback is not None:
+                if user_data is None:
+                    action.connect('activate', callback)
+                else:
+                    action.connect('activate', callback, user_data)
+
+            self.add_action_with_accel(action, accelerator)
+
+        for e in entries:
+            # using inner function above since entries can leave out optional arguments
+            _process_action(*e)
+
+    def add_radio_actions(self, entries, value=None, on_change=None, user_data=None):
+        """
+        The add_radio_actions() method is a convenience method that creates a
+        number of gtk.RadioAction objects based on the information in the list
+        of action entry tuples contained in entries and adds them to the action
+        group. The entry tuples can vary in size from one to six items with the
+        following information:
+
+            * The name of the action. Must be specified.
+            * The stock id for the action. Optional with a default value of None
+              if a label is specified.
+            * The label for the action. This field should typically be marked
+              for translation, see the set_translation_domain() method. Optional
+              with a default value of None if a stock id is specified.
+            * The accelerator for the action, in the format understood by the
+              gtk.accelerator_parse() function. Optional with a default value of
+              None.
+            * The tooltip for the action. This field should typically be marked
+              for translation, see the set_translation_domain() method. Optional
+              with a default value of None.
+            * The value to set on the radio action. Optional with a default
+              value of 0. Should be specified in applications.
+
+        The value parameter specifies the radio action that should be set
+        active. The "changed" signal of the first radio action is connected to
+        the on_change callback (if specified and not None) and the accel paths
+        of the actions are set to <Actions>/group-name/action-name.
+        """
+        try:
+            iter(entries)
+        except (TypeError):
+            raise TypeError('entries must be iterable')
+
+        first_action = None
+
+        def _process_action(group_source, name, stock_id=None, label=None, accelerator=None, tooltip=None, entry_value=0):
+            action = RadioAction(name=name, label=label, tooltip=tooltip, stock_id=stock_id, value=entry_value)
+
+            # FIXME: join_group is a patch to Gtk+ 3.0
+            #        otherwise we can't effectively add radio actions to a
+            #        group.  Should we depend on 3.0 and error out here
+            #        or should we offer the functionality via a compat
+            #        C module?
+            if hasattr(action, 'join_group'):
+                action.join_group(group_source)
+
+            if value == entry_value:
+                action.set_active(True)
+
+            self.add_action_with_accel(action, accelerator)
+            return action
+
+        for e in entries:
+            # using inner function above since entries can leave out optional arguments
+            action = _process_action(first_action, *e)
+            if first_action is None:
+                first_action = action
+
+        if first_action is not None and on_change is not None:
+            if user_data is None:
+                first_action.connect('changed', on_change)
+            else:
+                first_action.connect('changed', on_change, user_data)
+
+ActionGroup = override(ActionGroup)
+__all__.append('ActionGroup')
+
+
+class UIManager(Gtk.UIManager):
+    def add_ui_from_string(self, buffer, length=-1):
+        """add_ui_from_string(buffer, length=-1)
+
+        {{ all }}
+        """
+
+        return Gtk.UIManager.add_ui_from_string(self, buffer, length)
+
+    def insert_action_group(self, action_group, pos=-1):
+        return Gtk.UIManager.insert_action_group(self, action_group, pos)
+
+UIManager = override(UIManager)
+__all__.append('UIManager')
+
+
+class ComboBox(Gtk.ComboBox, Container):
+    get_active_iter = strip_boolean_result(Gtk.ComboBox.get_active_iter)
+    """
+    :returns: a :obj:`Gtk.TreeIter` or :obj:`None` if there is no active item
+    :rtype: :obj:`Gtk.TreeIter` or :obj:`None`
+
+    Returns the `iter` for the current active item, if it exists.
+    """
+
+ComboBox = override(ComboBox)
+__all__.append('ComboBox')
+
+
+class Box(Gtk.Box):
+    __init__ = deprecated_init(Gtk.Box.__init__,
+                               arg_names=('homogeneous', 'spacing'),
+                               category=PyGTKDeprecationWarning)
+
+Box = override(Box)
+__all__.append('Box')
+
+
+class SizeGroup(Gtk.SizeGroup):
+    __init__ = deprecated_init(Gtk.SizeGroup.__init__,
+                               arg_names=('mode',),
+                               deprecated_defaults={'mode': Gtk.SizeGroupMode.VERTICAL},
+                               category=PyGTKDeprecationWarning)
+
+SizeGroup = override(SizeGroup)
+__all__.append('SizeGroup')
+
+
+class MenuItem(Gtk.MenuItem):
+    __init__ = deprecated_init(Gtk.MenuItem.__init__,
+                               arg_names=('label',),
+                               category=PyGTKDeprecationWarning)
+
+MenuItem = override(MenuItem)
+__all__.append('MenuItem')
+
+
+class Builder(Gtk.Builder):
+    def connect_signals(self, obj_or_map):
+        """connect_signals(self, obj_or_map)
+
+        Connect signals specified by this builder to a name, handler mapping.
+
+        Connect signal, name, and handler sets specified in the builder with
+        the given mapping "obj_or_map". The handler/value aspect of the mapping
+        can also contain a tuple in the form of (handler [,arg1 [,argN]])
+        allowing for extra arguments to be passed to the handler. For example:
+
+        .. code-block:: python
+
+            builder.connect_signals({'on_clicked': (on_clicked, arg1, arg2)})
+        """
+        self.connect_signals_full(_builder_connect_callback, obj_or_map)
+
+    def add_from_string(self, buffer, length=-1):
+        """add_from_string(buffer, length=-1)
+
+        {{ all }}
+        """
+
+        return Gtk.Builder.add_from_string(self, buffer, length)
+
+    def add_objects_from_string(self, buffer, object_ids):
+        """add_objects_from_string(buffer, object_ids)
+
+        :param buffer: the string to parse
+        :type buffer: :obj:`str`
+        :param object_ids: array of objects to build
+        :type object_ids: [:obj:`str`]
+
+        :raises: :class:`GLib.Error`
+
+        :returns: A positive value on success, 0 if an error occurred
+        :rtype: :obj:`int`
+
+        {{ docs }}
+        """
+
+        length = -1
+        return Gtk.Builder.add_objects_from_string(self, buffer, length, object_ids)
+
+Builder = override(Builder)
+__all__.append('Builder')
+
+
+# NOTE: This must come before any other Window/Dialog subclassing, to ensure
+# that we have a correct inheritance hierarchy.
+
+
+class Window(Gtk.Window):
+    __init__ = deprecated_init(Gtk.Window.__init__,
+                               arg_names=('type',),
+                               category=PyGTKDeprecationWarning)
+
+Window = override(Window)
+__all__.append('Window')
+
+
+class Dialog(Gtk.Dialog, Container):
+    _old_arg_names = ('title', 'parent', 'flags', 'buttons', '_buttons_property')
+    _init = deprecated_init(Gtk.Dialog.__init__,
+                            arg_names=('title', 'transient_for', 'flags',
+                                       'add_buttons', 'buttons'),
+                            ignore=('flags', 'add_buttons'),
+                            deprecated_aliases={'transient_for': 'parent',
+                                                'buttons': '_buttons_property'},
+                            category=PyGTKDeprecationWarning)
+
+    def __init__(self, *args, **kwargs):
+
+        new_kwargs = kwargs.copy()
+        old_kwargs = dict(zip(self._old_arg_names, args))
+        old_kwargs.update(kwargs)
+
+        # Increment the warning stacklevel for sub-classes which implement their own __init__.
+        stacklevel = 2
+        if self.__class__ != Dialog and self.__class__.__init__ != Dialog.__init__:
+            stacklevel += 1
+
+        # buttons was overloaded by PyGtk but is needed for Gtk.MessageDialog
+        # as a pass through, so type check the argument and give a deprecation
+        # when it is not of type Gtk.ButtonsType
+        add_buttons = old_kwargs.get('buttons', None)
+        if add_buttons is not None and not isinstance(add_buttons, Gtk.ButtonsType):
+            warnings.warn('The "buttons" argument must be a Gtk.ButtonsType enum value. '
+                          'Please use the "add_buttons" method for adding buttons. '
+                          'See: https://wiki.gnome.org/PyGObject/InitializerDeprecations',
+                          PyGTKDeprecationWarning, stacklevel=stacklevel)
+            if 'buttons' in new_kwargs:
+                del new_kwargs['buttons']
+        else:
+            add_buttons = None
+
+        flags = old_kwargs.get('flags', 0)
+        if flags:
+            warnings.warn('The "flags" argument for dialog construction is deprecated. '
+                          'Please use initializer keywords: modal=True and/or destroy_with_parent=True. '
+                          'See: https://wiki.gnome.org/PyGObject/InitializerDeprecations',
+                          PyGTKDeprecationWarning, stacklevel=stacklevel)
+
+            if flags & Gtk.DialogFlags.MODAL:
+                new_kwargs['modal'] = True
+
+            if flags & Gtk.DialogFlags.DESTROY_WITH_PARENT:
+                new_kwargs['destroy_with_parent'] = True
+
+        self._init(*args, **new_kwargs)
+
+        if add_buttons:
+            self.add_buttons(*add_buttons)
+
+    action_area = property(lambda dialog: dialog.get_action_area())
+    vbox = property(lambda dialog: dialog.get_content_area())
+
+    def add_buttons(self, *args):
+        """add_buttons(*args)
+
+        The add_buttons() method adds several buttons to the Gtk.Dialog using
+        the button data passed as arguments to the method. This method is the
+        same as calling the Gtk.Dialog.add_button() repeatedly. The button data
+        pairs - button text (or stock ID) and a response ID integer are passed
+        individually. For example:
+
+        .. code-block:: python
+
+            dialog.add_buttons(Gtk.STOCK_OPEN, 42, "Close", Gtk.ResponseType.CLOSE)
+
+        will add "Open" and "Close" buttons to dialog.
+        """
+        def _button(b):
+            while b:
+                t, r = b[0:2]
+                b = b[2:]
+                yield t, r
+
+        try:
+            for text, response in _button(args):
+                self.add_button(text, response)
+        except (IndexError):
+            raise TypeError('Must pass an even number of arguments')
+
+Dialog = override(Dialog)
+__all__.append('Dialog')
+
+
+class MessageDialog(Gtk.MessageDialog, Dialog):
+    __init__ = deprecated_init(Gtk.MessageDialog.__init__,
+                               arg_names=('parent', 'flags', 'message_type',
+                                          'buttons', 'message_format'),
+                               deprecated_aliases={'text': 'message_format',
+                                                   'message_type': 'type'},
+                               category=PyGTKDeprecationWarning)
+
+    def format_secondary_text(self, message_format):
+        self.set_property('secondary-use-markup', False)
+        self.set_property('secondary-text', message_format)
+
+    def format_secondary_markup(self, message_format):
+        self.set_property('secondary-use-markup', True)
+        self.set_property('secondary-text', message_format)
+
+MessageDialog = override(MessageDialog)
+__all__.append('MessageDialog')
+
+
+class ColorSelectionDialog(Gtk.ColorSelectionDialog):
+    __init__ = deprecated_init(Gtk.ColorSelectionDialog.__init__,
+                               arg_names=('title',),
+                               category=PyGTKDeprecationWarning)
+
+ColorSelectionDialog = override(ColorSelectionDialog)
+__all__.append('ColorSelectionDialog')
+
+
+class FileChooserDialog(Gtk.FileChooserDialog):
+    __init__ = deprecated_init(Gtk.FileChooserDialog.__init__,
+                               arg_names=('title', 'parent', 'action', 'buttons'),
+                               category=PyGTKDeprecationWarning)
+
+FileChooserDialog = override(FileChooserDialog)
+__all__.append('FileChooserDialog')
+
+
+class FontSelectionDialog(Gtk.FontSelectionDialog):
+    __init__ = deprecated_init(Gtk.FontSelectionDialog.__init__,
+                               arg_names=('title',),
+                               category=PyGTKDeprecationWarning)
+
+FontSelectionDialog = override(FontSelectionDialog)
+__all__.append('FontSelectionDialog')
+
+
+class RecentChooserDialog(Gtk.RecentChooserDialog):
+    # Note, the "manager" keyword must work across the entire 3.x series because
+    # "recent_manager" is not backwards compatible with PyGObject versions prior to 3.10.
+    __init__ = deprecated_init(Gtk.RecentChooserDialog.__init__,
+                               arg_names=('title', 'parent', 'recent_manager', 'buttons'),
+                               deprecated_aliases={'recent_manager': 'manager'},
+                               category=PyGTKDeprecationWarning)
+
+RecentChooserDialog = override(RecentChooserDialog)
+__all__.append('RecentChooserDialog')
+
+
+class IconView(Gtk.IconView):
+    __init__ = deprecated_init(Gtk.IconView.__init__,
+                               arg_names=('model',),
+                               category=PyGTKDeprecationWarning)
+
+    get_item_at_pos = strip_boolean_result(Gtk.IconView.get_item_at_pos)
+    """
+    :param x: The x position to be identified
+    :type x: :obj:`int`
+
+    :param y: The y position to be identified
+    :type y: :obj:`int`
+
+    :returns:
+        If not item exists at the specified position returns :obj:`None`,
+        otherwise a tuple containing:
+
+        :path: The path
+        :cell: The renderer responsible for the cell at (`x`, `y`)
+
+    :rtype: (**path**: :obj:`Gtk.TreePath`, **cell**: :obj:`Gtk.CellRenderer`) or :obj:`None`
+
+    {{ docs }}
+    """
+
+    get_visible_range = strip_boolean_result(Gtk.IconView.get_visible_range)
+    """
+    :returns:
+        Returns :obj:`None` if there is no visible range or a tuple
+        containing:
+
+        :start_path: Start of region
+        :end_path: End of region
+
+    :rtype: (**start_path**: :obj:`Gtk.TreePath`, **end_path**: :obj:`Gtk.TreePath`) or :obj:`None`
+
+    {{ docs }}
+    """
+
+    get_dest_item_at_pos = strip_boolean_result(Gtk.IconView.get_dest_item_at_pos)
+    """
+    :param drag_x:
+        the position to determine the destination item for
+    :type drag_x: :obj:`int`
+
+    :param drag_y:
+        the position to determine the destination item for
+    :type drag_y: :obj:`int`
+
+    :returns:
+        If there is no item at the given position return :obj:`None` otherwise
+        a tuple containing:
+
+        :path: The path of the item
+        :pos: The drop position
+
+    :rtype: (**path**: :obj:`Gtk.TreePath`, **pos**: :obj:`Gtk.IconViewDropPosition`) or :obj:`None`
+
+    {{ docs }}
+    """
+
+IconView = override(IconView)
+__all__.append('IconView')
+
+
+class ToolButton(Gtk.ToolButton):
+    __init__ = deprecated_init(Gtk.ToolButton.__init__,
+                               arg_names=('stock_id',),
+                               category=PyGTKDeprecationWarning)
+
+ToolButton = override(ToolButton)
+__all__.append('ToolButton')
+
+
+class IMContext(Gtk.IMContext):
+    get_surrounding = strip_boolean_result(Gtk.IMContext.get_surrounding)
+    """
+    :returns:
+        :obj:`None` if no surrounding text was provided; otherwise a tuple
+        containing:
+
+        :text: text holding context around the insertion point.
+        :cursor_index: byte index of the insertion cursor within `text`
+
+    :rtype: (**text**: :obj:`str`, **cursor_index**: :obj:`int`) or :obj:`None`
+
+    {{ docs }}
+    """
+
+IMContext = override(IMContext)
+__all__.append('IMContext')
+
+
+class RecentInfo(Gtk.RecentInfo):
+    get_application_info = strip_boolean_result(Gtk.RecentInfo.get_application_info)
+    """
+    :param app_name: the name of the application that has registered this item
+    :type app_name: :obj:`str`
+
+    :returns:
+        :obj:`None` if no application with `app_name` has registered this
+        resource inside the recently used list otherwise a tuple containing:
+
+        :app_exec: string containing the command line
+        :count: the number of times this item was registered
+        :time_: the timestamp this item was last registered for this application
+
+    :rtype: (**app_exec**: :obj:`str`, **count**: :obj:`int`, **time_**: :obj:`int`) or :obj:`None`
+
+    {{ docs }}
+    """
+
+RecentInfo = override(RecentInfo)
+__all__.append('RecentInfo')
+
+
+class TextBuffer(Gtk.TextBuffer):
+    def _get_or_create_tag_table(self):
+        table = self.get_tag_table()
+        if table is None:
+            table = Gtk.TextTagTable()
+            self.set_tag_table(table)
+
+        return table
+
+    def create_tag(self, tag_name=None, **properties):
+        """Creates a tag and adds it to the tag table of the TextBuffer.
+
+        :param str tag_name:
+            Name of the new tag, or None
+        :param **properties:
+            Keyword list of properties and their values
+        :returns:
+            A new tag.
+
+        This is equivalent to creating a Gtk.TextTag and then adding the
+        tag to the buffer's tag table. The returned tag is owned by
+        the buffer's tag table.
+
+        If ``tag_name`` is None, the tag is anonymous.
+
+        If ``tag_name`` is not None, a tag called ``tag_name`` must not already
+        exist in the tag table for this buffer.
+
+        Properties are passed as a keyword list of names and values (e.g.
+        foreground='DodgerBlue', weight=Pango.Weight.BOLD)
+        """
+
+        tag = Gtk.TextTag(name=tag_name, **properties)
+        self._get_or_create_tag_table().add(tag)
+        return tag
+
+    def create_mark(self, mark_name, where, left_gravity=False):
+        return Gtk.TextBuffer.create_mark(self, mark_name, where, left_gravity)
+
+    def set_text(self, text, length=-1):
+        """set_text(text, length=-1)
+
+        {{ all }}
+        """
+
+        Gtk.TextBuffer.set_text(self, text, length)
+
+    def insert(self, iter, text, length=-1):
+        """insert(iter, text, length=-1)
+
+        {{ all }}
+        """
+
+        Gtk.TextBuffer.insert(self, iter, text, length)
+
+    def insert_with_tags(self, iter, text, *tags):
+        start_offset = iter.get_offset()
+        self.insert(iter, text)
+
+        if not tags:
+            return
+
+        start = self.get_iter_at_offset(start_offset)
+
+        for tag in tags:
+            self.apply_tag(tag, start, iter)
+
+    def insert_with_tags_by_name(self, iter, text, *tags):
+        if not tags:
+            return
+
+        tag_objs = []
+
+        for tag in tags:
+            tag_obj = self.get_tag_table().lookup(tag)
+            if not tag_obj:
+                raise ValueError('unknown text tag: %s' % tag)
+            tag_objs.append(tag_obj)
+
+        self.insert_with_tags(iter, text, *tag_objs)
+
+    def insert_at_cursor(self, text, length=-1):
+        if not isinstance(text, _basestring):
+            raise TypeError('text must be a string, not %s' % type(text))
+
+        Gtk.TextBuffer.insert_at_cursor(self, text, length)
+
+    get_selection_bounds = strip_boolean_result(Gtk.TextBuffer.get_selection_bounds, fail_ret=())
+    """
+    :returns:
+        If there is no selection returns an empty tuple otherwise a tuple
+        containing:
+
+        :start: selection start
+        :end: selection end
+
+    :rtype: (**start**: :obj:`Gtk.TextIter`, **end**: :obj:`Gtk.TextIter`) or :obj:`None`
+
+    {{ docs }}
+    """
+
+TextBuffer = override(TextBuffer)
+__all__.append('TextBuffer')
+
+
+class TextIter(Gtk.TextIter):
+    forward_search = strip_boolean_result(Gtk.TextIter.forward_search)
+    """
+    :param str: a search string
+    :type str: :obj:`str`
+
+    :param flags: flags affecting how the search is done
+    :type flags: :obj:`Gtk.TextSearchFlags`
+
+    :param limit: location of last possible `match_end`, or :obj:`None` for the end of the buffer
+    :type limit: :obj:`Gtk.TextIter` or :obj:`None`
+
+    :returns:
+        If no match was found returns :obj:`None` otherwise a tuple containing:
+
+        :match_start: start of match
+        :match_end: end of match
+
+    :rtype: (**match\_start**: :obj:`Gtk.TextIter`, **match\_end**: :obj:`Gtk.TextIter`) or :obj:`None`
+
+    {{ docs }}
+    """
+
+    backward_search = strip_boolean_result(Gtk.TextIter.backward_search)
+    """
+    :param str: search string
+    :type str: :obj:`str`
+
+    :param flags: bitmask of flags affecting the search
+    :type flags: :obj:`Gtk.TextSearchFlags`
+
+    :param limit: location of last possible `match_start`, or :obj:`None` for start of buffer
+    :type limit: :obj:`Gtk.TextIter` or :obj:`None`
+
+    :returns:
+        :obj:`None` if not match was found otherwise a tuple containing:
+
+        :match_start: start of match
+        :match_end: end of match
+
+    :rtype: (**match_start**: :obj:`Gtk.TextIter`, **match_end**: :obj:`Gtk.TextIter`) or :obj:`None`
+
+    {{ docs }}
+    """
+
+TextIter = override(TextIter)
+__all__.append('TextIter')
+
+
+class TreeModel(Gtk.TreeModel):
+    """
+    .. note::
+
+        Implements ``__len__``, ``__bool__``, ``__nonzero__``, ``__iter__``,
+        ``__getitem__``, ``__setitem__`` and ``__delitem__``.
+
+        Iterating over a :obj:`Gtk.TreeModel` yields
+        :obj:`Gtk.TreeModelRow` instances.
+
+        ``__getitem__`` returns a :obj:`Gtk.TreeModelRow`.
+
+    {{ all }}
+    """
+
+    def __len__(self):
+        return self.iter_n_children(None)
+
+    def __bool__(self):
+        return True
+
+    # alias for Python 2.x object protocol
+    __nonzero__ = __bool__
+
+    def _getiter(self, key):
+        if isinstance(key, Gtk.TreeIter):
+            return key
+        elif isinstance(key, int) and key < 0:
+            index = len(self) + key
+            if index < 0:
+                raise IndexError("row index is out of bounds: %d" % key)
+            try:
+                aiter = self.get_iter(index)
+            except ValueError:
+                raise IndexError("could not find tree path '%s'" % key)
+            return aiter
+        else:
+            try:
+                aiter = self.get_iter(key)
+            except ValueError:
+                raise IndexError("could not find tree path '%s'" % key)
+            return aiter
+
+    def _coerce_path(self, path):
+        if isinstance(path, Gtk.TreePath):
+            return path
+        else:
+            return TreePath(path)
+
+    def __getitem__(self, key):
+        aiter = self._getiter(key)
+        return TreeModelRow(self, aiter)
+
+    def __setitem__(self, key, value):
+        row = self[key]
+        self.set_row(row.iter, value)
+
+    def __delitem__(self, key):
+        aiter = self._getiter(key)
+        self.remove(aiter)
+
+    def __iter__(self):
+        return TreeModelRowIter(self, self.get_iter_first())
+
+    get_iter_first = strip_boolean_result(Gtk.TreeModel.get_iter_first)
+    """
+    :returns: :obj:`Gtk.TreeIter` or :obj:`None` if the tree is empty.
+    :rtype: :obj:`Gtk.TreeIter` or :obj:`None`
+
+    {{ docs }}
+    """
+
+    iter_children = strip_boolean_result(Gtk.TreeModel.iter_children)
+    """
+    :param parent: the :obj:`Gtk.TreeIter`-struct, or :obj:`None`
+    :type parent: :obj:`Gtk.TreeIter` or :obj:`None`
+
+    :returns: :obj:`Gtk.TreeIter` or :obj:`None`
+    :rtype: :obj:`Gtk.TreeIter` or :obj:`None`
+
+    Sets `iter` to point to the first child of `parent`.
+    If `parent` has no children, :obj:`None` is returned.
+    If `parent` is :obj:`None` returns the first node, equivalent to
+    ``Gtk.TreeModel.iter_first()``.
+    """
+
+    iter_nth_child = strip_boolean_result(Gtk.TreeModel.iter_nth_child)
+    """
+    :param parent: the :obj:`Gtk.TreeIter`-struct to get the child from, or :obj:`None`.
+    :type parent: :obj:`Gtk.TreeIter` or :obj:`None`
+
+    :param n: the index of the desired child
+    :type n: :obj:`int`
+
+    :returns: :obj:`Gtk.TreeIter` if `parent` has an `n`-th child otherwise :obj:`None`
+    :rtype: :obj:`Gtk.TreeIter` or :obj:`None`
+
+    Returns child `iter` of `parent`, using the given index.
+
+    The first index is 0. If `n` is too big, or `parent` has no children,
+    :obj:`None` is returned. `parent` will remain a valid node after this
+    function has been called. As a special case, if `parent` is :obj:`None`,
+    then the `n`-th root node is set.
+    """
+
+    iter_parent = strip_boolean_result(Gtk.TreeModel.iter_parent)
+    """
+    :param child: the :obj:`Gtk.TreeIter`-struct
+    :type child: :obj:`Gtk.TreeIter`
+
+    :returns: :obj:`Gtk.TreeIter` or :obj:`None` if `child` has a parent.
+    :rtype:  :obj:`Gtk.TreeIter` or :obj`None`
+
+    Returns iter of the parent of `child`.
+
+    If `child` is at the toplevel, and doesn't have a parent, then :obj:`None`
+    is returned. `child` will remain a valid node after this function has been
+    called.
+    """
+
+    get_iter_from_string = strip_boolean_result(Gtk.TreeModel.get_iter_from_string,
+                                                ValueError, 'invalid tree path')
+    """
+    :param path_string: a string representation of a :obj:`Gtk.TreePath`-struct
+    :type path_string: :obj:`str`
+
+    :raises: :class:`ValueError` if an iterator pointing to `path_string` does not exist.
+    :returns: a :obj:`Gtk.TreeIter`
+    :rtype: :obj:`Gtk.TreeIter`
+
+    Returns a valid iterator pointing to `path_string`, if it
+    exists. Otherwise raises :class:`ValueError`
+    """
+
+    def get_iter(self, path):
+        """
+        :param path: the :obj:`Gtk.TreePath`-struct
+        :type path: :obj:`Gtk.TreePath`
+
+        :raises: :class:`ValueError` if `path` doesn't exist
+        :returns: a :obj:`Gtk.TreeIter`
+        :rtype: :obj:`Gtk.TreeIter`
+
+        Returns an iterator pointing to `path`. If `path` does not exist
+        :class:`ValueError` is raised.
+        """
+
+        path = self._coerce_path(path)
+        success, aiter = super(TreeModel, self).get_iter(path)
+        if not success:
+            raise ValueError("invalid tree path '%s'" % path)
+        return aiter
+
+    def iter_next(self, iter):
+        """
+        :param iter: the :obj:`Gtk.TreeIter`-struct
+        :type iter: :obj:`Gtk.TreeIter`
+
+        :returns: a :obj:`Gtk.TreeIter` or :obj:`None`
+        :rtype: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        Returns an iterator pointing to the node following `iter` at the
+        current level.
+
+        If there is no next `iter`, :obj:`None` is returned.
+        """
+
+        next_iter = iter.copy()
+        success = super(TreeModel, self).iter_next(next_iter)
+        if success:
+            return next_iter
+
+    def iter_previous(self, iter):
+        """
+        :param iter: the :obj:`Gtk.TreeIter`-struct
+        :type iter: :obj:`Gtk.TreeIter`
+
+        :returns: a :obj:`Gtk.TreeIter` or :obj:`None`
+        :rtype: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        Returns an iterator pointing to the previous node at the current level.
+
+        If there is no previous `iter`, :obj:`None` is returned.
+        """
+
+        prev_iter = iter.copy()
+        success = super(TreeModel, self).iter_previous(prev_iter)
+        if success:
+            return prev_iter
+
+    def _convert_row(self, row):
+        # TODO: Accept a dictionary for row
+        # model.append(None,{COLUMN_ICON: icon, COLUMN_NAME: name})
+        if isinstance(row, str):
+            raise TypeError('Expected a list or tuple, but got str')
+
+        n_columns = self.get_n_columns()
+        if len(row) != n_columns:
+            raise ValueError('row sequence has the incorrect number of elements')
+
+        result = []
+        columns = []
+        for cur_col, value in enumerate(row):
+            # do not try to set None values, they are causing warnings
+            if value is None:
+                continue
+            result.append(self._convert_value(cur_col, value))
+            columns.append(cur_col)
+        return (result, columns)
+
+    def set_row(self, treeiter, row):
+        """
+        :param treeiter: the :obj:`Gtk.TreeIter`
+        :type treeiter: :obj:`Gtk.TreeIter`
+
+        :param row: a list of values for each column
+        :type row: [:obj:`object`]
+
+        Sets all values of a row pointed to by `treeiter` from a list of
+        values passes as `row`. The length of the row has to match the number
+        of columns of the model. :obj:`None` in `row` means the value will be
+        skipped and not set.
+
+        Also see :obj:`Gtk.ListStore.set_value`\() and
+        :obj:`Gtk.TreeStore.set_value`\()
+        """
+
+        converted_row, columns = self._convert_row(row)
+        for column in columns:
+            value = row[column]
+            if value is None:
+                continue  # None means skip this row
+
+            self.set_value(treeiter, column, value)
+
+    def _convert_value(self, column, value):
+        '''Convert value to a GObject.Value of the expected type'''
+
+        if isinstance(value, GObject.Value):
+            return value
+        return GObject.Value(self.get_column_type(column), value)
+
+    def get(self, treeiter, *columns):
+        """
+        :param treeiter: the :obj:`Gtk.TreeIter`
+        :type treeiter: :obj:`Gtk.TreeIter`
+
+        :param \\*columns: a list of column indices to fetch
+        :type columns: (:obj:`int`)
+
+        Returns a tuple of all values specified by their indices in `columns`
+        in the order the indices are contained in `columns`
+
+        Also see :obj:`Gtk.TreeStore.get_value`\()
+        """
+
+        n_columns = self.get_n_columns()
+
+        values = []
+        for col in columns:
+            if not isinstance(col, int):
+                raise TypeError("column numbers must be ints")
+
+            if col < 0 or col >= n_columns:
+                raise ValueError("column number is out of range")
+
+            values.append(self.get_value(treeiter, col))
+
+        return tuple(values)
+
+    #
+    # Signals supporting python iterables as tree paths
+    #
+    def row_changed(self, path, iter):
+        return super(TreeModel, self).row_changed(self._coerce_path(path), iter)
+
+    def row_inserted(self, path, iter):
+        return super(TreeModel, self).row_inserted(self._coerce_path(path), iter)
+
+    def row_has_child_toggled(self, path, iter):
+        return super(TreeModel, self).row_has_child_toggled(self._coerce_path(path),
+                                                            iter)
+
+    def row_deleted(self, path):
+        return super(TreeModel, self).row_deleted(self._coerce_path(path))
+
+    def rows_reordered(self, path, iter, new_order):
+        return super(TreeModel, self).rows_reordered(self._coerce_path(path),
+                                                     iter, new_order)
+
+
+TreeModel = override(TreeModel)
+__all__.append('TreeModel')
+
+
+class TreeSortable(Gtk.TreeSortable, ):
+
+    get_sort_column_id = strip_boolean_result(Gtk.TreeSortable.get_sort_column_id, fail_ret=(None, None))
+    """
+    :returns:
+        `(None, None)` if the sort column is one of the special sort
+        column ids. Otherwise a tuple containing:
+
+        :sort_column_id: The sort column id
+        :order: The :obj:`Gtk.SortType`
+
+    :rtype: (**sort_column_id**: :obj:`int`, **order**: :obj:`Gtk.SortType`) or (:obj:`None`, :obj:`None`)
+
+    Returns `sort_column_id` and `order` with the current sort column and the
+    order. It returns (:obj:`None`, :obj:`None`) if the `sort_column_id` is
+    :obj:`Gtk.TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID` or
+    :obj:`Gtk.TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID`.
+    """
+
+    def set_sort_func(self, sort_column_id, sort_func, user_data=None):
+        super(TreeSortable, self).set_sort_func(sort_column_id, sort_func, user_data)
+
+    def set_default_sort_func(self, sort_func, user_data=None):
+        super(TreeSortable, self).set_default_sort_func(sort_func, user_data)
+
+TreeSortable = override(TreeSortable)
+__all__.append('TreeSortable')
+
+
+class TreeModelSort(Gtk.TreeModelSort):
+    __init__ = deprecated_init(Gtk.TreeModelSort.__init__,
+                               arg_names=('model',),
+                               category=PyGTKDeprecationWarning)
+
+TreeModelSort = override(TreeModelSort)
+__all__.append('TreeModelSort')
+
+
+class ListStore(Gtk.ListStore, TreeModel, TreeSortable):
+    def __init__(self, *column_types):
+        Gtk.ListStore.__init__(self)
+        self.set_column_types(column_types)
+
+    def _do_insert(self, position, row):
+        if row is not None:
+            row, columns = self._convert_row(row)
+            treeiter = self.insert_with_valuesv(position, columns, row)
+        else:
+            treeiter = Gtk.ListStore.insert(self, position)
+
+        return treeiter
+
+    def append(self, row=None):
+        """append(row=None)
+
+        :param row: a list of values to apply to the newly append row or :obj:`None`
+        :type row: [:obj:`object`] or :obj:`None`
+
+        :returns: :obj:`Gtk.TreeIter` of the appended row
+        :rtype: :obj:`Gtk.TreeIter`
+
+        If `row` is :obj:`None` the appended row will be empty and to fill in
+        values you need to call :obj:`Gtk.ListStore.set`\() or
+        :obj:`Gtk.ListStore.set_value`\().
+
+        If `row` isn't :obj:`None` it has to be a list of values which will be
+        used to fill the row .
+        """
+
+        if row:
+            return self._do_insert(-1, row)
+        # gtk_list_store_insert() does not know about the "position == -1"
+        # case, so use append() here
+        else:
+            return Gtk.ListStore.append(self)
+
+    def prepend(self, row=None):
+        """prepend(row=None)
+
+        :param row: a list of values to apply to the newly prepend row or :obj:`None`
+        :type row: [:obj:`object`] or :obj:`None`
+
+        :returns: :obj:`Gtk.TreeIter` of the prepended row
+        :rtype: :obj:`Gtk.TreeIter`
+
+        If `row` is :obj:`None` the prepended row will be empty and to fill in
+        values you need to call :obj:`Gtk.ListStore.set`\() or
+        :obj:`Gtk.ListStore.set_value`\().
+
+        If `row` isn't :obj:`None` it has to be a list of values which will be
+        used to fill the row.
+        """
+
+        return self._do_insert(0, row)
+
+    def insert(self, position, row=None):
+        """insert(position, row=None)
+
+        :param position: the position the new row will be inserted at
+        :type position: :obj:`int`
+
+        :param row: a list of values to apply to the newly inserted row or :obj:`None`
+        :type row: [:obj:`object`] or :obj:`None`
+
+        :returns: :obj:`Gtk.TreeIter` of the inserted row
+        :rtype: :obj:`Gtk.TreeIter`
+
+        If `row` is :obj:`None` the inserted row will be empty and to fill in
+        values you need to call :obj:`Gtk.ListStore.set`\() or
+        :obj:`Gtk.ListStore.set_value`\().
+
+        If `row` isn't :obj:`None` it has to be a list of values which will be
+        used to fill the row.
+
+        If `position` is -1 or is larger than the number of rows on the list,
+        then the new row will be appended to the list.
+        """
+
+        return self._do_insert(position, row)
+
+    # FIXME: sends two signals; check if this can use an atomic
+    # insert_with_valuesv()
+
+    def insert_before(self, sibling, row=None):
+        """insert_before(sibling, row=None)
+
+        :param sibling: A valid :obj:`Gtk.TreeIter`, or :obj:`None`
+        :type sibling: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        :param row: a list of values to apply to the newly inserted row or :obj:`None`
+        :type row: [:obj:`object`] or :obj:`None`
+
+        :returns: :obj:`Gtk.TreeIter` pointing to the new row
+        :rtype: :obj:`Gtk.TreeIter`
+
+        Inserts a new row before `sibling`. If `sibling` is :obj:`None`, then
+        the row will be appended to the end of the list.
+
+        The row will be empty if `row` is :obj:`None. To fill in values, you
+        need to call :obj:`Gtk.ListStore.set`\() or
+        :obj:`Gtk.ListStore.set_value`\().
+
+        If `row` isn't :obj:`None` it has to be a list of values which will be
+        used to fill the row.
+        """
+
+        treeiter = Gtk.ListStore.insert_before(self, sibling)
+
+        if row is not None:
+            self.set_row(treeiter, row)
+
+        return treeiter
+
+    # FIXME: sends two signals; check if this can use an atomic
+    # insert_with_valuesv()
+
+    def insert_after(self, sibling, row=None):
+        """insert_after(sibling, row=None)
+
+        :param sibling: A valid :obj:`Gtk.TreeIter`, or :obj:`None`
+        :type sibling: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        :param row: a list of values to apply to the newly inserted row or :obj:`None`
+        :type row: [:obj:`object`] or :obj:`None`
+
+        :returns: :obj:`Gtk.TreeIter` pointing to the new row
+        :rtype: :obj:`Gtk.TreeIter`
+
+        Inserts a new row after `sibling`. If `sibling` is :obj:`None`, then
+        the row will be prepended to the beginning of the list.
+
+        The row will be empty if `row` is :obj:`None. To fill in values, you
+        need to call :obj:`Gtk.ListStore.set`\() or
+        :obj:`Gtk.ListStore.set_value`\().
+
+        If `row` isn't :obj:`None` it has to be a list of values which will be
+        used to fill the row.
+        """
+
+        treeiter = Gtk.ListStore.insert_after(self, sibling)
+
+        if row is not None:
+            self.set_row(treeiter, row)
+
+        return treeiter
+
+    def set_value(self, treeiter, column, value):
+        """
+        {{ all }}
+
+        `value` can also be a Python value and will be converted to a
+        :obj:`GObject.Value` using the corresponding column type (See
+        :obj:`Gtk.ListStore.set_column_types`\()).
+        """
+
+        value = self._convert_value(column, value)
+        Gtk.ListStore.set_value(self, treeiter, column, value)
+
+    def set(self, treeiter, *args):
+        def _set_lists(columns, values):
+            if len(columns) != len(values):
+                raise TypeError('The number of columns do not match the number of values')
+            for col_num, val in zip(columns, values):
+                if not isinstance(col_num, int):
+                    raise TypeError('TypeError: Expected integer argument for column.')
+                self.set_value(treeiter, col_num, val)
+
+        if args:
+            if isinstance(args[0], int):
+                columns = args[::2]
+                values = args[1::2]
+                _set_lists(columns, values)
+            elif isinstance(args[0], (tuple, list)):
+                if len(args) != 2:
+                    raise TypeError('Too many arguments')
+                _set_lists(args[0], args[1])
+            elif isinstance(args[0], dict):
+                columns = args[0].keys()
+                values = args[0].values()
+                _set_lists(columns, values)
+            else:
+                raise TypeError('Argument list must be in the form of (column, value, ...), ((columns,...), (values, ...)) or {column: value}.  No -1 termination is needed.')
+
+ListStore = override(ListStore)
+__all__.append('ListStore')
+
+
+class TreeModelRow(object):
+    """A :obj:`Gtk.TreeModelRow` object represents a row in a
+    :obj:`Gtk.TreeModel`. A :obj:`Gtk.TreeModelRow` is created by taking the
+    mapping of a :obj:`Gtk.TreeModel`. For example::
+
+        treemodelrow = liststore[0]
+        treemodelrow = liststore[(0,)]
+        treemodelrow = liststore['0']
+
+    all create a :obj:`Gtk.TreeModelRow` for the first row in liststore. The
+    :obj:`Gtk.TreeModelRow` implements some of the Python sequence protocol
+    that makes the row behave like a sequence of objects. Specifically a tree
+    model row has the capability of:
+
+    * getting and setting column values,
+    * returning a tuple or list containing the column values, and
+    * getting the number of values in the row i.e. the number of columns
+
+    For example to get and set the value in the second column of a row, you
+    could do the following::
+
+        value = treemodelrow[1]
+        treemodelrow[1] = value
+
+    You can use the Python len() function to get the number of columns in the
+    row and you can retrieve all the column values as a list (tuple) using the
+    Python list() (tuple()) function.
+
+    The :obj:`Gtk.TreeModelRow` supports one method: the iterchildren() method
+    that returns a :obj:`Gtk.TreeModelRowIter` for iterating over the children
+    of the row.
+    """
+
+    def __init__(self, model, iter_or_path):
+        if not isinstance(model, Gtk.TreeModel):
+            raise TypeError("expected Gtk.TreeModel, %s found" % type(model).__name__)
+        self.model = model
+        if isinstance(iter_or_path, Gtk.TreePath):
+            self.iter = model.get_iter(iter_or_path)
+        elif isinstance(iter_or_path, Gtk.TreeIter):
+            self.iter = iter_or_path
+        else:
+            raise TypeError("expected Gtk.TreeIter or Gtk.TreePath, \
+                %s found" % type(iter_or_path).__name__)
+
+    iter = None
+    """A :obj:`Gtk.TreeIter` pointing at the row"""
+
+    model = None
+    """	The :obj:`Gtk.TreeModel` that the row is part of"""
+
+    @property
+    def path(self):
+        """The tree path of the row"""
+
+        return self.model.get_path(self.iter)
+
+    @property
+    def next(self):
+        """	The next :obj:`Gtk.TreeModelRow` or None"""
+
+        return self.get_next()
+
+    @property
+    def previous(self):
+        """	The previous :obj:`Gtk.TreeModelRow` or None"""
+
+        return self.get_previous()
+
+    @property
+    def parent(self):
+        """The parent :obj:`Gtk.TreeModelRow` or htis row or None"""
+
+        return self.get_parent()
+
+    def get_next(self):
+        """Returns the next :obj:`Gtk.TreeModelRow` or None"""
+
+        next_iter = self.model.iter_next(self.iter)
+        if next_iter:
+            return TreeModelRow(self.model, next_iter)
+
+    def get_previous(self):
+        """Returns the previous :obj:`Gtk.TreeModelRow` or None"""
+
+        prev_iter = self.model.iter_previous(self.iter)
+        if prev_iter:
+            return TreeModelRow(self.model, prev_iter)
+
+    def get_parent(self):
+        """Returns the parent :obj:`Gtk.TreeModelRow` or htis row or None"""
+
+        parent_iter = self.model.iter_parent(self.iter)
+        if parent_iter:
+            return TreeModelRow(self.model, parent_iter)
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            if key >= self.model.get_n_columns():
+                raise IndexError("column index is out of bounds: %d" % key)
+            elif key < 0:
+                key = self._convert_negative_index(key)
+            return self.model.get_value(self.iter, key)
+        elif isinstance(key, slice):
+            start, stop, step = key.indices(self.model.get_n_columns())
+            alist = []
+            for i in range(start, stop, step):
+                alist.append(self.model.get_value(self.iter, i))
+            return alist
+        else:
+            raise TypeError("indices must be integers, not %s" % type(key).__name__)
+
+    def __setitem__(self, key, value):
+        if isinstance(key, int):
+            if key >= self.model.get_n_columns():
+                raise IndexError("column index is out of bounds: %d" % key)
+            elif key < 0:
+                key = self._convert_negative_index(key)
+            self.model.set_value(self.iter, key, value)
+        elif isinstance(key, slice):
+            start, stop, step = key.indices(self.model.get_n_columns())
+            indexList = range(start, stop, step)
+            if len(indexList) != len(value):
+                raise ValueError(
+                    "attempt to assign sequence of size %d to slice of size %d"
+                    % (len(value), len(indexList)))
+
+            for i, v in enumerate(indexList):
+                self.model.set_value(self.iter, v, value[i])
+        else:
+            raise TypeError("index must be an integer or slice, not %s" % type(key).__name__)
+
+    def _convert_negative_index(self, index):
+        new_index = self.model.get_n_columns() + index
+        if new_index < 0:
+            raise IndexError("column index is out of bounds: %d" % index)
+        return new_index
+
+    def iterchildren(self):
+        """Returns a :obj:`Gtk.TreeModelRowIter` for the row's children"""
+
+        child_iter = self.model.iter_children(self.iter)
+        return TreeModelRowIter(self.model, child_iter)
+
+__all__.append('TreeModelRow')
+
+
+class TreeModelRowIter(object):
+    """A :obj:`Gtk.TreeModelRowIter` is an object that implements the Python
+    Iterator protocol. It provides the means to iterate over a set of
+    :obj:`Gtk.TreeModelRow` objects in a :obj:`Gtk.TreeModel`. A
+    :obj:`Gtk.TreeModelRowIter` is created by calling the Python iter()
+    function on a :obj:`Gtk.TreeModel` object::
+
+        treemodelrowiter = iter(treestore)
+
+    or, calling the :obj:`Gtk.TreeModelRow.iterchildren`\() method to iterate
+    over its child rows.
+
+    Each time you call the next() method it returns the next sibling
+    :obj:`Gtk.TreeModelRow`. When there are no rows left the StopIteration
+    exception is raised. Note that a :obj:`Gtk.TreeModelRowIter` does not
+    iterate over the child rows of the rows it is iterating over. You'll have
+    to use the :obj:`Gtk.TreeModelRow.iterchildren`\() method to retrieve an
+    iterator for the child rows.
+    """
+
+    def __init__(self, model, aiter):
+        self.model = model
+        self.iter = aiter
+
+    def __next__(self):
+        if not self.iter:
+            raise StopIteration
+        row = TreeModelRow(self.model, self.iter)
+        self.iter = self.model.iter_next(self.iter)
+        return row
+
+    # alias for Python 2.x object protocol
+    next = __next__
+    """Returns the next :obj:`Gtk.TreeModelRow`"""
+
+    def __iter__(self):
+        return self
+
+__all__.append('TreeModelRowIter')
+
+
+class TreePath(Gtk.TreePath):
+
+    def __new__(cls, path=0):
+        if isinstance(path, int):
+            path = str(path)
+        elif not isinstance(path, _basestring):
+            path = ":".join(str(val) for val in path)
+
+        if len(path) == 0:
+            raise TypeError("could not parse subscript '%s' as a tree path" % path)
+        try:
+            return TreePath.new_from_string(path)
+        except TypeError:
+            raise TypeError("could not parse subscript '%s' as a tree path" % path)
+
+    def __init__(self, *args, **kwargs):
+        super(TreePath, self).__init__()
+
+    def __str__(self):
+        return self.to_string()
+
+    def __lt__(self, other):
+        return other is not None and self.compare(other) < 0
+
+    def __le__(self, other):
+        return other is not None and self.compare(other) <= 0
+
+    def __eq__(self, other):
+        return other is not None and self.compare(other) == 0
+
+    def __ne__(self, other):
+        return other is None or self.compare(other) != 0
+
+    def __gt__(self, other):
+        return other is None or self.compare(other) > 0
+
+    def __ge__(self, other):
+        return other is None or self.compare(other) >= 0
+
+    def __iter__(self):
+        return iter(self.get_indices())
+
+    def __len__(self):
+        return self.get_depth()
+
+    def __getitem__(self, index):
+        return self.get_indices()[index]
+
+TreePath = override(TreePath)
+__all__.append('TreePath')
+
+
+class TreeStore(Gtk.TreeStore, TreeModel, TreeSortable):
+    def __init__(self, *column_types):
+        Gtk.TreeStore.__init__(self)
+        self.set_column_types(column_types)
+
+    def _do_insert(self, parent, position, row):
+        if row is not None:
+            row, columns = self._convert_row(row)
+            treeiter = self.insert_with_values(parent, position, columns, row)
+        else:
+            treeiter = Gtk.TreeStore.insert(self, parent, position)
+
+        return treeiter
+
+    def append(self, parent, row=None):
+        """append(parent, row=None)
+
+        :param parent: A valid :obj:`Gtk.TreeIter`, or :obj:`None`
+        :type parent: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        :param row: a list of values to apply to the newly inserted row or :obj:`None`
+        :type row: [:obj:`object`] or :obj:`None`
+
+        :returns: obj:`Gtk.TreeIter` pointing to the inserted row
+        :rtype: :obj:`Gtk.TreeIter`
+
+        Appends a new row to `self`. If `parent` is not :obj:`None`, then it
+        will append the new row after the last child of `parent`, otherwise it
+        will append a row to the top level.
+
+        The returned `iterator will point to the new row. The row will be
+        empty after this function is called  if `row` is :obj:`None`. To fill
+        in values, you need to call :obj:`Gtk.TreeStore.set`\() or
+        :obj:`Gtk.TreeStore.set_value`\().
+
+        If `row` isn't :obj:`None` it has to be a list of values which will be
+        used to fill the row.
+        """
+
+        return self._do_insert(parent, -1, row)
+
+    def prepend(self, parent, row=None):
+        """prepend(parent, row=None)
+
+        :param parent: A valid :obj:`Gtk.TreeIter`, or :obj:`None`
+        :type parent: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        :param row: a list of values to apply to the newly inserted row or :obj:`None`
+        :type row: [:obj:`object`] or :obj:`None`
+
+        :returns: obj:`Gtk.TreeIter` pointing to the inserted row
+        :rtype: :obj:`Gtk.TreeIter`
+
+        Prepends a new row to `self`. If `parent` is not :obj:`None`, then it
+        will prepend the new row before the first child of `parent`, otherwise
+        it will prepend a row to the top level.
+
+        The returned `iterator will point to the new row. The row will be
+        empty after this function is called if `row` is :obj:`None`. To fill
+        in values, you need to call :obj:`Gtk.TreeStore.set`\() or
+        :obj:`Gtk.TreeStore.set_value`\().
+
+        If `row` isn't :obj:`None` it has to be a list of values which will be
+        used to fill the row.
+        """
+
+        return self._do_insert(parent, 0, row)
+
+    def insert(self, parent, position, row=None):
+        """insert(parent, position, row=None)
+
+        :param parent:
+            A valid :obj:`Gtk.TreeIter`, or :obj:`None`
+        :type parent: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        :param position:
+            position to insert the new row, or -1 for last
+        :type position: :obj:`int`
+
+        :param row: a list of values to apply to the newly inserted row or :obj:`None`
+        :type row: [:obj:`object`] or :obj:`None`
+
+        :returns: a :obj:`Gtk.TreeIter` pointing to the new row
+        :rtype: :obj:`Gtk.TreeIter`
+
+        Creates a new row at `position`.  If parent is not :obj:`None`, then
+        the row will be made a child of `parent`.  Otherwise, the row will be
+        created at the toplevel. If `position` is -1 or is larger than the
+        number of rows at that level, then the new row will be inserted to the
+        end of the list.
+
+        The returned iterator will point to the newly inserted row. The row
+        will be empty after this function is called if `row` is :obj:`None`.
+        To fill in values, you need to call :obj:`Gtk.TreeStore.set`\() or
+        :obj:`Gtk.TreeStore.set_value`\().
+
+        If `row` isn't :obj:`None` it has to be a list of values which will be
+        used to fill the row.
+        """
+
+        return self._do_insert(parent, position, row)
+
+    # FIXME: sends two signals; check if this can use an atomic
+    # insert_with_valuesv()
+
+    def insert_before(self, parent, sibling, row=None):
+        """insert_before(parent, sibling, row=None)
+
+        :param parent: A valid :obj:`Gtk.TreeIter`, or :obj:`None`
+        :type parent: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        :param sibling: A valid :obj:`Gtk.TreeIter`, or :obj:`None`
+        :type sibling: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        :param row: a list of values to apply to the newly inserted row or :obj:`None`
+        :type row: [:obj:`object`] or :obj:`None`
+
+        :returns: a :obj:`Gtk.TreeIter` pointing to the new row
+        :rtype: :obj:`Gtk.TreeIter`
+
+        Inserts a new row before `sibling`. If `sibling` is :obj:`None`, then
+        the row will be appended to `parent` 's children. If `parent` and
+        `sibling` are :obj:`None`, then the row will be appended to the
+        toplevel.  If both `sibling` and `parent` are set, then `parent` must
+        be the parent of `sibling`.  When `sibling` is set, `parent` is
+        optional.
+
+        The returned iterator will point to this new row. The row will be
+        empty after this function is called if `row` is :obj:`None`.  To fill
+        in values, you need to call :obj:`Gtk.TreeStore.set`\() or
+        :obj:`Gtk.TreeStore.set_value`\().
+
+        If `row` isn't :obj:`None` it has to be a list of values which will be
+        used to fill the row.
+        """
+
+        treeiter = Gtk.TreeStore.insert_before(self, parent, sibling)
+
+        if row is not None:
+            self.set_row(treeiter, row)
+
+        return treeiter
+
+    # FIXME: sends two signals; check if this can use an atomic
+    # insert_with_valuesv()
+
+    def insert_after(self, parent, sibling, row=None):
+        """
+        :param parent: A valid :obj:`Gtk.TreeIter`, or :obj:`None`
+        :type parent: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        :param sibling: A valid :obj:`Gtk.TreeIter`, or :obj:`None`
+        :type sibling: :obj:`Gtk.TreeIter` or :obj:`None`
+
+        :param row: a list of values to apply to the newly inserted row or :obj:`None`
+        :type row: [:obj:`object`] or :obj:`None`
+
+        :returns: a :obj:`Gtk.TreeIter` pointing to the new row
+        :rtype: :obj:`Gtk.TreeIter`
+
+        Inserts a new row after `sibling`.  If `sibling` is :obj:`None`, then
+        the row will be prepended to `parent` 's children.  If `parent` and
+        `sibling` are :obj:`None`, then the row will be prepended to the
+        toplevel.  If both `sibling` and `parent` are set, then `parent` must
+        be the parent of `sibling`.  When `sibling` is set, `parent` is
+        optional.
+
+        The returned iterator will point to this new row.  The row will be
+        empty after this function is called if `row` is :obj:`None`.  To fill
+        in values, you need to call :obj:`Gtk.TreeStore.set`\() or
+        :obj:`Gtk.TreeStore.set_value`\().
+
+        If `row` isn't :obj:`None` it has to be a list of values which will be
+        used to fill the row.
+        """
+
+        treeiter = Gtk.TreeStore.insert_after(self, parent, sibling)
+
+        if row is not None:
+            self.set_row(treeiter, row)
+
+        return treeiter
+
+    def set_value(self, treeiter, column, value):
+        """
+        {{ all }}
+
+        `value` can also be a Python value and will be converted to a
+        :obj:`GObject.Value` using the corresponding column type (See
+        :obj:`Gtk.ListStore.set_column_types`\()).
+        """
+
+        value = self._convert_value(column, value)
+        Gtk.TreeStore.set_value(self, treeiter, column, value)
+
+    def set(self, treeiter, *args):
+
+        def _set_lists(columns, values):
+            if len(columns) != len(values):
+                raise TypeError('The number of columns do not match the number of values')
+            for col_num, val in zip(columns, values):
+                if not isinstance(col_num, int):
+                    raise TypeError('TypeError: Expected integer argument for column.')
+                self.set_value(treeiter, col_num, val)
+
+        if args:
+            if isinstance(args[0], int):
+                columns = args[::2]
+                values = args[1::2]
+                _set_lists(columns, values)
+            elif isinstance(args[0], (tuple, list)):
+                if len(args) != 2:
+                    raise TypeError('Too many arguments')
+                _set_lists(args[0], args[1])
+            elif isinstance(args[0], dict):
+                columns = args[0].keys()
+                values = args[0].values()
+                _set_lists(columns, values)
+            else:
+                raise TypeError('Argument list must be in the form of (column, value, ...), ((columns,...), (values, ...)) or {column: value}.  No -1 termination is needed.')
+
+TreeStore = override(TreeStore)
+__all__.append('TreeStore')
+
+
+class TreeView(Gtk.TreeView, Container):
+    __init__ = deprecated_init(Gtk.TreeView.__init__,
+                               arg_names=('model',),
+                               category=PyGTKDeprecationWarning)
+
+    get_path_at_pos = strip_boolean_result(Gtk.TreeView.get_path_at_pos)
+    """
+    :param x: The x position to be identified (relative to bin\_window).
+    :type x: :obj:`int`
+
+    :param y: The y position to be identified (relative to bin\_window).
+    :type y: :obj:`int`
+
+    :returns:
+        :obj:`None` if the row doesn't exist at that coordinates or
+        a tuple containing:
+
+        :path: a :obj:`Gtk.TreePath`
+        :column: a :obj:`Gtk.TreeViewColumn`
+        :cell_x: the X coordinate relative to the cell
+        :cell_y: the Y coordinate relative to the cell
+
+    :rtype: (**path**: :obj:`Gtk.TreePath` or :obj:`None`, **column**: :obj:`Gtk.TreeViewColumn` or :obj:`None`, **cell_x**: :obj:`int`, **cell_y**: :obj:`int`) or :obj:`None`
+
+    {{ docs }}
+    """
+
+    get_visible_range = strip_boolean_result(Gtk.TreeView.get_visible_range)
+    """
+    :returns:
+        Either :obj:`None` if there is no visible range or a tuple containing:
+
+        :start_path: start of region
+        :end_path: end of region
+
+    :rtype: (**start_path**: :obj:`Gtk.TreePath`, **end_path**: :obj:`Gtk.TreePath`) or :obj:`None`
+
+    Returns the first and last visible path. Note that there may be invisible
+    paths in between.
+    """
+
+    get_dest_row_at_pos = strip_boolean_result(Gtk.TreeView.get_dest_row_at_pos)
+    """
+    :param drag_x: the position to determine the destination row for
+    :type drag_x: :obj:`int`
+
+    :param drag_y: the position to determine the destination row for
+    :type drag_y: :obj:`int`
+
+    :returns:
+        :obj:`None` if there is no row at the given position or a tuple
+        containing:
+
+        :path: the path of the highlighted row
+        :pos: the drop position
+
+    :rtype: (**path**: :obj:`Gtk.TreePath` or :obj:`None`, **pos**: :obj:`Gtk.TreeViewDropPosition`) or :obj:`None`
+
+    Determines the destination row for a given position.  `drag_x` and
+    `drag_y` are expected to be in widget coordinates.  This function is only
+    meaningful if `self` is realized.  Therefore this function will always
+    return :obj:`None` if `self` is not realized or does not have a model.
+    """
+
+    def enable_model_drag_source(self, start_button_mask, targets, actions):
+        target_entries = _construct_target_list(targets)
+        super(TreeView, self).enable_model_drag_source(start_button_mask,
+                                                       target_entries,
+                                                       actions)
+
+    def enable_model_drag_dest(self, targets, actions):
+        target_entries = _construct_target_list(targets)
+        super(TreeView, self).enable_model_drag_dest(target_entries,
+                                                     actions)
+
+    def scroll_to_cell(self, path, column=None, use_align=False, row_align=0.0, col_align=0.0):
+        if not isinstance(path, Gtk.TreePath):
+            path = TreePath(path)
+        super(TreeView, self).scroll_to_cell(path, column, use_align, row_align, col_align)
+
+    def set_cursor(self, path, column=None, start_editing=False):
+        if not isinstance(path, Gtk.TreePath):
+            path = TreePath(path)
+        super(TreeView, self).set_cursor(path, column, start_editing)
+
+    def get_cell_area(self, path, column=None):
+        if not isinstance(path, Gtk.TreePath):
+            path = TreePath(path)
+        return super(TreeView, self).get_cell_area(path, column)
+
+    def insert_column_with_attributes(self, position, title, cell, **kwargs):
+        """
+        :param position: The position to insert the new column in
+        :type position: :obj:`int`
+
+        :param title: The title to set the header to
+        :type title: :obj:`str`
+
+        :param cell: The :obj:`Gtk.CellRenderer`
+        :type cell: :obj:`Gtk.CellRenderer`
+
+        {{ docs }}
+        """
+
+        column = TreeViewColumn()
+        column.set_title(title)
+        column.pack_start(cell, False)
+        self.insert_column(column, position)
+        column.set_attributes(cell, **kwargs)
+
+TreeView = override(TreeView)
+__all__.append('TreeView')
+
+
+class TreeViewColumn(Gtk.TreeViewColumn):
+    def __init__(self, title='',
+                 cell_renderer=None,
+                 **attributes):
+        Gtk.TreeViewColumn.__init__(self, title=title)
+        if cell_renderer:
+            self.pack_start(cell_renderer, True)
+
+        for (name, value) in attributes.items():
+            self.add_attribute(cell_renderer, name, value)
+
+    cell_get_position = strip_boolean_result(Gtk.TreeViewColumn.cell_get_position)
+    """
+    :param cell_renderer: a :obj:`Gtk.CellRenderer`
+    :type cell_renderer: :obj:`Gtk.CellRenderer`
+
+    :returns:
+        :obj:`None` if `cell` does not belong to `self` or a tuple containing:
+
+        :x_offset: the horizontal position of `cell` within `self`
+        :width: the width of `cell`
+
+    :rtype: (**x_offset**: :obj:`int`, **width**: :obj:`int`) or :obj:`None`
+
+    Obtains the horizontal position and size of a cell in a column. If the
+    cell is not found in the column :obj:`None` is returned.
+    """
+
+    def set_cell_data_func(self, cell_renderer, func, func_data=None):
+        super(TreeViewColumn, self).set_cell_data_func(cell_renderer, func, func_data)
+
+    def set_attributes(self, cell_renderer, **attributes):
+        """
+        :param cell_renderer: the :obj:`Gtk.CellRenderer` we're setting the attributes of
+        :type cell_renderer: :obj:`Gtk.CellRenderer`
+
+        {{ docs }}
+        """
+
+        Gtk.CellLayout.clear_attributes(self, cell_renderer)
+
+        for (name, value) in attributes.items():
+            Gtk.CellLayout.add_attribute(self, cell_renderer, name, value)
+
+
+TreeViewColumn = override(TreeViewColumn)
+__all__.append('TreeViewColumn')
+
+
+class TreeSelection(Gtk.TreeSelection):
+
+    def select_path(self, path):
+        if not isinstance(path, Gtk.TreePath):
+            path = TreePath(path)
+        super(TreeSelection, self).select_path(path)
+
+    def get_selected(self):
+        """
+        :returns:
+            :model: the :obj:`Gtk.TreeModel`
+            :iter: The :obj:`Gtk.TreeIter` or :obj:`None`
+
+        :rtype: (**model**: :obj:`Gtk.TreeModel`, **iter**: :obj:`Gtk.TreeIter` or :obj:`None`)
+
+        {{ docs }}
+        """
+
+        success, model, aiter = super(TreeSelection, self).get_selected()
+        if success:
+            return (model, aiter)
+        else:
+            return (model, None)
+
+    # for compatibility with PyGtk
+
+    def get_selected_rows(self):
+        """
+        :returns:
+            A list containing a :obj:`Gtk.TreePath` for each selected row
+            and a :obj:`Gtk.TreeModel` or :obj:`None`.
+
+        :rtype: (:obj:`Gtk.TreeModel`, [:obj:`Gtk.TreePath`])
+
+        {{ docs }}
+        """
+
+        rows, model = super(TreeSelection, self).get_selected_rows()
+        return (model, rows)
+
+
+TreeSelection = override(TreeSelection)
+__all__.append('TreeSelection')
+
+
+class Button(Gtk.Button, Container):
+    _init = deprecated_init(Gtk.Button.__init__,
+                            arg_names=('label', 'stock', 'use_stock', 'use_underline'),
+                            ignore=('stock',),
+                            category=PyGTKDeprecationWarning,
+                            stacklevel=3)
+
+    def __init__(self, *args, **kwargs):
+        # Doubly deprecated initializer, the stock keyword is non-standard.
+        # Simply give a warning that stock items are deprecated even though
+        # we want to deprecate the non-standard keyword as well here from
+        # the overrides.
+        if 'stock' in kwargs and kwargs['stock']:
+            warnings.warn('Stock items are deprecated. '
+                          'Please use: Gtk.Button.new_with_mnemonic(label)',
+                          PyGTKDeprecationWarning, stacklevel=2)
+            new_kwargs = kwargs.copy()
+            new_kwargs['label'] = new_kwargs['stock']
+            new_kwargs['use_stock'] = True
+            new_kwargs['use_underline'] = True
+            del new_kwargs['stock']
+            Gtk.Button.__init__(self, **new_kwargs)
+        else:
+            self._init(*args, **kwargs)
+
+Button = override(Button)
+__all__.append('Button')
+
+
+class LinkButton(Gtk.LinkButton):
+    __init__ = deprecated_init(Gtk.LinkButton.__init__,
+                               arg_names=('uri', 'label'),
+                               category=PyGTKDeprecationWarning)
+
+LinkButton = override(LinkButton)
+__all__.append('LinkButton')
+
+
+class Label(Gtk.Label):
+    __init__ = deprecated_init(Gtk.Label.__init__,
+                               arg_names=('label',),
+                               category=PyGTKDeprecationWarning)
+
+Label = override(Label)
+__all__.append('Label')
+
+
+class Adjustment(Gtk.Adjustment):
+    _init = deprecated_init(Gtk.Adjustment.__init__,
+                            arg_names=('value', 'lower', 'upper',
+                                       'step_increment', 'page_increment', 'page_size'),
+                            deprecated_aliases={'page_increment': 'page_incr',
+                                                'step_increment': 'step_incr'},
+                            category=PyGTKDeprecationWarning,
+                            stacklevel=3)
+
+    def __init__(self, *args, **kwargs):
+        self._init(*args, **kwargs)
+
+        # The value property is set between lower and (upper - page_size).
+        # Just in case lower, upper or page_size was still 0 when value
+        # was set, we set it again here.
+        if 'value' in kwargs:
+            self.set_value(kwargs['value'])
+
+Adjustment = override(Adjustment)
+__all__.append('Adjustment')
+
+
+class Table(Gtk.Table, Container):
+    __init__ = deprecated_init(Gtk.Table.__init__,
+                               arg_names=('n_rows', 'n_columns', 'homogeneous'),
+                               deprecated_aliases={'n_rows': 'rows', 'n_columns': 'columns'},
+                               category=PyGTKDeprecationWarning)
+
+    def attach(self, child, left_attach, right_attach, top_attach, bottom_attach, xoptions=Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL, yoptions=Gtk.AttachOptions.EXPAND | Gtk.AttachOptions.FILL, xpadding=0, ypadding=0):
+        Gtk.Table.attach(self, child, left_attach, right_attach, top_attach, bottom_attach, xoptions, yoptions, xpadding, ypadding)
+
+Table = override(Table)
+__all__.append('Table')
+
+
+class ScrolledWindow(Gtk.ScrolledWindow):
+    __init__ = deprecated_init(Gtk.ScrolledWindow.__init__,
+                               arg_names=('hadjustment', 'vadjustment'),
+                               category=PyGTKDeprecationWarning)
+
+ScrolledWindow = override(ScrolledWindow)
+__all__.append('ScrolledWindow')
+
+
+class HScrollbar(Gtk.HScrollbar):
+    __init__ = deprecated_init(Gtk.HScrollbar.__init__,
+                               arg_names=('adjustment',),
+                               category=PyGTKDeprecationWarning)
+
+HScrollbar = override(HScrollbar)
+__all__.append('HScrollbar')
+
+
+class VScrollbar(Gtk.VScrollbar):
+    __init__ = deprecated_init(Gtk.VScrollbar.__init__,
+                               arg_names=('adjustment',),
+                               category=PyGTKDeprecationWarning)
+
+VScrollbar = override(VScrollbar)
+__all__.append('VScrollbar')
+
+
+class Paned(Gtk.Paned):
+    def pack1(self, child, resize=False, shrink=True):
+        super(Paned, self).pack1(child, resize, shrink)
+
+    def pack2(self, child, resize=True, shrink=True):
+        super(Paned, self).pack2(child, resize, shrink)
+
+Paned = override(Paned)
+__all__.append('Paned')
+
+
+class Arrow(Gtk.Arrow):
+    __init__ = deprecated_init(Gtk.Arrow.__init__,
+                               arg_names=('arrow_type', 'shadow_type'),
+                               category=PyGTKDeprecationWarning)
+
+Arrow = override(Arrow)
+__all__.append('Arrow')
+
+
+class IconSet(Gtk.IconSet):
+    def __new__(cls, pixbuf=None):
+        if pixbuf is not None:
+            warnings.warn('Gtk.IconSet(pixbuf) has been deprecated. Please use: '
+                          'Gtk.IconSet.new_from_pixbuf(pixbuf)',
+                          PyGTKDeprecationWarning, stacklevel=2)
+            iconset = Gtk.IconSet.new_from_pixbuf(pixbuf)
+        else:
+            iconset = Gtk.IconSet.__new__(cls)
+        return iconset
+
+    def __init__(self, *args, **kwargs):
+        return super(IconSet, self).__init__()
+
+IconSet = override(IconSet)
+__all__.append('IconSet')
+
+
+class Viewport(Gtk.Viewport):
+    __init__ = deprecated_init(Gtk.Viewport.__init__,
+                               arg_names=('hadjustment', 'vadjustment'),
+                               category=PyGTKDeprecationWarning)
+
+Viewport = override(Viewport)
+__all__.append('Viewport')
+
+
+class TreeModelFilter(Gtk.TreeModelFilter):
+    def set_visible_func(self, func, data=None):
+        super(TreeModelFilter, self).set_visible_func(func, data)
+
+    def set_value(self, iter, column, value):
+        """Set the value of the child model"""
+
+        # Delegate to child model
+        iter = self.convert_iter_to_child_iter(iter)
+        self.get_model().set_value(iter, column, value)
+
+TreeModelFilter = override(TreeModelFilter)
+__all__.append('TreeModelFilter')
+
+if Gtk._version != '2.0':
+    class Menu(Gtk.Menu):
+        def popup(self, parent_menu_shell, parent_menu_item, func, data, button, activate_time):
+            self.popup_for_device(None, parent_menu_shell, parent_menu_item, func, data, button, activate_time)
+    Menu = override(Menu)
+    __all__.append('Menu')
+
+_Gtk_main_quit = Gtk.main_quit
+
+
+@override(Gtk.main_quit)
+def main_quit(*args):
+    _Gtk_main_quit()
+
+stock_lookup = strip_boolean_result(Gtk.stock_lookup)
+"""
+:param stock_id: a stock item name
+:type stock_id: :obj:`str`
+
+:returns: a stock item or :obj:`None` if the stock icon isn't known.
+:rtype: :obj:`Gtk.StockItem` or :obj:`None`
+"""
+
+__all__.append('stock_lookup')
+
+initialized, argv = Gtk.init_check(sys.argv)
+sys.argv = list(argv)