initial

9 files changed, 3105 insertions, 0 deletions

diff --git a/plugin-loaders/python/bindings/Makefile.am b/plugin-loaders/python/bindings/Makefile.am
new file mode 100755
index 00000000..47183a55
--- /dev/null
+++ b/plugin-loaders/python/bindings/Makefile.am
@@ -0,0 +1,115 @@
+## Process this file with automake to produce Makefile.in
+
+noinst_LTLIBRARIES = \
+	gedit.la
+
+nodist_gedit_la_SOURCES = 	\
+	gedit.c			\
+	geditutils.c		\
+	geditcommands.c
+
+gedit_la_LDFLAGS = \
+	-module -avoid-version
+
+gedit_la_LIBADD = \
+	$(PYTHON_LIB_LOC)       \
+	$(PYTHON_LIBS)		\
+	$(PYTHON_EXTRA_LIBS)	\
+	$(PYGTK_LIBS)
+
+gedit_la_CFLAGS = \
+	-I$(top_srcdir)					\
+	-I$(top_builddir)				\
+	-I$(top_srcdir)/gedit				\
+	-I$(top_builddir)/gedit				\
+	-I$(top_srcdir)/plugin-loaders/python		\
+	-I$(top_builddir)/plugin-loaders/python		\
+	$(GEDIT_CFLAGS)					\
+	$(NO_STRICT_ALIASING_CFLAGS)			\
+	$(PYGTK_CFLAGS)					\
+	$(PYTHON_CFLAGS)				\
+	$(AM_CFLAGS)
+
+$(top_builddir)/gedit/gedit-enum-types.h:
+	cd $(top_builddir)/gedit && $(MAKE) gedit-enum-types.h
+
+gedit.c: gedit.defs gedit.override geditplugin.override geditmessage.override $(top_builddir)/gedit/gedit-enum-types.h
+	( cd $(srcdir) && $(PYGTK_CODEGEN) \
+		--register $(PYGTK_DEFSDIR)/pango-types.defs \
+		--register $(PYGTK_DEFSDIR)/gdk-types.defs \
+		--register $(PYGTK_DEFSDIR)/gtk-types.defs \
+		--register $(PYGTK_DEFSDIR)/gtksourceview2.defs \
+		--register $(PYGOBJECT_DEFSDIR)/gio-types.defs \
+		--override $*.override \
+		--prefix py$* $(<F) ) > $@ 
+
+geditutils.c: geditutils.defs geditutils.override
+	( cd $(srcdir) && $(PYGTK_CODEGEN) \
+		--override $*.override \
+		--prefix py$* $(<F) ) > $@ 
+
+geditcommands.c: geditcommands.defs geditcommands.override gedit.defs
+	( cd $(srcdir) && $(PYGTK_CODEGEN) \
+		--register gedit.defs \
+		--register $(PYGTK_DEFSDIR)/gtk-types.defs \
+		--override $*.override \
+		--prefix py$* $(<F) ) > $@ 
+
+BINDING_GEDIT_HEADERS_SRCDIR_IN = \
+	gedit/gedit-app.h		\
+	gedit/gedit-document.h		\
+	gedit/gedit-encodings.h		\
+	gedit/gedit-plugin.h		\
+	plugin-loaders/python/gedit-plugin-python.h \
+	gedit/gedit-view.h		\
+	gedit/gedit-statusbar.h		\
+	gedit/gedit-tab.h 		\
+	gedit/gedit-panel.h 		\
+	gedit/gedit-window.h 		\
+	gedit/gedit-help.h		\
+	gedit/gedit-debug.h		\
+	gedit/gedit-message-type.h	\
+	gedit/gedit-message.h		\
+	gedit/gedit-message-bus.h	\
+	gedit/gedit-language-manager.h
+
+BINDING_UTILS_HEADERS_SRCDIR_IN = \
+	gedit/gedit-utils.h
+
+BINDING_COMMANDS_HEADERS_SRCDIR_IN = \
+	gedit/gedit-commands.h
+
+BINDING_HEADERS_BUILDDIR_IN = 
+
+BINDING_GEDIT_HEADERS_SRCDIR	:= $(addprefix $(top_srcdir)/,$(BINDING_GEDIT_HEADERS_SRCDIR_IN))
+BINDING_UTILS_HEADERS_SRCDIR	:= $(addprefix $(top_srcdir)/,$(BINDING_UTILS_HEADERS_SRCDIR_IN))
+BINDING_COMMANDS_HEADERS_SRCDIR	:= $(addprefix $(top_srcdir)/,$(BINDING_COMMANDS_HEADERS_SRCDIR_IN))
+
+BINDING_HEADERS_BUILDDIR	:= $(addprefix $(top_builddir)/,$(BINDING_HEADERS_BUILDDIR_IN))
+
+regenerate-python-binding:
+	$(PYGTK_H2DEF) $(sort $(BINDING_GEDIT_HEADERS_SRCDIR) $(BINDING_HEADERS_BUILDDIR)) > gedit.defs.new
+	$(PYGTK_H2DEF) $(sort $(BINDING_UTILS_HEADERS_SRCDIR) $(BINDING_HEADERS_BUILDDIR)) > geditutils.defs.new
+	$(PYGTK_H2DEF) $(sort $(BINDING_COMMANDS_HEADERS_SRCDIR) $(BINDING_HEADERS_BUILDDIR)) > geditcommands.defs.new
+
+BUILT_SOURCES = \
+	gedit.c		\
+	geditutils.c	\
+	geditcommands.c
+
+EXTRA_DIST = \
+	gedit.override		\
+	gedit.defs		\
+	geditutils.override	\
+	geditutils.defs		\
+	geditcommands.override 	\
+	geditcommands.defs	\
+	geditmessage.override	\
+	geditplugin.override
+
+CLEANFILES = $(BUILT_SOURCES)
+
+dist-hook:
+	cd $(distdir); rm -f $(BUILT_SOURCES)
+
+-include $(top_srcdir)/git.mk
diff --git a/plugin-loaders/python/bindings/gedit.defs b/plugin-loaders/python/bindings/gedit.defs
new file mode 100755
index 00000000..1b116396
--- /dev/null
+++ b/plugin-loaders/python/bindings/gedit.defs
@@ -0,0 +1,1461 @@
+;; -*- scheme -*-
+; object definitions ...
+(define-object App
+  (in-module "Gedit")
+  (parent "GObject")
+  (c-name "GeditApp")
+  (gtype-id "GEDIT_TYPE_APP")
+)
+
+(define-object Document
+  (in-module "Gedit")
+  (parent "GtkSourceBuffer")
+  (c-name "GeditDocument")
+  (gtype-id "GEDIT_TYPE_DOCUMENT")
+)
+
+(define-object Message
+  (in-module "Gedit")
+  (parent "GObject")
+  (c-name "GeditMessage")
+  (gtype-id "GEDIT_TYPE_MESSAGE")
+)
+
+(define-object MessageBus
+  (in-module "Gedit")
+  (parent "GObject")
+  (c-name "GeditMessageBus")
+  (gtype-id "GEDIT_TYPE_MESSAGE_BUS")
+)
+
+(define-object Panel
+  (in-module "Gedit")
+  (parent "GtkVBox")
+  (c-name "GeditPanel")
+  (gtype-id "GEDIT_TYPE_PANEL")
+)
+
+(define-object __Plugin
+  (in-module "Gedit")
+  (parent "GObject")
+  (c-name "GeditPlugin")
+  (gtype-id "GEDIT_TYPE_PLUGIN")
+)
+
+(define-object Plugin
+  (in-module "Gedit")
+  (parent "GeditPlugin")
+  (c-name "GeditPluginPython")
+  (gtype-id "GEDIT_TYPE_PLUGIN_PYTHON")
+)
+
+(define-object Statusbar
+  (in-module "Gedit")
+  (parent "GtkStatusbar")
+  (c-name "GeditStatusbar")
+  (gtype-id "GEDIT_TYPE_STATUSBAR")
+)
+
+(define-object Tab
+  (in-module "Gedit")
+  (parent "GtkVBox")
+  (c-name "GeditTab")
+  (gtype-id "GEDIT_TYPE_TAB")
+)
+
+(define-object View
+  (in-module "Gedit")
+  (parent "GtkSourceView")
+  (c-name "GeditView")
+  (gtype-id "GEDIT_TYPE_VIEW")
+)
+
+(define-object Window
+  (in-module "Gedit")
+  (parent "GtkWindow")
+  (c-name "GeditWindow")
+  (gtype-id "GEDIT_TYPE_WINDOW")
+)
+
+;; Enumerations and flags ...
+
+(define-flags LockdownMask
+  (in-module "Gedit")
+  (c-name "GeditLockdownMask")
+  (gtype-id "GEDIT_TYPE_LOCKDOWN_MASK")
+  (values
+    '("command-line" "GEDIT_LOCKDOWN_COMMAND_LINE")
+    '("printing" "GEDIT_LOCKDOWN_PRINTING")
+    '("print-setup" "GEDIT_LOCKDOWN_PRINT_SETUP")
+    '("save-to-disk" "GEDIT_LOCKDOWN_SAVE_TO_DISK")
+    '("all" "GEDIT_LOCKDOWN_ALL")
+  )
+)
+
+(define-flags SearchFlags
+  (in-module "Gedit")
+  (c-name "GeditSearchFlags")
+  (gtype-id "GEDIT_TYPE_SEARCH_FLAGS")
+  (values
+    '("dont-set-flags" "GEDIT_SEARCH_DONT_SET_FLAGS")
+    '("entire-word" "GEDIT_SEARCH_ENTIRE_WORD")
+    '("case-sensitive" "GEDIT_SEARCH_CASE_SENSITIVE")
+  )
+)
+
+(define-flags DocumentSaveFlags
+  (in-module "Gedit")
+  (c-name "GeditDocumentSaveFlags")
+  (gtype-id "GEDIT_TYPE_DOCUMENT_SAVE_FLAGS")
+  (values
+    '("ignore-mtime" "GEDIT_DOCUMENT_SAVE_IGNORE_MTIME")
+    '("ignore-backup" "GEDIT_DOCUMENT_SAVE_IGNORE_BACKUP")
+    '("preserve-backup" "GEDIT_DOCUMENT_SAVE_PRESERVE_BACKUP")
+  )
+)
+
+(define-enum TabState
+  (in-module "Gedit")
+  (c-name "GeditTabState")
+  (gtype-id "GEDIT_TYPE_TAB_STATE")
+  (values
+    '("normal" "GEDIT_TAB_STATE_NORMAL")
+    '("loading" "GEDIT_TAB_STATE_LOADING")
+    '("reverting" "GEDIT_TAB_STATE_REVERTING")
+    '("saving" "GEDIT_TAB_STATE_SAVING")
+    '("printing" "GEDIT_TAB_STATE_PRINTING")
+    '("print-previewing" "GEDIT_TAB_STATE_PRINT_PREVIEWING")
+    '("showing-print-preview" "GEDIT_TAB_STATE_SHOWING_PRINT_PREVIEW")
+    '("generic-not-editable" "GEDIT_TAB_STATE_GENERIC_NOT_EDITABLE")
+    '("loading-error" "GEDIT_TAB_STATE_LOADING_ERROR")
+    '("reverting-error" "GEDIT_TAB_STATE_REVERTING_ERROR")
+    '("saving-error" "GEDIT_TAB_STATE_SAVING_ERROR")
+    '("generic-error" "GEDIT_TAB_STATE_GENERIC_ERROR")
+    '("closing" "GEDIT_TAB_STATE_CLOSING")
+  )
+)
+
+(define-flags WindowState
+  (in-module "Gedit")
+  (c-name "GeditWindowState")
+  (gtype-id "GEDIT_TYPE_WINDOW_STATE")
+  (values
+    '("normal" "GEDIT_WINDOW_STATE_NORMAL")
+    '("saving" "GEDIT_WINDOW_STATE_SAVING")
+    '("printing" "GEDIT_WINDOW_STATE_PRINTING")
+    '("loading" "GEDIT_WINDOW_STATE_LOADING")
+    '("error" "GEDIT_WINDOW_STATE_ERROR")
+    '("saving-session" "GEDIT_WINDOW_STATE_SAVING_SESSION")    
+  )
+)
+
+;; Boxed types
+(define-boxed Encoding
+  (in-module "Gedit")
+  (c-name "GeditEncoding")
+  (gtype-id "GEDIT_TYPE_ENCODING")
+  (copy-func "gedit_encoding_copy")
+  (release-func "gedit_encoding_free")
+;;  (fields
+;;    '("gint" "index")
+;;    '("gchar*" "charset")
+;;    '("gchar*" "name")
+;;  )
+)
+
+(define-boxed MessageType
+  (in-module "Gedit")
+  (c-name "GeditMessageType")
+  (gtype-id "GEDIT_TYPE_MESSAGE_TYPE")
+  (copy-func "gedit_message_type_ref")
+  (release-func "gedit_message_type_unref")
+)
+
+
+;; From ../../gedit/gedit-app.h
+
+(define-function gedit_app_get_type
+  (c-name "gedit_app_get_type")
+  (return-type "GType")
+)
+
+(define-function app_get_default
+  (c-name "gedit_app_get_default")
+  (return-type "GeditApp*")
+)
+
+; deprecated version !
+(define-function gedit_app_get_default
+  (c-name "gedit_app_get_default_deprecated")
+  (return-type "GeditApp*")
+)
+
+(define-method create_window
+  (of-object "GeditApp")
+  (c-name "gedit_app_create_window")
+  (return-type "GeditWindow*")
+  (parameters
+    '("GdkScreen*" "screen")
+  )
+)
+
+(define-method get_windows
+  (of-object "GeditApp")
+  (c-name "gedit_app_get_windows")
+  (return-type "const-GList*")
+)
+
+(define-method get_active_window
+  (of-object "GeditApp")
+  (c-name "gedit_app_get_active_window")
+  (return-type "GeditWindow*")
+)
+
+(define-method get_documents
+  (of-object "GeditApp")
+  (c-name "gedit_app_get_documents")
+  (return-type "GList*")
+)
+
+(define-method get_views
+  (of-object "GeditApp")
+  (c-name "gedit_app_get_views")
+  (return-type "GList*")
+)
+
+(define-method get_lockdown
+  (of-object "GeditApp")
+  (c-name "gedit_app_get_lockdown")
+  (return-type "GeditLockdownMask")
+)
+
+
+;; From ../../gedit/gedit-document.h
+
+(define-function document_error_quark
+  (c-name "gedit_document_error_quark")
+  (return-type "GQuark")
+)
+
+(define-function gedit_document_get_type
+  (c-name "gedit_document_get_type")
+  (return-type "GType")
+)
+
+(define-function gedit_document_new
+  (c-name "gedit_document_new")
+  (is-constructor-of "GeditDocument")
+  (return-type "GeditDocument*")
+)
+
+(define-method get_location
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_location")
+  (return-type "GFile*")
+)
+
+(define-method get_uri
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_uri")
+  (return-type "gchar*")
+)
+
+(define-method set_uri
+  (of-object "GeditDocument")
+  (c-name "gedit_document_set_uri")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "uri")
+  )
+)
+
+(define-method get_uri_for_display
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_uri_for_display")
+  (return-type "gchar*")
+)
+
+(define-method get_short_name_for_display
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_short_name_for_display")
+  (return-type "gchar*")
+)
+
+(define-method get_content_type
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_content_type")
+  (return-type "gchar*")
+)
+
+(define-method get_mime_type
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_mime_type")
+  (return-type "gchar*")
+)
+
+(define-method get_readonly
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_readonly")
+  (return-type "gboolean")
+)
+
+(define-method load
+  (of-object "GeditDocument")
+  (c-name "gedit_document_load")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "uri")
+    '("const-GeditEncoding*" "encoding")
+    '("gint" "line_pos")
+    '("gboolean" "create")
+  )
+)
+
+(define-method insert_file
+  (of-object "GeditDocument")
+  (c-name "gedit_document_insert_file")
+  (return-type "gboolean")
+  (parameters
+    '("GtkTextIter*" "iter")
+    '("const-gchar*" "uri")
+    '("const-GeditEncoding*" "encoding")
+  )
+)
+
+(define-method load_cancel
+  (of-object "GeditDocument")
+  (c-name "gedit_document_load_cancel")
+  (return-type "gboolean")
+)
+
+(define-method save
+  (of-object "GeditDocument")
+  (c-name "gedit_document_save")
+  (parameters
+    '("GeditDocumentSaveFlags" "flags")
+  )
+  (return-type "none")
+)
+
+(define-method save_as
+  (of-object "GeditDocument")
+  (c-name "gedit_document_save_as")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "uri")
+    '("const-GeditEncoding*" "encoding")
+    '("GeditDocumentSaveFlags" "flags")
+  )
+)
+
+(define-method is_untouched
+  (of-object "GeditDocument")
+  (c-name "gedit_document_is_untouched")
+  (return-type "gboolean")
+)
+
+(define-method is_untitled
+  (of-object "GeditDocument")
+  (c-name "gedit_document_is_untitled")
+  (return-type "gboolean")
+)
+
+(define-method is_local
+  (of-object "GeditDocument")
+  (c-name "gedit_document_is_local")
+  (return-type "gboolean")
+)
+
+(define-method get_deleted
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_deleted")
+  (return-type "gboolean")
+)
+
+(define-method goto_line
+  (of-object "GeditDocument")
+  (c-name "gedit_document_goto_line")
+  (return-type "gboolean")
+  (parameters
+    '("gint" "line")
+  )
+)
+
+(define-method set_search_text
+  (of-object "GeditDocument")
+  (c-name "gedit_document_set_search_text")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "text")
+    '("guint" "flags")
+  )
+)
+
+(define-method get_search_text
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_search_text")
+  (return-type "gchar*")
+  (parameters
+    '("guint*" "flags")
+  )
+)
+
+(define-method get_can_search_again
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_can_search_again")
+  (return-type "gboolean")
+)
+
+(define-method search_forward
+  (of-object "GeditDocument")
+  (c-name "gedit_document_search_forward")
+  (return-type "gboolean")
+  (parameters
+    '("const-GtkTextIter*" "start")
+    '("const-GtkTextIter*" "end")
+    '("GtkTextIter*" "match_start")
+    '("GtkTextIter*" "match_end")
+  )
+)
+
+(define-method replace_all
+  (of-object "GeditDocument")
+  (c-name "gedit_document_replace_all")
+  (return-type "gint")
+  (parameters
+    '("const-gchar*" "find")
+    '("const-gchar*" "replace")
+    '("guint" "flags")
+  )
+)
+
+(define-method search_backward
+  (of-object "GeditDocument")
+  (c-name "gedit_document_search_backward")
+  (return-type "gboolean")
+  (parameters
+    '("const-GtkTextIter*" "start")
+    '("const-GtkTextIter*" "end")
+    '("GtkTextIter*" "match_start")
+    '("GtkTextIter*" "match_end")
+  )
+)
+
+(define-method set_language
+  (of-object "GeditDocument")
+  (c-name "gedit_document_set_language")
+  (return-type "none")
+  (parameters
+    '("GtkSourceLanguage*" "lang" (null-ok))
+  )
+)
+
+(define-method get_language
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_language")
+  (return-type "GtkSourceLanguage*")
+)
+
+(define-method get_encoding
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_encoding")
+  (return-type "const-GeditEncoding*")
+)
+
+(define-method set_enable_search_highlighting
+  (of-object "GeditDocument")
+  (c-name "gedit_document_set_enable_search_highlighting")
+  (return-type "none")
+  (parameters
+    '("gboolean" "enable")
+  )
+)
+
+(define-method get_enable_search_highlighting
+  (of-object "GeditDocument")
+  (c-name "gedit_document_get_enable_search_highlighting")
+  (return-type "gboolean")
+)
+
+;; From ../../gedit/gedit-encodings.h
+
+(define-function gedit_encoding_get_type
+  (c-name "gedit_encoding_get_type")
+  (return-type "GType")
+)
+
+(define-method copy
+  (of-object "GeditEncoding")
+  (c-name "gedit_encoding_copy")
+  (return-type "GeditEncoding*")
+)
+
+(define-method free
+  (of-object "GeditEncoding")
+  (c-name "gedit_encoding_free")
+  (return-type "none")
+)
+
+(define-function encoding_get_from_charset
+  (c-name "gedit_encoding_get_from_charset")
+  (return-type "const-GeditEncoding*")
+  (parameters
+    '("const-gchar*" "charset")
+  )
+)
+
+; Deprecated version !
+(define-function gedit_encoding_get_from_charset
+  (c-name "gedit_encoding_get_from_charset_deprecated")
+  (return-type "const-GeditEncoding*")
+  (parameters
+    '("const-gchar*" "charset")
+  )
+)
+
+(define-function encoding_get_from_index
+  (c-name "gedit_encoding_get_from_index")
+  (return-type "const-GeditEncoding*")
+  (parameters
+    '("gint" "index")
+  )
+)
+
+; Deprecated version !
+(define-function gedit_encoding_get_from_index
+  (c-name "gedit_encoding_get_from_index_deprecated")
+  (return-type "const-GeditEncoding*")
+  (parameters
+    '("gint" "index")
+  )
+)
+
+(define-method to_string
+  (of-object "GeditEncoding")
+  (c-name "gedit_encoding_to_string")
+  (return-type "gchar*")
+)
+
+(define-method get_name
+  (of-object "GeditEncoding")
+  (c-name "gedit_encoding_get_name")
+  (return-type "const-gchar*")
+)
+
+(define-method get_charset
+  (of-object "GeditEncoding")
+  (c-name "gedit_encoding_get_charset")
+  (return-type "const-gchar*")
+)
+
+(define-function encoding_get_utf8
+  (c-name "gedit_encoding_get_utf8")
+  (return-type "const-GeditEncoding*")
+)
+
+; Deprecated version !
+(define-function gedit_encoding_get_utf8
+  (c-name "gedit_encoding_get_utf8_deprecated")
+  (return-type "const-GeditEncoding*")
+)
+
+(define-function encoding_get_current
+  (c-name "gedit_encoding_get_current")
+  (return-type "const-GeditEncoding*")
+)
+
+; Deprecated version !
+(define-function gedit_encoding_get_current
+  (c-name "gedit_encoding_get_current_deprecated")
+  (return-type "const-GeditEncoding*")
+)
+
+;; From ../../gedit/gedit-help.h
+
+(define-function help_display
+  (c-name "gedit_help_display")
+  (return-type "gboolean")
+  (parameters
+    '("GtkWindow*" "parent")
+    '("const-gchar*" "name")
+    '("const-gchar*" "link_id")
+  )
+)
+
+
+
+;; From ../../gedit/gedit-panel.h
+
+(define-function gedit_panel_get_type
+  (c-name "gedit_panel_get_type")
+  (return-type "GType")
+)
+
+(define-function gedit_panel_new
+  (c-name "gedit_panel_new")
+  (is-constructor-of "GeditPanel")
+  (return-type "GtkWidget*")
+)
+
+(define-method add_item
+  (of-object "GeditPanel")
+  (c-name "gedit_panel_add_item")
+  (return-type "none")
+  (parameters
+    '("GtkWidget*" "item")
+    '("const-gchar*" "name")
+    '("GtkWidget*" "image")
+  )
+)
+
+(define-method add_item_with_stock_icon
+  (of-object "GeditPanel")
+  (c-name "gedit_panel_add_item_with_stock_icon")
+  (return-type "none")
+  (parameters
+    '("GtkWidget*" "item")
+    '("const-gchar*" "name")
+    '("const-gchar*" "stock_id")
+  )
+)
+
+(define-method remove_item
+  (of-object "GeditPanel")
+  (c-name "gedit_panel_remove_item")
+  (return-type "gboolean")
+  (parameters
+    '("GtkWidget*" "item")
+  )
+)
+
+(define-method activate_item
+  (of-object "GeditPanel")
+  (c-name "gedit_panel_activate_item")
+  (return-type "gboolean")
+  (parameters
+    '("GtkWidget*" "item")
+  )
+)
+
+(define-method item_is_active
+  (of-object "GeditPanel")
+  (c-name "gedit_panel_item_is_active")
+  (return-type "gboolean")
+  (parameters
+    '("GtkWidget*" "item")
+  )
+)
+
+(define-method get_orientation
+  (of-object "GeditPanel")
+  (c-name "gedit_panel_get_orientation")
+  (return-type "GtkOrientation")
+)
+
+(define-method get_n_items
+  (of-object "GeditPanel")
+  (c-name "gedit_panel_get_n_items")
+  (return-type "gint")
+)
+
+
+;; From ../../gedit/gedit-plugin.h
+
+(define-function gedit_plugin_get_type
+  (c-name "gedit_plugin_get_type")
+  (return-type "GType")
+)
+
+(define-method get_install_dir
+  (of-object "GeditPlugin")
+  (c-name "gedit_plugin_get_install_dir")
+  (return-type "gchar*")
+)
+
+(define-method get_data_dir
+  (of-object "GeditPlugin")
+  (c-name "gedit_plugin_get_data_dir")
+  (return-type "gchar*")
+)
+
+(define-method activate
+  (of-object "GeditPlugin")
+  (c-name "gedit_plugin_activate")
+  (return-type "none")
+  (parameters
+    '("GeditWindow*" "window")
+  )
+)
+
+(define-method deactivate
+  (of-object "GeditPlugin")
+  (c-name "gedit_plugin_deactivate")
+  (return-type "none")
+  (parameters
+    '("GeditWindow*" "window")
+  )
+)
+
+(define-method update_ui
+  (of-object "GeditPlugin")
+  (c-name "gedit_plugin_update_ui")
+  (return-type "none")
+  (parameters
+    '("GeditWindow*" "window")
+  )
+)
+
+(define-method is_configurable
+  (of-object "GeditPlugin")
+  (c-name "gedit_plugin_is_configurable")
+  (return-type "gboolean")
+)
+
+(define-method create_configure_dialog
+  (of-object "GeditPlugin")
+  (c-name "gedit_plugin_create_configure_dialog")
+  (return-type "GtkWidget*")
+)
+
+;; From ../gedit/gedit-plugin-python.h
+
+(define-function gedit_plugin_python_get_type
+  (c-name "gedit_plugin_python_get_type")
+  (return-type "GType")
+)
+
+(define-function gedit_plugin_python_new
+  (c-name "gedit_plugin_python_new")
+  (is-constructor-of "GeditPluginPython")
+  (return-type "GeditPluginPython*")
+)
+
+;; From ../../gedit/gedit-status-bar.h
+
+(define-method flash_message
+  (of-object "GeditStatusbar")
+  (c-name "gedit_statusbar_flash_message")
+  (return-type "none")
+  (parameters
+    '("int" "context_id")
+    '("const-gchar*" "message")
+  )
+ )
+
+;; From ../../gedit/gedit-tab.h
+
+(define-function gedit_tab_get_type
+  (c-name "gedit_tab_get_type")
+  (return-type "GType")
+)
+
+(define-method get_view
+  (of-object "GeditTab")
+  (c-name "gedit_tab_get_view")
+  (return-type "GeditView*")
+)
+
+(define-method get_document
+  (of-object "GeditTab")
+  (c-name "gedit_tab_get_document")
+  (return-type "GeditDocument*")
+)
+
+(define-function tab_get_from_document
+  (c-name "gedit_tab_get_from_document")
+  (return-type "GeditTab*")
+  (parameters
+    '("GeditDocument*" "doc")
+  )
+)
+
+; Deprecated version !
+(define-function gedit_tab_get_from_document
+  (c-name "gedit_tab_get_from_document_deprecated")
+  (return-type "GeditTab*")
+  (parameters
+    '("GeditDocument*" "doc")
+  )
+)
+
+(define-method get_state
+  (of-object "GeditTab")
+  (c-name "gedit_tab_get_state")
+  (return-type "GeditTabState")
+)
+
+(define-method set_auto_save_enabled
+  (of-object "GeditTab")
+  (c-name "gedit_tab_set_auto_save_enabled")
+  (return-type "none")
+  (parameters
+    '("gboolean" "enable")
+  )
+)
+
+(define-method get_auto_save_enabled
+  (of-object "GeditTab")
+  (c-name "gedit_tab_get_auto_save_enabled")
+  (return-type "gboolean")
+)
+
+(define-method set_auto_save_interval
+  (of-object "GeditTab")
+  (c-name "gedit_tab_set_auto_save_interval")
+  (return-type "none")
+  (parameters
+    '("gint" "interval")
+  )
+)
+
+(define-method get_auto_save_interval
+  (of-object "GeditTab")
+  (c-name "gedit_tab_get_auto_save_interval")
+  (return-type "gint")
+)
+
+;; From ../../gedit/gedit-view.h
+
+(define-function gedit_view_get_type
+  (c-name "gedit_view_get_type")
+  (return-type "GtkType")
+)
+
+(define-function gedit_view_new
+  (c-name "gedit_view_new")
+  (is-constructor-of "GeditView")
+  (return-type "GtkWidget*")
+  (parameters
+    '("GeditDocument*" "doc")
+  )
+)
+
+(define-method cut_clipboard
+  (of-object "GeditView")
+  (c-name "gedit_view_cut_clipboard")
+  (return-type "none")
+)
+
+(define-method copy_clipboard
+  (of-object "GeditView")
+  (c-name "gedit_view_copy_clipboard")
+  (return-type "none")
+)
+
+(define-method paste_clipboard
+  (of-object "GeditView")
+  (c-name "gedit_view_paste_clipboard")
+  (return-type "none")
+)
+
+(define-method delete_selection
+  (of-object "GeditView")
+  (c-name "gedit_view_delete_selection")
+  (return-type "none")
+)
+
+(define-method select_all
+  (of-object "GeditView")
+  (c-name "gedit_view_select_all")
+  (return-type "none")
+)
+
+(define-method scroll_to_cursor
+  (of-object "GeditView")
+  (c-name "gedit_view_scroll_to_cursor")
+  (return-type "none")
+)
+
+(define-method set_font
+  (of-object "GeditView")
+  (c-name "gedit_view_set_font")
+  (return-type "none")
+  (parameters
+    '("gboolean" "def")
+    '("const-gchar*" "font_name")
+  )
+)
+
+
+
+;; From ../../gedit/gedit-window.h
+
+(define-function gedit_window_get_type
+  (c-name "gedit_window_get_type")
+  (return-type "GType")
+)
+
+(define-method create_tab
+  (of-object "GeditWindow")
+  (c-name "gedit_window_create_tab")
+  (return-type "GeditTab*")
+  (parameters
+    '("gboolean" "jump_to")
+  )
+)
+
+(define-method create_tab_from_uri
+  (of-object "GeditWindow")
+  (c-name "gedit_window_create_tab_from_uri")
+  (return-type "GeditTab*")
+  (parameters
+    '("const-gchar*" "uri")
+    '("const-GeditEncoding*" "encoding" (null-ok))
+    '("gint" "line_pos")
+    '("gboolean" "create")
+    '("gboolean" "jump_to")
+  )
+)
+
+(define-method close_tab
+  (of-object "GeditWindow")
+  (c-name "gedit_window_close_tab")
+  (return-type "none")
+  (parameters
+    '("GeditTab*" "tab")
+  )
+)
+
+(define-method close_tabs
+  (of-object "GeditWindow")
+  (c-name "gedit_window_close_tabs")
+  (return-type "none")
+  (parameters
+    '("const-GList*" "tabs")
+  )
+)
+
+(define-method close_all_tabs
+  (of-object "GeditWindow")
+  (c-name "gedit_window_close_all_tabs")
+  (return-type "none")
+)
+
+(define-method get_active_tab
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_active_tab")
+  (return-type "GeditTab*")
+)
+
+(define-method set_active_tab
+  (of-object "GeditWindow")
+  (c-name "gedit_window_set_active_tab")
+  (return-type "none")
+  (parameters
+    '("GeditTab*" "tab")
+  )
+)
+
+(define-method get_active_view
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_active_view")
+  (return-type "GeditView*")
+)
+
+(define-method get_active_document
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_active_document")
+  (return-type "GeditDocument*")
+)
+
+(define-method get_documents
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_documents")
+  (return-type "GList*")
+)
+
+(define-method get_unsaved_documents
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_unsaved_documents")
+  (return-type "GList*")
+)
+
+(define-method get_views
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_views")
+  (return-type "GList*")
+)
+
+(define-method get_group
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_group")
+  (return-type "GtkWindowGroup*")
+)
+
+(define-method get_side_panel
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_side_panel")
+  (return-type "GeditPanel*")
+)
+
+(define-method get_bottom_panel
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_bottom_panel")
+  (return-type "GeditPanel*")
+)
+
+(define-method get_statusbar
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_statusbar")
+  (return-type "GtkWidget*")
+)
+
+(define-method get_ui_manager
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_ui_manager")
+  (return-type "GtkUIManager*")
+)
+
+(define-method get_state
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_state")
+  (return-type "GeditWindowState")
+)
+
+(define-method get_message_bus
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_message_bus")
+  (return-type "GeditMessageBus*")
+)
+
+(define-method get_tab_from_uri
+  (of-object "GeditWindow")
+  (c-name "gedit_window_get_tab_from_uri")
+  (return-type "GeditTab*")
+  (parameters
+    '("const-gchar*" "uri")
+  )
+)
+
+;; From gedit-language-manager.h
+
+(define-function get_language_manager
+  (c-name "gedit_get_language_manager")
+  (return-type "GtkSourceLanguageManager*")
+)
+
+(define-function language_manager_list_languages_sorted
+  (c-name "gedit_language_manager_list_languages_sorted")
+  (return-type "GSList*")
+  (parameters
+    '("GtkSourceLanguageManager*" "lm")
+    '("gboolean" "include_hidden")
+  )
+)
+
+
+;; From gedit-message-bus.h
+
+(define-function gedit_message_bus_get_type
+  (c-name "gedit_message_bus_get_type")
+  (return-type "GType")
+)
+
+(define-function message_bus_get_default
+  (c-name "gedit_message_bus_get_default")
+  (return-type "GeditMessageBus*")
+)
+
+(define-function gedit_message_bus_new
+  (c-name "gedit_message_bus_new")
+  (is-constructor-of "GeditMessageBus")
+  (return-type "GeditMessageBus*")
+)
+
+(define-method lookup
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_lookup")
+  (return-type "GeditMessageType*")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+  )
+)
+
+(define-method register
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_register")
+  (return-type "GeditMessageType*")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+    '("guint" "num_optional")
+  )
+  (varargs #t)
+)
+
+(define-method unregister
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_unregister")
+  (return-type "none")
+  (parameters
+    '("GeditMessageType*" "message_type")
+  )
+)
+
+(define-method unregister_all
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_unregister_all")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "object_path")
+  )
+)
+
+(define-method is_registered
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_is_registered")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+  )
+)
+
+(define-method connect
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_connect")
+  (return-type "guint")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+    '("GeditMessageCallback" "callback")
+    '("gpointer" "userdata")
+    '("GDestroyNotify" "destroy_data")
+  )
+)
+
+(define-method disconnect
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_disconnect")
+  (return-type "none")
+  (parameters
+    '("guint" "id")
+  )
+)
+
+(define-method disconnect_by_func
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_disconnect_by_func")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+    '("GeditMessageCallback" "callback")
+    '("gpointer" "userdata")
+  )
+)
+
+(define-method block
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_block")
+  (return-type "none")
+  (parameters
+    '("guint" "id")
+  )
+)
+
+(define-method block_by_func
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_block_by_func")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+    '("GeditMessageCallback" "callback")
+    '("gpointer" "userdata")
+  )
+)
+
+(define-method unblock
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_unblock")
+  (return-type "none")
+  (parameters
+    '("guint" "id")
+  )
+)
+
+(define-method unblock_by_func
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_unblock_by_func")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+    '("GeditMessageCallback" "callback")
+    '("gpointer" "userdata")
+  )
+)
+
+(define-method send_message
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_send_message")
+  (return-type "none")
+  (parameters
+    '("GeditMessage*" "message")
+  )
+)
+
+(define-method send_message_sync
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_send_message_sync")
+  (return-type "none")
+  (parameters
+    '("GeditMessage*" "message")
+  )
+)
+
+(define-method send
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_send")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+  )
+  (varargs #t)
+)
+
+(define-method send_sync
+  (of-object "GeditMessageBus")
+  (c-name "gedit_message_bus_send_sync")
+  (return-type "GeditMessage*")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+  )
+  (varargs #t)
+)
+
+
+;; From gedit-message-type.h
+
+(define-function gedit_message_type_get_type
+  (c-name "gedit_message_type_get_type")
+  (return-type "GType")
+)
+
+(define-function gedit_message_type_is_supported
+  (c-name "gedit_message_type_is_supported")
+  (return-type "gboolean")
+  (parameters
+    '("GType" "type")
+  )
+)
+
+(define-function gedit_message_type_identifier
+  (c-name "gedit_message_type_identifier")
+  (return-type "gchar*")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+  )
+)
+
+(define-function gedit_message_type_new
+  (c-name "gedit_message_type_new")
+  (is-constructor-of "GeditMessageType")
+  (return-type "GeditMessageType*")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+    '("guint" "num_optional")
+  )
+  (varargs #t)
+)
+
+(define-function gedit_message_type_new_valist
+  (c-name "gedit_message_type_new_valist")
+  (return-type "GeditMessageType*")
+  (parameters
+    '("const-gchar*" "object_path")
+    '("const-gchar*" "method")
+    '("guint" "num_optional")
+    '("va_list" "va_args")
+  )
+)
+
+(define-method ref
+  (of-object "GeditMessageType")
+  (c-name "gedit_message_type_ref")
+  (return-type "GeditMessageType*")
+)
+
+(define-method unref
+  (of-object "GeditMessageType")
+  (c-name "gedit_message_type_unref")
+  (return-type "none")
+)
+
+(define-method instantiate_valist
+  (of-object "GeditMessageType")
+  (c-name "gedit_message_type_instantiate_valist")
+  (return-type "GeditMessage*")
+  (parameters
+    '("va_list" "va_args")
+  )
+)
+
+(define-method instantiate
+  (of-object "GeditMessageType")
+  (c-name "gedit_message_type_instantiate")
+  (return-type "GeditMessage*")
+  (parameters
+  )
+  (varargs #t)
+)
+
+(define-method get_object_path
+  (of-object "GeditMessageType")
+  (c-name "gedit_message_type_get_object_path")
+  (return-type "const-gchar*")
+)
+
+(define-method get_method
+  (of-object "GeditMessageType")
+  (c-name "gedit_message_type_get_method")
+  (return-type "const-gchar*")
+)
+
+(define-method lookup
+  (of-object "GeditMessageType")
+  (c-name "gedit_message_type_lookup")
+  (return-type "GType")
+  (parameters
+    '("const-gchar*" "key")
+  )
+)
+
+(define-method foreach
+  (of-object "GeditMessageType")
+  (c-name "gedit_message_type_foreach")
+  (return-type "none")
+  (parameters
+    '("GeditMessageTypeForeach" "func")
+    '("gpointer" "user_data")
+  )
+)
+
+
+;; From gedit-message.h
+
+(define-function gedit_message_get_type
+  (c-name "gedit_message_get_type")
+  (return-type "GType")
+)
+
+(define-method get
+  (of-object "GeditMessage")
+  (c-name "gedit_message_get")
+  (return-type "none")
+  (parameters
+  )
+  (varargs #t)
+)
+
+(define-method get_valist
+  (of-object "GeditMessage")
+  (c-name "gedit_message_get_valist")
+  (return-type "none")
+  (parameters
+    '("va_list" "var_args")
+  )
+)
+
+(define-method get_value
+  (of-object "GeditMessage")
+  (c-name "gedit_message_get_value")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "key")
+    '("GValue*" "value")
+  )
+)
+
+(define-method set
+  (of-object "GeditMessage")
+  (c-name "gedit_message_set")
+  (return-type "none")
+  (parameters
+  )
+  (varargs #t)
+)
+
+(define-method set_valist
+  (of-object "GeditMessage")
+  (c-name "gedit_message_set_valist")
+  (return-type "none")
+  (parameters
+    '("va_list" "var_args")
+  )
+)
+
+(define-method set_value
+  (of-object "GeditMessage")
+  (c-name "gedit_message_set_value")
+  (return-type "none")
+  (parameters
+    '("const-gchar*" "key")
+    '("GValue*" "value")
+  )
+)
+
+(define-method set_valuesv
+  (of-object "GeditMessage")
+  (c-name "gedit_message_set_valuesv")
+  (return-type "none")
+  (parameters
+    '("const-gchar**" "keys")
+    '("GValue*" "values")
+    '("gint" "n_values")
+  )
+)
+
+(define-method get_object_path
+  (of-object "GeditMessage")
+  (c-name "gedit_message_get_object_path")
+  (return-type "const-gchar*")
+)
+
+(define-method get_method
+  (of-object "GeditMessage")
+  (c-name "gedit_message_get_method")
+  (return-type "const-gchar*")
+)
+
+(define-method has_key
+  (of-object "GeditMessage")
+  (c-name "gedit_message_has_key")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "key")
+  )
+)
+
+(define-method get_key_type
+  (of-object "GeditMessage")
+  (c-name "gedit_message_get_key_type")
+  (return-type "GType")
+  (parameters
+    '("const-gchar*" "key")
+  )
+)
+
+(define-method validate
+  (of-object "GeditMessage")
+  (c-name "gedit_message_validate")
+  (return-type "gboolean")
+)
+
+
+;; From ../../gedit/gedit-debug.h
+
+(define-function debug
+  (c-name "gedit_debug")
+  (parameters
+    '("const-gchar*" "message")
+  )
+  (return-type "none")
+)
+
diff --git a/plugin-loaders/python/bindings/gedit.override b/plugin-loaders/python/bindings/gedit.override
new file mode 100755
index 00000000..52c492a4
--- /dev/null
+++ b/plugin-loaders/python/bindings/gedit.override
@@ -0,0 +1,461 @@
+%%
+headers
+#include <pygobject.h>
+#include <pygtk/pygtk.h>
+
+#include <gedit/gedit-language-manager.h>
+#include <gedit/gedit-plugin.h>
+#include <gedit/gedit-app.h>
+#include <gedit/gedit-encodings.h>
+#include <gedit/gedit-enum-types.h>
+#include <gedit/gedit-statusbar.h>
+#include <gedit/gedit-debug.h>
+#include <gedit/gedit-help.h>
+
+#include "gedit-plugin-python.h"
+
+void pygedit_register_classes (PyObject *d); 
+void pygedit_add_constants (PyObject *module, const gchar *strip_prefix);
+
+static PyObject *
+_helper_wrap_gobject_glist (const GList *list)
+{
+    PyObject *py_list;
+    const GList *tmp;
+
+    if ((py_list = PyList_New(0)) == NULL) {
+        return NULL;
+    }
+    for (tmp = list; tmp != NULL; tmp = tmp->next) {
+        PyObject *py_obj = pygobject_new(G_OBJECT(tmp->data));
+
+        if (py_obj == NULL) {
+            Py_DECREF(py_list);
+            return NULL;
+        }
+        PyList_Append(py_list, py_obj);
+        Py_DECREF(py_obj);
+    }
+    return py_list;
+}
+
+static PyObject *
+_helper_wrap_gobject_gslist (const GSList *list)
+{
+    PyObject *py_list;
+    const GSList *tmp;
+
+    if ((py_list = PyList_New(0)) == NULL) {
+        return NULL;
+    }
+    for (tmp = list; tmp != NULL; tmp = tmp->next) {
+        PyObject *py_obj = pygobject_new(G_OBJECT(tmp->data));
+
+        if (py_obj == NULL) {
+            Py_DECREF(py_list);
+            return NULL;
+        }
+        PyList_Append(py_list, py_obj);
+        Py_DECREF(py_obj);
+    }
+    return py_list;
+}
+%%
+include
+  geditplugin.override
+  geditmessage.override
+%%
+modulename gedit 
+%%
+import gtk.Widget as PyGtkWidget_Type
+import gobject.GObject as PyGObject_Type
+import gtk.gdk.Screen as PyGdkScreen_Type
+import gtk.VBox as PyGtkVBox_Type
+import gtk.Window as PyGtkWindow_Type
+import gtk.Image as PyGtkImage_Type
+import gtk.Statusbar as PyGtkStatusbar_Type
+import gtksourceview2.Buffer as PyGtkSourceBuffer_Type
+import gtksourceview2.View as PyGtkSourceView_Type
+import gtksourceview2.Language as PyGtkSourceLanguage_Type
+import gtksourceview2.LanguageManager as PyGtkSourceLanguageManager_Type
+%%
+ignore-glob
+  *_get_type
+  gedit_document_error_quark
+  gedit_panel_add_item_with_stock_icon
+%%
+override gedit_app_create_window kwargs
+static PyObject *
+_wrap_gedit_app_create_window(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "screen", NULL};
+    PyGObject *screen = NULL;
+    GeditWindow *ret;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+			"|O!", kwlist,
+			&PyGdkScreen_Type, &screen))
+        return NULL;
+
+    ret = gedit_app_create_window(GEDIT_APP(self->obj),
+				  screen ? GDK_SCREEN(screen->obj) : NULL);
+
+    /* pygobject_new handles NULL checking */
+    return pygobject_new((GObject *)ret);
+}
+%%
+override gedit_app_get_windows
+static PyObject *
+_wrap_gedit_app_get_windows(PyGObject *self)
+{
+    const GList *list;
+    PyObject *py_list;
+
+    list = gedit_app_get_windows (GEDIT_APP (self->obj));
+
+    py_list = _helper_wrap_gobject_glist (list);
+
+    return py_list;
+}
+%%
+override gedit_app_get_views
+static PyObject *
+_wrap_gedit_app_get_views(PyGObject *self)
+{
+    GList *list;
+    PyObject *py_list;
+
+    list = gedit_app_get_views (GEDIT_APP (self->obj));
+
+    py_list = _helper_wrap_gobject_glist (list);
+
+    g_list_free (list);
+
+    return py_list;
+}
+%%
+override gedit_app_get_documents
+static PyObject *
+_wrap_gedit_app_get_documents(PyGObject *self)
+{
+    GList *list;
+    PyObject *py_list;
+
+    list = gedit_app_get_documents (GEDIT_APP (self->obj));
+
+    py_list = _helper_wrap_gobject_glist (list);
+
+    g_list_free (list);
+
+    return py_list;
+}
+%%
+override gedit_window_get_documents
+static PyObject *
+_wrap_gedit_window_get_documents(PyGObject *self)
+{
+    GList *list;
+    PyObject *py_list;
+
+    list = gedit_window_get_documents (GEDIT_WINDOW (self->obj));
+
+    py_list = _helper_wrap_gobject_glist (list);
+
+    g_list_free(list);
+
+    return py_list;
+}
+%%
+override gedit_window_get_unsaved_documents
+static PyObject *
+_wrap_gedit_window_get_unsaved_documents(PyGObject *self)
+{
+    GList *list;
+    PyObject *py_list;
+
+    list = gedit_window_get_unsaved_documents (GEDIT_WINDOW (self->obj));
+
+    py_list = _helper_wrap_gobject_glist (list);
+
+    g_list_free(list);
+
+    return py_list;
+}
+%%
+override gedit_window_get_views
+static PyObject *
+_wrap_gedit_window_get_views(PyGObject *self)
+{
+    GList *list;
+    PyObject *py_list;
+
+    list = gedit_window_get_views (GEDIT_WINDOW (self->obj));
+
+    py_list = _helper_wrap_gobject_glist (list);
+
+    g_list_free(list);
+
+    return py_list;
+}
+%%
+override gedit_window_close_tabs kwargs
+static PyObject *
+_wrap_gedit_window_close_tabs (PyGObject *self,
+			       PyObject  *args,
+			       PyObject  *kwargs)
+{
+	static char *kwlist[] = { "tabs", NULL };
+	PyObject *list, *item;
+	GList *glist = NULL;
+	int len, i;
+
+	if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+					  "O:GeditWindow.close_tabs", kwlist,
+					  &list))
+		return NULL;
+
+	if (!PySequence_Check (list))
+	{
+		PyErr_SetString (PyExc_TypeError,
+				 "first argument must be a sequence");
+		return NULL;
+	}
+
+	len = PySequence_Length (list);
+
+	for (i = 0; i < len; i++)
+	{
+		item = PySequence_GetItem (list, i);
+		Py_DECREF(item);
+
+		if (!pygobject_check (item, &PyGeditTab_Type))
+		{
+			PyErr_SetString (PyExc_TypeError,
+					 "sequence item not a Gtkwidget object");
+			g_list_free (glist);
+			return NULL;
+		}
+
+		glist = g_list_append (glist, pygobject_get (item));
+	}
+
+	gedit_window_close_tabs (GEDIT_WINDOW (self->obj), glist);
+
+	g_list_free (glist);
+	Py_INCREF (Py_None);
+	return Py_None;
+}
+%%
+override gedit_document_get_search_text
+static PyObject *
+_wrap_gedit_document_get_search_text(PyGObject *self)
+{
+    PyObject *tuple, *string;
+    guint flags;
+    gchar *ret;
+
+    ret = gedit_document_get_search_text (GEDIT_DOCUMENT (self->obj), &flags);
+
+    tuple = PyTuple_New(2);
+    if (ret) {
+        string = PyString_FromString(ret);
+        PyTuple_SetItem(tuple, 0, string);
+    } else {
+        Py_INCREF(Py_None);
+        PyTuple_SetItem(tuple, 0, Py_None);
+    }
+    PyTuple_SetItem(tuple, 1, PyInt_FromLong(flags));
+
+    g_free(ret);
+
+    return tuple;
+}
+%%
+override gedit_panel_add_item kwargs
+static PyObject *
+_wrap_gedit_panel_add_item(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist1[] = { "item", "name", "image", NULL };
+    static char *kwlist2[] = { "item", "name", "stock_id", NULL };
+    PyGObject *item, *image;
+    char *name = NULL;
+    char *stock_id = NULL;
+
+    if (PyArg_ParseTupleAndKeywords(args, kwargs, "O!sO!:GeditPanel.add_item", kwlist1, &PyGtkWidget_Type, &item, &name, &PyGtkImage_Type, &image)) {
+        gedit_panel_add_item(GEDIT_PANEL(self->obj), GTK_WIDGET(item->obj), name, GTK_WIDGET(image->obj));
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    PyErr_Clear();
+
+    if (PyArg_ParseTupleAndKeywords(args, kwargs, "O!ss:GeditPanel.add_item", kwlist2, &PyGtkWidget_Type, &item, &name, &stock_id)) {
+        gedit_panel_add_item_with_stock_icon(GEDIT_PANEL(self->obj), GTK_WIDGET(item->obj), name, stock_id);
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
+
+    PyErr_Clear();
+    PyErr_SetString(PyExc_TypeError, "the last arg should be either a gtk.Image or a stock_id string");
+    return NULL;
+}
+%%
+override gedit_app_get_default_deprecated
+/* deprecated wrappers */
+static PyObject *
+_wrap_gedit_app_get_default_deprecated(PyObject *self)
+{
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.app_get_default instead") < 0)
+	return NULL;
+    return _wrap_gedit_app_get_default(self);
+}
+%%
+override gedit_encoding_get_from_charset_deprecated kwargs
+static PyObject *
+_wrap_gedit_encoding_get_from_charset_deprecated(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.encoding_get_from_charset instead") < 0)
+	return NULL;
+    return _wrap_gedit_encoding_get_from_charset(self, args, kwargs);
+}
+%%
+override gedit_encoding_get_from_index_deprecated kwargs
+static PyObject *
+_wrap_gedit_encoding_get_from_index_deprecated(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.encoding_get_from_index instead") < 0)
+	return NULL;
+    return _wrap_gedit_encoding_get_from_index(self, args, kwargs);
+}
+%%
+override gedit_encoding_get_utf8_deprecated
+static PyObject *
+_wrap_gedit_encoding_get_utf8_deprecated(PyObject *self)
+{
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.encoding_get_utf8 instead") < 0)
+	return NULL;
+    return _wrap_gedit_encoding_get_utf8(self);
+}
+%%
+override gedit_encoding_get_current_deprecated
+static PyObject *
+_wrap_gedit_encoding_get_current_deprecated(PyObject *self)
+{
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.encoding_get_current instead") < 0)
+	return NULL;
+    return _wrap_gedit_encoding_get_current(self);
+}
+%%
+override gedit_tab_get_from_document_deprecated kwargs
+static PyObject *
+_wrap_gedit_tab_get_from_document_deprecated(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    if (PyErr_Warn(PyExc_DeprecationWarning, "use gedit.tab_get_from_document instead") < 0)
+	return NULL;
+    return _wrap_gedit_tab_get_from_document(self, args, kwargs);
+}
+%%
+override gedit_language_manager_list_languages_sorted kwargs
+static PyObject *
+_wrap_gedit_language_manager_list_languages_sorted(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "lm", "include_hidden", NULL };
+    PyGObject *lm;
+    int include_hidden;
+    PyObject *py_list;
+    GSList *list;
+
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+                                      "O!i:language_manager_list_languages_sorted",
+                                      kwlist, &PyGtkSourceLanguageManager_Type, &lm,
+                                      &include_hidden))
+        return NULL;
+
+    list = gedit_language_manager_list_languages_sorted (GTK_SOURCE_LANGUAGE_MANAGER (lm->obj),
+                                                         include_hidden);
+
+    py_list = _helper_wrap_gobject_gslist (list);
+
+    g_slist_free (list);
+
+    return py_list;
+}
+%%
+override gedit_debug kwargs
+static PyObject *
+_wrap_gedit_debug(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "message", NULL };
+    PyObject *traceback_module, *mdict, *func, *traceback, *tuple;
+    PyObject *filename, *lineno, *funcname;
+    char *message = NULL;
+
+    if (g_getenv ("GEDIT_DEBUG_PLUGINS") == NULL)
+    {
+        Py_INCREF (Py_None);
+        return Py_None;
+    }
+
+    if (!PyArg_ParseTupleAndKeywords (args, kwargs, "|s", kwlist, &message))
+        return NULL;
+
+    traceback_module = PyImport_ImportModule ("traceback");
+    if (traceback_module == NULL)
+    {
+        g_warning ("traceback module cannot be imported");
+        Py_INCREF (Py_None);
+        return Py_None;
+    }
+
+    mdict = PyModule_GetDict (traceback_module);
+    func = PyDict_GetItemString (mdict, "extract_stack");
+    traceback = PyObject_CallFunction (func, "zi", NULL, 1);
+    tuple = PyList_GetItem (traceback, 0);
+
+    if (tuple == NULL || !PyTuple_Check (tuple))
+    {
+        g_warning ("traceback tuple is null!");
+    }
+    else
+    {
+        filename = PyTuple_GetItem (tuple, 0);
+        lineno = PyTuple_GetItem (tuple, 1);
+        funcname = PyTuple_GetItem (tuple, 2);
+
+        if (message == NULL)
+            gedit_debug (GEDIT_DEBUG_PLUGINS,
+                         PyString_AsString (filename),
+                         PyInt_AsLong (lineno),
+                         PyString_AsString (funcname));
+        else
+            gedit_debug_message (GEDIT_DEBUG_PLUGINS,
+                                 PyString_AsString (filename),
+                                 PyInt_AsLong (lineno),
+                                 PyString_AsString (funcname),
+                                 "%s",
+                                 message);
+    }
+    Py_DECREF (traceback);
+    Py_DECREF (traceback_module);
+
+    Py_INCREF (Py_None);
+    return Py_None;
+}
+%%
+override gedit_statusbar_flash_message kwargs
+static PyObject *
+_wrap_gedit_statusbar_flash_message(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "context_id", "message", NULL };
+    int context_id;
+    char *message;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,"is:GeditStatusbar.flash_message", kwlist, &context_id, &message))
+        return NULL;
+   
+    gedit_statusbar_flash_message(GEDIT_STATUSBAR(self->obj), context_id, "%s", message);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
diff --git a/plugin-loaders/python/bindings/geditcommands.defs b/plugin-loaders/python/bindings/geditcommands.defs
new file mode 100755
index 00000000..3808fa43
--- /dev/null
+++ b/plugin-loaders/python/bindings/geditcommands.defs
@@ -0,0 +1,45 @@
+;; -*- scheme -*-
+; object definitions ...
+;; Enumerations and flags ...
+
+
+;; From ../../gedit/gedit-commands.h
+
+(define-function load_uri
+  (c-name "gedit_commands_load_uri")
+  (return-type "none")
+  (parameters
+    '("GeditWindow*" "window")
+    '("const-gchar*" "uri")
+    '("const-GeditEncoding*" "encoding")
+    '("gint" "line_pos")
+  )
+)
+
+(define-function load_uris
+  (c-name "gedit_commands_load_uris")
+  (return-type "gint")
+  (parameters
+    '("GeditWindow*" "window")
+    '("const-GSList*" "uris")
+    '("const-GeditEncoding*" "encoding")
+    '("gint" "line_pos")
+  )
+)
+
+(define-function save_document
+  (c-name "gedit_commands_save_document")
+  (return-type "none")
+  (parameters
+    '("GeditWindow*" "window")
+    '("GeditDocument*" "document")
+  )
+)
+
+(define-function save_all_documents
+  (c-name "gedit_commands_save_all_documents")
+  (return-type "none")
+  (parameters
+    '("GeditWindow*" "window")
+  )
+)
diff --git a/plugin-loaders/python/bindings/geditcommands.override b/plugin-loaders/python/bindings/geditcommands.override
new file mode 100755
index 00000000..a81f9181
--- /dev/null
+++ b/plugin-loaders/python/bindings/geditcommands.override
@@ -0,0 +1,122 @@
+%%
+headers
+#define NO_IMPORT_PYGOBJECT
+#define NO_IMPORT_PYGTK
+#include <pygobject.h>
+#include <pygtk/pygtk.h>
+
+#include "gedit-commands.h"
+#include "gedit-window.h"
+
+void pygeditcommands_register_classes (PyObject *d);
+void pygeditcommands_add_constants (PyObject *module, const gchar *strip_prefix);
+
+%%
+modulename gedit.commands
+%%
+import gedit.Window as PyGeditWindow_Type
+import gedit.Document as PyGeditDocument_Type
+%%
+ignore-glob
+  _*
+%%
+override gedit_commands_load_uri kwargs 
+static PyObject *
+_wrap_gedit_commands_load_uri (PyObject *self, PyObject *args, PyObject *kwargs)
+{
+	static char *kwlist[] = { "window", "uri", "encoding", "line_pos", NULL };
+	PyGObject *window;
+	char *uri;
+	int line_pos = 0;
+	PyObject *py_encoding = NULL;
+	GeditEncoding *encoding = NULL;
+
+	if (!PyArg_ParseTupleAndKeywords (args, kwargs, "O!s|Oi:load_uri", 
+	                                  kwlist, &PyGeditWindow_Type, 
+	                                  &window, &uri, &py_encoding, 
+	                                  &line_pos))
+		return NULL;
+    
+	if (py_encoding != NULL && py_encoding != Py_None)
+	{
+		if (pyg_boxed_check (py_encoding, GEDIT_TYPE_ENCODING))
+			encoding = pyg_boxed_get (py_encoding, GeditEncoding);
+		else
+		{
+			PyErr_SetString (PyExc_TypeError, 
+			                 "encoding should be a GeditEncoding");
+			return NULL;
+		}
+	}
+
+	gedit_commands_load_uri (GEDIT_WINDOW (window->obj), uri, encoding, 
+	                        line_pos);
+	Py_INCREF (Py_None);
+	return Py_None;
+}
+%%
+override gedit_commands_load_uris kwargs 
+static PyObject *
+_wrap_gedit_commands_load_uris (PyObject *self, PyObject *args, PyObject *kwargs)
+{
+	static char *kwlist[] = { "window", "uris", "encoding", "line_pos", NULL };
+	PyGObject *window;
+	GSList *uris = NULL;
+	int line_pos = 0;
+	PyObject *py_encoding = NULL;
+	PyObject *list;
+	PyObject *item;
+	GeditEncoding *encoding = NULL;
+	int len;
+	int i;
+
+	if (!PyArg_ParseTupleAndKeywords (args, kwargs, "O!O|Oi:load_uri", 
+	                                  kwlist, &PyGeditWindow_Type, 
+	                                  &window, &list, &py_encoding, 
+	                                  &line_pos))
+		return NULL;
+    
+	if (py_encoding != NULL && py_encoding != Py_None)
+	{
+		if (pyg_boxed_check (py_encoding, GEDIT_TYPE_ENCODING))
+			encoding = pyg_boxed_get (py_encoding, GeditEncoding);
+		else {
+			PyErr_SetString (PyExc_TypeError, 
+			                 "encoding should be a GeditEncoding");
+			return NULL;
+		}
+	}
+
+	if (!PySequence_Check (list))
+	{
+		PyErr_SetString (PyExc_TypeError, 
+		                 "second argument must be a sequence");
+		return NULL;
+	}
+
+	len = PySequence_Length (list);
+
+	for (i = 0; i < len; i++)
+	{
+		item = PySequence_GetItem (list, i);
+		Py_DECREF (item);
+
+		if (!PyString_Check (item))
+		{
+			PyErr_SetString (PyExc_TypeError,
+					 "sequence item not a string");
+			g_slist_free (uris);
+			return NULL;
+		}
+
+		uris = g_slist_prepend (uris, PyString_AsString (item));
+	}
+
+	uris = g_slist_reverse (uris);
+	gedit_commands_load_uris (GEDIT_WINDOW (window->obj), uris, 
+	                          encoding, line_pos);
+	g_slist_free (uris);
+
+	Py_INCREF (Py_None);
+	return Py_None;
+}
diff --git a/plugin-loaders/python/bindings/geditmessage.override b/plugin-loaders/python/bindings/geditmessage.override
new file mode 100755
index 00000000..244d60ce
--- /dev/null
+++ b/plugin-loaders/python/bindings/geditmessage.override
@@ -0,0 +1,556 @@
+%%
+headers
+
+#include <gedit/gedit-message-bus.h>
+#include <gedit/gedit-message.h>
+
+static GType
+_helper_wrap_get_gtype_from_pytype (PyObject *pytype)
+{
+    PyTypeObject *type = (PyTypeObject *)pytype;
+    
+    if (type == &PyList_Type || type == &PyTuple_Type)
+    	return G_TYPE_STRV;
+
+    return pyg_type_from_object (pytype);
+}
+
+static gchar *
+_helper_wrap_get_string (PyObject *obj)
+{
+	PyObject *str;
+	gchar *result;
+	
+	str = PyObject_Str (obj);
+	
+	if (!str)
+		return NULL;
+	
+	result = g_strdup (PyString_AsString (str));
+	Py_DECREF (str);
+	
+	return result;
+}
+
+static int
+_helper_wrap_list_to_gvalue (GValue *gvalue, PyObject *pyvalue)
+{
+	int num;
+	gchar **lst;
+	gint i;
+	
+	num = PySequence_Size (pyvalue);
+	lst = g_new0 (gchar *, num + 1);
+	
+	for (i = 0; i < num; i++)
+	{
+		lst[i] = _helper_wrap_get_string (PySequence_GetItem (pyvalue, i));
+		
+		if (lst[i] == NULL)
+		{
+			g_strfreev (lst);
+			return 1;
+		}
+	}
+	
+	g_value_set_boxed (gvalue, lst);
+	g_strfreev (lst);
+	
+	return 0;
+}
+
+static int
+_helper_wrap_get_gvalue_from_pyobject (GValue *gvalue, PyObject *pyvalue)
+{
+	if (pyvalue->ob_type == &PyList_Type || pyvalue->ob_type == &PyTuple_Type)
+		return _helper_wrap_list_to_gvalue (gvalue, pyvalue);
+
+	return pyg_value_from_pyobject(gvalue, pyvalue);
+}
+
+static int
+_helper_wrap_message_set_value(GeditMessage *message, PyObject *pykey, PyObject *pyvalue)
+{
+    gchar *key;
+    GType gtype;
+    GValue value = {0,};
+
+    key = _helper_wrap_get_string(pykey);
+    
+    if (key == NULL)
+        return 0;
+
+    gtype = gedit_message_get_key_type(message, key);
+    
+    if (gtype == 0) {
+        PyErr_SetString(PyExc_TypeError, "invalid key");
+        g_free (key);
+        return 0;
+    }
+
+    g_value_init(&value, gtype);
+    
+    if (_helper_wrap_get_gvalue_from_pyobject (&value, pyvalue)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "value is of the wrong type for this key");
+        g_free (key);
+        return 0;
+    }
+
+    gedit_message_set_value(message, key, &value);
+    g_value_unset(&value);
+    g_free (key);
+    
+    return 1;
+}
+
+typedef void (*ParsePairFunc)(PyObject *key, PyObject *value, gpointer user_data);
+
+static void
+_helper_parse_pairs_dict (PyObject *dict, ParsePairFunc func, gpointer user_data)
+{
+    if (!dict)
+        return;
+    
+    PyObject *key, *value;
+    Py_ssize_t i = 0;
+    
+    while (PyDict_Next(dict, &i, &key, &value))
+    {
+        func(key, value, user_data);
+    }
+}
+
+static void
+_helper_parse_pairs(PyObject *args, PyObject *kwargs, ParsePairFunc func, gpointer user_data)
+{
+    guint len;
+    guint i;
+    
+    len = PyTuple_Size(args);
+    
+    for (i = 0; i < len; ++i)
+    {
+    	PyObject *d = PyTuple_GetItem(args, i);
+    	
+    	if (PyDict_Check(d))
+            _helper_parse_pairs_dict(d, func, user_data);
+    }
+  
+    _helper_parse_pairs_dict(kwargs, func, user_data);  
+}
+
+static void
+_helper_message_set(PyObject *key, PyObject *value, GeditMessage *message)
+{
+    _helper_wrap_message_set_value(message, key, value);
+}
+
+static void
+_helper_message_set_values(GeditMessage *message, PyObject *args, PyObject *kwargs)
+{
+    _helper_parse_pairs(args, kwargs, (ParsePairFunc)_helper_message_set, message);
+}
+
+static GeditMessage *
+_helper_wrap_create_message(GeditMessageBus *bus, PyObject *args, PyObject *kwargs)
+{
+    PyObject *pypath, *pymethod, *pydict;
+    
+    if (!PyArg_ParseTuple(args, "OO|O:GeditMessage.create", &pypath, &pymethod, &pydict))
+        return NULL;
+    
+    gchar *object_path = _helper_wrap_get_string(pypath);
+    gchar *method = _helper_wrap_get_string(pymethod);
+    
+    GeditMessageType *message_type = gedit_message_bus_lookup (bus, object_path, method);
+    GeditMessage *message;
+     
+    if (message_type)
+    {
+        message = gedit_message_type_instantiate(message_type, NULL);
+        _helper_message_set_values(message, args, kwargs);
+    }
+    else
+    {
+    	PyErr_SetString(PyExc_StandardError, "Message type does not exist");
+        message = NULL;
+    }
+    
+    g_free(object_path);
+    g_free(method);
+    
+    return message;
+}
+
+typedef struct {
+    PyObject *func;
+    PyObject *data;
+} PyGeditCustomNotify;
+
+static void 
+pygedit_custom_destroy_notify(gpointer user_data)
+{
+    PyGeditCustomNotify *cunote = user_data;
+    PyGILState_STATE state;
+    
+    g_return_if_fail(user_data);
+    state = pyg_gil_state_ensure();
+    Py_XDECREF(cunote->func);
+    Py_XDECREF(cunote->data);
+    pyg_gil_state_release(state);
+    
+    g_free(cunote);
+}
+%%
+ignore-glob
+  *_get_type
+  gedit_message_type_foreach
+  gedit_message_type_instantiate_valist
+  gedit_message_type_new_valist
+  gedit_message_get_valist
+  gedit_message_set_valist
+  gedit_message_set_valuesv
+  gedit_message_bus_disconnect_by_func
+  gedit_message_bus_block_by_func
+  gedit_message_bus_unblock_by_func
+%%
+override gedit_message_type_new kwargs
+
+typedef struct
+{
+    GeditMessageType *message_type;
+    PyObject *optional;
+} MessageTypeSetInfo;
+
+static void
+_message_type_set(PyObject *key, PyObject *value, MessageTypeSetInfo *info)
+{
+    GType gtype;
+    
+    gchar *k = _helper_wrap_get_string(key);
+
+    if (!k)
+        return;
+
+    gtype = _helper_wrap_get_gtype_from_pytype(value);
+    
+    gboolean optional = info->optional && PySequence_Contains(info->optional, key);
+    
+    gedit_message_type_set(info->message_type, optional, k, gtype, NULL);
+    g_free(k);
+}
+
+static int
+_wrap_gedit_message_type_new(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *pypath, *pymethod, *optional = NULL, *pydict;
+    
+    if (!PyArg_ParseTuple(args, "OO|OO:GeditMessageType.new", &pypath, &pymethod, &optional, &pydict))
+        return -1;
+    
+    GeditMessageType *message_type = GEDIT_MESSAGE_TYPE(g_object_new(pyg_type_from_object((PyObject *) self), NULL));
+    
+    MessageTypeSetInfo info = {message_type, optional && PySequence_Check(optional) ? optional : NULL};
+    _helper_parse_pairs (args, kwargs, (ParsePairFunc)_message_type_set, &info);
+    
+    self->obj = (GObject *)message_type;    
+    pygobject_register_wrapper((PyObject *) self);
+    
+    return 0;
+}
+%%
+override gedit_message_type_instantiate kwargs
+static PyObject *
+_wrap_gedit_message_type_instantiate(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    GeditMessageType *message_type = GEDIT_MESSAGE_TYPE (self->obj);
+    GeditMessage *message = gedit_message_type_instantiate(message_type, NULL);
+    
+    _helper_message_set_values(message, args, kwargs);
+    
+    return pygobject_new((GObject *)message);
+}
+%%
+override gedit_message_get args
+static PyObject *
+_wrap_gedit_message_get(PyGObject *self, PyObject *args)
+{
+    guint len, i;
+    PyObject *ret;
+
+    len = PyTuple_Size(args);
+    
+    ret = PyTuple_New(len);
+    
+    for (i = 0; i < len; i++) {
+        GValue value = { 0, };
+        PyObject *py_key = PyTuple_GetItem(args, i);
+        gchar *key = _helper_wrap_get_string(py_key);
+        
+        if (!key) {
+	    PyErr_SetString(PyExc_TypeError, "keys must be strings");
+	    Py_DECREF(ret);
+	    return NULL;
+	}
+	
+	gedit_message_get_value (GEDIT_MESSAGE (self->obj), key, &value);
+	g_free (key);
+
+	PyTuple_SetItem(ret, i, pyg_value_as_pyobject(&value, TRUE));
+	g_value_unset(&value);
+    }
+    
+    return ret;
+}
+%%
+override gedit_message_get_value kwargs
+static PyObject *
+_wrap_gedit_message_get_value(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "key", NULL };
+    const gchar *key;
+    PyObject *ret;
+    GValue value = { 0, };
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:GeditMessage.get_value", kwlist, &key))
+        return NULL;
+
+    gedit_message_get_value(GEDIT_MESSAGE(self->obj), key, &value);
+    ret = pyg_value_as_pyobject(&value, TRUE);
+    g_value_unset(&value);
+    
+    return ret;
+}
+%%
+override gedit_message_set_value kwargs
+static PyObject *
+_wrap_gedit_message_set_value(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = { "key", "value", NULL };
+    PyObject *pykey, *pyvalue;
+    
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GeditMessage.set_value", kwlist, &pykey, &pyvalue))
+        return NULL;
+    
+    if (!_helper_wrap_message_set_value(GEDIT_MESSAGE(self->obj), pykey, pyvalue))
+        return NULL;
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gedit_message_set kwargs
+static PyObject *
+_wrap_gedit_message_set (PyGObject *self, PyObject *args, PyObject *kwargs) {
+    _helper_message_set_values(GEDIT_MESSAGE(self->obj), args, kwargs);
+
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gedit_message_bus_new
+static int
+_wrap_gedit_message_bus_new(PyGObject *self)
+{
+    pygobject_construct (self, NULL);
+    
+    if (!self->obj) {
+        PyErr_SetString (PyExc_RuntimeError, "could not create gedit.MessageBus object");
+        return -1;
+    }
+
+    return 0;
+}
+%%
+new-constructor GEDIT_TYPE_MESSAGE_BUS
+%%
+override gedit_message_bus_register kwargs
+static PyObject *
+_wrap_gedit_message_bus_register(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *pypath, *pymethod, *optional = NULL, *pydict;
+    GeditMessageBus *bus = GEDIT_MESSAGE_BUS(self->obj);
+
+    if (!PyArg_ParseTuple(args, "OO|OO:GeditMessageBus.register", &pypath, &pymethod, &optional, &pydict))
+        return NULL;
+    
+    gchar *object_path = _helper_wrap_get_string(pypath);
+    gchar *method = _helper_wrap_get_string(pymethod);
+    
+    GeditMessageType *message_type = gedit_message_bus_register(bus, object_path, method, 0, NULL);
+    
+    g_free(object_path);
+    g_free(method);
+    
+    if (!message_type)
+    {
+    	PyErr_SetString(PyExc_StandardError, "Message type already exists");
+    	return NULL;
+    }
+    
+    MessageTypeSetInfo info = {message_type, optional && PySequence_Check(optional) ? optional : NULL};
+    _helper_parse_pairs (args, kwargs, (ParsePairFunc)_message_type_set, &info);
+    
+    return pyg_boxed_new(GEDIT_TYPE_MESSAGE_TYPE, message_type, TRUE, TRUE);
+}
+%%
+override gedit_message_bus_connect kwargs
+static void
+pygedit_message_bus_connect_cb(GeditMessageBus *bus, GeditMessage *message, gpointer data)
+{
+    PyGILState_STATE state;
+    PyGeditCustomNotify *cunote = data;
+    PyObject *pybus, *pymessage, *retobj;
+
+    g_assert(cunote->func);
+
+    state = pyg_gil_state_ensure();
+
+    pybus = pygobject_new((GObject *)bus);
+    pymessage = pygobject_new((GObject *)message);
+
+    if (cunote->data) {
+        retobj = PyEval_CallFunction(cunote->func, "(NNO)", pybus, pymessage, cunote->data);
+    } else {
+        retobj = PyEval_CallFunction(cunote->func, "(NN)", pybus, pymessage);
+    }
+
+    if (PyErr_Occurred()) {
+        PyErr_Print();
+    }
+
+    Py_XDECREF(retobj);
+
+    pyg_gil_state_release(state);
+}
+
+static PyObject *
+_wrap_gedit_message_bus_connect(PyGObject *self, PyObject *args, PyObject *kwargs) 
+{
+    static char *kwlist[] = { "domain", "name", "func", "data", NULL };
+    PyObject *pyfunc, *pyarg = NULL;
+    const gchar *domain;
+    const gchar *name;
+    PyGeditCustomNotify *cunote;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+				     "ssO|O:GeditMessageBus.connect",
+				     kwlist, &domain, &name, &pyfunc, &pyarg))
+        return NULL;
+
+    if (!PyCallable_Check(pyfunc)) {
+        PyErr_SetString(PyExc_TypeError, "func must be a callable object");
+        return NULL;
+    }
+    cunote = g_new(PyGeditCustomNotify, 1);
+    Py_INCREF(pyfunc);
+    cunote->func = pyfunc;
+    Py_XINCREF(pyarg);
+    cunote->data = pyarg;
+
+    guint id = gedit_message_bus_connect(GEDIT_MESSAGE_BUS(self->obj),
+                                         domain,
+                                         name,
+                                         pygedit_message_bus_connect_cb,
+                                         (gpointer)cunote,
+                                         pygedit_custom_destroy_notify);
+    return PyLong_FromUnsignedLong(id);
+}
+%%
+override gedit_message_bus_send kwargs
+static PyObject *
+_wrap_gedit_message_bus_send(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    /* create a new message object */
+    GeditMessage *message;
+    GeditMessageBus *bus = GEDIT_MESSAGE_BUS(self->obj);
+    message = _helper_wrap_create_message(bus, args, kwargs);
+    
+    if (!message)
+        return NULL;
+    
+    gedit_message_bus_send_message(bus, message);
+    g_object_unref (message);
+    
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+%%
+override gedit_message_bus_send_sync kwargs
+static PyObject *
+_wrap_gedit_message_bus_send_sync(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+    /* create a new message object */
+    GeditMessage *message;
+    GeditMessageBus *bus = GEDIT_MESSAGE_BUS(self->obj);
+    
+    message = _helper_wrap_create_message(bus, args, kwargs);
+    
+    if (!message)
+        return NULL;
+    
+    gedit_message_bus_send_message_sync(bus, message);
+    return pygobject_new((GObject *)message);
+}
+%%
+override-slot GeditMessage.tp_getattro
+static PyObject *
+_wrap_gedit_message_tp_getattro(PyObject *self, PyObject *attrname)
+{
+	GeditMessage *message = GEDIT_MESSAGE(((PyGObject *)self)->obj);
+	GeditMessageType *type;
+
+	gchar *name = _helper_wrap_get_string (attrname);
+	gboolean exists;
+	gboolean intype;
+	PyObject *ret;
+	
+	if (name == NULL)
+	{
+		PyErr_SetString(PyExc_TypeError, "attr name somehow not a string");
+		return NULL;
+	}
+	
+	g_object_get (message, "type", &type, NULL);
+	intype = gedit_message_type_lookup (type, name) != G_TYPE_INVALID;
+	gedit_message_type_unref (type);
+	
+	exists = gedit_message_has_key (message, name);
+	
+	if (!intype)
+	{
+		ret = PyObject_GenericGetAttr(self, attrname);
+	}
+	else if (exists)
+	{
+		GValue value = { 0, };
+		gedit_message_get_value (message, name, &value);
+		ret = pyg_value_as_pyobject(&value, TRUE);
+		g_value_unset (&value);
+	}
+	else
+	{
+		Py_INCREF(Py_None);
+		ret = Py_None;
+	}
+
+	g_free (name);
+	return ret;
+}
+%%
+override-slot GeditMessage.tp_setattro
+static int
+_wrap_gedit_message_tp_setattro(PyObject *self, PyObject *attrname, PyObject *value)
+{
+	GeditMessage *message = GEDIT_MESSAGE(((PyGObject *)self)->obj);
+
+	if (!_helper_wrap_message_set_value(message, attrname, value))
+	{
+		return PyObject_GenericSetAttr(self, attrname, value);
+	}
+	else
+	{
+		return 1;
+	}
+}
diff --git a/plugin-loaders/python/bindings/geditplugin.override b/plugin-loaders/python/bindings/geditplugin.override
new file mode 100755
index 00000000..178ea997
--- /dev/null
+++ b/plugin-loaders/python/bindings/geditplugin.override
@@ -0,0 +1,193 @@
+%%
+headers
+#include <gedit/gedit-plugin.h>
+#include <gedit/gedit-window.h>
+%%
+override gedit_plugin_activate kwargs
+static PyObject *
+_wrap_gedit_plugin_activate(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+	gpointer klass, klass2;
+	static char *kwlist[] = { "window", NULL };
+	PyGObject *window;
+	PyObject *cls = (PyObject *)(((PyObject *)self)->ob_type);
+	
+	if (!PyArg_ParseTupleAndKeywords (args, 
+					  kwargs,
+					  "O!:GeditPlugin.activate", 
+					  kwlist,
+					  &PyGeditWindow_Type, 
+					  &window))
+		return NULL;
+
+	klass = g_type_class_ref (pyg_type_from_object (cls));
+	
+	if (GEDIT_IS_PLUGIN_PYTHON_CLASS (klass))
+	{
+		klass2 = g_type_class_peek_parent (klass);
+		g_type_class_unref (klass);
+		klass = g_type_class_ref (G_TYPE_FROM_CLASS (klass2));
+	}
+
+	if (GEDIT_PLUGIN_CLASS (klass)->activate)
+		GEDIT_PLUGIN_CLASS (klass)->activate (GEDIT_PLUGIN (self->obj), 
+						      GEDIT_WINDOW (window->obj));
+	else {
+		PyErr_SetString (PyExc_NotImplementedError, 
+				 "virtual method GeditPlugin.activate not implemented");
+		g_type_class_unref (klass);
+		return NULL;
+	}
+
+	g_type_class_unref (klass);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+%%
+override gedit_plugin_deactivate kwargs
+static PyObject *
+_wrap_gedit_plugin_deactivate(PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+	gpointer klass, klass2;
+	static char *kwlist[] = {"window", NULL};
+	PyGObject *window;
+	PyObject *cls = (PyObject *)(((PyObject *)self)->ob_type);
+
+	if (!PyArg_ParseTupleAndKeywords (args, 
+					  kwargs,
+					  "O!:GeditPlugin.deactivate", 
+					  kwlist,
+					  &PyGeditWindow_Type, 
+					  &window))
+		return NULL;
+
+	klass = g_type_class_ref (pyg_type_from_object (cls));
+
+	if (GEDIT_IS_PLUGIN_PYTHON_CLASS (klass))
+	{
+		klass2 = g_type_class_peek_parent (klass);
+		g_type_class_unref (klass);
+		klass = g_type_class_ref (G_TYPE_FROM_CLASS (klass2));
+	}
+	
+	if (GEDIT_PLUGIN_CLASS (klass)->deactivate)
+		GEDIT_PLUGIN_CLASS (klass)->deactivate (GEDIT_PLUGIN (self->obj), 
+							GEDIT_WINDOW (window->obj));
+	else {
+		PyErr_SetString (PyExc_NotImplementedError, 
+				 "virtual method GeditPlugin.deactivate not implemented");
+		g_type_class_unref (klass);
+		return NULL;
+	}
+
+	g_type_class_unref (klass);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+%%
+override gedit_plugin_update_ui kwargs
+static PyObject *
+_wrap_gedit_plugin_update_ui (PyGObject *self, PyObject *args, PyObject *kwargs)
+{
+	gpointer klass, klass2;
+	static char *kwlist[] = {"window", NULL};
+	PyGObject *window;
+	PyObject *cls = (PyObject *)(((PyObject *)self)->ob_type);
+
+	if (!PyArg_ParseTupleAndKeywords (args, 
+					  kwargs,
+					  "O!:GeditPlugin.update_ui", 
+					  kwlist,
+					  &PyGeditWindow_Type, 
+					  &window))
+		return NULL;
+
+	klass = g_type_class_ref (pyg_type_from_object (cls));
+
+	if (GEDIT_IS_PLUGIN_PYTHON_CLASS (klass))
+	{
+		klass2 = g_type_class_peek_parent (klass);
+		g_type_class_unref (klass);
+		klass = g_type_class_ref (G_TYPE_FROM_CLASS (klass2));
+	}
+	
+	if (GEDIT_PLUGIN_CLASS (klass)->update_ui)
+		GEDIT_PLUGIN_CLASS (klass)->update_ui (GEDIT_PLUGIN (self->obj), 
+						       GEDIT_WINDOW (window->obj));
+	else {
+		PyErr_SetString (PyExc_NotImplementedError, 
+				 "virtual method GeditPlugin.update_ui not implemented");
+		g_type_class_unref (klass);
+		return NULL;
+	}
+
+	g_type_class_unref (klass);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+%%
+override gedit_plugin_is_configurable
+static PyObject *
+_wrap_gedit_plugin_is_configurable (PyGObject *self)
+{
+	int ret;
+	gpointer klass, klass2;
+	PyObject *cls = (PyObject *)(((PyObject *)self)->ob_type);
+
+	klass = g_type_class_ref (pyg_type_from_object (cls));
+
+	if (GEDIT_IS_PLUGIN_PYTHON_CLASS (klass))
+	{
+		klass2 = g_type_class_peek_parent (klass);
+		g_type_class_unref (klass);
+		klass = g_type_class_ref (G_TYPE_FROM_CLASS (klass2));
+	}
+	
+	if (GEDIT_PLUGIN_CLASS (klass)->is_configurable)
+		ret = GEDIT_PLUGIN_CLASS (klass)->is_configurable (GEDIT_PLUGIN (self->obj));
+	else {
+		PyErr_SetString (PyExc_NotImplementedError, 
+				 "virtual method GeditPlugin.is_configurable not implemented");
+		g_type_class_unref (klass);
+		return NULL;
+	}
+
+	g_type_class_unref (klass);
+	return PyBool_FromLong (ret);
+}
+
+%%
+override gedit_plugin_configure_dialog
+static PyObject *
+_wrap_gedit_plugin_create_configure_dialog (PyGObject *self)
+{
+	GtkWidget *ret;
+	gpointer klass, klass2;
+	PyObject *cls = (PyObject *)(((PyObject *)self)->ob_type);
+
+	klass = g_type_class_ref(pyg_type_from_object (cls));
+
+	if (GEDIT_IS_PLUGIN_PYTHON_CLASS (klass))
+	{
+		klass2 = g_type_class_peek_parent (klass);
+		g_type_class_unref (klass);
+		klass = g_type_class_ref (G_TYPE_FROM_CLASS (klass2));
+	}
+	
+	if (GEDIT_PLUGIN_CLASS (klass)->create_configure_dialog)
+		ret = GEDIT_PLUGIN_CLASS (klass)->create_configure_dialog (GEDIT_PLUGIN (self->obj));
+	else {
+		PyErr_SetString (PyExc_NotImplementedError, 
+				 "virtual method GeditPlugin.create_configure_dialog not implemented");
+		g_type_class_unref (klass);
+		return NULL;
+	}
+
+	g_type_class_unref (klass);
+
+	/* pygobject_new handles NULL checking */
+	return pygobject_new ((GObject *)ret);
+}
diff --git a/plugin-loaders/python/bindings/geditutils.defs b/plugin-loaders/python/bindings/geditutils.defs
new file mode 100755
index 00000000..3482f21c
--- /dev/null
+++ b/plugin-loaders/python/bindings/geditutils.defs
@@ -0,0 +1,67 @@
+;; -*- scheme -*-
+
+;; From ../../gedit/gedit-utils.h
+
+(define-function uri_has_writable_scheme
+  (c-name "gedit_utils_uri_has_writable_scheme")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "uri")
+  )
+)
+
+(define-function uri_has_file_scheme
+  (c-name "gedit_utils_uri_has_file_scheme")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "uri")
+  )
+)
+
+(define-function uri_exists
+  (c-name "gedit_utils_uri_exists")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "text_uri")
+  )
+)
+
+(define-function uri_is_valid
+  (c-name "gedit_utils_is_valid_uri")
+  (return-type "gboolean")
+  (parameters
+    '("const-gchar*" "uri")
+  )
+)
+
+(define-function uri_get_dirname
+  (c-name "gedit_utils_uri_get_dirname")
+  (return-type "gchar*")
+  (parameters
+    '("const-char*" "uri")
+  )
+)
+
+(define-function menu_position_under_widget
+  (c-name "gedit_utils_menu_position_under_widget")
+  (return-type "none")
+  (parameters
+    '("GtkMenu*" "menu")
+    '("gint*" "x")
+    '("gint*" "y")
+    '("gboolean*" "push_in")
+    '("gpointer" "user_data")
+  )
+)
+
+(define-function menu_position_under_tree_view
+  (c-name "gedit_utils_menu_position_under_tree_view")
+  (return-type "none")
+  (parameters
+    '("GtkMenu*" "menu")
+    '("gint*" "x")
+    '("gint*" "y")
+    '("gboolean*" "push_in")
+    '("gpointer" "user_data")
+  )
+)
diff --git a/plugin-loaders/python/bindings/geditutils.override b/plugin-loaders/python/bindings/geditutils.override
new file mode 100755
index 00000000..a7bf7fbe
--- /dev/null
+++ b/plugin-loaders/python/bindings/geditutils.override
@@ -0,0 +1,85 @@
+%%
+headers
+#define NO_IMPORT_PYGOBJECT
+#define NO_IMPORT_PYGTK
+#include <pygobject.h>
+#include <pygtk/pygtk.h>
+
+#include "gedit-utils.h"
+
+void pygeditutils_register_classes (PyObject *d);
+void pygeditutils_add_constants (PyObject *module, const gchar *strip_prefix);
+
+%%
+modulename gedit.utils
+%%
+import gtk.Widget as PyGtkWidget_Type
+import gtk.TreeView as PyGtkTreeView_Type
+import gtk.Menu as PyGtkMenu_Type
+%%
+ignore-glob
+  _*
+%%
+override gedit_utils_menu_position_under_widget kwargs
+static PyObject *
+_wrap_gedit_utils_menu_position_under_widget (PyObject *self,
+					      PyObject *args,
+					      PyObject *kwargs)
+{
+	static char *kwlist[] = { "menu", "widget", NULL };
+	PyObject *py_menu, *py_widget;
+	GtkMenu *menu;
+	GtkWidget *widget;
+	gint x, y;
+	gboolean push_in;
+	PyObject *tuple;
+	
+	if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+					  "O!O!", kwlist,
+					  &PyGtkMenu_Type, &py_menu,
+					  &PyGtkWidget_Type, &py_widget))
+		return NULL;
+	
+	menu   = GTK_MENU (pygobject_get (py_menu));
+	widget = GTK_WIDGET (pygobject_get (py_widget));
+
+	gedit_utils_menu_position_under_widget (menu, &x, &y, &push_in, widget);
+
+	tuple = PyTuple_New (3);
+	PyTuple_SetItem (tuple, 0, PyInt_FromLong (x));
+	PyTuple_SetItem (tuple, 1, PyInt_FromLong (y));
+	PyTuple_SetItem (tuple, 2, PyBool_FromLong (push_in));
+	return tuple;
+}
+%%
+override gedit_utils_menu_position_under_tree_view kwargs
+static PyObject *
+_wrap_gedit_utils_menu_position_under_tree_view (PyObject *self,
+					         PyObject *args,
+					         PyObject *kwargs)
+{
+	static char *kwlist[] = { "menu", "tree_view", NULL };
+	PyObject *py_menu, *py_view;
+	GtkMenu *menu;
+	GtkTreeView *view;
+	gint x, y;
+	gboolean push_in;
+	PyObject *tuple;
+	
+	if (!PyArg_ParseTupleAndKeywords (args, kwargs,
+					  "O!O!", kwlist,
+					  &PyGtkMenu_Type, &py_menu,
+					  &PyGtkTreeView_Type, &py_view))
+		return NULL;
+	
+	menu = GTK_MENU (pygobject_get (py_menu));
+	view = GTK_TREE_VIEW (pygobject_get (py_view));
+
+	gedit_utils_menu_position_under_widget (menu, &x, &y, &push_in, view);
+
+	tuple = PyTuple_New (3);
+	PyTuple_SetItem (tuple, 0, PyInt_FromLong (x));
+	PyTuple_SetItem (tuple, 1, PyInt_FromLong (y));
+	PyTuple_SetItem (tuple, 2, PyBool_FromLong (push_in));
+	return tuple;
+}