15ac05c37c7424daf59d0e95939d133ce2be53c4
diff --git a/gi/overrides/Gtk.py b/gi/overrides/Gtk.py
index b5fb605..807488e 100644
--- a/gi/overrides/Gtk.py
+++ b/gi/overrides/Gtk.py
@@ -19,13 +19,122 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
 # USA
 
+import gobject
+from gi.repository import Gdk
+from gi.repository import GObject
+from ..types import override
 from ..importer import modules
 
 Gtk = modules['Gtk']
 
+class GenericTreeModel(gobject.GObject, Gtk.TreeModel):
+    __gtype_name__ = "GenericTreeModel"
 
-__all__ = []
+    def __init__(self):
+        gobject.GObject.__init__(self)
 
+    def get_iter(self, path):
+        result = None
+        success = False
+        iter = None
+
+        if isinstance(path, basestring):
+            (success, iter) = Gtk.TreeModel.get_iter_from_string(self, path)
+        elif isinstance(path, Gtk.TreePath):
+            (success, iter) = Gtk.TreeModel.get_iter(self, path)
+        elif isinstance(path, (tuple, list)):
+            # FIXME: We should be doing this but PyGI doesn't support valists yet
+            # gtk_path = Gtk.TreePath.new_from_indices(*path, -1)
+            gtk_path = Gtk.TreePath.new()
+            for i in path:
+                gtk_path.append_index(i)
+            (success, iter) = Gtk.TreeModel.get_iter(self, gtk_path)
+
+        else:
+            raise ValueError('Expected a string, Gtk.TreePath, tuple or list, got %s' % type(path))
+
+        if success:
+            result = iter
+
+        return result
+
+    def do_get_flags(self):
+        return self.on_get_flags()
+
+    def do_get_n_columns(self):
+        return self.on_get_n_columns()
+
+    def do_get_column_type(self, index):
+        return self.on_get_column_type(*index)
+
+    def do_get_iter(self, path):
+        return self.do_get_iter(path)
+
+    def do_get_path(self, iter):
+        return self.on_get_path(iter)
+
+    def do_get_value(self, iter, col):
+        return self.on_get_value(iter, col)
+
+    def do_iter_next(self, iter):
+        return self.on_iter_next(iter)
+
+    def do_iter_children(self, parent_iter):
+        return self.on_iter_children(parent_iter)
+
+    def do_iter_has_child(self, iter):
+        return self.on_iter_has_child(iter)
+
+    def do_iter_n_children(self, iter):
+        return self.on_iter_n_children(iter)
+
+    def do_iter_nth_child(self, parent_iter, index):
+        return self.on_iter_nth_child(parent_iter, index)
+
+    def do_iter_parent(self, child_iter):
+        return self.on_iter_parent(child_iter)
+
+    def do_ref_node(self, iter):
+        if hasattr(self, 'ref_node'):
+            self.on_ref_node(iter)
+
+    def do_unref_node(self, iter):
+        if hasattr(self, 'unref_node'):
+            self.unref_node(iter)
+
+class Builder(Gtk.Builder):
+    __gtype_name__ = "Builder"
+
+    def connect_signals(self, obj_or_map):
+        def _full_callback(builder, gobj, signal_name, handler_name, connect_obj, flags, dict_or_obj):
+            print ("full callback")
+            handler = None
+            if isinstance(dict_or_obj, dict):
+                handler = dict_or_obj.get(handler_name, None)
+
+            if not handler:
+                raise AttributeError('Handler %s not found' % handler_name)
+
+            if not callable(handler):
+                raise TypeError('Handler %s is not a method or function' % handler_name)
+
+            after = False #flags and GObject.ConnectFlags.AFTER
+            if connect_obj:
+                if after:
+                    gobj.connect_object_after(signal_name, handler, connect_obj)
+                else:
+                    gobj.connect_object(signal_name, handler, connect_obj)
+            else:
+                if after:
+                    gobj.connect_after(signal_name, handler)
+                else:
+                    gobj.connect(signal_name, handler)
+
+        self.connect_signals_full(_full_callback,
+                                  obj_or_map);
+
+Builder = override(Builder)
+__all__ = [GenericTreeModel, Builder]
 
 import sys
 
