no more submodule

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GLib/GLibSharp.AsyncReadyCallbackNative.cs

@@ -0,0 +1,91 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GLibSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void AsyncReadyCallbackNative(IntPtr source_object, IntPtr res, IntPtr user_data);
+
+	internal class AsyncReadyCallbackInvoker {
+
+		AsyncReadyCallbackNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~AsyncReadyCallbackInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal AsyncReadyCallbackInvoker (AsyncReadyCallbackNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal AsyncReadyCallbackInvoker (AsyncReadyCallbackNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal AsyncReadyCallbackInvoker (AsyncReadyCallbackNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GLib.AsyncReadyCallback Handler {
+			get {
+				return new GLib.AsyncReadyCallback(InvokeNative);
+			}
+		}
+
+		void InvokeNative (GLib.Object source_object, GLib.IAsyncResult res)
+		{
+			native_cb (source_object == null ? IntPtr.Zero : source_object.Handle, res == null ? IntPtr.Zero : ((res is GLib.Object) ? (res as GLib.Object).Handle : (res as GLib.AsyncResultAdapter).Handle), __data);
+		}
+	}
+
+	internal class AsyncReadyCallbackWrapper {
+
+		public void NativeCallback (IntPtr source_object, IntPtr res, IntPtr user_data)
+		{
+			try {
+				managed (GLib.Object.GetObject (source_object), GLib.AsyncResultAdapter.GetObject (res, false));
+				if (release_on_call)
+					gch.Free ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal AsyncReadyCallbackNative NativeDelegate;
+		GLib.AsyncReadyCallback managed;
+
+		public AsyncReadyCallbackWrapper (GLib.AsyncReadyCallback managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new AsyncReadyCallbackNative (NativeCallback);
+		}
+
+		public static GLib.AsyncReadyCallback GetManagedDelegate (AsyncReadyCallbackNative native)
+		{
+			if (native == null)
+				return null;
+			AsyncReadyCallbackWrapper wrapper = (AsyncReadyCallbackWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GLib/GLibSharp.FileProgressCallbackNative.cs

@@ -0,0 +1,91 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GLibSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate void FileProgressCallbackNative(long current_num_bytes, long total_num_bytes, IntPtr user_data);
+
+	internal class FileProgressCallbackInvoker {
+
+		FileProgressCallbackNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~FileProgressCallbackInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal FileProgressCallbackInvoker (FileProgressCallbackNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal FileProgressCallbackInvoker (FileProgressCallbackNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal FileProgressCallbackInvoker (FileProgressCallbackNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GLib.FileProgressCallback Handler {
+			get {
+				return new GLib.FileProgressCallback(InvokeNative);
+			}
+		}
+
+		void InvokeNative (long current_num_bytes, long total_num_bytes)
+		{
+			native_cb (current_num_bytes, total_num_bytes, __data);
+		}
+	}
+
+	internal class FileProgressCallbackWrapper {
+
+		public void NativeCallback (long current_num_bytes, long total_num_bytes, IntPtr user_data)
+		{
+			try {
+				managed (current_num_bytes, total_num_bytes);
+				if (release_on_call)
+					gch.Free ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal FileProgressCallbackNative NativeDelegate;
+		GLib.FileProgressCallback managed;
+
+		public FileProgressCallbackWrapper (GLib.FileProgressCallback managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new FileProgressCallbackNative (NativeCallback);
+		}
+
+		public static GLib.FileProgressCallback GetManagedDelegate (FileProgressCallbackNative native)
+		{
+			if (native == null)
+				return null;
+			FileProgressCallbackWrapper wrapper = (FileProgressCallbackWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSharp/ObjectManager.cs

@@ -0,0 +1,50 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSharp.GtkSourceSharp {
+
+	public partial class ObjectManager {
+
+		static bool initialized = false;
+		// Call this method from the appropriate module init function.
+		public static void Initialize ()
+		{
+			if (initialized)
+				return;
+
+			initialized = true;
+			GLib.GType.Register (GtkSource.Buffer.GType, typeof (GtkSource.Buffer));
+			GLib.GType.Register (GtkSource.Completion.GType, typeof (GtkSource.Completion));
+			GLib.GType.Register (GtkSource.CompletionContext.GType, typeof (GtkSource.CompletionContext));
+			GLib.GType.Register (GtkSource.CompletionInfo.GType, typeof (GtkSource.CompletionInfo));
+			GLib.GType.Register (GtkSource.CompletionItem.GType, typeof (GtkSource.CompletionItem));
+			GLib.GType.Register (GtkSource.File.GType, typeof (GtkSource.File));
+			GLib.GType.Register (GtkSource.FileLoader.GType, typeof (GtkSource.FileLoader));
+			GLib.GType.Register (GtkSource.FileSaver.GType, typeof (GtkSource.FileSaver));
+			GLib.GType.Register (GtkSource.Gutter.GType, typeof (GtkSource.Gutter));
+			GLib.GType.Register (GtkSource.GutterRenderer.GType, typeof (GtkSource.GutterRenderer));
+			GLib.GType.Register (GtkSource.GutterRendererPixbuf.GType, typeof (GtkSource.GutterRendererPixbuf));
+			GLib.GType.Register (GtkSource.GutterRendererText.GType, typeof (GtkSource.GutterRendererText));
+			GLib.GType.Register (GtkSource.Language.GType, typeof (GtkSource.Language));
+			GLib.GType.Register (GtkSource.LanguageManager.GType, typeof (GtkSource.LanguageManager));
+			GLib.GType.Register (GtkSource.Map.GType, typeof (GtkSource.Map));
+			GLib.GType.Register (GtkSource.Mark.GType, typeof (GtkSource.Mark));
+			GLib.GType.Register (GtkSource.MarkAttributes.GType, typeof (GtkSource.MarkAttributes));
+			GLib.GType.Register (GtkSource.PrintCompositor.GType, typeof (GtkSource.PrintCompositor));
+			GLib.GType.Register (GtkSource.SearchContext.GType, typeof (GtkSource.SearchContext));
+			GLib.GType.Register (GtkSource.SearchSettings.GType, typeof (GtkSource.SearchSettings));
+			GLib.GType.Register (GtkSource.SpaceDrawer.GType, typeof (GtkSource.SpaceDrawer));
+			GLib.GType.Register (GtkSource.Style.GType, typeof (GtkSource.Style));
+			GLib.GType.Register (GtkSource.StyleScheme.GType, typeof (GtkSource.StyleScheme));
+			GLib.GType.Register (GtkSource.StyleSchemeChooserButton.GType, typeof (GtkSource.StyleSchemeChooserButton));
+			GLib.GType.Register (GtkSource.StyleSchemeChooserWidget.GType, typeof (GtkSource.StyleSchemeChooserWidget));
+			GLib.GType.Register (GtkSource.StyleSchemeManager.GType, typeof (GtkSource.StyleSchemeManager));
+			GLib.GType.Register (GtkSource.SourceView.GType, typeof (GtkSource.SourceView));
+
+			InitializeExtras();
+		}
+
+		static partial void InitializeExtras();
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Action.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Action : GLib.Opaque {
+
+		public Action(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ActionGroup.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ActionGroup : GLib.Opaque {
+
+		public ActionGroup(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ActivatableQueriedHandler.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void ActivatableQueriedHandler(object o, ActivatableQueriedArgs args);
+
+	public class ActivatableQueriedArgs : GLib.SignalArgs {
+		public Gtk.TextIter Iter{
+			get {
+				return (Gtk.TextIter) Args [0];
+			}
+		}
+
+		public Gdk.Rectangle Area{
+			get {
+				return (Gdk.Rectangle) Args [1];
+			}
+		}
+
+		public Gdk.Event Event{
+			get {
+				return (Gdk.Event) Args [2];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ActivatedHandler.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void ActivatedHandler(object o, ActivatedArgs args);
+
+	public class ActivatedArgs : GLib.SignalArgs {
+		public Gtk.TextIter Iter{
+			get {
+				return (Gtk.TextIter) Args [0];
+			}
+		}
+
+		public Gdk.Rectangle Area{
+			get {
+				return (Gdk.Rectangle) Args [1];
+			}
+		}
+
+		public Gdk.Event Event{
+			get {
+				return (Gdk.Event) Args [2];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/AddStyleIdData.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class AddStyleIdData : GLib.Opaque {
+
+		public AddStyleIdData(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/BackgroundPatternType.cs

@@ -0,0 +1,16 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum BackgroundPatternType {
+
+		None,
+		Grid,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/BracketMatchType.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum BracketMatchType {
+
+		None,
+		OutOfRange,
+		NotFound,
+		Found,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/BracketMatchedHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void BracketMatchedHandler(object o, BracketMatchedArgs args);
+
+	public class BracketMatchedArgs : GLib.SignalArgs {
+		public Gtk.TextIter Iter{
+			get {
+				return (Gtk.TextIter) Args [0];
+			}
+		}
+
+		public GtkSource.BracketMatchType State{
+			get {
+				return (GtkSource.BracketMatchType) Args [1];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Buffer.cs

@@ -0,0 +1,823 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Buffer : Gtk.TextBuffer {
+
+		public Buffer (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_buffer_new(IntPtr table);
+		static d_gtk_source_buffer_new gtk_source_buffer_new = FuncLoader.LoadFunction<d_gtk_source_buffer_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_new"));
+
+		public Buffer (Gtk.TextTagTable table) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Buffer)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gtk_source_buffer_new(table == null ? IntPtr.Zero : table.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_buffer_new_with_language(IntPtr language);
+		static d_gtk_source_buffer_new_with_language gtk_source_buffer_new_with_language = FuncLoader.LoadFunction<d_gtk_source_buffer_new_with_language>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_new_with_language"));
+
+		public Buffer (GtkSource.Language language) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Buffer)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (language != null) {
+					names.Add ("language");
+					vals.Add (new GLib.Value (language));
+				}
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gtk_source_buffer_new_with_language(language == null ? IntPtr.Zero : language.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_buffer_get_highlight_syntax(IntPtr raw);
+		static d_gtk_source_buffer_get_highlight_syntax gtk_source_buffer_get_highlight_syntax = FuncLoader.LoadFunction<d_gtk_source_buffer_get_highlight_syntax>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_highlight_syntax"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_set_highlight_syntax(IntPtr raw, bool highlight);
+		static d_gtk_source_buffer_set_highlight_syntax gtk_source_buffer_set_highlight_syntax = FuncLoader.LoadFunction<d_gtk_source_buffer_set_highlight_syntax>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_set_highlight_syntax"));
+
+		[GLib.Property ("highlight-syntax")]
+		public bool HighlightSyntax {
+			get  {
+				bool raw_ret = gtk_source_buffer_get_highlight_syntax(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_buffer_set_highlight_syntax(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_buffer_get_highlight_matching_brackets(IntPtr raw);
+		static d_gtk_source_buffer_get_highlight_matching_brackets gtk_source_buffer_get_highlight_matching_brackets = FuncLoader.LoadFunction<d_gtk_source_buffer_get_highlight_matching_brackets>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_highlight_matching_brackets"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_set_highlight_matching_brackets(IntPtr raw, bool highlight);
+		static d_gtk_source_buffer_set_highlight_matching_brackets gtk_source_buffer_set_highlight_matching_brackets = FuncLoader.LoadFunction<d_gtk_source_buffer_set_highlight_matching_brackets>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_set_highlight_matching_brackets"));
+
+		[GLib.Property ("highlight-matching-brackets")]
+		public bool HighlightMatchingBrackets {
+			get  {
+				bool raw_ret = gtk_source_buffer_get_highlight_matching_brackets(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_buffer_set_highlight_matching_brackets(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_buffer_get_max_undo_levels(IntPtr raw);
+		static d_gtk_source_buffer_get_max_undo_levels gtk_source_buffer_get_max_undo_levels = FuncLoader.LoadFunction<d_gtk_source_buffer_get_max_undo_levels>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_max_undo_levels"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_set_max_undo_levels(IntPtr raw, int max_undo_levels);
+		static d_gtk_source_buffer_set_max_undo_levels gtk_source_buffer_set_max_undo_levels = FuncLoader.LoadFunction<d_gtk_source_buffer_set_max_undo_levels>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_set_max_undo_levels"));
+
+		[GLib.Property ("max-undo-levels")]
+		public int MaxUndoLevels {
+			get  {
+				int raw_ret = gtk_source_buffer_get_max_undo_levels(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_buffer_set_max_undo_levels(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_buffer_get_language(IntPtr raw);
+		static d_gtk_source_buffer_get_language gtk_source_buffer_get_language = FuncLoader.LoadFunction<d_gtk_source_buffer_get_language>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_language"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_set_language(IntPtr raw, IntPtr language);
+		static d_gtk_source_buffer_set_language gtk_source_buffer_set_language = FuncLoader.LoadFunction<d_gtk_source_buffer_set_language>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_set_language"));
+
+		[GLib.Property ("language")]
+		public GtkSource.Language Language {
+			get  {
+				IntPtr raw_ret = gtk_source_buffer_get_language(Handle);
+				GtkSource.Language ret = GLib.Object.GetObject(raw_ret) as GtkSource.Language;
+				return ret;
+			}
+			set  {
+				gtk_source_buffer_set_language(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[GLib.Property ("can-undo")]
+		public bool CanUndo {
+			get {
+				GLib.Value val = GetProperty ("can-undo");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("can-redo")]
+		public bool CanRedo {
+			get {
+				GLib.Value val = GetProperty ("can-redo");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_buffer_get_style_scheme(IntPtr raw);
+		static d_gtk_source_buffer_get_style_scheme gtk_source_buffer_get_style_scheme = FuncLoader.LoadFunction<d_gtk_source_buffer_get_style_scheme>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_style_scheme"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_set_style_scheme(IntPtr raw, IntPtr scheme);
+		static d_gtk_source_buffer_set_style_scheme gtk_source_buffer_set_style_scheme = FuncLoader.LoadFunction<d_gtk_source_buffer_set_style_scheme>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_set_style_scheme"));
+
+		[GLib.Property ("style-scheme")]
+		public GtkSource.StyleScheme StyleScheme {
+			get  {
+				IntPtr raw_ret = gtk_source_buffer_get_style_scheme(Handle);
+				GtkSource.StyleScheme ret = GLib.Object.GetObject(raw_ret) as GtkSource.StyleScheme;
+				return ret;
+			}
+			set  {
+				gtk_source_buffer_set_style_scheme(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_buffer_get_undo_manager(IntPtr raw);
+		static d_gtk_source_buffer_get_undo_manager gtk_source_buffer_get_undo_manager = FuncLoader.LoadFunction<d_gtk_source_buffer_get_undo_manager>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_undo_manager"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_set_undo_manager(IntPtr raw, IntPtr manager);
+		static d_gtk_source_buffer_set_undo_manager gtk_source_buffer_set_undo_manager = FuncLoader.LoadFunction<d_gtk_source_buffer_set_undo_manager>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_set_undo_manager"));
+
+		[GLib.Property ("undo-manager")]
+		public GtkSource.IUndoManager UndoManager {
+			get  {
+				IntPtr raw_ret = gtk_source_buffer_get_undo_manager(Handle);
+				GtkSource.IUndoManager ret = GtkSource.UndoManagerAdapter.GetObject (raw_ret, false);
+				return ret;
+			}
+			set  {
+				gtk_source_buffer_set_undo_manager(Handle, value == null ? IntPtr.Zero : ((value is GLib.Object) ? (value as GLib.Object).Handle : (value as GtkSource.UndoManagerAdapter).Handle));
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_buffer_get_implicit_trailing_newline(IntPtr raw);
+		static d_gtk_source_buffer_get_implicit_trailing_newline gtk_source_buffer_get_implicit_trailing_newline = FuncLoader.LoadFunction<d_gtk_source_buffer_get_implicit_trailing_newline>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_implicit_trailing_newline"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_set_implicit_trailing_newline(IntPtr raw, bool implicit_trailing_newline);
+		static d_gtk_source_buffer_set_implicit_trailing_newline gtk_source_buffer_set_implicit_trailing_newline = FuncLoader.LoadFunction<d_gtk_source_buffer_set_implicit_trailing_newline>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_set_implicit_trailing_newline"));
+
+		[GLib.Property ("implicit-trailing-newline")]
+		public bool ImplicitTrailingNewline {
+			get  {
+				bool raw_ret = gtk_source_buffer_get_implicit_trailing_newline(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_buffer_set_implicit_trailing_newline(Handle, value);
+			}
+		}
+
+		[GLib.Signal("redo")]
+		public event System.EventHandler RedoFired {
+			add {
+				this.AddSignalHandler ("redo", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("redo", value);
+			}
+		}
+
+		[GLib.Signal("bracket-matched")]
+		public event GtkSource.BracketMatchedHandler BracketMatched {
+			add {
+				this.AddSignalHandler ("bracket-matched", value, typeof (GtkSource.BracketMatchedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("bracket-matched", value);
+			}
+		}
+
+		[GLib.Signal("source-mark-updated")]
+		public event GtkSource.SourceMarkUpdatedHandler SourceMarkUpdated {
+			add {
+				this.AddSignalHandler ("source-mark-updated", value, typeof (GtkSource.SourceMarkUpdatedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("source-mark-updated", value);
+			}
+		}
+
+		[GLib.Signal("highlight-updated")]
+		public event GtkSource.HighlightUpdatedHandler HighlightUpdated {
+			add {
+				this.AddSignalHandler ("highlight-updated", value, typeof (GtkSource.HighlightUpdatedArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("highlight-updated", value);
+			}
+		}
+
+		[GLib.Signal("undo")]
+		public event System.EventHandler UndoFired {
+			add {
+				this.AddSignalHandler ("undo", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("undo", value);
+			}
+		}
+
+		static HighlightUpdatedNativeDelegate HighlightUpdated_cb_delegate;
+		static HighlightUpdatedNativeDelegate HighlightUpdatedVMCallback {
+			get {
+				if (HighlightUpdated_cb_delegate == null)
+					HighlightUpdated_cb_delegate = new HighlightUpdatedNativeDelegate (HighlightUpdated_cb);
+				return HighlightUpdated_cb_delegate;
+			}
+		}
+
+		static void OverrideHighlightUpdated (GLib.GType gtype)
+		{
+			OverrideHighlightUpdated (gtype, HighlightUpdatedVMCallback);
+		}
+
+		static void OverrideHighlightUpdated (GLib.GType gtype, HighlightUpdatedNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "highlight-updated", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void HighlightUpdatedNativeDelegate (IntPtr inst, IntPtr p0, IntPtr p1);
+
+		static void HighlightUpdated_cb (IntPtr inst, IntPtr p0, IntPtr p1)
+		{
+			try {
+				Buffer __obj = GLib.Object.GetObject (inst, false) as Buffer;
+				__obj.OnHighlightUpdated (Gtk.TextIter.New (p0), Gtk.TextIter.New (p1));
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Buffer), ConnectionMethod="OverrideHighlightUpdated")]
+		protected virtual void OnHighlightUpdated (Gtk.TextIter p0, Gtk.TextIter p1)
+		{
+			InternalHighlightUpdated (p0, p1);
+		}
+
+		private void InternalHighlightUpdated (Gtk.TextIter p0, Gtk.TextIter p1)
+		{
+			GLib.Value ret = GLib.Value.Empty;
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
+			GLib.Value[] vals = new GLib.Value [3];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			vals [1] = new GLib.Value (p0);
+			inst_and_params.Append (vals [1]);
+			vals [2] = new GLib.Value (p1);
+			inst_and_params.Append (vals [2]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+		}
+
+		static SourceMarkUpdatedNativeDelegate SourceMarkUpdated_cb_delegate;
+		static SourceMarkUpdatedNativeDelegate SourceMarkUpdatedVMCallback {
+			get {
+				if (SourceMarkUpdated_cb_delegate == null)
+					SourceMarkUpdated_cb_delegate = new SourceMarkUpdatedNativeDelegate (SourceMarkUpdated_cb);
+				return SourceMarkUpdated_cb_delegate;
+			}
+		}
+
+		static void OverrideSourceMarkUpdated (GLib.GType gtype)
+		{
+			OverrideSourceMarkUpdated (gtype, SourceMarkUpdatedVMCallback);
+		}
+
+		static void OverrideSourceMarkUpdated (GLib.GType gtype, SourceMarkUpdatedNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "source-mark-updated", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void SourceMarkUpdatedNativeDelegate (IntPtr inst, IntPtr p0);
+
+		static void SourceMarkUpdated_cb (IntPtr inst, IntPtr p0)
+		{
+			try {
+				Buffer __obj = GLib.Object.GetObject (inst, false) as Buffer;
+				__obj.OnSourceMarkUpdated (GLib.Object.GetObject(p0) as Gtk.TextMark);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Buffer), ConnectionMethod="OverrideSourceMarkUpdated")]
+		protected virtual void OnSourceMarkUpdated (Gtk.TextMark p0)
+		{
+			InternalSourceMarkUpdated (p0);
+		}
+
+		private void InternalSourceMarkUpdated (Gtk.TextMark p0)
+		{
+			GLib.Value ret = GLib.Value.Empty;
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+			GLib.Value[] vals = new GLib.Value [2];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			vals [1] = new GLib.Value (p0);
+			inst_and_params.Append (vals [1]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+		}
+
+		static UndoFiredNativeDelegate UndoFired_cb_delegate;
+		static UndoFiredNativeDelegate UndoFiredVMCallback {
+			get {
+				if (UndoFired_cb_delegate == null)
+					UndoFired_cb_delegate = new UndoFiredNativeDelegate (UndoFired_cb);
+				return UndoFired_cb_delegate;
+			}
+		}
+
+		static void OverrideUndoFired (GLib.GType gtype)
+		{
+			OverrideUndoFired (gtype, UndoFiredVMCallback);
+		}
+
+		static void OverrideUndoFired (GLib.GType gtype, UndoFiredNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("undo"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void UndoFiredNativeDelegate (IntPtr inst);
+
+		static void UndoFired_cb (IntPtr inst)
+		{
+			try {
+				Buffer __obj = GLib.Object.GetObject (inst, false) as Buffer;
+				__obj.OnUndoFired ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Buffer), ConnectionMethod="OverrideUndoFired")]
+		protected virtual void OnUndoFired ()
+		{
+			InternalUndoFired ();
+		}
+
+		private void InternalUndoFired ()
+		{
+			UndoFiredNativeDelegate unmanaged = class_abi.BaseOverride<UndoFiredNativeDelegate>(this.LookupGType(), "undo");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+		static RedoFiredNativeDelegate RedoFired_cb_delegate;
+		static RedoFiredNativeDelegate RedoFiredVMCallback {
+			get {
+				if (RedoFired_cb_delegate == null)
+					RedoFired_cb_delegate = new RedoFiredNativeDelegate (RedoFired_cb);
+				return RedoFired_cb_delegate;
+			}
+		}
+
+		static void OverrideRedoFired (GLib.GType gtype)
+		{
+			OverrideRedoFired (gtype, RedoFiredVMCallback);
+		}
+
+		static void OverrideRedoFired (GLib.GType gtype, RedoFiredNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("redo"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void RedoFiredNativeDelegate (IntPtr inst);
+
+		static void RedoFired_cb (IntPtr inst)
+		{
+			try {
+				Buffer __obj = GLib.Object.GetObject (inst, false) as Buffer;
+				__obj.OnRedoFired ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Buffer), ConnectionMethod="OverrideRedoFired")]
+		protected virtual void OnRedoFired ()
+		{
+			InternalRedoFired ();
+		}
+
+		private void InternalRedoFired ()
+		{
+			RedoFiredNativeDelegate unmanaged = class_abi.BaseOverride<RedoFiredNativeDelegate>(this.LookupGType(), "redo");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+		static BracketMatchedNativeDelegate BracketMatched_cb_delegate;
+		static BracketMatchedNativeDelegate BracketMatchedVMCallback {
+			get {
+				if (BracketMatched_cb_delegate == null)
+					BracketMatched_cb_delegate = new BracketMatchedNativeDelegate (BracketMatched_cb);
+				return BracketMatched_cb_delegate;
+			}
+		}
+
+		static void OverrideBracketMatched (GLib.GType gtype)
+		{
+			OverrideBracketMatched (gtype, BracketMatchedVMCallback);
+		}
+
+		static void OverrideBracketMatched (GLib.GType gtype, BracketMatchedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("bracket_matched"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void BracketMatchedNativeDelegate (IntPtr inst, IntPtr iter, int state);
+
+		static void BracketMatched_cb (IntPtr inst, IntPtr iter, int state)
+		{
+			try {
+				Buffer __obj = GLib.Object.GetObject (inst, false) as Buffer;
+				__obj.OnBracketMatched (Gtk.TextIter.New (iter), (GtkSource.BracketMatchType) state);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Buffer), ConnectionMethod="OverrideBracketMatched")]
+		protected virtual void OnBracketMatched (Gtk.TextIter iter, GtkSource.BracketMatchType state)
+		{
+			InternalBracketMatched (iter, state);
+		}
+
+		private void InternalBracketMatched (Gtk.TextIter iter, GtkSource.BracketMatchType state)
+		{
+			BracketMatchedNativeDelegate unmanaged = class_abi.BaseOverride<BracketMatchedNativeDelegate>(this.LookupGType(), "bracket_matched");
+			if (unmanaged == null) return;
+
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			unmanaged (this.Handle, native_iter, (int) state);
+			Marshal.FreeHGlobal (native_iter);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("undo"
+							, Gtk.TextBuffer.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // undo
+							, null
+							, "redo"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("redo"
+							, -1
+							, (uint) sizeof( IntPtr ) // redo
+							, "undo"
+							, "bracket_matched"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("bracket_matched"
+							, -1
+							, (uint) sizeof( IntPtr ) // bracket_matched
+							, "redo"
+							, "padding"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("padding"
+							, -1
+							, (uint) sizeof( IntPtr ) * 20 // padding
+							, "bracket_matched"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_buffer_backward_iter_to_source_mark(IntPtr raw, IntPtr iter, IntPtr category);
+		static d_gtk_source_buffer_backward_iter_to_source_mark gtk_source_buffer_backward_iter_to_source_mark = FuncLoader.LoadFunction<d_gtk_source_buffer_backward_iter_to_source_mark>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_backward_iter_to_source_mark"));
+
+		public bool BackwardIterToSourceMark(Gtk.TextIter iter, string category) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			IntPtr native_category = GLib.Marshaller.StringToPtrGStrdup (category);
+			bool raw_ret = gtk_source_buffer_backward_iter_to_source_mark(Handle, native_iter, native_category);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_iter);
+			GLib.Marshaller.Free (native_category);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_begin_not_undoable_action(IntPtr raw);
+		static d_gtk_source_buffer_begin_not_undoable_action gtk_source_buffer_begin_not_undoable_action = FuncLoader.LoadFunction<d_gtk_source_buffer_begin_not_undoable_action>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_begin_not_undoable_action"));
+
+		public void BeginNotUndoableAction() {
+			gtk_source_buffer_begin_not_undoable_action(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_change_case(IntPtr raw, int case_type, IntPtr start, IntPtr end);
+		static d_gtk_source_buffer_change_case gtk_source_buffer_change_case = FuncLoader.LoadFunction<d_gtk_source_buffer_change_case>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_change_case"));
+
+		public void ChangeCase(GtkSource.ChangeCaseType case_type, Gtk.TextIter start, Gtk.TextIter end) {
+			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
+			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
+			gtk_source_buffer_change_case(Handle, (int) case_type, native_start, native_end);
+			Marshal.FreeHGlobal (native_start);
+			Marshal.FreeHGlobal (native_end);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_buffer_create_source_mark(IntPtr raw, IntPtr name, IntPtr category, IntPtr wh3r3);
+		static d_gtk_source_buffer_create_source_mark gtk_source_buffer_create_source_mark = FuncLoader.LoadFunction<d_gtk_source_buffer_create_source_mark>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_create_source_mark"));
+
+		public GtkSource.Mark CreateSourceMark(string name, string category, Gtk.TextIter wh3r3) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			IntPtr native_category = GLib.Marshaller.StringToPtrGStrdup (category);
+			IntPtr native_wh3r3 = GLib.Marshaller.StructureToPtrAlloc (wh3r3);
+			IntPtr raw_ret = gtk_source_buffer_create_source_mark(Handle, native_name, native_category, native_wh3r3);
+			GtkSource.Mark ret = GLib.Object.GetObject(raw_ret) as GtkSource.Mark;
+			GLib.Marshaller.Free (native_name);
+			GLib.Marshaller.Free (native_category);
+			Marshal.FreeHGlobal (native_wh3r3);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_end_not_undoable_action(IntPtr raw);
+		static d_gtk_source_buffer_end_not_undoable_action gtk_source_buffer_end_not_undoable_action = FuncLoader.LoadFunction<d_gtk_source_buffer_end_not_undoable_action>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_end_not_undoable_action"));
+
+		public void EndNotUndoableAction() {
+			gtk_source_buffer_end_not_undoable_action(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_ensure_highlight(IntPtr raw, IntPtr start, IntPtr end);
+		static d_gtk_source_buffer_ensure_highlight gtk_source_buffer_ensure_highlight = FuncLoader.LoadFunction<d_gtk_source_buffer_ensure_highlight>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_ensure_highlight"));
+
+		public void EnsureHighlight(Gtk.TextIter start, Gtk.TextIter end) {
+			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
+			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
+			gtk_source_buffer_ensure_highlight(Handle, native_start, native_end);
+			Marshal.FreeHGlobal (native_start);
+			Marshal.FreeHGlobal (native_end);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_buffer_forward_iter_to_source_mark(IntPtr raw, IntPtr iter, IntPtr category);
+		static d_gtk_source_buffer_forward_iter_to_source_mark gtk_source_buffer_forward_iter_to_source_mark = FuncLoader.LoadFunction<d_gtk_source_buffer_forward_iter_to_source_mark>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_forward_iter_to_source_mark"));
+
+		public bool ForwardIterToSourceMark(Gtk.TextIter iter, string category) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			IntPtr native_category = GLib.Marshaller.StringToPtrGStrdup (category);
+			bool raw_ret = gtk_source_buffer_forward_iter_to_source_mark(Handle, native_iter, native_category);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_iter);
+			GLib.Marshaller.Free (native_category);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_buffer_get_context_classes_at_iter(IntPtr raw, IntPtr iter);
+		static d_gtk_source_buffer_get_context_classes_at_iter gtk_source_buffer_get_context_classes_at_iter = FuncLoader.LoadFunction<d_gtk_source_buffer_get_context_classes_at_iter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_context_classes_at_iter"));
+
+		public string GetContextClassesAtIter(Gtk.TextIter iter) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			IntPtr raw_ret = gtk_source_buffer_get_context_classes_at_iter(Handle, native_iter);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			Marshal.FreeHGlobal (native_iter);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_buffer_get_source_marks_at_iter(IntPtr raw, IntPtr iter, IntPtr category);
+		static d_gtk_source_buffer_get_source_marks_at_iter gtk_source_buffer_get_source_marks_at_iter = FuncLoader.LoadFunction<d_gtk_source_buffer_get_source_marks_at_iter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_source_marks_at_iter"));
+
+		public GtkSource.Mark[] GetSourceMarksAtIter(Gtk.TextIter iter, string category) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			IntPtr native_category = GLib.Marshaller.StringToPtrGStrdup (category);
+			IntPtr raw_ret = gtk_source_buffer_get_source_marks_at_iter(Handle, native_iter, native_category);
+			GtkSource.Mark[] ret = GLib.Marshaller.SListPtrToArray<GtkSource.Mark, GtkSource.Mark> (raw_ret, true, false);
+			Marshal.FreeHGlobal (native_iter);
+			GLib.Marshaller.Free (native_category);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_buffer_get_source_marks_at_line(IntPtr raw, int line, IntPtr category);
+		static d_gtk_source_buffer_get_source_marks_at_line gtk_source_buffer_get_source_marks_at_line = FuncLoader.LoadFunction<d_gtk_source_buffer_get_source_marks_at_line>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_source_marks_at_line"));
+
+		public GtkSource.Mark[] GetSourceMarksAtLine(int line, string category) {
+			IntPtr native_category = GLib.Marshaller.StringToPtrGStrdup (category);
+			IntPtr raw_ret = gtk_source_buffer_get_source_marks_at_line(Handle, line, native_category);
+			GtkSource.Mark[] ret = GLib.Marshaller.SListPtrToArray<GtkSource.Mark, GtkSource.Mark> (raw_ret, true, false);
+			GLib.Marshaller.Free (native_category);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_buffer_get_type();
+		static d_gtk_source_buffer_get_type gtk_source_buffer_get_type = FuncLoader.LoadFunction<d_gtk_source_buffer_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_buffer_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_buffer_iter_backward_to_context_class_toggle(IntPtr raw, IntPtr iter, IntPtr context_class);
+		static d_gtk_source_buffer_iter_backward_to_context_class_toggle gtk_source_buffer_iter_backward_to_context_class_toggle = FuncLoader.LoadFunction<d_gtk_source_buffer_iter_backward_to_context_class_toggle>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_iter_backward_to_context_class_toggle"));
+
+		public bool IterBackwardToContextClassToggle(Gtk.TextIter iter, string context_class) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			IntPtr native_context_class = GLib.Marshaller.StringToPtrGStrdup (context_class);
+			bool raw_ret = gtk_source_buffer_iter_backward_to_context_class_toggle(Handle, native_iter, native_context_class);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_iter);
+			GLib.Marshaller.Free (native_context_class);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_buffer_iter_forward_to_context_class_toggle(IntPtr raw, IntPtr iter, IntPtr context_class);
+		static d_gtk_source_buffer_iter_forward_to_context_class_toggle gtk_source_buffer_iter_forward_to_context_class_toggle = FuncLoader.LoadFunction<d_gtk_source_buffer_iter_forward_to_context_class_toggle>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_iter_forward_to_context_class_toggle"));
+
+		public bool IterForwardToContextClassToggle(Gtk.TextIter iter, string context_class) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			IntPtr native_context_class = GLib.Marshaller.StringToPtrGStrdup (context_class);
+			bool raw_ret = gtk_source_buffer_iter_forward_to_context_class_toggle(Handle, native_iter, native_context_class);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_iter);
+			GLib.Marshaller.Free (native_context_class);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_buffer_iter_has_context_class(IntPtr raw, IntPtr iter, IntPtr context_class);
+		static d_gtk_source_buffer_iter_has_context_class gtk_source_buffer_iter_has_context_class = FuncLoader.LoadFunction<d_gtk_source_buffer_iter_has_context_class>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_iter_has_context_class"));
+
+		public bool IterHasContextClass(Gtk.TextIter iter, string context_class) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			IntPtr native_context_class = GLib.Marshaller.StringToPtrGStrdup (context_class);
+			bool raw_ret = gtk_source_buffer_iter_has_context_class(Handle, native_iter, native_context_class);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_iter);
+			GLib.Marshaller.Free (native_context_class);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_join_lines(IntPtr raw, IntPtr start, IntPtr end);
+		static d_gtk_source_buffer_join_lines gtk_source_buffer_join_lines = FuncLoader.LoadFunction<d_gtk_source_buffer_join_lines>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_join_lines"));
+
+		public void JoinLines(Gtk.TextIter start, Gtk.TextIter end) {
+			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
+			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
+			gtk_source_buffer_join_lines(Handle, native_start, native_end);
+			Marshal.FreeHGlobal (native_start);
+			Marshal.FreeHGlobal (native_end);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_redo(IntPtr raw);
+		static d_gtk_source_buffer_redo gtk_source_buffer_redo = FuncLoader.LoadFunction<d_gtk_source_buffer_redo>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_redo"));
+
+		public void Redo() {
+			gtk_source_buffer_redo(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_remove_source_marks(IntPtr raw, IntPtr start, IntPtr end, IntPtr category);
+		static d_gtk_source_buffer_remove_source_marks gtk_source_buffer_remove_source_marks = FuncLoader.LoadFunction<d_gtk_source_buffer_remove_source_marks>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_remove_source_marks"));
+
+		public void RemoveSourceMarks(Gtk.TextIter start, Gtk.TextIter end, string category) {
+			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
+			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
+			IntPtr native_category = GLib.Marshaller.StringToPtrGStrdup (category);
+			gtk_source_buffer_remove_source_marks(Handle, native_start, native_end, native_category);
+			Marshal.FreeHGlobal (native_start);
+			Marshal.FreeHGlobal (native_end);
+			GLib.Marshaller.Free (native_category);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_sort_lines(IntPtr raw, IntPtr start, IntPtr end, int flags, int column);
+		static d_gtk_source_buffer_sort_lines gtk_source_buffer_sort_lines = FuncLoader.LoadFunction<d_gtk_source_buffer_sort_lines>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_sort_lines"));
+
+		public void SortLines(Gtk.TextIter start, Gtk.TextIter end, GtkSource.SortFlags flags, int column) {
+			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
+			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
+			gtk_source_buffer_sort_lines(Handle, native_start, native_end, (int) flags, column);
+			Marshal.FreeHGlobal (native_start);
+			Marshal.FreeHGlobal (native_end);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_buffer_undo(IntPtr raw);
+		static d_gtk_source_buffer_undo gtk_source_buffer_undo = FuncLoader.LoadFunction<d_gtk_source_buffer_undo>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_buffer_undo"));
+
+		public void Undo() {
+			gtk_source_buffer_undo(Handle);
+		}
+
+
+		static Buffer ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, Gtk.TextBuffer.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ChangeCaseHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void ChangeCaseHandler(object o, ChangeCaseArgs args);
+
+	public class ChangeCaseArgs : GLib.SignalArgs {
+		public GtkSource.ChangeCaseType P0{
+			get {
+				return (GtkSource.ChangeCaseType) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ChangeCaseType.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum ChangeCaseType {
+
+		Lower,
+		Upper,
+		Toggle,
+		Title,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ChangeNumberHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void ChangeNumberHandler(object o, ChangeNumberArgs args);
+
+	public class ChangeNumberArgs : GLib.SignalArgs {
+		public int P0{
+			get {
+				return (int) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Completion.cs

@@ -0,0 +1,790 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Completion : GLib.Object {
+
+		public Completion (IntPtr raw) : base(raw) {}
+
+		protected Completion() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_get_view(IntPtr raw);
+		static d_gtk_source_completion_get_view gtk_source_completion_get_view = FuncLoader.LoadFunction<d_gtk_source_completion_get_view>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_get_view"));
+
+		[GLib.Property ("view")]
+		public GtkSource.SourceView View {
+			get  {
+				IntPtr raw_ret = gtk_source_completion_get_view(Handle);
+				GtkSource.SourceView ret = GLib.Object.GetObject(raw_ret) as GtkSource.SourceView;
+				return ret;
+			}
+		}
+
+		[GLib.Property ("remember-info-visibility")]
+		public bool RememberInfoVisibility {
+			get {
+				GLib.Value val = GetProperty ("remember-info-visibility");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("remember-info-visibility", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("select-on-show")]
+		public bool SelectOnShow {
+			get {
+				GLib.Value val = GetProperty ("select-on-show");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("select-on-show", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("show-headers")]
+		public bool ShowHeaders {
+			get {
+				GLib.Value val = GetProperty ("show-headers");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("show-headers", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("show-icons")]
+		public bool ShowIcons {
+			get {
+				GLib.Value val = GetProperty ("show-icons");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("show-icons", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("accelerators")]
+		public uint Accelerators {
+			get {
+				GLib.Value val = GetProperty ("accelerators");
+				uint ret = (uint) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("accelerators", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("auto-complete-delay")]
+		public uint AutoCompleteDelay {
+			get {
+				GLib.Value val = GetProperty ("auto-complete-delay");
+				uint ret = (uint) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("auto-complete-delay", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("provider-page-size")]
+		public uint ProviderPageSize {
+			get {
+				GLib.Value val = GetProperty ("provider-page-size");
+				uint ret = (uint) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("provider-page-size", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Property ("proposal-page-size")]
+		public uint ProposalPageSize {
+			get {
+				GLib.Value val = GetProperty ("proposal-page-size");
+				uint ret = (uint) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value);
+				SetProperty("proposal-page-size", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Signal("show")]
+		public event System.EventHandler Show {
+			add {
+				this.AddSignalHandler ("show", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("show", value);
+			}
+		}
+
+		[GLib.Signal("activate-proposal")]
+		public event System.EventHandler ActivateProposal {
+			add {
+				this.AddSignalHandler ("activate-proposal", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("activate-proposal", value);
+			}
+		}
+
+		[GLib.Signal("populate-context")]
+		public event GtkSource.PopulateContextHandler PopulateContext {
+			add {
+				this.AddSignalHandler ("populate-context", value, typeof (GtkSource.PopulateContextArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("populate-context", value);
+			}
+		}
+
+		[GLib.Signal("move-page")]
+		public event GtkSource.MovePageHandler MovePage {
+			add {
+				this.AddSignalHandler ("move-page", value, typeof (GtkSource.MovePageArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("move-page", value);
+			}
+		}
+
+		[GLib.Signal("hide")]
+		public event System.EventHandler Hidden {
+			add {
+				this.AddSignalHandler ("hide", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("hide", value);
+			}
+		}
+
+		[GLib.Signal("move-cursor")]
+		public event GtkSource.MoveCursorHandler MoveCursor {
+			add {
+				this.AddSignalHandler ("move-cursor", value, typeof (GtkSource.MoveCursorArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("move-cursor", value);
+			}
+		}
+
+		static ProposalActivatedNativeDelegate ProposalActivated_cb_delegate;
+		static ProposalActivatedNativeDelegate ProposalActivatedVMCallback {
+			get {
+				if (ProposalActivated_cb_delegate == null)
+					ProposalActivated_cb_delegate = new ProposalActivatedNativeDelegate (ProposalActivated_cb);
+				return ProposalActivated_cb_delegate;
+			}
+		}
+
+		static void OverrideProposalActivated (GLib.GType gtype)
+		{
+			OverrideProposalActivated (gtype, ProposalActivatedVMCallback);
+		}
+
+		static void OverrideProposalActivated (GLib.GType gtype, ProposalActivatedNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("proposal_activated"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool ProposalActivatedNativeDelegate (IntPtr inst, IntPtr provider, IntPtr proposal);
+
+		static bool ProposalActivated_cb (IntPtr inst, IntPtr provider, IntPtr proposal)
+		{
+			try {
+				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
+				bool __result;
+				__result = __obj.OnProposalActivated (GtkSource.CompletionProviderAdapter.GetObject (provider, false), GtkSource.CompletionProposalAdapter.GetObject (proposal, false));
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideProposalActivated")]
+		protected virtual bool OnProposalActivated (GtkSource.ICompletionProvider provider, GtkSource.ICompletionProposal proposal)
+		{
+			return InternalProposalActivated (provider, proposal);
+		}
+
+		private bool InternalProposalActivated (GtkSource.ICompletionProvider provider, GtkSource.ICompletionProposal proposal)
+		{
+			ProposalActivatedNativeDelegate unmanaged = class_abi.BaseOverride<ProposalActivatedNativeDelegate>(this.LookupGType(), "proposal_activated");
+			if (unmanaged == null) return false;
+
+			bool __result = unmanaged (this.Handle, provider == null ? IntPtr.Zero : ((provider is GLib.Object) ? (provider as GLib.Object).Handle : (provider as GtkSource.CompletionProviderAdapter).Handle), proposal == null ? IntPtr.Zero : ((proposal is GLib.Object) ? (proposal as GLib.Object).Handle : (proposal as GtkSource.CompletionProposalAdapter).Handle));
+			return __result;
+		}
+
+		static ShowNativeDelegate Show_cb_delegate;
+		static ShowNativeDelegate ShowVMCallback {
+			get {
+				if (Show_cb_delegate == null)
+					Show_cb_delegate = new ShowNativeDelegate (Show_cb);
+				return Show_cb_delegate;
+			}
+		}
+
+		static void OverrideShow (GLib.GType gtype)
+		{
+			OverrideShow (gtype, ShowVMCallback);
+		}
+
+		static void OverrideShow (GLib.GType gtype, ShowNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("show"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void ShowNativeDelegate (IntPtr inst);
+
+		static void Show_cb (IntPtr inst)
+		{
+			try {
+				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
+				__obj.OnShow ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideShow")]
+		protected virtual void OnShow ()
+		{
+			InternalShow ();
+		}
+
+		private void InternalShow ()
+		{
+			ShowNativeDelegate unmanaged = class_abi.BaseOverride<ShowNativeDelegate>(this.LookupGType(), "show");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+		static HiddenNativeDelegate Hidden_cb_delegate;
+		static HiddenNativeDelegate HiddenVMCallback {
+			get {
+				if (Hidden_cb_delegate == null)
+					Hidden_cb_delegate = new HiddenNativeDelegate (Hidden_cb);
+				return Hidden_cb_delegate;
+			}
+		}
+
+		static void OverrideHidden (GLib.GType gtype)
+		{
+			OverrideHidden (gtype, HiddenVMCallback);
+		}
+
+		static void OverrideHidden (GLib.GType gtype, HiddenNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("hide"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void HiddenNativeDelegate (IntPtr inst);
+
+		static void Hidden_cb (IntPtr inst)
+		{
+			try {
+				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
+				__obj.OnHidden ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideHidden")]
+		protected virtual void OnHidden ()
+		{
+			InternalHidden ();
+		}
+
+		private void InternalHidden ()
+		{
+			HiddenNativeDelegate unmanaged = class_abi.BaseOverride<HiddenNativeDelegate>(this.LookupGType(), "hide");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+		static PopulateContextNativeDelegate PopulateContext_cb_delegate;
+		static PopulateContextNativeDelegate PopulateContextVMCallback {
+			get {
+				if (PopulateContext_cb_delegate == null)
+					PopulateContext_cb_delegate = new PopulateContextNativeDelegate (PopulateContext_cb);
+				return PopulateContext_cb_delegate;
+			}
+		}
+
+		static void OverridePopulateContext (GLib.GType gtype)
+		{
+			OverridePopulateContext (gtype, PopulateContextVMCallback);
+		}
+
+		static void OverridePopulateContext (GLib.GType gtype, PopulateContextNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("populate_context"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void PopulateContextNativeDelegate (IntPtr inst, IntPtr context);
+
+		static void PopulateContext_cb (IntPtr inst, IntPtr context)
+		{
+			try {
+				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
+				__obj.OnPopulateContext (GLib.Object.GetObject(context) as GtkSource.CompletionContext);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverridePopulateContext")]
+		protected virtual void OnPopulateContext (GtkSource.CompletionContext context)
+		{
+			InternalPopulateContext (context);
+		}
+
+		private void InternalPopulateContext (GtkSource.CompletionContext context)
+		{
+			PopulateContextNativeDelegate unmanaged = class_abi.BaseOverride<PopulateContextNativeDelegate>(this.LookupGType(), "populate_context");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, context == null ? IntPtr.Zero : context.Handle);
+		}
+
+		static MoveCursorNativeDelegate MoveCursor_cb_delegate;
+		static MoveCursorNativeDelegate MoveCursorVMCallback {
+			get {
+				if (MoveCursor_cb_delegate == null)
+					MoveCursor_cb_delegate = new MoveCursorNativeDelegate (MoveCursor_cb);
+				return MoveCursor_cb_delegate;
+			}
+		}
+
+		static void OverrideMoveCursor (GLib.GType gtype)
+		{
+			OverrideMoveCursor (gtype, MoveCursorVMCallback);
+		}
+
+		static void OverrideMoveCursor (GLib.GType gtype, MoveCursorNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("move_cursor"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void MoveCursorNativeDelegate (IntPtr inst, int step, int num);
+
+		static void MoveCursor_cb (IntPtr inst, int step, int num)
+		{
+			try {
+				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
+				__obj.OnMoveCursor ((Gtk.ScrollStep) step, num);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideMoveCursor")]
+		protected virtual void OnMoveCursor (Gtk.ScrollStep step, int num)
+		{
+			InternalMoveCursor (step, num);
+		}
+
+		private void InternalMoveCursor (Gtk.ScrollStep step, int num)
+		{
+			MoveCursorNativeDelegate unmanaged = class_abi.BaseOverride<MoveCursorNativeDelegate>(this.LookupGType(), "move_cursor");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, (int) step, num);
+		}
+
+		static MovePageNativeDelegate MovePage_cb_delegate;
+		static MovePageNativeDelegate MovePageVMCallback {
+			get {
+				if (MovePage_cb_delegate == null)
+					MovePage_cb_delegate = new MovePageNativeDelegate (MovePage_cb);
+				return MovePage_cb_delegate;
+			}
+		}
+
+		static void OverrideMovePage (GLib.GType gtype)
+		{
+			OverrideMovePage (gtype, MovePageVMCallback);
+		}
+
+		static void OverrideMovePage (GLib.GType gtype, MovePageNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("move_page"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void MovePageNativeDelegate (IntPtr inst, int step, int num);
+
+		static void MovePage_cb (IntPtr inst, int step, int num)
+		{
+			try {
+				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
+				__obj.OnMovePage ((Gtk.ScrollStep) step, num);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideMovePage")]
+		protected virtual void OnMovePage (Gtk.ScrollStep step, int num)
+		{
+			InternalMovePage (step, num);
+		}
+
+		private void InternalMovePage (Gtk.ScrollStep step, int num)
+		{
+			MovePageNativeDelegate unmanaged = class_abi.BaseOverride<MovePageNativeDelegate>(this.LookupGType(), "move_page");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle, (int) step, num);
+		}
+
+		static ActivateProposalNativeDelegate ActivateProposal_cb_delegate;
+		static ActivateProposalNativeDelegate ActivateProposalVMCallback {
+			get {
+				if (ActivateProposal_cb_delegate == null)
+					ActivateProposal_cb_delegate = new ActivateProposalNativeDelegate (ActivateProposal_cb);
+				return ActivateProposal_cb_delegate;
+			}
+		}
+
+		static void OverrideActivateProposal (GLib.GType gtype)
+		{
+			OverrideActivateProposal (gtype, ActivateProposalVMCallback);
+		}
+
+		static void OverrideActivateProposal (GLib.GType gtype, ActivateProposalNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("activate_proposal"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void ActivateProposalNativeDelegate (IntPtr inst);
+
+		static void ActivateProposal_cb (IntPtr inst)
+		{
+			try {
+				Completion __obj = GLib.Object.GetObject (inst, false) as Completion;
+				__obj.OnActivateProposal ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.Completion), ConnectionMethod="OverrideActivateProposal")]
+		protected virtual void OnActivateProposal ()
+		{
+			InternalActivateProposal ();
+		}
+
+		private void InternalActivateProposal ()
+		{
+			ActivateProposalNativeDelegate unmanaged = class_abi.BaseOverride<ActivateProposalNativeDelegate>(this.LookupGType(), "activate_proposal");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("proposal_activated"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // proposal_activated
+							, null
+							, "show"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("show"
+							, -1
+							, (uint) sizeof( IntPtr ) // show
+							, "proposal_activated"
+							, "hide"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("hide"
+							, -1
+							, (uint) sizeof( IntPtr ) // hide
+							, "show"
+							, "populate_context"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("populate_context"
+							, -1
+							, (uint) sizeof( IntPtr ) // populate_context
+							, "hide"
+							, "move_cursor"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("move_cursor"
+							, -1
+							, (uint) sizeof( IntPtr ) // move_cursor
+							, "populate_context"
+							, "move_page"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("move_page"
+							, -1
+							, (uint) sizeof( IntPtr ) // move_page
+							, "move_cursor"
+							, "activate_proposal"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("activate_proposal"
+							, -1
+							, (uint) sizeof( IntPtr ) // activate_proposal
+							, "move_page"
+							, "padding"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("padding"
+							, -1
+							, (uint) sizeof( IntPtr ) * 20 // padding
+							, "activate_proposal"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_completion_add_provider(IntPtr raw, IntPtr provider, out IntPtr error);
+		static d_gtk_source_completion_add_provider gtk_source_completion_add_provider = FuncLoader.LoadFunction<d_gtk_source_completion_add_provider>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_add_provider"));
+
+		public unsafe bool AddProvider(GtkSource.ICompletionProvider provider) {
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = gtk_source_completion_add_provider(Handle, provider == null ? IntPtr.Zero : ((provider is GLib.Object) ? (provider as GLib.Object).Handle : (provider as GtkSource.CompletionProviderAdapter).Handle), out error);
+			bool ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_block_interactive(IntPtr raw);
+		static d_gtk_source_completion_block_interactive gtk_source_completion_block_interactive = FuncLoader.LoadFunction<d_gtk_source_completion_block_interactive>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_block_interactive"));
+
+		public void BlockInteractive() {
+			gtk_source_completion_block_interactive(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_create_context(IntPtr raw, IntPtr position);
+		static d_gtk_source_completion_create_context gtk_source_completion_create_context = FuncLoader.LoadFunction<d_gtk_source_completion_create_context>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_create_context"));
+
+		public GtkSource.CompletionContext CreateContext(Gtk.TextIter position) {
+			IntPtr native_position = GLib.Marshaller.StructureToPtrAlloc (position);
+			IntPtr raw_ret = gtk_source_completion_create_context(Handle, native_position);
+			GtkSource.CompletionContext ret = GLib.Object.GetObject(raw_ret) as GtkSource.CompletionContext;
+			Marshal.FreeHGlobal (native_position);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_completion_error_quark();
+		static d_gtk_source_completion_error_quark gtk_source_completion_error_quark = FuncLoader.LoadFunction<d_gtk_source_completion_error_quark>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_error_quark"));
+
+		public static int ErrorQuark() {
+			int raw_ret = gtk_source_completion_error_quark();
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_get_info_window(IntPtr raw);
+		static d_gtk_source_completion_get_info_window gtk_source_completion_get_info_window = FuncLoader.LoadFunction<d_gtk_source_completion_get_info_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_get_info_window"));
+
+		public GtkSource.CompletionInfo InfoWindow { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_get_info_window(Handle);
+				GtkSource.CompletionInfo ret = GLib.Object.GetObject(raw_ret) as GtkSource.CompletionInfo;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_get_providers(IntPtr raw);
+		static d_gtk_source_completion_get_providers gtk_source_completion_get_providers = FuncLoader.LoadFunction<d_gtk_source_completion_get_providers>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_get_providers"));
+
+		public GtkSource.ICompletionProvider[] Providers { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_get_providers(Handle);
+				GtkSource.ICompletionProvider[] ret = GLib.Marshaller.ListPtrToArray<GtkSource.ICompletionProvider, GtkSource.ICompletionProvider> (raw_ret, false, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_get_type();
+		static d_gtk_source_completion_get_type gtk_source_completion_get_type = FuncLoader.LoadFunction<d_gtk_source_completion_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_hide(IntPtr raw);
+		static d_gtk_source_completion_hide gtk_source_completion_hide = FuncLoader.LoadFunction<d_gtk_source_completion_hide>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_hide"));
+
+		public void Hide() {
+			gtk_source_completion_hide(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_completion_remove_provider(IntPtr raw, IntPtr provider, out IntPtr error);
+		static d_gtk_source_completion_remove_provider gtk_source_completion_remove_provider = FuncLoader.LoadFunction<d_gtk_source_completion_remove_provider>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_remove_provider"));
+
+		public unsafe bool RemoveProvider(GtkSource.ICompletionProvider provider) {
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = gtk_source_completion_remove_provider(Handle, provider == null ? IntPtr.Zero : ((provider is GLib.Object) ? (provider as GLib.Object).Handle : (provider as GtkSource.CompletionProviderAdapter).Handle), out error);
+			bool ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_completion_start(IntPtr raw, IntPtr providers, IntPtr context);
+		static d_gtk_source_completion_start gtk_source_completion_start = FuncLoader.LoadFunction<d_gtk_source_completion_start>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_start"));
+
+		public bool Start(GLib.List providers, GtkSource.CompletionContext context) {
+			bool raw_ret = gtk_source_completion_start(Handle, providers == null ? IntPtr.Zero : providers.Handle, context == null ? IntPtr.Zero : context.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_unblock_interactive(IntPtr raw);
+		static d_gtk_source_completion_unblock_interactive gtk_source_completion_unblock_interactive = FuncLoader.LoadFunction<d_gtk_source_completion_unblock_interactive>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_unblock_interactive"));
+
+		public void UnblockInteractive() {
+			gtk_source_completion_unblock_interactive(Handle);
+		}
+
+
+		static Completion ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/CompletionActivation.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	public enum CompletionActivation {
+
+		None,
+		Interactive = 1 << 0,
+		UserRequested = 1 << 1,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/CompletionContext.cs

@@ -0,0 +1,219 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class CompletionContext : GLib.InitiallyUnowned {
+
+		public CompletionContext (IntPtr raw) : base(raw) {}
+
+		protected CompletionContext() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[GLib.Property ("completion")]
+		public GtkSource.Completion Completion {
+			get {
+				GLib.Value val = GetProperty ("completion");
+				GtkSource.Completion ret = (GtkSource.Completion) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("iter")]
+		public Gtk.TextIter Iter {
+			get {
+				GLib.Value val = GetProperty ("iter");
+				Gtk.TextIter ret = (Gtk.TextIter) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = (GLib.Value) value;
+				SetProperty("iter", val);
+				val.Dispose ();
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_completion_context_get_activation(IntPtr raw);
+		static d_gtk_source_completion_context_get_activation gtk_source_completion_context_get_activation = FuncLoader.LoadFunction<d_gtk_source_completion_context_get_activation>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_context_get_activation"));
+
+		[GLib.Property ("activation")]
+		public GtkSource.CompletionActivation Activation {
+			get  {
+				int raw_ret = gtk_source_completion_context_get_activation(Handle);
+				GtkSource.CompletionActivation ret = (GtkSource.CompletionActivation) raw_ret;
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value((Enum) value);
+				SetProperty("activation", val);
+				val.Dispose ();
+			}
+		}
+
+		[GLib.Signal("cancelled")]
+		public event System.EventHandler Cancelled {
+			add {
+				this.AddSignalHandler ("cancelled", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("cancelled", value);
+			}
+		}
+
+		static CancelledNativeDelegate Cancelled_cb_delegate;
+		static CancelledNativeDelegate CancelledVMCallback {
+			get {
+				if (Cancelled_cb_delegate == null)
+					Cancelled_cb_delegate = new CancelledNativeDelegate (Cancelled_cb);
+				return Cancelled_cb_delegate;
+			}
+		}
+
+		static void OverrideCancelled (GLib.GType gtype)
+		{
+			OverrideCancelled (gtype, CancelledVMCallback);
+		}
+
+		static void OverrideCancelled (GLib.GType gtype, CancelledNativeDelegate callback)
+		{
+			unsafe {
+				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("cancelled"));
+				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void CancelledNativeDelegate (IntPtr inst);
+
+		static void Cancelled_cb (IntPtr inst)
+		{
+			try {
+				CompletionContext __obj = GLib.Object.GetObject (inst, false) as CompletionContext;
+				__obj.OnCancelled ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.CompletionContext), ConnectionMethod="OverrideCancelled")]
+		protected virtual void OnCancelled ()
+		{
+			InternalCancelled ();
+		}
+
+		private void InternalCancelled ()
+		{
+			CancelledNativeDelegate unmanaged = class_abi.BaseOverride<CancelledNativeDelegate>(this.LookupGType(), "cancelled");
+			if (unmanaged == null) return;
+
+			unmanaged (this.Handle);
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("cancelled"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) // cancelled
+							, null
+							, "padding"
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+						new GLib.AbiField("padding"
+							, -1
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, "cancelled"
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_context_add_proposals(IntPtr raw, IntPtr provider, IntPtr proposals, bool finished);
+		static d_gtk_source_completion_context_add_proposals gtk_source_completion_context_add_proposals = FuncLoader.LoadFunction<d_gtk_source_completion_context_add_proposals>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_context_add_proposals"));
+
+		public void AddProposals(GtkSource.ICompletionProvider provider, GLib.List proposals, bool finished) {
+			gtk_source_completion_context_add_proposals(Handle, provider == null ? IntPtr.Zero : ((provider is GLib.Object) ? (provider as GLib.Object).Handle : (provider as GtkSource.CompletionProviderAdapter).Handle), proposals == null ? IntPtr.Zero : proposals.Handle, finished);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_completion_context_get_iter(IntPtr raw, IntPtr iter);
+		static d_gtk_source_completion_context_get_iter gtk_source_completion_context_get_iter = FuncLoader.LoadFunction<d_gtk_source_completion_context_get_iter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_context_get_iter"));
+
+		public bool GetIter(Gtk.TextIter iter) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			bool raw_ret = gtk_source_completion_context_get_iter(Handle, native_iter);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_iter);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_context_get_type();
+		static d_gtk_source_completion_context_get_type gtk_source_completion_context_get_type = FuncLoader.LoadFunction<d_gtk_source_completion_context_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_context_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_context_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static CompletionContext ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/CompletionError.cs

@@ -0,0 +1,16 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum CompletionError {
+
+		AlreadyBound,
+		NotBound,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/CompletionInfo.cs

@@ -0,0 +1,107 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class CompletionInfo : Gtk.Window {
+
+		public CompletionInfo (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_info_new();
+		static d_gtk_source_completion_info_new gtk_source_completion_info_new = FuncLoader.LoadFunction<d_gtk_source_completion_info_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_info_new"));
+
+		public CompletionInfo () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (CompletionInfo)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_completion_info_new();
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, Gtk.Window.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_info_get_type();
+		static d_gtk_source_completion_info_get_type gtk_source_completion_info_get_type = FuncLoader.LoadFunction<d_gtk_source_completion_info_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_info_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_info_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_info_move_to_iter(IntPtr raw, IntPtr view, IntPtr iter);
+		static d_gtk_source_completion_info_move_to_iter gtk_source_completion_info_move_to_iter = FuncLoader.LoadFunction<d_gtk_source_completion_info_move_to_iter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_info_move_to_iter"));
+
+		public void MoveToIter(Gtk.TextView view, Gtk.TextIter iter) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			gtk_source_completion_info_move_to_iter(Handle, view == null ? IntPtr.Zero : view.Handle, native_iter);
+			Marshal.FreeHGlobal (native_iter);
+		}
+
+
+		static CompletionInfo ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, Gtk.Window.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/CompletionItem.cs

@@ -0,0 +1,397 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class CompletionItem : GLib.Object, GtkSource.ICompletionProposal {
+
+		public CompletionItem (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_item_new();
+		static d_gtk_source_completion_item_new gtk_source_completion_item_new = FuncLoader.LoadFunction<d_gtk_source_completion_item_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_item_new"));
+
+		public CompletionItem () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (CompletionItem)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_completion_item_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_item_set_label(IntPtr raw, IntPtr label);
+		static d_gtk_source_completion_item_set_label gtk_source_completion_item_set_label = FuncLoader.LoadFunction<d_gtk_source_completion_item_set_label>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_item_set_label"));
+
+		[GLib.Property ("label")]
+		public string Label {
+			get {
+				GLib.Value val = GetProperty ("label");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_completion_item_set_label(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_item_set_markup(IntPtr raw, IntPtr markup);
+		static d_gtk_source_completion_item_set_markup gtk_source_completion_item_set_markup = FuncLoader.LoadFunction<d_gtk_source_completion_item_set_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_item_set_markup"));
+
+		[GLib.Property ("markup")]
+		public string Markup {
+			get {
+				GLib.Value val = GetProperty ("markup");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_completion_item_set_markup(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_item_set_text(IntPtr raw, IntPtr text);
+		static d_gtk_source_completion_item_set_text gtk_source_completion_item_set_text = FuncLoader.LoadFunction<d_gtk_source_completion_item_set_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_item_set_text"));
+
+		[GLib.Property ("text")]
+		public string Text {
+			get {
+				GLib.Value val = GetProperty ("text");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_completion_item_set_text(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_item_set_icon(IntPtr raw, IntPtr icon);
+		static d_gtk_source_completion_item_set_icon gtk_source_completion_item_set_icon = FuncLoader.LoadFunction<d_gtk_source_completion_item_set_icon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_item_set_icon"));
+
+		[GLib.Property ("icon")]
+		public Gdk.Pixbuf Icon {
+			get {
+				GLib.Value val = GetProperty ("icon");
+				Gdk.Pixbuf ret = (Gdk.Pixbuf) val;
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				gtk_source_completion_item_set_icon(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_item_set_icon_name(IntPtr raw, IntPtr icon_name);
+		static d_gtk_source_completion_item_set_icon_name gtk_source_completion_item_set_icon_name = FuncLoader.LoadFunction<d_gtk_source_completion_item_set_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_item_set_icon_name"));
+
+		[GLib.Property ("icon-name")]
+		public string IconName {
+			get {
+				GLib.Value val = GetProperty ("icon-name");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_completion_item_set_icon_name(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_item_set_gicon(IntPtr raw, IntPtr gicon);
+		static d_gtk_source_completion_item_set_gicon gtk_source_completion_item_set_gicon = FuncLoader.LoadFunction<d_gtk_source_completion_item_set_gicon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_item_set_gicon"));
+
+		[GLib.Property ("gicon")]
+		public GLib.IIcon Gicon {
+			get {
+				GLib.Value val = GetProperty ("gicon");
+				GLib.IIcon ret = GLib.IconAdapter.GetObject ((GLib.Object) val);
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				gtk_source_completion_item_set_gicon(Handle, value == null ? IntPtr.Zero : ((value is GLib.Object) ? (value as GLib.Object).Handle : (value as GLib.IconAdapter).Handle));
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_item_set_info(IntPtr raw, IntPtr info);
+		static d_gtk_source_completion_item_set_info gtk_source_completion_item_set_info = FuncLoader.LoadFunction<d_gtk_source_completion_item_set_info>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_item_set_info"));
+
+		[GLib.Property ("info")]
+		public string Info {
+			get {
+				GLib.Value val = GetProperty ("info");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_completion_item_set_info(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_item_get_type();
+		static d_gtk_source_completion_item_get_type gtk_source_completion_item_get_type = FuncLoader.LoadFunction<d_gtk_source_completion_item_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_item_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_item_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_proposal_changed(IntPtr raw);
+		static d_gtk_source_completion_proposal_changed gtk_source_completion_proposal_changed = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_changed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_changed"));
+
+		public void Changed() {
+			gtk_source_completion_proposal_changed(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_completion_proposal_equal(IntPtr raw, IntPtr other);
+		static d_gtk_source_completion_proposal_equal gtk_source_completion_proposal_equal = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_equal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_equal"));
+
+		public bool Equal(GtkSource.ICompletionProposal other) {
+			bool raw_ret = gtk_source_completion_proposal_equal(Handle, other == null ? IntPtr.Zero : ((other is GLib.Object) ? (other as GLib.Object).Handle : (other as GtkSource.CompletionProposalAdapter).Handle));
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_gicon(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_gicon gtk_source_completion_proposal_get_gicon = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_gicon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_gicon"));
+
+		GLib.IIcon GtkSource.ICompletionProposal.Gicon { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_gicon(Handle);
+				GLib.IIcon ret = GLib.IconAdapter.GetObject (raw_ret, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_icon(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_icon gtk_source_completion_proposal_get_icon = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_icon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_icon"));
+
+		Gdk.Pixbuf GtkSource.ICompletionProposal.Icon { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_icon(Handle);
+				Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_icon_name(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_icon_name gtk_source_completion_proposal_get_icon_name = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_icon_name"));
+
+		string GtkSource.ICompletionProposal.IconName { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_icon_name(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_info(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_info gtk_source_completion_proposal_get_info = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_info>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_info"));
+
+		string GtkSource.ICompletionProposal.Info { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_info(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_label(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_label gtk_source_completion_proposal_get_label = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_label>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_label"));
+
+		string GtkSource.ICompletionProposal.Label { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_label(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_markup(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_markup gtk_source_completion_proposal_get_markup = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_markup"));
+
+		string GtkSource.ICompletionProposal.Markup { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_markup(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_text(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_text gtk_source_completion_proposal_get_text = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_text"));
+
+		string GtkSource.ICompletionProposal.Text { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_text(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gtk_source_completion_proposal_hash(IntPtr raw);
+		static d_gtk_source_completion_proposal_hash gtk_source_completion_proposal_hash = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_hash>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_hash"));
+
+		public uint Hash() {
+			uint raw_ret = gtk_source_completion_proposal_hash(Handle);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+		[GLib.Signal("changed")]
+		public event System.EventHandler EmitChanged {
+			add {
+				this.AddSignalHandler ("changed", value);
+			}
+			remove {
+				this.RemoveSignalHandler ("changed", value);
+			}
+		}
+
+		static EmitChangedNativeDelegate EmitChanged_cb_delegate;
+		static EmitChangedNativeDelegate EmitChangedVMCallback {
+			get {
+				if (EmitChanged_cb_delegate == null)
+					EmitChanged_cb_delegate = new EmitChangedNativeDelegate (EmitChanged_cb);
+				return EmitChanged_cb_delegate;
+			}
+		}
+
+		static void OverrideEmitChanged (GLib.GType gtype)
+		{
+			OverrideEmitChanged (gtype, EmitChangedVMCallback);
+		}
+
+		static void OverrideEmitChanged (GLib.GType gtype, EmitChangedNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "changed", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void EmitChangedNativeDelegate (IntPtr inst);
+
+		static void EmitChanged_cb (IntPtr inst)
+		{
+			try {
+				GtkSource.CompletionItem __obj = GLib.Object.GetObject (inst, false) as GtkSource.CompletionItem;
+				__obj.OnEmitChanged ();
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.CompletionItem), ConnectionMethod="OverrideEmitChanged")]
+		protected virtual void OnEmitChanged ()
+		{
+			InternalEmitChanged ();
+		}
+
+		private void InternalEmitChanged ()
+		{
+			GLib.Value ret = GLib.Value.Empty;
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
+			GLib.Value[] vals = new GLib.Value [1];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+		}
+
+
+		static CompletionItem ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/CompletionProposalAdapter.cs

@@ -0,0 +1,414 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CompletionProposalAdapter : GLib.GInterfaceAdapter, GtkSource.ICompletionProposal {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct GtkSourceCompletionProposalIface {
+			public GetLabelNativeDelegate GetLabel;
+			public GetMarkupNativeDelegate GetMarkup;
+			public GetTextNativeDelegate GetText;
+			public GetIconNativeDelegate GetIcon;
+			public GetIconNameNativeDelegate GetIconName;
+			public GetGiconNativeDelegate GetGicon;
+			public GetInfoNativeDelegate GetInfo;
+			public HashNativeDelegate Hash;
+			public EqualNativeDelegate Equal;
+			IntPtr EmitChanged;
+		}
+
+		static GtkSourceCompletionProposalIface iface;
+
+		static CompletionProposalAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (CompletionProposalAdapter));
+			iface.GetLabel = new GetLabelNativeDelegate (GetLabel_cb);
+			iface.GetMarkup = new GetMarkupNativeDelegate (GetMarkup_cb);
+			iface.GetText = new GetTextNativeDelegate (GetText_cb);
+			iface.GetIcon = new GetIconNativeDelegate (GetIcon_cb);
+			iface.GetIconName = new GetIconNameNativeDelegate (GetIconName_cb);
+			iface.GetGicon = new GetGiconNativeDelegate (GetGicon_cb);
+			iface.GetInfo = new GetInfoNativeDelegate (GetInfo_cb);
+			iface.Hash = new HashNativeDelegate (Hash_cb);
+			iface.Equal = new EqualNativeDelegate (Equal_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetLabelNativeDelegate (IntPtr inst);
+
+		static IntPtr GetLabel_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProposalImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProposalImplementor;
+				string __result;
+				__result = __obj.Label;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetMarkupNativeDelegate (IntPtr inst);
+
+		static IntPtr GetMarkup_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProposalImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProposalImplementor;
+				string __result;
+				__result = __obj.Markup;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetTextNativeDelegate (IntPtr inst);
+
+		static IntPtr GetText_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProposalImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProposalImplementor;
+				string __result;
+				__result = __obj.Text;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetIconNativeDelegate (IntPtr inst);
+
+		static IntPtr GetIcon_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProposalImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProposalImplementor;
+				Gdk.Pixbuf __result;
+				__result = __obj.Icon;
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetIconNameNativeDelegate (IntPtr inst);
+
+		static IntPtr GetIconName_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProposalImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProposalImplementor;
+				string __result;
+				__result = __obj.IconName;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetGiconNativeDelegate (IntPtr inst);
+
+		static IntPtr GetGicon_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProposalImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProposalImplementor;
+				GLib.IIcon __result;
+				__result = __obj.Gicon;
+				return __result == null ? IntPtr.Zero : ((__result is GLib.Object) ? (__result as GLib.Object).Handle : (__result as GLib.IconAdapter).Handle);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetInfoNativeDelegate (IntPtr inst);
+
+		static IntPtr GetInfo_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProposalImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProposalImplementor;
+				string __result;
+				__result = __obj.Info;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint HashNativeDelegate (IntPtr inst);
+
+		static uint Hash_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProposalImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProposalImplementor;
+				uint __result;
+				__result = __obj.Hash ();
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool EqualNativeDelegate (IntPtr inst, IntPtr other);
+
+		static bool Equal_cb (IntPtr inst, IntPtr other)
+		{
+			try {
+				ICompletionProposalImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProposalImplementor;
+				bool __result;
+				__result = __obj.Equal (GtkSource.CompletionProposalAdapter.GetObject (other, false));
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		static int class_offset = 2 * IntPtr.Size;
+
+		static void Initialize (IntPtr ptr, IntPtr data)
+		{
+			IntPtr ifaceptr = new IntPtr (ptr.ToInt64 () + class_offset);
+			GtkSourceCompletionProposalIface native_iface = (GtkSourceCompletionProposalIface) Marshal.PtrToStructure (ifaceptr, typeof (GtkSourceCompletionProposalIface));
+			native_iface.GetLabel = iface.GetLabel;
+			native_iface.GetMarkup = iface.GetMarkup;
+			native_iface.GetText = iface.GetText;
+			native_iface.GetIcon = iface.GetIcon;
+			native_iface.GetIconName = iface.GetIconName;
+			native_iface.GetGicon = iface.GetGicon;
+			native_iface.GetInfo = iface.GetInfo;
+			native_iface.Hash = iface.Hash;
+			native_iface.Equal = iface.Equal;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public CompletionProposalAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public CompletionProposalAdapter (ICompletionProposalImplementor implementor)
+		{
+			if (implementor == null)
+				throw new ArgumentNullException ("implementor");
+			else if (!(implementor is GLib.Object))
+				throw new ArgumentException ("implementor must be a subclass of GLib.Object");
+			this.implementor = implementor as GLib.Object;
+		}
+
+		public CompletionProposalAdapter (IntPtr handle)
+		{
+			if (!_gtype.IsInstance (handle))
+				throw new ArgumentException ("The gobject doesn't implement the GInterface of this adapter", "handle");
+			implementor = GLib.Object.GetObject (handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_type();
+		static d_gtk_source_completion_proposal_get_type gtk_source_completion_proposal_get_type = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (gtk_source_completion_proposal_get_type ());
+
+		public static GLib.GType GType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override GLib.GType GInterfaceGType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override IntPtr Handle {
+			get {
+				return implementor.Handle;
+			}
+		}
+
+		public IntPtr OwnedHandle {
+			get {
+				return implementor.OwnedHandle;
+			}
+		}
+
+		public static ICompletionProposal GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static ICompletionProposal GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is ICompletionProposalImplementor)
+				return new CompletionProposalAdapter (obj as ICompletionProposalImplementor);
+			else if (obj as ICompletionProposal == null)
+				return new CompletionProposalAdapter (obj.Handle);
+			else
+				return obj as ICompletionProposal;
+		}
+
+		public ICompletionProposalImplementor Implementor {
+			get {
+				return implementor as ICompletionProposalImplementor;
+			}
+		}
+
+		[GLib.Signal("changed")]
+		public event System.EventHandler EmitChanged {
+			add {
+				GLib.Object.GetObject (Handle).AddSignalHandler ("changed", value);
+			}
+			remove {
+				GLib.Object.GetObject (Handle).RemoveSignalHandler ("changed", value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_proposal_changed(IntPtr raw);
+		static d_gtk_source_completion_proposal_changed gtk_source_completion_proposal_changed = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_changed>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_changed"));
+
+		public void Changed() {
+			gtk_source_completion_proposal_changed(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_completion_proposal_equal(IntPtr raw, IntPtr other);
+		static d_gtk_source_completion_proposal_equal gtk_source_completion_proposal_equal = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_equal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_equal"));
+
+		public bool Equal(GtkSource.ICompletionProposal other) {
+			bool raw_ret = gtk_source_completion_proposal_equal(Handle, other == null ? IntPtr.Zero : ((other is GLib.Object) ? (other as GLib.Object).Handle : (other as GtkSource.CompletionProposalAdapter).Handle));
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_gicon(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_gicon gtk_source_completion_proposal_get_gicon = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_gicon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_gicon"));
+
+		public GLib.IIcon Gicon { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_gicon(Handle);
+				GLib.IIcon ret = GLib.IconAdapter.GetObject (raw_ret, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_icon(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_icon gtk_source_completion_proposal_get_icon = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_icon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_icon"));
+
+		public Gdk.Pixbuf Icon { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_icon(Handle);
+				Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_icon_name(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_icon_name gtk_source_completion_proposal_get_icon_name = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_icon_name"));
+
+		public string IconName { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_icon_name(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_info(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_info gtk_source_completion_proposal_get_info = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_info>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_info"));
+
+		public string Info { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_info(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_label(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_label gtk_source_completion_proposal_get_label = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_label>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_label"));
+
+		public string Label { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_label(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_markup(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_markup gtk_source_completion_proposal_get_markup = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_markup"));
+
+		public string Markup { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_markup(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_proposal_get_text(IntPtr raw);
+		static d_gtk_source_completion_proposal_get_text gtk_source_completion_proposal_get_text = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_get_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_get_text"));
+
+		public string Text { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_proposal_get_text(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gtk_source_completion_proposal_hash(IntPtr raw);
+		static d_gtk_source_completion_proposal_hash gtk_source_completion_proposal_hash = FuncLoader.LoadFunction<d_gtk_source_completion_proposal_hash>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_proposal_hash"));
+
+		public uint Hash() {
+			uint raw_ret = gtk_source_completion_proposal_hash(Handle);
+			uint ret = raw_ret;
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/CompletionProviderAdapter.cs

@@ -0,0 +1,507 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class CompletionProviderAdapter : GLib.GInterfaceAdapter, GtkSource.ICompletionProvider {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct GtkSourceCompletionProviderIface {
+			public GetNameNativeDelegate GetName;
+			public GetIconNativeDelegate GetIcon;
+			public GetIconNameNativeDelegate GetIconName;
+			public GetGiconNativeDelegate GetGicon;
+			public PopulateNativeDelegate Populate;
+			public MatchNativeDelegate Match;
+			public GetActivationNativeDelegate GetActivation;
+			public GetInfoWidgetNativeDelegate GetInfoWidget;
+			public UpdateInfoNativeDelegate UpdateInfo;
+			public GetStartIterNativeDelegate GetStartIter;
+			public ActivateProposalNativeDelegate ActivateProposal;
+			public GetInteractiveDelayNativeDelegate GetInteractiveDelay;
+			public GetPriorityNativeDelegate GetPriority;
+		}
+
+		static GtkSourceCompletionProviderIface iface;
+
+		static CompletionProviderAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (CompletionProviderAdapter));
+			iface.GetName = new GetNameNativeDelegate (GetName_cb);
+			iface.GetIcon = new GetIconNativeDelegate (GetIcon_cb);
+			iface.GetIconName = new GetIconNameNativeDelegate (GetIconName_cb);
+			iface.GetGicon = new GetGiconNativeDelegate (GetGicon_cb);
+			iface.Populate = new PopulateNativeDelegate (Populate_cb);
+			iface.Match = new MatchNativeDelegate (Match_cb);
+			iface.GetActivation = new GetActivationNativeDelegate (GetActivation_cb);
+			iface.GetInfoWidget = new GetInfoWidgetNativeDelegate (GetInfoWidget_cb);
+			iface.UpdateInfo = new UpdateInfoNativeDelegate (UpdateInfo_cb);
+			iface.GetStartIter = new GetStartIterNativeDelegate (GetStartIter_cb);
+			iface.ActivateProposal = new ActivateProposalNativeDelegate (ActivateProposal_cb);
+			iface.GetInteractiveDelay = new GetInteractiveDelayNativeDelegate (GetInteractiveDelay_cb);
+			iface.GetPriority = new GetPriorityNativeDelegate (GetPriority_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetNameNativeDelegate (IntPtr inst);
+
+		static IntPtr GetName_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				string __result;
+				__result = __obj.Name;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetIconNativeDelegate (IntPtr inst);
+
+		static IntPtr GetIcon_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				Gdk.Pixbuf __result;
+				__result = __obj.Icon;
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetIconNameNativeDelegate (IntPtr inst);
+
+		static IntPtr GetIconName_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				string __result;
+				__result = __obj.IconName;
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetGiconNativeDelegate (IntPtr inst);
+
+		static IntPtr GetGicon_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				GLib.IIcon __result;
+				__result = __obj.Gicon;
+				return __result == null ? IntPtr.Zero : ((__result is GLib.Object) ? (__result as GLib.Object).Handle : (__result as GLib.IconAdapter).Handle);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void PopulateNativeDelegate (IntPtr inst, IntPtr context);
+
+		static void Populate_cb (IntPtr inst, IntPtr context)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				__obj.Populate (GLib.Object.GetObject(context) as GtkSource.CompletionContext);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool MatchNativeDelegate (IntPtr inst, IntPtr context);
+
+		static bool Match_cb (IntPtr inst, IntPtr context)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				bool __result;
+				__result = __obj.Match (GLib.Object.GetObject(context) as GtkSource.CompletionContext);
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetActivationNativeDelegate (IntPtr inst);
+
+		static int GetActivation_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				GtkSource.CompletionActivation __result;
+				__result = __obj.Activation;
+				return (int) __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetInfoWidgetNativeDelegate (IntPtr inst, IntPtr proposal);
+
+		static IntPtr GetInfoWidget_cb (IntPtr inst, IntPtr proposal)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				Gtk.Widget __result;
+				__result = __obj.GetInfoWidget (GtkSource.CompletionProposalAdapter.GetObject (proposal, false));
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void UpdateInfoNativeDelegate (IntPtr inst, IntPtr proposal, IntPtr info);
+
+		static void UpdateInfo_cb (IntPtr inst, IntPtr proposal, IntPtr info)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				__obj.UpdateInfo (GtkSource.CompletionProposalAdapter.GetObject (proposal, false), GLib.Object.GetObject(info) as GtkSource.CompletionInfo);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool GetStartIterNativeDelegate (IntPtr inst, IntPtr context, IntPtr proposal, IntPtr iter);
+
+		static bool GetStartIter_cb (IntPtr inst, IntPtr context, IntPtr proposal, IntPtr iter)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				bool __result;
+				__result = __obj.GetStartIter (GLib.Object.GetObject(context) as GtkSource.CompletionContext, GtkSource.CompletionProposalAdapter.GetObject (proposal, false), Gtk.TextIter.New (iter));
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool ActivateProposalNativeDelegate (IntPtr inst, IntPtr proposal, IntPtr iter);
+
+		static bool ActivateProposal_cb (IntPtr inst, IntPtr proposal, IntPtr iter)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				bool __result;
+				__result = __obj.ActivateProposal (GtkSource.CompletionProposalAdapter.GetObject (proposal, false), Gtk.TextIter.New (iter));
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetInteractiveDelayNativeDelegate (IntPtr inst);
+
+		static int GetInteractiveDelay_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				int __result;
+				__result = __obj.InteractiveDelay;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int GetPriorityNativeDelegate (IntPtr inst);
+
+		static int GetPriority_cb (IntPtr inst)
+		{
+			try {
+				ICompletionProviderImplementor __obj = GLib.Object.GetObject (inst, false) as ICompletionProviderImplementor;
+				int __result;
+				__result = __obj.Priority;
+				return __result;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		static int class_offset = 2 * IntPtr.Size;
+
+		static void Initialize (IntPtr ptr, IntPtr data)
+		{
+			IntPtr ifaceptr = new IntPtr (ptr.ToInt64 () + class_offset);
+			GtkSourceCompletionProviderIface native_iface = (GtkSourceCompletionProviderIface) Marshal.PtrToStructure (ifaceptr, typeof (GtkSourceCompletionProviderIface));
+			native_iface.GetName = iface.GetName;
+			native_iface.GetIcon = iface.GetIcon;
+			native_iface.GetIconName = iface.GetIconName;
+			native_iface.GetGicon = iface.GetGicon;
+			native_iface.Populate = iface.Populate;
+			native_iface.Match = iface.Match;
+			native_iface.GetActivation = iface.GetActivation;
+			native_iface.GetInfoWidget = iface.GetInfoWidget;
+			native_iface.UpdateInfo = iface.UpdateInfo;
+			native_iface.GetStartIter = iface.GetStartIter;
+			native_iface.ActivateProposal = iface.ActivateProposal;
+			native_iface.GetInteractiveDelay = iface.GetInteractiveDelay;
+			native_iface.GetPriority = iface.GetPriority;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public CompletionProviderAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public CompletionProviderAdapter (ICompletionProviderImplementor implementor)
+		{
+			if (implementor == null)
+				throw new ArgumentNullException ("implementor");
+			else if (!(implementor is GLib.Object))
+				throw new ArgumentException ("implementor must be a subclass of GLib.Object");
+			this.implementor = implementor as GLib.Object;
+		}
+
+		public CompletionProviderAdapter (IntPtr handle)
+		{
+			if (!_gtype.IsInstance (handle))
+				throw new ArgumentException ("The gobject doesn't implement the GInterface of this adapter", "handle");
+			implementor = GLib.Object.GetObject (handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_provider_get_type();
+		static d_gtk_source_completion_provider_get_type gtk_source_completion_provider_get_type = FuncLoader.LoadFunction<d_gtk_source_completion_provider_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (gtk_source_completion_provider_get_type ());
+
+		public static GLib.GType GType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override GLib.GType GInterfaceGType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override IntPtr Handle {
+			get {
+				return implementor.Handle;
+			}
+		}
+
+		public IntPtr OwnedHandle {
+			get {
+				return implementor.OwnedHandle;
+			}
+		}
+
+		public static ICompletionProvider GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static ICompletionProvider GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is ICompletionProviderImplementor)
+				return new CompletionProviderAdapter (obj as ICompletionProviderImplementor);
+			else if (obj as ICompletionProvider == null)
+				return new CompletionProviderAdapter (obj.Handle);
+			else
+				return obj as ICompletionProvider;
+		}
+
+		public ICompletionProviderImplementor Implementor {
+			get {
+				return implementor as ICompletionProviderImplementor;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_completion_provider_activate_proposal(IntPtr raw, IntPtr proposal, IntPtr iter);
+		static d_gtk_source_completion_provider_activate_proposal gtk_source_completion_provider_activate_proposal = FuncLoader.LoadFunction<d_gtk_source_completion_provider_activate_proposal>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_activate_proposal"));
+
+		public bool ActivateProposal(GtkSource.ICompletionProposal proposal, Gtk.TextIter iter) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			bool raw_ret = gtk_source_completion_provider_activate_proposal(Handle, proposal == null ? IntPtr.Zero : ((proposal is GLib.Object) ? (proposal as GLib.Object).Handle : (proposal as GtkSource.CompletionProposalAdapter).Handle), native_iter);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_iter);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_completion_provider_get_activation(IntPtr raw);
+		static d_gtk_source_completion_provider_get_activation gtk_source_completion_provider_get_activation = FuncLoader.LoadFunction<d_gtk_source_completion_provider_get_activation>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_get_activation"));
+
+		public GtkSource.CompletionActivation Activation { 
+			get {
+				int raw_ret = gtk_source_completion_provider_get_activation(Handle);
+				GtkSource.CompletionActivation ret = (GtkSource.CompletionActivation) raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_provider_get_gicon(IntPtr raw);
+		static d_gtk_source_completion_provider_get_gicon gtk_source_completion_provider_get_gicon = FuncLoader.LoadFunction<d_gtk_source_completion_provider_get_gicon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_get_gicon"));
+
+		public GLib.IIcon Gicon { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_provider_get_gicon(Handle);
+				GLib.IIcon ret = GLib.IconAdapter.GetObject (raw_ret, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_provider_get_icon(IntPtr raw);
+		static d_gtk_source_completion_provider_get_icon gtk_source_completion_provider_get_icon = FuncLoader.LoadFunction<d_gtk_source_completion_provider_get_icon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_get_icon"));
+
+		public Gdk.Pixbuf Icon { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_provider_get_icon(Handle);
+				Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_provider_get_icon_name(IntPtr raw);
+		static d_gtk_source_completion_provider_get_icon_name gtk_source_completion_provider_get_icon_name = FuncLoader.LoadFunction<d_gtk_source_completion_provider_get_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_get_icon_name"));
+
+		public string IconName { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_provider_get_icon_name(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_provider_get_info_widget(IntPtr raw, IntPtr proposal);
+		static d_gtk_source_completion_provider_get_info_widget gtk_source_completion_provider_get_info_widget = FuncLoader.LoadFunction<d_gtk_source_completion_provider_get_info_widget>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_get_info_widget"));
+
+		public Gtk.Widget GetInfoWidget(GtkSource.ICompletionProposal proposal) {
+			IntPtr raw_ret = gtk_source_completion_provider_get_info_widget(Handle, proposal == null ? IntPtr.Zero : ((proposal is GLib.Object) ? (proposal as GLib.Object).Handle : (proposal as GtkSource.CompletionProposalAdapter).Handle));
+			Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_completion_provider_get_interactive_delay(IntPtr raw);
+		static d_gtk_source_completion_provider_get_interactive_delay gtk_source_completion_provider_get_interactive_delay = FuncLoader.LoadFunction<d_gtk_source_completion_provider_get_interactive_delay>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_get_interactive_delay"));
+
+		public int InteractiveDelay { 
+			get {
+				int raw_ret = gtk_source_completion_provider_get_interactive_delay(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_completion_provider_get_name(IntPtr raw);
+		static d_gtk_source_completion_provider_get_name gtk_source_completion_provider_get_name = FuncLoader.LoadFunction<d_gtk_source_completion_provider_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_get_name"));
+
+		public string Name { 
+			get {
+				IntPtr raw_ret = gtk_source_completion_provider_get_name(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_completion_provider_get_priority(IntPtr raw);
+		static d_gtk_source_completion_provider_get_priority gtk_source_completion_provider_get_priority = FuncLoader.LoadFunction<d_gtk_source_completion_provider_get_priority>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_get_priority"));
+
+		public int Priority { 
+			get {
+				int raw_ret = gtk_source_completion_provider_get_priority(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_completion_provider_get_start_iter(IntPtr raw, IntPtr context, IntPtr proposal, IntPtr iter);
+		static d_gtk_source_completion_provider_get_start_iter gtk_source_completion_provider_get_start_iter = FuncLoader.LoadFunction<d_gtk_source_completion_provider_get_start_iter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_get_start_iter"));
+
+		public bool GetStartIter(GtkSource.CompletionContext context, GtkSource.ICompletionProposal proposal, Gtk.TextIter iter) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			bool raw_ret = gtk_source_completion_provider_get_start_iter(Handle, context == null ? IntPtr.Zero : context.Handle, proposal == null ? IntPtr.Zero : ((proposal is GLib.Object) ? (proposal as GLib.Object).Handle : (proposal as GtkSource.CompletionProposalAdapter).Handle), native_iter);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_iter);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_completion_provider_match(IntPtr raw, IntPtr context);
+		static d_gtk_source_completion_provider_match gtk_source_completion_provider_match = FuncLoader.LoadFunction<d_gtk_source_completion_provider_match>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_match"));
+
+		public bool Match(GtkSource.CompletionContext context) {
+			bool raw_ret = gtk_source_completion_provider_match(Handle, context == null ? IntPtr.Zero : context.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_provider_populate(IntPtr raw, IntPtr context);
+		static d_gtk_source_completion_provider_populate gtk_source_completion_provider_populate = FuncLoader.LoadFunction<d_gtk_source_completion_provider_populate>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_populate"));
+
+		public void Populate(GtkSource.CompletionContext context) {
+			gtk_source_completion_provider_populate(Handle, context == null ? IntPtr.Zero : context.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_completion_provider_update_info(IntPtr raw, IntPtr proposal, IntPtr info);
+		static d_gtk_source_completion_provider_update_info gtk_source_completion_provider_update_info = FuncLoader.LoadFunction<d_gtk_source_completion_provider_update_info>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_completion_provider_update_info"));
+
+		public void UpdateInfo(GtkSource.ICompletionProposal proposal, GtkSource.CompletionInfo info) {
+			gtk_source_completion_provider_update_info(Handle, proposal == null ? IntPtr.Zero : ((proposal is GLib.Object) ? (proposal as GLib.Object).Handle : (proposal as GtkSource.CompletionProposalAdapter).Handle), info == null ? IntPtr.Zero : info.Handle);
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/CompressionType.cs

@@ -0,0 +1,16 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum CompressionType {
+
+		None,
+		Gzip,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Context.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Context : GLib.Opaque {
+
+		public Context(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ContextClass.cs

@@ -0,0 +1,79 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ContextClass : GLib.Opaque {
+
+		public ContextClass(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_context_class_new(IntPtr name, bool enabled);
+		static d_gtk_source_context_class_new gtk_source_context_class_new = FuncLoader.LoadFunction<d_gtk_source_context_class_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_context_class_new"));
+
+		public ContextClass (string name, bool enabled) 
+		{
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			Raw = gtk_source_context_class_new(native_name, enabled);
+			GLib.Marshaller.Free (native_name);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_context_class_free(IntPtr raw);
+		static d_gtk_source_context_class_free gtk_source_context_class_free = FuncLoader.LoadFunction<d_gtk_source_context_class_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_context_class_free"));
+
+		protected override void Free (IntPtr raw)
+		{
+			gtk_source_context_class_free (raw);
+		}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				gtk_source_context_class_free (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~ContextClass ()
+		{
+			if (!Owned)
+				return;
+			FinalizerInfo info = new FinalizerInfo (Handle);
+			info.timeoutHandlerId = GLib.Timeout.Add (50, new GLib.TimeoutHandler (info.Handler));
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ContextClassTag.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ContextClassTag : GLib.Opaque {
+
+		public ContextClassTag(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ContextData.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ContextData : GLib.Opaque {
+
+		public ContextData(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ContextDefinition.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ContextDefinition : GLib.Opaque {
+
+		public ContextDefinition(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ContextFlags.cs

@@ -0,0 +1,21 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	public enum ContextFlags {
+
+		ExtendParent = 1 << 0,
+		EndParent = 1 << 1,
+		EndAtLineEnd = 1 << 2,
+		FirstLineOnly = 1 << 3,
+		OnceOnly = 1 << 4,
+		StyleInside = 1 << 5,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ContextPtr.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ContextPtr : GLib.Opaque {
+
+		public ContextPtr(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ContextRefOptions.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	public enum ContextRefOptions {
+
+		IgnoreStyle = 1 << 0,
+		OverrideStyle = 1 << 1,
+		RefOriginal = 1 << 2,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ContextReplace.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ContextReplace : GLib.Opaque {
+
+		public ContextReplace(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/DataQueriedHandler.cs

@@ -0,0 +1,30 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void DataQueriedHandler(object o, DataQueriedArgs args);
+
+	public class DataQueriedArgs : GLib.SignalArgs {
+		public Gtk.TextIter Start{
+			get {
+				return (Gtk.TextIter) Args [0];
+			}
+		}
+
+		public Gtk.TextIter End{
+			get {
+				return (Gtk.TextIter) Args [1];
+			}
+		}
+
+		public GtkSource.GutterRendererState State{
+			get {
+				return (GtkSource.GutterRendererState) Args [2];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/DefinitionChild.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class DefinitionChild : GLib.Opaque {
+
+		public DefinitionChild(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/DefinitionsIter.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class DefinitionsIter : GLib.Opaque {
+
+		public DefinitionsIter(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Encoding.cs

@@ -0,0 +1,184 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Encoding : GLib.Opaque {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_encoding_copy(IntPtr raw);
+		static d_gtk_source_encoding_copy gtk_source_encoding_copy = FuncLoader.LoadFunction<d_gtk_source_encoding_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_copy"));
+
+		public GtkSource.Encoding Copy() {
+			IntPtr raw_ret = gtk_source_encoding_copy(Handle);
+			GtkSource.Encoding ret = raw_ret == IntPtr.Zero ? null : (GtkSource.Encoding) GLib.Opaque.GetOpaque (raw_ret, typeof (GtkSource.Encoding), true);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_encoding_get_all();
+		static d_gtk_source_encoding_get_all gtk_source_encoding_get_all = FuncLoader.LoadFunction<d_gtk_source_encoding_get_all>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_get_all"));
+
+		public static GtkSource.Encoding[] All { 
+			get {
+				IntPtr raw_ret = gtk_source_encoding_get_all();
+				GtkSource.Encoding[] ret = GLib.Marshaller.SListPtrToArray<GtkSource.Encoding, GtkSource.Encoding> (raw_ret, true, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_encoding_get_charset(IntPtr raw);
+		static d_gtk_source_encoding_get_charset gtk_source_encoding_get_charset = FuncLoader.LoadFunction<d_gtk_source_encoding_get_charset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_get_charset"));
+
+		public string Charset { 
+			get {
+				IntPtr raw_ret = gtk_source_encoding_get_charset(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_encoding_get_current();
+		static d_gtk_source_encoding_get_current gtk_source_encoding_get_current = FuncLoader.LoadFunction<d_gtk_source_encoding_get_current>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_get_current"));
+
+		public static GtkSource.Encoding Current { 
+			get {
+				IntPtr raw_ret = gtk_source_encoding_get_current();
+				GtkSource.Encoding ret = raw_ret == IntPtr.Zero ? null : (GtkSource.Encoding) GLib.Opaque.GetOpaque (raw_ret, typeof (GtkSource.Encoding), false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_encoding_get_default_candidates();
+		static d_gtk_source_encoding_get_default_candidates gtk_source_encoding_get_default_candidates = FuncLoader.LoadFunction<d_gtk_source_encoding_get_default_candidates>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_get_default_candidates"));
+
+		public static GtkSource.Encoding[] DefaultCandidates { 
+			get {
+				IntPtr raw_ret = gtk_source_encoding_get_default_candidates();
+				GtkSource.Encoding[] ret = GLib.Marshaller.SListPtrToArray<GtkSource.Encoding, GtkSource.Encoding> (raw_ret, true, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_encoding_get_from_charset(IntPtr charset);
+		static d_gtk_source_encoding_get_from_charset gtk_source_encoding_get_from_charset = FuncLoader.LoadFunction<d_gtk_source_encoding_get_from_charset>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_get_from_charset"));
+
+		public static GtkSource.Encoding GetFromCharset(string charset) {
+			IntPtr native_charset = GLib.Marshaller.StringToPtrGStrdup (charset);
+			IntPtr raw_ret = gtk_source_encoding_get_from_charset(native_charset);
+			GtkSource.Encoding ret = raw_ret == IntPtr.Zero ? null : (GtkSource.Encoding) GLib.Opaque.GetOpaque (raw_ret, typeof (GtkSource.Encoding), false);
+			GLib.Marshaller.Free (native_charset);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_encoding_get_name(IntPtr raw);
+		static d_gtk_source_encoding_get_name gtk_source_encoding_get_name = FuncLoader.LoadFunction<d_gtk_source_encoding_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_get_name"));
+
+		public string Name { 
+			get {
+				IntPtr raw_ret = gtk_source_encoding_get_name(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_encoding_get_type();
+		static d_gtk_source_encoding_get_type gtk_source_encoding_get_type = FuncLoader.LoadFunction<d_gtk_source_encoding_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_get_type"));
+
+		public static GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_encoding_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_encoding_get_utf8();
+		static d_gtk_source_encoding_get_utf8 gtk_source_encoding_get_utf8 = FuncLoader.LoadFunction<d_gtk_source_encoding_get_utf8>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_get_utf8"));
+
+		public static GtkSource.Encoding Utf8 { 
+			get {
+				IntPtr raw_ret = gtk_source_encoding_get_utf8();
+				GtkSource.Encoding ret = raw_ret == IntPtr.Zero ? null : (GtkSource.Encoding) GLib.Opaque.GetOpaque (raw_ret, typeof (GtkSource.Encoding), false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_encoding_to_string(IntPtr raw);
+		static d_gtk_source_encoding_to_string gtk_source_encoding_to_string = FuncLoader.LoadFunction<d_gtk_source_encoding_to_string>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_to_string"));
+
+		public override string ToString() {
+			IntPtr raw_ret = gtk_source_encoding_to_string(Handle);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		public Encoding(IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_encoding_free(IntPtr raw);
+		static d_gtk_source_encoding_free gtk_source_encoding_free = FuncLoader.LoadFunction<d_gtk_source_encoding_free>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_encoding_free"));
+
+		protected override void Free (IntPtr raw)
+		{
+			gtk_source_encoding_free (raw);
+		}
+
+		class FinalizerInfo {
+			IntPtr handle;
+			public uint timeoutHandlerId;
+
+			public FinalizerInfo (IntPtr handle)
+			{
+				this.handle = handle;
+			}
+
+			public bool Handler ()
+			{
+				gtk_source_encoding_free (handle);
+				GLib.Timeout.Remove(timeoutHandlerId);
+				return false;
+			}
+		}
+
+		~Encoding ()
+		{
+			if (!Owned)
+				return;
+			FinalizerInfo info = new FinalizerInfo (Handle);
+			info.timeoutHandlerId = GLib.Timeout.Add (50, new GLib.TimeoutHandler (info.Handler));
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/File.cs

@@ -0,0 +1,242 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class File : GLib.Object {
+
+		public File (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_new();
+		static d_gtk_source_file_new gtk_source_file_new = FuncLoader.LoadFunction<d_gtk_source_file_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_new"));
+
+		public File () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (File)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_file_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_get_location(IntPtr raw);
+		static d_gtk_source_file_get_location gtk_source_file_get_location = FuncLoader.LoadFunction<d_gtk_source_file_get_location>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_get_location"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_file_set_location(IntPtr raw, IntPtr location);
+		static d_gtk_source_file_set_location gtk_source_file_set_location = FuncLoader.LoadFunction<d_gtk_source_file_set_location>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_set_location"));
+
+		[GLib.Property ("location")]
+		public GLib.IFile Location {
+			get  {
+				IntPtr raw_ret = gtk_source_file_get_location(Handle);
+				GLib.IFile ret = GLib.FileAdapter.GetObject (raw_ret, false);
+				return ret;
+			}
+			set  {
+				gtk_source_file_set_location(Handle, value == null ? IntPtr.Zero : ((value is GLib.Object) ? (value as GLib.Object).Handle : (value as GLib.FileAdapter).Handle));
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_get_encoding(IntPtr raw);
+		static d_gtk_source_file_get_encoding gtk_source_file_get_encoding = FuncLoader.LoadFunction<d_gtk_source_file_get_encoding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_get_encoding"));
+
+		[GLib.Property ("encoding")]
+		public GtkSource.Encoding Encoding {
+			get  {
+				IntPtr raw_ret = gtk_source_file_get_encoding(Handle);
+				GtkSource.Encoding ret = raw_ret == IntPtr.Zero ? null : (GtkSource.Encoding) GLib.Opaque.GetOpaque (raw_ret, typeof (GtkSource.Encoding), false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_file_get_newline_type(IntPtr raw);
+		static d_gtk_source_file_get_newline_type gtk_source_file_get_newline_type = FuncLoader.LoadFunction<d_gtk_source_file_get_newline_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_get_newline_type"));
+
+		[GLib.Property ("newline-type")]
+		public GtkSource.NewlineType NewlineType {
+			get  {
+				int raw_ret = gtk_source_file_get_newline_type(Handle);
+				GtkSource.NewlineType ret = (GtkSource.NewlineType) raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_file_get_compression_type(IntPtr raw);
+		static d_gtk_source_file_get_compression_type gtk_source_file_get_compression_type = FuncLoader.LoadFunction<d_gtk_source_file_get_compression_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_get_compression_type"));
+
+		[GLib.Property ("compression-type")]
+		public GtkSource.CompressionType CompressionType {
+			get  {
+				int raw_ret = gtk_source_file_get_compression_type(Handle);
+				GtkSource.CompressionType ret = (GtkSource.CompressionType) raw_ret;
+				return ret;
+			}
+		}
+
+		[GLib.Property ("read-only")]
+		public bool ReadOnly {
+			get {
+				GLib.Value val = GetProperty ("read-only");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_file_check_file_on_disk(IntPtr raw);
+		static d_gtk_source_file_check_file_on_disk gtk_source_file_check_file_on_disk = FuncLoader.LoadFunction<d_gtk_source_file_check_file_on_disk>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_check_file_on_disk"));
+
+		public void CheckFileOnDisk() {
+			gtk_source_file_check_file_on_disk(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_get_type();
+		static d_gtk_source_file_get_type gtk_source_file_get_type = FuncLoader.LoadFunction<d_gtk_source_file_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_file_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_file_is_deleted(IntPtr raw);
+		static d_gtk_source_file_is_deleted gtk_source_file_is_deleted = FuncLoader.LoadFunction<d_gtk_source_file_is_deleted>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_is_deleted"));
+
+		public bool IsDeleted { 
+			get {
+				bool raw_ret = gtk_source_file_is_deleted(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_file_is_externally_modified(IntPtr raw);
+		static d_gtk_source_file_is_externally_modified gtk_source_file_is_externally_modified = FuncLoader.LoadFunction<d_gtk_source_file_is_externally_modified>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_is_externally_modified"));
+
+		public bool IsExternallyModified { 
+			get {
+				bool raw_ret = gtk_source_file_is_externally_modified(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_file_is_local(IntPtr raw);
+		static d_gtk_source_file_is_local gtk_source_file_is_local = FuncLoader.LoadFunction<d_gtk_source_file_is_local>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_is_local"));
+
+		public bool IsLocal { 
+			get {
+				bool raw_ret = gtk_source_file_is_local(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_file_is_readonly(IntPtr raw);
+		static d_gtk_source_file_is_readonly gtk_source_file_is_readonly = FuncLoader.LoadFunction<d_gtk_source_file_is_readonly>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_is_readonly"));
+
+		public bool IsReadonly { 
+			get {
+				bool raw_ret = gtk_source_file_is_readonly(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_file_set_mount_operation_factory(IntPtr raw, GtkSourceSharp.MountOperationFactoryNative cb, IntPtr user_data, GLib.DestroyNotify notify);
+		static d_gtk_source_file_set_mount_operation_factory gtk_source_file_set_mount_operation_factory = FuncLoader.LoadFunction<d_gtk_source_file_set_mount_operation_factory>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_set_mount_operation_factory"));
+
+		public GtkSource.MountOperationFactory MountOperationFactory { 
+			set {
+				GtkSourceSharp.MountOperationFactoryWrapper value_wrapper = new GtkSourceSharp.MountOperationFactoryWrapper (value);
+				IntPtr user_data;
+				GLib.DestroyNotify notify;
+				if (value == null) {
+					user_data = IntPtr.Zero;
+					notify = null;
+				} else {
+					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
+					notify = GLib.DestroyHelper.NotifyHandler;
+				}
+				gtk_source_file_set_mount_operation_factory(Handle, value_wrapper.NativeDelegate, user_data, notify);
+			}
+		}
+
+
+		static File ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/FileLoader.cs

@@ -0,0 +1,261 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class FileLoader : GLib.Object {
+
+		public FileLoader (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_loader_new(IntPtr buffer, IntPtr file);
+		static d_gtk_source_file_loader_new gtk_source_file_loader_new = FuncLoader.LoadFunction<d_gtk_source_file_loader_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_new"));
+
+		public FileLoader (GtkSource.Buffer buffer, GtkSource.File file) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (FileLoader)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (buffer != null) {
+					names.Add ("buffer");
+					vals.Add (new GLib.Value (buffer));
+				}
+				if (file != null) {
+					names.Add ("file");
+					vals.Add (new GLib.Value (file));
+				}
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gtk_source_file_loader_new(buffer == null ? IntPtr.Zero : buffer.Handle, file == null ? IntPtr.Zero : file.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_loader_new_from_stream(IntPtr buffer, IntPtr file, IntPtr stream);
+		static d_gtk_source_file_loader_new_from_stream gtk_source_file_loader_new_from_stream = FuncLoader.LoadFunction<d_gtk_source_file_loader_new_from_stream>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_new_from_stream"));
+
+		public FileLoader (GtkSource.Buffer buffer, GtkSource.File file, GLib.InputStream stream) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (FileLoader)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (buffer != null) {
+					names.Add ("buffer");
+					vals.Add (new GLib.Value (buffer));
+				}
+				if (file != null) {
+					names.Add ("file");
+					vals.Add (new GLib.Value (file));
+				}
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gtk_source_file_loader_new_from_stream(buffer == null ? IntPtr.Zero : buffer.Handle, file == null ? IntPtr.Zero : file.Handle, stream == null ? IntPtr.Zero : stream.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_loader_get_buffer(IntPtr raw);
+		static d_gtk_source_file_loader_get_buffer gtk_source_file_loader_get_buffer = FuncLoader.LoadFunction<d_gtk_source_file_loader_get_buffer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_get_buffer"));
+
+		[GLib.Property ("buffer")]
+		public GtkSource.Buffer Buffer {
+			get  {
+				IntPtr raw_ret = gtk_source_file_loader_get_buffer(Handle);
+				GtkSource.Buffer ret = GLib.Object.GetObject(raw_ret) as GtkSource.Buffer;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_loader_get_file(IntPtr raw);
+		static d_gtk_source_file_loader_get_file gtk_source_file_loader_get_file = FuncLoader.LoadFunction<d_gtk_source_file_loader_get_file>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_get_file"));
+
+		[GLib.Property ("file")]
+		public GtkSource.File File {
+			get  {
+				IntPtr raw_ret = gtk_source_file_loader_get_file(Handle);
+				GtkSource.File ret = GLib.Object.GetObject(raw_ret) as GtkSource.File;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_loader_get_location(IntPtr raw);
+		static d_gtk_source_file_loader_get_location gtk_source_file_loader_get_location = FuncLoader.LoadFunction<d_gtk_source_file_loader_get_location>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_get_location"));
+
+		[GLib.Property ("location")]
+		public GLib.IFile Location {
+			get  {
+				IntPtr raw_ret = gtk_source_file_loader_get_location(Handle);
+				GLib.IFile ret = GLib.FileAdapter.GetObject (raw_ret, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_loader_get_input_stream(IntPtr raw);
+		static d_gtk_source_file_loader_get_input_stream gtk_source_file_loader_get_input_stream = FuncLoader.LoadFunction<d_gtk_source_file_loader_get_input_stream>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_get_input_stream"));
+
+		[GLib.Property ("input-stream")]
+		public GLib.InputStream InputStream {
+			get  {
+				IntPtr raw_ret = gtk_source_file_loader_get_input_stream(Handle);
+				GLib.InputStream ret = GLib.Object.GetObject(raw_ret) as GLib.InputStream;
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_file_loader_error_quark();
+		static d_gtk_source_file_loader_error_quark gtk_source_file_loader_error_quark = FuncLoader.LoadFunction<d_gtk_source_file_loader_error_quark>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_error_quark"));
+
+		public static int ErrorQuark() {
+			int raw_ret = gtk_source_file_loader_error_quark();
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_file_loader_get_compression_type(IntPtr raw);
+		static d_gtk_source_file_loader_get_compression_type gtk_source_file_loader_get_compression_type = FuncLoader.LoadFunction<d_gtk_source_file_loader_get_compression_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_get_compression_type"));
+
+		public GtkSource.CompressionType CompressionType { 
+			get {
+				int raw_ret = gtk_source_file_loader_get_compression_type(Handle);
+				GtkSource.CompressionType ret = (GtkSource.CompressionType) raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_loader_get_encoding(IntPtr raw);
+		static d_gtk_source_file_loader_get_encoding gtk_source_file_loader_get_encoding = FuncLoader.LoadFunction<d_gtk_source_file_loader_get_encoding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_get_encoding"));
+
+		public GtkSource.Encoding Encoding { 
+			get {
+				IntPtr raw_ret = gtk_source_file_loader_get_encoding(Handle);
+				GtkSource.Encoding ret = raw_ret == IntPtr.Zero ? null : (GtkSource.Encoding) GLib.Opaque.GetOpaque (raw_ret, typeof (GtkSource.Encoding), false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_file_loader_get_newline_type(IntPtr raw);
+		static d_gtk_source_file_loader_get_newline_type gtk_source_file_loader_get_newline_type = FuncLoader.LoadFunction<d_gtk_source_file_loader_get_newline_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_get_newline_type"));
+
+		public GtkSource.NewlineType NewlineType { 
+			get {
+				int raw_ret = gtk_source_file_loader_get_newline_type(Handle);
+				GtkSource.NewlineType ret = (GtkSource.NewlineType) raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_loader_get_type();
+		static d_gtk_source_file_loader_get_type gtk_source_file_loader_get_type = FuncLoader.LoadFunction<d_gtk_source_file_loader_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_file_loader_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_file_loader_load_async(IntPtr raw, int io_priority, IntPtr cancellable, GLibSharp.FileProgressCallbackNative progress_callback, IntPtr progress_callback_data, GLib.DestroyNotify progress_callback_notify, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
+		static d_gtk_source_file_loader_load_async gtk_source_file_loader_load_async = FuncLoader.LoadFunction<d_gtk_source_file_loader_load_async>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_load_async"));
+
+		public void LoadAsync(int io_priority, GLib.Cancellable cancellable, GLib.FileProgressCallback progress_callback, GLib.DestroyNotify progress_callback_notify, GLib.AsyncReadyCallback cb) {
+			GLibSharp.FileProgressCallbackWrapper progress_callback_wrapper = new GLibSharp.FileProgressCallbackWrapper (progress_callback);
+			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
+			cb_wrapper.PersistUntilCalled ();
+			gtk_source_file_loader_load_async(Handle, io_priority, cancellable == null ? IntPtr.Zero : cancellable.Handle, progress_callback_wrapper.NativeDelegate, IntPtr.Zero, progress_callback_notify, cb_wrapper.NativeDelegate, IntPtr.Zero);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_file_loader_load_finish(IntPtr raw, IntPtr result, out IntPtr error);
+		static d_gtk_source_file_loader_load_finish gtk_source_file_loader_load_finish = FuncLoader.LoadFunction<d_gtk_source_file_loader_load_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_load_finish"));
+
+		public unsafe bool LoadFinish(GLib.IAsyncResult result) {
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = gtk_source_file_loader_load_finish(Handle, result == null ? IntPtr.Zero : ((result is GLib.Object) ? (result as GLib.Object).Handle : (result as GLib.AsyncResultAdapter).Handle), out error);
+			bool ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_file_loader_set_candidate_encodings(IntPtr raw, IntPtr candidate_encodings);
+		static d_gtk_source_file_loader_set_candidate_encodings gtk_source_file_loader_set_candidate_encodings = FuncLoader.LoadFunction<d_gtk_source_file_loader_set_candidate_encodings>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_loader_set_candidate_encodings"));
+
+		public GLib.SList CandidateEncodings { 
+			set {
+				gtk_source_file_loader_set_candidate_encodings(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+
+		static FileLoader ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/FileLoaderError.cs

@@ -0,0 +1,17 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum FileLoaderError {
+
+		TooBig,
+		EncodingAutoDetectionFailed,
+		ConversionFallback,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/FileSaver.cs

@@ -0,0 +1,282 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class FileSaver : GLib.Object {
+
+		public FileSaver (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_saver_new(IntPtr buffer, IntPtr file);
+		static d_gtk_source_file_saver_new gtk_source_file_saver_new = FuncLoader.LoadFunction<d_gtk_source_file_saver_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_new"));
+
+		public FileSaver (GtkSource.Buffer buffer, GtkSource.File file) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (FileSaver)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (buffer != null) {
+					names.Add ("buffer");
+					vals.Add (new GLib.Value (buffer));
+				}
+				if (file != null) {
+					names.Add ("file");
+					vals.Add (new GLib.Value (file));
+				}
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gtk_source_file_saver_new(buffer == null ? IntPtr.Zero : buffer.Handle, file == null ? IntPtr.Zero : file.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_saver_new_with_target(IntPtr buffer, IntPtr file, IntPtr target_location);
+		static d_gtk_source_file_saver_new_with_target gtk_source_file_saver_new_with_target = FuncLoader.LoadFunction<d_gtk_source_file_saver_new_with_target>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_new_with_target"));
+
+		public FileSaver (GtkSource.Buffer buffer, GtkSource.File file, GLib.IFile target_location) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (FileSaver)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (buffer != null) {
+					names.Add ("buffer");
+					vals.Add (new GLib.Value (buffer));
+				}
+				if (file != null) {
+					names.Add ("file");
+					vals.Add (new GLib.Value (file));
+				}
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gtk_source_file_saver_new_with_target(buffer == null ? IntPtr.Zero : buffer.Handle, file == null ? IntPtr.Zero : file.Handle, target_location == null ? IntPtr.Zero : ((target_location is GLib.Object) ? (target_location as GLib.Object).Handle : (target_location as GLib.FileAdapter).Handle));
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_saver_get_buffer(IntPtr raw);
+		static d_gtk_source_file_saver_get_buffer gtk_source_file_saver_get_buffer = FuncLoader.LoadFunction<d_gtk_source_file_saver_get_buffer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_get_buffer"));
+
+		[GLib.Property ("buffer")]
+		public GtkSource.Buffer Buffer {
+			get  {
+				IntPtr raw_ret = gtk_source_file_saver_get_buffer(Handle);
+				GtkSource.Buffer ret = GLib.Object.GetObject(raw_ret) as GtkSource.Buffer;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_saver_get_file(IntPtr raw);
+		static d_gtk_source_file_saver_get_file gtk_source_file_saver_get_file = FuncLoader.LoadFunction<d_gtk_source_file_saver_get_file>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_get_file"));
+
+		[GLib.Property ("file")]
+		public GtkSource.File File {
+			get  {
+				IntPtr raw_ret = gtk_source_file_saver_get_file(Handle);
+				GtkSource.File ret = GLib.Object.GetObject(raw_ret) as GtkSource.File;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_saver_get_location(IntPtr raw);
+		static d_gtk_source_file_saver_get_location gtk_source_file_saver_get_location = FuncLoader.LoadFunction<d_gtk_source_file_saver_get_location>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_get_location"));
+
+		[GLib.Property ("location")]
+		public GLib.IFile Location {
+			get  {
+				IntPtr raw_ret = gtk_source_file_saver_get_location(Handle);
+				GLib.IFile ret = GLib.FileAdapter.GetObject (raw_ret, false);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_saver_get_encoding(IntPtr raw);
+		static d_gtk_source_file_saver_get_encoding gtk_source_file_saver_get_encoding = FuncLoader.LoadFunction<d_gtk_source_file_saver_get_encoding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_get_encoding"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_file_saver_set_encoding(IntPtr raw, IntPtr encoding);
+		static d_gtk_source_file_saver_set_encoding gtk_source_file_saver_set_encoding = FuncLoader.LoadFunction<d_gtk_source_file_saver_set_encoding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_set_encoding"));
+
+		[GLib.Property ("encoding")]
+		public GtkSource.Encoding Encoding {
+			get  {
+				IntPtr raw_ret = gtk_source_file_saver_get_encoding(Handle);
+				GtkSource.Encoding ret = raw_ret == IntPtr.Zero ? null : (GtkSource.Encoding) GLib.Opaque.GetOpaque (raw_ret, typeof (GtkSource.Encoding), false);
+				return ret;
+			}
+			set  {
+				gtk_source_file_saver_set_encoding(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_file_saver_get_newline_type(IntPtr raw);
+		static d_gtk_source_file_saver_get_newline_type gtk_source_file_saver_get_newline_type = FuncLoader.LoadFunction<d_gtk_source_file_saver_get_newline_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_get_newline_type"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_file_saver_set_newline_type(IntPtr raw, int newline_type);
+		static d_gtk_source_file_saver_set_newline_type gtk_source_file_saver_set_newline_type = FuncLoader.LoadFunction<d_gtk_source_file_saver_set_newline_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_set_newline_type"));
+
+		[GLib.Property ("newline-type")]
+		public GtkSource.NewlineType NewlineType {
+			get  {
+				int raw_ret = gtk_source_file_saver_get_newline_type(Handle);
+				GtkSource.NewlineType ret = (GtkSource.NewlineType) raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_file_saver_set_newline_type(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_file_saver_get_compression_type(IntPtr raw);
+		static d_gtk_source_file_saver_get_compression_type gtk_source_file_saver_get_compression_type = FuncLoader.LoadFunction<d_gtk_source_file_saver_get_compression_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_get_compression_type"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_file_saver_set_compression_type(IntPtr raw, int compression_type);
+		static d_gtk_source_file_saver_set_compression_type gtk_source_file_saver_set_compression_type = FuncLoader.LoadFunction<d_gtk_source_file_saver_set_compression_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_set_compression_type"));
+
+		[GLib.Property ("compression-type")]
+		public GtkSource.CompressionType CompressionType {
+			get  {
+				int raw_ret = gtk_source_file_saver_get_compression_type(Handle);
+				GtkSource.CompressionType ret = (GtkSource.CompressionType) raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_file_saver_set_compression_type(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_file_saver_get_flags(IntPtr raw);
+		static d_gtk_source_file_saver_get_flags gtk_source_file_saver_get_flags = FuncLoader.LoadFunction<d_gtk_source_file_saver_get_flags>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_get_flags"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_file_saver_set_flags(IntPtr raw, int flags);
+		static d_gtk_source_file_saver_set_flags gtk_source_file_saver_set_flags = FuncLoader.LoadFunction<d_gtk_source_file_saver_set_flags>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_set_flags"));
+
+		[GLib.Property ("flags")]
+		public GtkSource.FileSaverFlags Flags {
+			get  {
+				int raw_ret = gtk_source_file_saver_get_flags(Handle);
+				GtkSource.FileSaverFlags ret = (GtkSource.FileSaverFlags) raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_file_saver_set_flags(Handle, (int) value);
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_file_saver_error_quark();
+		static d_gtk_source_file_saver_error_quark gtk_source_file_saver_error_quark = FuncLoader.LoadFunction<d_gtk_source_file_saver_error_quark>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_error_quark"));
+
+		public static int ErrorQuark() {
+			int raw_ret = gtk_source_file_saver_error_quark();
+			int ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_file_saver_get_type();
+		static d_gtk_source_file_saver_get_type gtk_source_file_saver_get_type = FuncLoader.LoadFunction<d_gtk_source_file_saver_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_file_saver_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_file_saver_save_async(IntPtr raw, int io_priority, IntPtr cancellable, GLibSharp.FileProgressCallbackNative progress_callback, IntPtr progress_callback_data, GLib.DestroyNotify progress_callback_notify, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
+		static d_gtk_source_file_saver_save_async gtk_source_file_saver_save_async = FuncLoader.LoadFunction<d_gtk_source_file_saver_save_async>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_save_async"));
+
+		public void SaveAsync(int io_priority, GLib.Cancellable cancellable, GLib.FileProgressCallback progress_callback, GLib.DestroyNotify progress_callback_notify, GLib.AsyncReadyCallback cb) {
+			GLibSharp.FileProgressCallbackWrapper progress_callback_wrapper = new GLibSharp.FileProgressCallbackWrapper (progress_callback);
+			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
+			cb_wrapper.PersistUntilCalled ();
+			gtk_source_file_saver_save_async(Handle, io_priority, cancellable == null ? IntPtr.Zero : cancellable.Handle, progress_callback_wrapper.NativeDelegate, IntPtr.Zero, progress_callback_notify, cb_wrapper.NativeDelegate, IntPtr.Zero);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_file_saver_save_finish(IntPtr raw, IntPtr result, out IntPtr error);
+		static d_gtk_source_file_saver_save_finish gtk_source_file_saver_save_finish = FuncLoader.LoadFunction<d_gtk_source_file_saver_save_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_file_saver_save_finish"));
+
+		public unsafe bool SaveFinish(GLib.IAsyncResult result) {
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = gtk_source_file_saver_save_finish(Handle, result == null ? IntPtr.Zero : ((result is GLib.Object) ? (result as GLib.Object).Handle : (result as GLib.AsyncResultAdapter).Handle), out error);
+			bool ret = raw_ret;
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+
+		static FileSaver ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/FileSaverError.cs

@@ -0,0 +1,16 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum FileSaverError {
+
+		InvalidChars,
+		ExternallyModified,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/FileSaverFlags.cs

@@ -0,0 +1,19 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	public enum FileSaverFlags {
+
+		None,
+		IgnoreInvalidChars = 1 << 0,
+		IgnoreModificationTime = 1 << 1,
+		CreateBackup = 1 << 2,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Global.cs

@@ -0,0 +1,26 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Global {
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_tag_new(IntPtr name);
+		static d_gtk_source_tag_new gtk_source_tag_new = FuncLoader.LoadFunction<d_gtk_source_tag_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_tag_new"));
+
+		public static Gtk.TextTag TagNew(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			IntPtr raw_ret = gtk_source_tag_new(native_name);
+			Gtk.TextTag ret = GLib.Object.GetObject(raw_ret) as Gtk.TextTag;
+			GLib.Marshaller.Free (native_name);
+			return ret;
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/GtkSourceSharp.MountOperationFactoryNative.cs

@@ -0,0 +1,95 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSourceSharp {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	internal delegate IntPtr MountOperationFactoryNative(IntPtr file, IntPtr userdata);
+
+	internal class MountOperationFactoryInvoker {
+
+		MountOperationFactoryNative native_cb;
+		IntPtr __data;
+		GLib.DestroyNotify __notify;
+
+		~MountOperationFactoryInvoker ()
+		{
+			if (__notify == null)
+				return;
+			__notify (__data);
+		}
+
+		internal MountOperationFactoryInvoker (MountOperationFactoryNative native_cb) : this (native_cb, IntPtr.Zero, null) {}
+
+		internal MountOperationFactoryInvoker (MountOperationFactoryNative native_cb, IntPtr data) : this (native_cb, data, null) {}
+
+		internal MountOperationFactoryInvoker (MountOperationFactoryNative native_cb, IntPtr data, GLib.DestroyNotify notify)
+		{
+			this.native_cb = native_cb;
+			__data = data;
+			__notify = notify;
+		}
+
+		internal GtkSource.MountOperationFactory Handler {
+			get {
+				return new GtkSource.MountOperationFactory(InvokeNative);
+			}
+		}
+
+		GLib.MountOperation InvokeNative (GtkSource.File file)
+		{
+			GLib.MountOperation __result = GLib.Object.GetObject(native_cb (file == null ? IntPtr.Zero : file.Handle, __data)) as GLib.MountOperation;
+			return __result;
+		}
+	}
+
+	internal class MountOperationFactoryWrapper {
+
+		public IntPtr NativeCallback (IntPtr file, IntPtr userdata)
+		{
+			try {
+				GLib.MountOperation __ret = managed (GLib.Object.GetObject(file) as GtkSource.File);
+				if (release_on_call)
+					gch.Free ();
+				return __ret == null ? IntPtr.Zero : __ret.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: Above call does not return.
+				throw;
+			}
+		}
+
+		bool release_on_call = false;
+		GCHandle gch;
+
+		public void PersistUntilCalled ()
+		{
+			release_on_call = true;
+			gch = GCHandle.Alloc (this);
+		}
+
+		internal MountOperationFactoryNative NativeDelegate;
+		GtkSource.MountOperationFactory managed;
+
+		public MountOperationFactoryWrapper (GtkSource.MountOperationFactory managed)
+		{
+			this.managed = managed;
+			if (managed != null)
+				NativeDelegate = new MountOperationFactoryNative (NativeCallback);
+		}
+
+		public static GtkSource.MountOperationFactory GetManagedDelegate (MountOperationFactoryNative native)
+		{
+			if (native == null)
+				return null;
+			MountOperationFactoryWrapper wrapper = (MountOperationFactoryWrapper) native.Target;
+			if (wrapper == null)
+				return null;
+			return wrapper.managed;
+		}
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Gutter.cs

@@ -0,0 +1,159 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Gutter : GLib.Object {
+
+		public Gutter (IntPtr raw) : base(raw) {}
+
+		protected Gutter() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_gutter_get_view(IntPtr raw);
+		static d_gtk_source_gutter_get_view gtk_source_gutter_get_view = FuncLoader.LoadFunction<d_gtk_source_gutter_get_view>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_get_view"));
+
+		[GLib.Property ("view")]
+		public GtkSource.SourceView View {
+			get  {
+				IntPtr raw_ret = gtk_source_gutter_get_view(Handle);
+				GtkSource.SourceView ret = GLib.Object.GetObject(raw_ret) as GtkSource.SourceView;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_gutter_get_window_type(IntPtr raw);
+		static d_gtk_source_gutter_get_window_type gtk_source_gutter_get_window_type = FuncLoader.LoadFunction<d_gtk_source_gutter_get_window_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_get_window_type"));
+
+		[GLib.Property ("window_type")]
+		public Gtk.TextWindowType WindowType {
+			get  {
+				int raw_ret = gtk_source_gutter_get_window_type(Handle);
+				Gtk.TextWindowType ret = (Gtk.TextWindowType) raw_ret;
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_gutter_get_renderer_at_pos(IntPtr raw, int x, int y);
+		static d_gtk_source_gutter_get_renderer_at_pos gtk_source_gutter_get_renderer_at_pos = FuncLoader.LoadFunction<d_gtk_source_gutter_get_renderer_at_pos>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_get_renderer_at_pos"));
+
+		public GtkSource.GutterRenderer GetRendererAtPos(int x, int y) {
+			IntPtr raw_ret = gtk_source_gutter_get_renderer_at_pos(Handle, x, y);
+			GtkSource.GutterRenderer ret = GLib.Object.GetObject(raw_ret) as GtkSource.GutterRenderer;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_gutter_get_type();
+		static d_gtk_source_gutter_get_type gtk_source_gutter_get_type = FuncLoader.LoadFunction<d_gtk_source_gutter_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_gutter_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_gutter_insert(IntPtr raw, IntPtr renderer, int position);
+		static d_gtk_source_gutter_insert gtk_source_gutter_insert = FuncLoader.LoadFunction<d_gtk_source_gutter_insert>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_insert"));
+
+		public bool Insert(GtkSource.GutterRenderer renderer, int position) {
+			bool raw_ret = gtk_source_gutter_insert(Handle, renderer == null ? IntPtr.Zero : renderer.Handle, position);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_gutter_queue_draw(IntPtr raw);
+		static d_gtk_source_gutter_queue_draw gtk_source_gutter_queue_draw = FuncLoader.LoadFunction<d_gtk_source_gutter_queue_draw>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_queue_draw"));
+
+		public void QueueDraw() {
+			gtk_source_gutter_queue_draw(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_gutter_remove(IntPtr raw, IntPtr renderer);
+		static d_gtk_source_gutter_remove gtk_source_gutter_remove = FuncLoader.LoadFunction<d_gtk_source_gutter_remove>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_remove"));
+
+		public void Remove(GtkSource.GutterRenderer renderer) {
+			gtk_source_gutter_remove(Handle, renderer == null ? IntPtr.Zero : renderer.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_gutter_reorder(IntPtr raw, IntPtr renderer, int position);
+		static d_gtk_source_gutter_reorder gtk_source_gutter_reorder = FuncLoader.LoadFunction<d_gtk_source_gutter_reorder>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_reorder"));
+
+		public void Reorder(GtkSource.GutterRenderer renderer, int position) {
+			gtk_source_gutter_reorder(Handle, renderer == null ? IntPtr.Zero : renderer.Handle, position);
+		}
+
+
+		static Gutter ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/GutterRendererAlignmentMode.cs

@@ -0,0 +1,17 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum GutterRendererAlignmentMode {
+
+		Cell,
+		First,
+		Last,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/GutterRendererPixbuf.cs

@@ -0,0 +1,159 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class GutterRendererPixbuf : GtkSource.GutterRenderer {
+
+		public GutterRendererPixbuf (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_gutter_renderer_pixbuf_new();
+		static d_gtk_source_gutter_renderer_pixbuf_new gtk_source_gutter_renderer_pixbuf_new = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_pixbuf_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_pixbuf_new"));
+
+		public GutterRendererPixbuf () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (GutterRendererPixbuf)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_gutter_renderer_pixbuf_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_gutter_renderer_pixbuf_get_pixbuf(IntPtr raw);
+		static d_gtk_source_gutter_renderer_pixbuf_get_pixbuf gtk_source_gutter_renderer_pixbuf_get_pixbuf = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_pixbuf_get_pixbuf>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_pixbuf_get_pixbuf"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_gutter_renderer_pixbuf_set_pixbuf(IntPtr raw, IntPtr pixbuf);
+		static d_gtk_source_gutter_renderer_pixbuf_set_pixbuf gtk_source_gutter_renderer_pixbuf_set_pixbuf = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_pixbuf_set_pixbuf>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_pixbuf_set_pixbuf"));
+
+		[GLib.Property ("pixbuf")]
+		public Gdk.Pixbuf Pixbuf {
+			get  {
+				IntPtr raw_ret = gtk_source_gutter_renderer_pixbuf_get_pixbuf(Handle);
+				Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
+				return ret;
+			}
+			set  {
+				gtk_source_gutter_renderer_pixbuf_set_pixbuf(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_gutter_renderer_pixbuf_get_icon_name(IntPtr raw);
+		static d_gtk_source_gutter_renderer_pixbuf_get_icon_name gtk_source_gutter_renderer_pixbuf_get_icon_name = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_pixbuf_get_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_pixbuf_get_icon_name"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_gutter_renderer_pixbuf_set_icon_name(IntPtr raw, IntPtr icon_name);
+		static d_gtk_source_gutter_renderer_pixbuf_set_icon_name gtk_source_gutter_renderer_pixbuf_set_icon_name = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_pixbuf_set_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_pixbuf_set_icon_name"));
+
+		[GLib.Property ("icon-name")]
+		public string IconName {
+			get  {
+				IntPtr raw_ret = gtk_source_gutter_renderer_pixbuf_get_icon_name(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_gutter_renderer_pixbuf_set_icon_name(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_gutter_renderer_pixbuf_get_gicon(IntPtr raw);
+		static d_gtk_source_gutter_renderer_pixbuf_get_gicon gtk_source_gutter_renderer_pixbuf_get_gicon = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_pixbuf_get_gicon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_pixbuf_get_gicon"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_gutter_renderer_pixbuf_set_gicon(IntPtr raw, IntPtr icon);
+		static d_gtk_source_gutter_renderer_pixbuf_set_gicon gtk_source_gutter_renderer_pixbuf_set_gicon = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_pixbuf_set_gicon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_pixbuf_set_gicon"));
+
+		[GLib.Property ("gicon")]
+		public GLib.IIcon Gicon {
+			get  {
+				IntPtr raw_ret = gtk_source_gutter_renderer_pixbuf_get_gicon(Handle);
+				GLib.IIcon ret = GLib.IconAdapter.GetObject (raw_ret, false);
+				return ret;
+			}
+			set  {
+				gtk_source_gutter_renderer_pixbuf_set_gicon(Handle, value == null ? IntPtr.Zero : ((value is GLib.Object) ? (value as GLib.Object).Handle : (value as GLib.IconAdapter).Handle));
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GtkSource.GutterRenderer.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_gutter_renderer_pixbuf_get_type();
+		static d_gtk_source_gutter_renderer_pixbuf_get_type gtk_source_gutter_renderer_pixbuf_get_type = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_pixbuf_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_pixbuf_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_gutter_renderer_pixbuf_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static GutterRendererPixbuf ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GtkSource.GutterRenderer.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/GutterRendererState.cs

@@ -0,0 +1,19 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	public enum GutterRendererState {
+
+		Normal,
+		Cursor = 1 << 0,
+		Prelit = 1 << 1,
+		Selected = 1 << 2,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/GutterRendererText.cs

@@ -0,0 +1,155 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class GutterRendererText : GtkSource.GutterRenderer {
+
+		public GutterRendererText (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_gutter_renderer_text_new();
+		static d_gtk_source_gutter_renderer_text_new gtk_source_gutter_renderer_text_new = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_text_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_text_new"));
+
+		public GutterRendererText () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (GutterRendererText)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_gutter_renderer_text_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_gutter_renderer_text_set_markup(IntPtr raw, IntPtr markup, int length);
+		static d_gtk_source_gutter_renderer_text_set_markup gtk_source_gutter_renderer_text_set_markup = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_text_set_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_text_set_markup"));
+
+		[GLib.Property ("markup")]
+		public string Markup {
+			get {
+				GLib.Value val = GetProperty ("markup");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_gutter_renderer_text_set_markup(Handle, native_value, System.Text.Encoding.UTF8.GetByteCount (value));
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_gutter_renderer_text_set_text(IntPtr raw, IntPtr text, int length);
+		static d_gtk_source_gutter_renderer_text_set_text gtk_source_gutter_renderer_text_set_text = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_text_set_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_text_set_text"));
+
+		[GLib.Property ("text")]
+		public string Text {
+			get {
+				GLib.Value val = GetProperty ("text");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_gutter_renderer_text_set_text(Handle, native_value, System.Text.Encoding.UTF8.GetByteCount (value));
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GtkSource.GutterRenderer.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_gutter_renderer_text_get_type();
+		static d_gtk_source_gutter_renderer_text_get_type gtk_source_gutter_renderer_text_get_type = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_text_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_text_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_gutter_renderer_text_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_gutter_renderer_text_measure(IntPtr raw, IntPtr text, out int width, out int height);
+		static d_gtk_source_gutter_renderer_text_measure gtk_source_gutter_renderer_text_measure = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_text_measure>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_text_measure"));
+
+		public void Measure(string text, out int width, out int height) {
+			IntPtr native_text = GLib.Marshaller.StringToPtrGStrdup (text);
+			gtk_source_gutter_renderer_text_measure(Handle, native_text, out width, out height);
+			GLib.Marshaller.Free (native_text);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_gutter_renderer_text_measure_markup(IntPtr raw, IntPtr markup, out int width, out int height);
+		static d_gtk_source_gutter_renderer_text_measure_markup gtk_source_gutter_renderer_text_measure_markup = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_text_measure_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_text_measure_markup"));
+
+		public void MeasureMarkup(string markup, out int width, out int height) {
+			IntPtr native_markup = GLib.Marshaller.StringToPtrGStrdup (markup);
+			gtk_source_gutter_renderer_text_measure_markup(Handle, native_markup, out width, out height);
+			GLib.Marshaller.Free (native_markup);
+		}
+
+
+		static GutterRendererText ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GtkSource.GutterRenderer.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/HighlightUpdatedHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void HighlightUpdatedHandler(object o, HighlightUpdatedArgs args);
+
+	public class HighlightUpdatedArgs : GLib.SignalArgs {
+		public Gtk.TextIter P0{
+			get {
+				return (Gtk.TextIter) Args [0];
+			}
+		}
+
+		public Gtk.TextIter P1{
+			get {
+				return (Gtk.TextIter) Args [1];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ICompletionProposal.cs

@@ -0,0 +1,52 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface ICompletionProposal : GLib.IWrapper {
+
+		event System.EventHandler EmitChanged;
+		void Changed();
+		bool Equal(GtkSource.ICompletionProposal other);
+		GLib.IIcon Gicon { 
+			get;
+		}
+		Gdk.Pixbuf Icon { 
+			get;
+		}
+		string IconName { 
+			get;
+		}
+		string Info { 
+			get;
+		}
+		string Label { 
+			get;
+		}
+		string Markup { 
+			get;
+		}
+		string Text { 
+			get;
+		}
+		uint Hash();
+	}
+
+	[GLib.GInterface (typeof (CompletionProposalAdapter))]
+	public partial interface ICompletionProposalImplementor : GLib.IWrapper {
+
+		string Label { get; }
+		string Markup { get; }
+		string Text { get; }
+		Gdk.Pixbuf Icon { get; }
+		string IconName { get; }
+		GLib.IIcon Gicon { get; }
+		string Info { get; }
+		uint Hash ();
+		bool Equal (GtkSource.ICompletionProposal other);
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ICompletionProvider.cs

@@ -0,0 +1,58 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface ICompletionProvider : GLib.IWrapper {
+
+		bool ActivateProposal(GtkSource.ICompletionProposal proposal, Gtk.TextIter iter);
+		GtkSource.CompletionActivation Activation { 
+			get;
+		}
+		GLib.IIcon Gicon { 
+			get;
+		}
+		Gdk.Pixbuf Icon { 
+			get;
+		}
+		string IconName { 
+			get;
+		}
+		Gtk.Widget GetInfoWidget(GtkSource.ICompletionProposal proposal);
+		int InteractiveDelay { 
+			get;
+		}
+		string Name { 
+			get;
+		}
+		int Priority { 
+			get;
+		}
+		bool GetStartIter(GtkSource.CompletionContext context, GtkSource.ICompletionProposal proposal, Gtk.TextIter iter);
+		bool Match(GtkSource.CompletionContext context);
+		void Populate(GtkSource.CompletionContext context);
+		void UpdateInfo(GtkSource.ICompletionProposal proposal, GtkSource.CompletionInfo info);
+	}
+
+	[GLib.GInterface (typeof (CompletionProviderAdapter))]
+	public partial interface ICompletionProviderImplementor : GLib.IWrapper {
+
+		string Name { get; }
+		Gdk.Pixbuf Icon { get; }
+		string IconName { get; }
+		GLib.IIcon Gicon { get; }
+		void Populate (GtkSource.CompletionContext context);
+		bool Match (GtkSource.CompletionContext context);
+		GtkSource.CompletionActivation Activation { get; }
+		Gtk.Widget GetInfoWidget (GtkSource.ICompletionProposal proposal);
+		void UpdateInfo (GtkSource.ICompletionProposal proposal, GtkSource.CompletionInfo info);
+		bool GetStartIter (GtkSource.CompletionContext context, GtkSource.ICompletionProposal proposal, Gtk.TextIter iter);
+		bool ActivateProposal (GtkSource.ICompletionProposal proposal, Gtk.TextIter iter);
+		int InteractiveDelay { get; }
+		int Priority { get; }
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/IStyleSchemeChooser.cs

@@ -0,0 +1,22 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IStyleSchemeChooser : GLib.IWrapper {
+
+		GtkSource.StyleScheme StyleScheme { 
+			get; set;
+		}
+	}
+
+	[GLib.GInterface (typeof (StyleSchemeChooserAdapter))]
+	public partial interface IStyleSchemeChooserImplementor : GLib.IWrapper {
+
+		GtkSource.StyleScheme StyleScheme { get; set; }
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/IUndoManager.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+#region Autogenerated code
+	public partial interface IUndoManager : GLib.IWrapper {
+
+		event System.EventHandler EmitCanUndoChanged;
+		event System.EventHandler EmitCanRedoChanged;
+		void BeginNotUndoableAction();
+		bool CanRedo();
+		void CanRedoChanged();
+		bool CanUndo();
+		void CanUndoChanged();
+		void EndNotUndoableAction();
+		void Redo();
+		void Undo();
+	}
+
+	[GLib.GInterface (typeof (UndoManagerAdapter))]
+	public partial interface IUndoManagerImplementor : GLib.IWrapper {
+
+		bool CanUndo ();
+		bool CanRedo ();
+		void Undo ();
+		void Redo ();
+		void BeginNotUndoableAction ();
+		void EndNotUndoableAction ();
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/InvalidRegion.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class InvalidRegion : GLib.Opaque {
+
+		public InvalidRegion(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Language.cs

@@ -0,0 +1,213 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Language : GLib.Object {
+
+		public Language (IntPtr raw) : base(raw) {}
+
+		protected Language() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_get_id(IntPtr raw);
+		static d_gtk_source_language_get_id gtk_source_language_get_id = FuncLoader.LoadFunction<d_gtk_source_language_get_id>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_id"));
+
+		[GLib.Property ("id")]
+		public string Id {
+			get  {
+				IntPtr raw_ret = gtk_source_language_get_id(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_get_name(IntPtr raw);
+		static d_gtk_source_language_get_name gtk_source_language_get_name = FuncLoader.LoadFunction<d_gtk_source_language_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_name"));
+
+		[GLib.Property ("name")]
+		public string Name {
+			get  {
+				IntPtr raw_ret = gtk_source_language_get_name(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_get_section(IntPtr raw);
+		static d_gtk_source_language_get_section gtk_source_language_get_section = FuncLoader.LoadFunction<d_gtk_source_language_get_section>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_section"));
+
+		[GLib.Property ("section")]
+		public string Section {
+			get  {
+				IntPtr raw_ret = gtk_source_language_get_section(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_language_get_hidden(IntPtr raw);
+		static d_gtk_source_language_get_hidden gtk_source_language_get_hidden = FuncLoader.LoadFunction<d_gtk_source_language_get_hidden>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_hidden"));
+
+		[GLib.Property ("hidden")]
+		public bool Hidden {
+			get  {
+				bool raw_ret = gtk_source_language_get_hidden(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_get_globs(IntPtr raw);
+		static d_gtk_source_language_get_globs gtk_source_language_get_globs = FuncLoader.LoadFunction<d_gtk_source_language_get_globs>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_globs"));
+
+		public string[] Globs { 
+			get {
+				IntPtr raw_ret = gtk_source_language_get_globs(Handle);
+				string[] ret = GLib.Marshaller.NullTermPtrToStringArray (raw_ret, true);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_get_metadata(IntPtr raw, IntPtr name);
+		static d_gtk_source_language_get_metadata gtk_source_language_get_metadata = FuncLoader.LoadFunction<d_gtk_source_language_get_metadata>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_metadata"));
+
+		public string GetMetadata(string name) {
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			IntPtr raw_ret = gtk_source_language_get_metadata(Handle, native_name);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			GLib.Marshaller.Free (native_name);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_get_mime_types(IntPtr raw);
+		static d_gtk_source_language_get_mime_types gtk_source_language_get_mime_types = FuncLoader.LoadFunction<d_gtk_source_language_get_mime_types>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_mime_types"));
+
+		public string MimeTypes { 
+			get {
+				IntPtr raw_ret = gtk_source_language_get_mime_types(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_get_style_fallback(IntPtr raw, IntPtr style_id);
+		static d_gtk_source_language_get_style_fallback gtk_source_language_get_style_fallback = FuncLoader.LoadFunction<d_gtk_source_language_get_style_fallback>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_style_fallback"));
+
+		public string GetStyleFallback(string style_id) {
+			IntPtr native_style_id = GLib.Marshaller.StringToPtrGStrdup (style_id);
+			IntPtr raw_ret = gtk_source_language_get_style_fallback(Handle, native_style_id);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			GLib.Marshaller.Free (native_style_id);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_get_style_ids(IntPtr raw);
+		static d_gtk_source_language_get_style_ids gtk_source_language_get_style_ids = FuncLoader.LoadFunction<d_gtk_source_language_get_style_ids>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_style_ids"));
+
+		public string StyleIds { 
+			get {
+				IntPtr raw_ret = gtk_source_language_get_style_ids(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_get_style_name(IntPtr raw, IntPtr style_id);
+		static d_gtk_source_language_get_style_name gtk_source_language_get_style_name = FuncLoader.LoadFunction<d_gtk_source_language_get_style_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_style_name"));
+
+		public string GetStyleName(string style_id) {
+			IntPtr native_style_id = GLib.Marshaller.StringToPtrGStrdup (style_id);
+			IntPtr raw_ret = gtk_source_language_get_style_name(Handle, native_style_id);
+			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+			GLib.Marshaller.Free (native_style_id);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_get_type();
+		static d_gtk_source_language_get_type gtk_source_language_get_type = FuncLoader.LoadFunction<d_gtk_source_language_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_language_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static Language ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/LanguageManager.cs

@@ -0,0 +1,168 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class LanguageManager : GLib.Object {
+
+		public LanguageManager (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_manager_new();
+		static d_gtk_source_language_manager_new gtk_source_language_manager_new = FuncLoader.LoadFunction<d_gtk_source_language_manager_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_manager_new"));
+
+		public LanguageManager () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (LanguageManager)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_language_manager_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_manager_get_search_path(IntPtr raw);
+		static d_gtk_source_language_manager_get_search_path gtk_source_language_manager_get_search_path = FuncLoader.LoadFunction<d_gtk_source_language_manager_get_search_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_manager_get_search_path"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_language_manager_set_search_path(IntPtr raw, IntPtr dirs);
+		static d_gtk_source_language_manager_set_search_path gtk_source_language_manager_set_search_path = FuncLoader.LoadFunction<d_gtk_source_language_manager_set_search_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_manager_set_search_path"));
+
+		[GLib.Property ("search-path")]
+		public string SearchPath {
+			get  {
+				IntPtr raw_ret = gtk_source_language_manager_get_search_path(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+			set  {
+				gtk_source_language_manager_set_search_path(Handle, GLib.Marshaller.StringToPtrGStrdup(value));
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_manager_get_language_ids(IntPtr raw);
+		static d_gtk_source_language_manager_get_language_ids gtk_source_language_manager_get_language_ids = FuncLoader.LoadFunction<d_gtk_source_language_manager_get_language_ids>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_manager_get_language_ids"));
+
+		[GLib.Property ("language-ids")]
+		public string[] LanguageIds {
+			get  {
+				IntPtr raw_ret = gtk_source_language_manager_get_language_ids(Handle);
+				string[] ret = GLib.Marshaller.NullTermPtrToStringArray (raw_ret, true);
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_manager_get_default();
+		static d_gtk_source_language_manager_get_default gtk_source_language_manager_get_default = FuncLoader.LoadFunction<d_gtk_source_language_manager_get_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_manager_get_default"));
+
+		public static GtkSource.LanguageManager Default { 
+			get {
+				IntPtr raw_ret = gtk_source_language_manager_get_default();
+				GtkSource.LanguageManager ret = GLib.Object.GetObject(raw_ret) as GtkSource.LanguageManager;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_manager_get_language(IntPtr raw, IntPtr id);
+		static d_gtk_source_language_manager_get_language gtk_source_language_manager_get_language = FuncLoader.LoadFunction<d_gtk_source_language_manager_get_language>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_manager_get_language"));
+
+		public GtkSource.Language GetLanguage(string id) {
+			IntPtr native_id = GLib.Marshaller.StringToPtrGStrdup (id);
+			IntPtr raw_ret = gtk_source_language_manager_get_language(Handle, native_id);
+			GtkSource.Language ret = GLib.Object.GetObject(raw_ret) as GtkSource.Language;
+			GLib.Marshaller.Free (native_id);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_manager_get_type();
+		static d_gtk_source_language_manager_get_type gtk_source_language_manager_get_type = FuncLoader.LoadFunction<d_gtk_source_language_manager_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_manager_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_language_manager_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_language_manager_guess_language(IntPtr raw, IntPtr filename, IntPtr content_type);
+		static d_gtk_source_language_manager_guess_language gtk_source_language_manager_guess_language = FuncLoader.LoadFunction<d_gtk_source_language_manager_guess_language>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_language_manager_guess_language"));
+
+		public GtkSource.Language GuessLanguage(string filename, string content_type) {
+			IntPtr native_filename = GLib.Marshaller.StringToPtrGStrdup (filename);
+			IntPtr native_content_type = GLib.Marshaller.StringToPtrGStrdup (content_type);
+			IntPtr raw_ret = gtk_source_language_manager_guess_language(Handle, native_filename, native_content_type);
+			GtkSource.Language ret = GLib.Object.GetObject(raw_ret) as GtkSource.Language;
+			GLib.Marshaller.Free (native_filename);
+			GLib.Marshaller.Free (native_content_type);
+			return ret;
+		}
+
+
+		static LanguageManager ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/LineInfo.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class LineInfo : GLib.Opaque {
+
+		public LineInfo(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/LineMarkActivatedHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void LineMarkActivatedHandler(object o, LineMarkActivatedArgs args);
+
+	public class LineMarkActivatedArgs : GLib.SignalArgs {
+		public Gtk.TextIter Iter{
+			get {
+				return (Gtk.TextIter) Args [0];
+			}
+		}
+
+		public Gdk.Event Event{
+			get {
+				return (Gdk.Event) Args [1];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/LinesInfo.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class LinesInfo : GLib.Opaque {
+
+		public LinesInfo(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Map.cs

@@ -0,0 +1,123 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Map : GtkSource.SourceView {
+
+		public Map (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_map_new();
+		static d_gtk_source_map_new gtk_source_map_new = FuncLoader.LoadFunction<d_gtk_source_map_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_map_new"));
+
+		public Map () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Map)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_map_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_map_get_view(IntPtr raw);
+		static d_gtk_source_map_get_view gtk_source_map_get_view = FuncLoader.LoadFunction<d_gtk_source_map_get_view>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_map_get_view"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_map_set_view(IntPtr raw, IntPtr view);
+		static d_gtk_source_map_set_view gtk_source_map_set_view = FuncLoader.LoadFunction<d_gtk_source_map_set_view>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_map_set_view"));
+
+		[GLib.Property ("view")]
+		public GtkSource.SourceView View {
+			get  {
+				IntPtr raw_ret = gtk_source_map_get_view(Handle);
+				GtkSource.SourceView ret = GLib.Object.GetObject(raw_ret) as GtkSource.SourceView;
+				return ret;
+			}
+			set  {
+				gtk_source_map_set_view(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[GLib.Property ("font-desc")]
+		public Pango.FontDescription FontDesc {
+			get {
+				GLib.Value val = GetProperty ("font-desc");
+				Pango.FontDescription ret = (Pango.FontDescription) val;
+				val.Dispose ();
+				return ret;
+			}
+			set {
+				GLib.Value val = new GLib.Value(value, "PangoFontDescription");
+				SetProperty("font-desc", val);
+				val.Dispose ();
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GtkSource.SourceView.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_map_get_type();
+		static d_gtk_source_map_get_type gtk_source_map_get_type = FuncLoader.LoadFunction<d_gtk_source_map_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_map_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_map_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static Map ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (GtkSource.SourceView.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Mark.cs

@@ -0,0 +1,144 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Mark : Gtk.TextMark {
+
+		public Mark (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_new(IntPtr name, IntPtr category);
+		static d_gtk_source_mark_new gtk_source_mark_new = FuncLoader.LoadFunction<d_gtk_source_mark_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_new"));
+
+		public Mark (string name, string category) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (Mark)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				names.Add ("name");
+				vals.Add (new GLib.Value (name));
+				names.Add ("category");
+				vals.Add (new GLib.Value (category));
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
+			IntPtr native_category = GLib.Marshaller.StringToPtrGStrdup (category);
+			Raw = gtk_source_mark_new(native_name, native_category);
+			GLib.Marshaller.Free (native_name);
+			GLib.Marshaller.Free (native_category);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_get_category(IntPtr raw);
+		static d_gtk_source_mark_get_category gtk_source_mark_get_category = FuncLoader.LoadFunction<d_gtk_source_mark_get_category>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_get_category"));
+
+		[GLib.Property ("category")]
+		public string Category {
+			get  {
+				IntPtr raw_ret = gtk_source_mark_get_category(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, Gtk.TextMark.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_get_type();
+		static d_gtk_source_mark_get_type gtk_source_mark_get_type = FuncLoader.LoadFunction<d_gtk_source_mark_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_mark_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_next(IntPtr raw, IntPtr category);
+		static d_gtk_source_mark_next gtk_source_mark_next = FuncLoader.LoadFunction<d_gtk_source_mark_next>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_next"));
+
+		public GtkSource.Mark Next(string category) {
+			IntPtr native_category = GLib.Marshaller.StringToPtrGStrdup (category);
+			IntPtr raw_ret = gtk_source_mark_next(Handle, native_category);
+			GtkSource.Mark ret = GLib.Object.GetObject(raw_ret) as GtkSource.Mark;
+			GLib.Marshaller.Free (native_category);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_prev(IntPtr raw, IntPtr category);
+		static d_gtk_source_mark_prev gtk_source_mark_prev = FuncLoader.LoadFunction<d_gtk_source_mark_prev>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_prev"));
+
+		public GtkSource.Mark Prev(string category) {
+			IntPtr native_category = GLib.Marshaller.StringToPtrGStrdup (category);
+			IntPtr raw_ret = gtk_source_mark_prev(Handle, native_category);
+			GtkSource.Mark ret = GLib.Object.GetObject(raw_ret) as GtkSource.Mark;
+			GLib.Marshaller.Free (native_category);
+			return ret;
+		}
+
+
+		static Mark ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, Gtk.TextMark.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/MarkAttributes.cs

@@ -0,0 +1,356 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class MarkAttributes : GLib.Object {
+
+		public MarkAttributes (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_attributes_new();
+		static d_gtk_source_mark_attributes_new gtk_source_mark_attributes_new = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_new"));
+
+		public MarkAttributes () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (MarkAttributes)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_mark_attributes_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_mark_attributes_set_background(IntPtr raw, IntPtr value);
+		static d_gtk_source_mark_attributes_set_background gtk_source_mark_attributes_set_background = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_set_background>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_set_background"));
+
+		[GLib.Property ("background")]
+		public Gdk.RGBA Background {
+			get {
+				GLib.Value val = GetProperty ("background");
+				Gdk.RGBA ret = (Gdk.RGBA) val;
+				val.Dispose ();
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
+				gtk_source_mark_attributes_set_background(Handle, native_value);
+				Marshal.FreeHGlobal (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_attributes_get_pixbuf(IntPtr raw);
+		static d_gtk_source_mark_attributes_get_pixbuf gtk_source_mark_attributes_get_pixbuf = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_get_pixbuf>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_get_pixbuf"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_mark_attributes_set_pixbuf(IntPtr raw, IntPtr pixbuf);
+		static d_gtk_source_mark_attributes_set_pixbuf gtk_source_mark_attributes_set_pixbuf = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_set_pixbuf>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_set_pixbuf"));
+
+		[GLib.Property ("pixbuf")]
+		public Gdk.Pixbuf Pixbuf {
+			get  {
+				IntPtr raw_ret = gtk_source_mark_attributes_get_pixbuf(Handle);
+				Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
+				return ret;
+			}
+			set  {
+				gtk_source_mark_attributes_set_pixbuf(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_attributes_get_icon_name(IntPtr raw);
+		static d_gtk_source_mark_attributes_get_icon_name gtk_source_mark_attributes_get_icon_name = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_get_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_get_icon_name"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_mark_attributes_set_icon_name(IntPtr raw, IntPtr icon_name);
+		static d_gtk_source_mark_attributes_set_icon_name gtk_source_mark_attributes_set_icon_name = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_set_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_set_icon_name"));
+
+		[GLib.Property ("icon-name")]
+		public string IconName {
+			get  {
+				IntPtr raw_ret = gtk_source_mark_attributes_get_icon_name(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_mark_attributes_set_icon_name(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_attributes_get_gicon(IntPtr raw);
+		static d_gtk_source_mark_attributes_get_gicon gtk_source_mark_attributes_get_gicon = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_get_gicon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_get_gicon"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_mark_attributes_set_gicon(IntPtr raw, IntPtr gicon);
+		static d_gtk_source_mark_attributes_set_gicon gtk_source_mark_attributes_set_gicon = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_set_gicon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_set_gicon"));
+
+		[GLib.Property ("gicon")]
+		public GLib.IIcon Gicon {
+			get  {
+				IntPtr raw_ret = gtk_source_mark_attributes_get_gicon(Handle);
+				GLib.IIcon ret = GLib.IconAdapter.GetObject (raw_ret, false);
+				return ret;
+			}
+			set  {
+				gtk_source_mark_attributes_set_gicon(Handle, value == null ? IntPtr.Zero : ((value is GLib.Object) ? (value as GLib.Object).Handle : (value as GLib.IconAdapter).Handle));
+			}
+		}
+
+		[GLib.Signal("query-tooltip-text")]
+		public event GtkSource.QueryTooltipTextHandler QueryTooltipText {
+			add {
+				this.AddSignalHandler ("query-tooltip-text", value, typeof (GtkSource.QueryTooltipTextArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("query-tooltip-text", value);
+			}
+		}
+
+		[GLib.Signal("query-tooltip-markup")]
+		public event GtkSource.QueryTooltipMarkupHandler QueryTooltipMarkup {
+			add {
+				this.AddSignalHandler ("query-tooltip-markup", value, typeof (GtkSource.QueryTooltipMarkupArgs));
+			}
+			remove {
+				this.RemoveSignalHandler ("query-tooltip-markup", value);
+			}
+		}
+
+		static QueryTooltipTextNativeDelegate QueryTooltipText_cb_delegate;
+		static QueryTooltipTextNativeDelegate QueryTooltipTextVMCallback {
+			get {
+				if (QueryTooltipText_cb_delegate == null)
+					QueryTooltipText_cb_delegate = new QueryTooltipTextNativeDelegate (QueryTooltipText_cb);
+				return QueryTooltipText_cb_delegate;
+			}
+		}
+
+		static void OverrideQueryTooltipText (GLib.GType gtype)
+		{
+			OverrideQueryTooltipText (gtype, QueryTooltipTextVMCallback);
+		}
+
+		static void OverrideQueryTooltipText (GLib.GType gtype, QueryTooltipTextNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "query-tooltip-text", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr QueryTooltipTextNativeDelegate (IntPtr inst, IntPtr p0);
+
+		static IntPtr QueryTooltipText_cb (IntPtr inst, IntPtr p0)
+		{
+			try {
+				MarkAttributes __obj = GLib.Object.GetObject (inst, false) as MarkAttributes;
+				string __result;
+				__result = __obj.OnQueryTooltipText (GLib.Object.GetObject(p0) as GtkSource.Mark);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.MarkAttributes), ConnectionMethod="OverrideQueryTooltipText")]
+		protected virtual string OnQueryTooltipText (GtkSource.Mark p0)
+		{
+			return InternalQueryTooltipText (p0);
+		}
+
+		private string InternalQueryTooltipText (GtkSource.Mark p0)
+		{
+			GLib.Value ret = new GLib.Value (GLib.GType.String);
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+			GLib.Value[] vals = new GLib.Value [2];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			vals [1] = new GLib.Value (p0);
+			inst_and_params.Append (vals [1]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+			string result = (string) ret;
+			ret.Dispose ();
+			return result;
+		}
+
+		static QueryTooltipMarkupNativeDelegate QueryTooltipMarkup_cb_delegate;
+		static QueryTooltipMarkupNativeDelegate QueryTooltipMarkupVMCallback {
+			get {
+				if (QueryTooltipMarkup_cb_delegate == null)
+					QueryTooltipMarkup_cb_delegate = new QueryTooltipMarkupNativeDelegate (QueryTooltipMarkup_cb);
+				return QueryTooltipMarkup_cb_delegate;
+			}
+		}
+
+		static void OverrideQueryTooltipMarkup (GLib.GType gtype)
+		{
+			OverrideQueryTooltipMarkup (gtype, QueryTooltipMarkupVMCallback);
+		}
+
+		static void OverrideQueryTooltipMarkup (GLib.GType gtype, QueryTooltipMarkupNativeDelegate callback)
+		{
+			OverrideVirtualMethod (gtype, "query-tooltip-markup", callback);
+		}
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr QueryTooltipMarkupNativeDelegate (IntPtr inst, IntPtr p0);
+
+		static IntPtr QueryTooltipMarkup_cb (IntPtr inst, IntPtr p0)
+		{
+			try {
+				MarkAttributes __obj = GLib.Object.GetObject (inst, false) as MarkAttributes;
+				string __result;
+				__result = __obj.OnQueryTooltipMarkup (GLib.Object.GetObject(p0) as GtkSource.Mark);
+				return GLib.Marshaller.StringToPtrGStrdup(__result);
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.MarkAttributes), ConnectionMethod="OverrideQueryTooltipMarkup")]
+		protected virtual string OnQueryTooltipMarkup (GtkSource.Mark p0)
+		{
+			return InternalQueryTooltipMarkup (p0);
+		}
+
+		private string InternalQueryTooltipMarkup (GtkSource.Mark p0)
+		{
+			GLib.Value ret = new GLib.Value (GLib.GType.String);
+			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
+			GLib.Value[] vals = new GLib.Value [2];
+			vals [0] = new GLib.Value (this);
+			inst_and_params.Append (vals [0]);
+			vals [1] = new GLib.Value (p0);
+			inst_and_params.Append (vals [1]);
+			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
+			foreach (GLib.Value v in vals)
+				v.Dispose ();
+			string result = (string) ret;
+			ret.Dispose ();
+			return result;
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_mark_attributes_get_background(IntPtr raw, IntPtr background);
+		static d_gtk_source_mark_attributes_get_background gtk_source_mark_attributes_get_background = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_get_background>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_get_background"));
+
+		public bool GetBackground(Gdk.RGBA background) {
+			IntPtr native_background = GLib.Marshaller.StructureToPtrAlloc (background);
+			bool raw_ret = gtk_source_mark_attributes_get_background(Handle, native_background);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_background);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_attributes_get_tooltip_markup(IntPtr raw, IntPtr mark);
+		static d_gtk_source_mark_attributes_get_tooltip_markup gtk_source_mark_attributes_get_tooltip_markup = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_get_tooltip_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_get_tooltip_markup"));
+
+		public string GetTooltipMarkup(GtkSource.Mark mark) {
+			IntPtr raw_ret = gtk_source_mark_attributes_get_tooltip_markup(Handle, mark == null ? IntPtr.Zero : mark.Handle);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_attributes_get_tooltip_text(IntPtr raw, IntPtr mark);
+		static d_gtk_source_mark_attributes_get_tooltip_text gtk_source_mark_attributes_get_tooltip_text = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_get_tooltip_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_get_tooltip_text"));
+
+		public string GetTooltipText(GtkSource.Mark mark) {
+			IntPtr raw_ret = gtk_source_mark_attributes_get_tooltip_text(Handle, mark == null ? IntPtr.Zero : mark.Handle);
+			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_attributes_get_type();
+		static d_gtk_source_mark_attributes_get_type gtk_source_mark_attributes_get_type = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_mark_attributes_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_mark_attributes_render_icon(IntPtr raw, IntPtr widget, int size);
+		static d_gtk_source_mark_attributes_render_icon gtk_source_mark_attributes_render_icon = FuncLoader.LoadFunction<d_gtk_source_mark_attributes_render_icon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_mark_attributes_render_icon"));
+
+		public Gdk.Pixbuf RenderIcon(Gtk.Widget widget, int size) {
+			IntPtr raw_ret = gtk_source_mark_attributes_render_icon(Handle, widget == null ? IntPtr.Zero : widget.Handle, size);
+			Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
+			return ret;
+		}
+
+
+		static MarkAttributes ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/MarkCategory.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class MarkCategory : GLib.Opaque {
+
+		public MarkCategory(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/MountOperationFactory.cs

@@ -0,0 +1,10 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate GLib.MountOperation MountOperationFactory(GtkSource.File file);
+
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/MoveCursorHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void MoveCursorHandler(object o, MoveCursorArgs args);
+
+	public class MoveCursorArgs : GLib.SignalArgs {
+		public Gtk.ScrollStep Step{
+			get {
+				return (Gtk.ScrollStep) Args [0];
+			}
+		}
+
+		public int Num{
+			get {
+				return (int) Args [1];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/MoveLinesHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void MoveLinesHandler(object o, MoveLinesArgs args);
+
+	public class MoveLinesArgs : GLib.SignalArgs {
+		public bool Down{
+			get {
+				return (bool) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/MovePageHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void MovePageHandler(object o, MovePageArgs args);
+
+	public class MovePageArgs : GLib.SignalArgs {
+		public Gtk.ScrollStep Step{
+			get {
+				return (Gtk.ScrollStep) Args [0];
+			}
+		}
+
+		public int Num{
+			get {
+				return (int) Args [1];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/MoveToMatchingBracketHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void MoveToMatchingBracketHandler(object o, MoveToMatchingBracketArgs args);
+
+	public class MoveToMatchingBracketArgs : GLib.SignalArgs {
+		public bool P0{
+			get {
+				return (bool) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/MoveWordsHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void MoveWordsHandler(object o, MoveWordsArgs args);
+
+	public class MoveWordsArgs : GLib.SignalArgs {
+		public int Step{
+			get {
+				return (int) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/NewlineType.cs

@@ -0,0 +1,17 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum NewlineType {
+
+		Lf,
+		Cr,
+		CrLf,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/ParserState.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class ParserState : GLib.Opaque {
+
+		public ParserState(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/PopulateContextHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void PopulateContextHandler(object o, PopulateContextArgs args);
+
+	public class PopulateContextArgs : GLib.SignalArgs {
+		public GtkSource.CompletionContext Context{
+			get {
+				return (GtkSource.CompletionContext) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/PrintCompositor.cs

@@ -0,0 +1,482 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class PrintCompositor : GLib.Object {
+
+		public PrintCompositor (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_print_compositor_new(IntPtr buffer);
+		static d_gtk_source_print_compositor_new gtk_source_print_compositor_new = FuncLoader.LoadFunction<d_gtk_source_print_compositor_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_new"));
+
+		public PrintCompositor (GtkSource.Buffer buffer) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (PrintCompositor)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (buffer != null) {
+					names.Add ("buffer");
+					vals.Add (new GLib.Value (buffer));
+				}
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gtk_source_print_compositor_new(buffer == null ? IntPtr.Zero : buffer.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_print_compositor_new_from_view(IntPtr view);
+		static d_gtk_source_print_compositor_new_from_view gtk_source_print_compositor_new_from_view = FuncLoader.LoadFunction<d_gtk_source_print_compositor_new_from_view>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_new_from_view"));
+
+		public PrintCompositor (GtkSource.SourceView view) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (PrintCompositor)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gtk_source_print_compositor_new_from_view(view == null ? IntPtr.Zero : view.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_print_compositor_get_buffer(IntPtr raw);
+		static d_gtk_source_print_compositor_get_buffer gtk_source_print_compositor_get_buffer = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_buffer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_buffer"));
+
+		[GLib.Property ("buffer")]
+		public GtkSource.Buffer Buffer {
+			get  {
+				IntPtr raw_ret = gtk_source_print_compositor_get_buffer(Handle);
+				GtkSource.Buffer ret = GLib.Object.GetObject(raw_ret) as GtkSource.Buffer;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gtk_source_print_compositor_get_tab_width(IntPtr raw);
+		static d_gtk_source_print_compositor_get_tab_width gtk_source_print_compositor_get_tab_width = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_tab_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_tab_width"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_tab_width(IntPtr raw, uint width);
+		static d_gtk_source_print_compositor_set_tab_width gtk_source_print_compositor_set_tab_width = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_tab_width>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_tab_width"));
+
+		[GLib.Property ("tab-width")]
+		public uint TabWidth {
+			get  {
+				uint raw_ret = gtk_source_print_compositor_get_tab_width(Handle);
+				uint ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_print_compositor_set_tab_width(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_print_compositor_get_wrap_mode(IntPtr raw);
+		static d_gtk_source_print_compositor_get_wrap_mode gtk_source_print_compositor_get_wrap_mode = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_wrap_mode>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_wrap_mode"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_wrap_mode(IntPtr raw, int wrap_mode);
+		static d_gtk_source_print_compositor_set_wrap_mode gtk_source_print_compositor_set_wrap_mode = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_wrap_mode>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_wrap_mode"));
+
+		[GLib.Property ("wrap-mode")]
+		public Gtk.WrapMode WrapMode {
+			get  {
+				int raw_ret = gtk_source_print_compositor_get_wrap_mode(Handle);
+				Gtk.WrapMode ret = (Gtk.WrapMode) raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_print_compositor_set_wrap_mode(Handle, (int) value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_print_compositor_get_highlight_syntax(IntPtr raw);
+		static d_gtk_source_print_compositor_get_highlight_syntax gtk_source_print_compositor_get_highlight_syntax = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_highlight_syntax>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_highlight_syntax"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_highlight_syntax(IntPtr raw, bool highlight);
+		static d_gtk_source_print_compositor_set_highlight_syntax gtk_source_print_compositor_set_highlight_syntax = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_highlight_syntax>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_highlight_syntax"));
+
+		[GLib.Property ("highlight-syntax")]
+		public bool HighlightSyntax {
+			get  {
+				bool raw_ret = gtk_source_print_compositor_get_highlight_syntax(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_print_compositor_set_highlight_syntax(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gtk_source_print_compositor_get_print_line_numbers(IntPtr raw);
+		static d_gtk_source_print_compositor_get_print_line_numbers gtk_source_print_compositor_get_print_line_numbers = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_print_line_numbers>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_print_line_numbers"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_print_line_numbers(IntPtr raw, uint interval);
+		static d_gtk_source_print_compositor_set_print_line_numbers gtk_source_print_compositor_set_print_line_numbers = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_print_line_numbers>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_print_line_numbers"));
+
+		[GLib.Property ("print-line-numbers")]
+		public uint PrintLineNumbers {
+			get  {
+				uint raw_ret = gtk_source_print_compositor_get_print_line_numbers(Handle);
+				uint ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_print_compositor_set_print_line_numbers(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_print_compositor_get_print_header(IntPtr raw);
+		static d_gtk_source_print_compositor_get_print_header gtk_source_print_compositor_get_print_header = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_print_header>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_print_header"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_print_header(IntPtr raw, bool print);
+		static d_gtk_source_print_compositor_set_print_header gtk_source_print_compositor_set_print_header = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_print_header>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_print_header"));
+
+		[GLib.Property ("print-header")]
+		public bool PrintHeader {
+			get  {
+				bool raw_ret = gtk_source_print_compositor_get_print_header(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_print_compositor_set_print_header(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_print_compositor_get_print_footer(IntPtr raw);
+		static d_gtk_source_print_compositor_get_print_footer gtk_source_print_compositor_get_print_footer = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_print_footer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_print_footer"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_print_footer(IntPtr raw, bool print);
+		static d_gtk_source_print_compositor_set_print_footer gtk_source_print_compositor_set_print_footer = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_print_footer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_print_footer"));
+
+		[GLib.Property ("print-footer")]
+		public bool PrintFooter {
+			get  {
+				bool raw_ret = gtk_source_print_compositor_get_print_footer(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_print_compositor_set_print_footer(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_print_compositor_get_body_font_name(IntPtr raw);
+		static d_gtk_source_print_compositor_get_body_font_name gtk_source_print_compositor_get_body_font_name = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_body_font_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_body_font_name"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_body_font_name(IntPtr raw, IntPtr font_name);
+		static d_gtk_source_print_compositor_set_body_font_name gtk_source_print_compositor_set_body_font_name = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_body_font_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_body_font_name"));
+
+		[GLib.Property ("body-font-name")]
+		public string BodyFontName {
+			get  {
+				IntPtr raw_ret = gtk_source_print_compositor_get_body_font_name(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_print_compositor_set_body_font_name(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_print_compositor_get_line_numbers_font_name(IntPtr raw);
+		static d_gtk_source_print_compositor_get_line_numbers_font_name gtk_source_print_compositor_get_line_numbers_font_name = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_line_numbers_font_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_line_numbers_font_name"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_line_numbers_font_name(IntPtr raw, IntPtr font_name);
+		static d_gtk_source_print_compositor_set_line_numbers_font_name gtk_source_print_compositor_set_line_numbers_font_name = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_line_numbers_font_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_line_numbers_font_name"));
+
+		[GLib.Property ("line-numbers-font-name")]
+		public string LineNumbersFontName {
+			get  {
+				IntPtr raw_ret = gtk_source_print_compositor_get_line_numbers_font_name(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_print_compositor_set_line_numbers_font_name(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_print_compositor_get_header_font_name(IntPtr raw);
+		static d_gtk_source_print_compositor_get_header_font_name gtk_source_print_compositor_get_header_font_name = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_header_font_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_header_font_name"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_header_font_name(IntPtr raw, IntPtr font_name);
+		static d_gtk_source_print_compositor_set_header_font_name gtk_source_print_compositor_set_header_font_name = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_header_font_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_header_font_name"));
+
+		[GLib.Property ("header-font-name")]
+		public string HeaderFontName {
+			get  {
+				IntPtr raw_ret = gtk_source_print_compositor_get_header_font_name(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_print_compositor_set_header_font_name(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_print_compositor_get_footer_font_name(IntPtr raw);
+		static d_gtk_source_print_compositor_get_footer_font_name gtk_source_print_compositor_get_footer_font_name = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_footer_font_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_footer_font_name"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_footer_font_name(IntPtr raw, IntPtr font_name);
+		static d_gtk_source_print_compositor_set_footer_font_name gtk_source_print_compositor_set_footer_font_name = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_footer_font_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_footer_font_name"));
+
+		[GLib.Property ("footer-font-name")]
+		public string FooterFontName {
+			get  {
+				IntPtr raw_ret = gtk_source_print_compositor_get_footer_font_name(Handle);
+				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_print_compositor_set_footer_font_name(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_print_compositor_get_n_pages(IntPtr raw);
+		static d_gtk_source_print_compositor_get_n_pages gtk_source_print_compositor_get_n_pages = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_n_pages>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_n_pages"));
+
+		[GLib.Property ("n-pages")]
+		public int NPages {
+			get  {
+				int raw_ret = gtk_source_print_compositor_get_n_pages(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_draw_page(IntPtr raw, IntPtr context, int page_nr);
+		static d_gtk_source_print_compositor_draw_page gtk_source_print_compositor_draw_page = FuncLoader.LoadFunction<d_gtk_source_print_compositor_draw_page>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_draw_page"));
+
+		public void DrawPage(Gtk.PrintContext context, int page_nr) {
+			gtk_source_print_compositor_draw_page(Handle, context == null ? IntPtr.Zero : context.Handle, page_nr);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_gtk_source_print_compositor_get_bottom_margin(IntPtr raw, int unit);
+		static d_gtk_source_print_compositor_get_bottom_margin gtk_source_print_compositor_get_bottom_margin = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_bottom_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_bottom_margin"));
+
+		public double GetBottomMargin(Gtk.Unit unit) {
+			double raw_ret = gtk_source_print_compositor_get_bottom_margin(Handle, (int) unit);
+			double ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_gtk_source_print_compositor_get_left_margin(IntPtr raw, int unit);
+		static d_gtk_source_print_compositor_get_left_margin gtk_source_print_compositor_get_left_margin = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_left_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_left_margin"));
+
+		public double GetLeftMargin(Gtk.Unit unit) {
+			double raw_ret = gtk_source_print_compositor_get_left_margin(Handle, (int) unit);
+			double ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_gtk_source_print_compositor_get_pagination_progress(IntPtr raw);
+		static d_gtk_source_print_compositor_get_pagination_progress gtk_source_print_compositor_get_pagination_progress = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_pagination_progress>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_pagination_progress"));
+
+		public double PaginationProgress { 
+			get {
+				double raw_ret = gtk_source_print_compositor_get_pagination_progress(Handle);
+				double ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_gtk_source_print_compositor_get_right_margin(IntPtr raw, int unit);
+		static d_gtk_source_print_compositor_get_right_margin gtk_source_print_compositor_get_right_margin = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_right_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_right_margin"));
+
+		public double GetRightMargin(Gtk.Unit unit) {
+			double raw_ret = gtk_source_print_compositor_get_right_margin(Handle, (int) unit);
+			double ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate double d_gtk_source_print_compositor_get_top_margin(IntPtr raw, int unit);
+		static d_gtk_source_print_compositor_get_top_margin gtk_source_print_compositor_get_top_margin = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_top_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_top_margin"));
+
+		public double GetTopMargin(Gtk.Unit unit) {
+			double raw_ret = gtk_source_print_compositor_get_top_margin(Handle, (int) unit);
+			double ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_print_compositor_get_type();
+		static d_gtk_source_print_compositor_get_type gtk_source_print_compositor_get_type = FuncLoader.LoadFunction<d_gtk_source_print_compositor_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_print_compositor_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_print_compositor_paginate(IntPtr raw, IntPtr context);
+		static d_gtk_source_print_compositor_paginate gtk_source_print_compositor_paginate = FuncLoader.LoadFunction<d_gtk_source_print_compositor_paginate>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_paginate"));
+
+		public bool Paginate(Gtk.PrintContext context) {
+			bool raw_ret = gtk_source_print_compositor_paginate(Handle, context == null ? IntPtr.Zero : context.Handle);
+			bool ret = raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_bottom_margin(IntPtr raw, double margin, int unit);
+		static d_gtk_source_print_compositor_set_bottom_margin gtk_source_print_compositor_set_bottom_margin = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_bottom_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_bottom_margin"));
+
+		public void SetBottomMargin(double margin, Gtk.Unit unit) {
+			gtk_source_print_compositor_set_bottom_margin(Handle, margin, (int) unit);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_footer_format(IntPtr raw, bool separator, IntPtr left, IntPtr center, IntPtr right);
+		static d_gtk_source_print_compositor_set_footer_format gtk_source_print_compositor_set_footer_format = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_footer_format>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_footer_format"));
+
+		public void SetFooterFormat(bool separator, string left, string center, string right) {
+			IntPtr native_left = GLib.Marshaller.StringToPtrGStrdup (left);
+			IntPtr native_center = GLib.Marshaller.StringToPtrGStrdup (center);
+			IntPtr native_right = GLib.Marshaller.StringToPtrGStrdup (right);
+			gtk_source_print_compositor_set_footer_format(Handle, separator, native_left, native_center, native_right);
+			GLib.Marshaller.Free (native_left);
+			GLib.Marshaller.Free (native_center);
+			GLib.Marshaller.Free (native_right);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_header_format(IntPtr raw, bool separator, IntPtr left, IntPtr center, IntPtr right);
+		static d_gtk_source_print_compositor_set_header_format gtk_source_print_compositor_set_header_format = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_header_format>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_header_format"));
+
+		public void SetHeaderFormat(bool separator, string left, string center, string right) {
+			IntPtr native_left = GLib.Marshaller.StringToPtrGStrdup (left);
+			IntPtr native_center = GLib.Marshaller.StringToPtrGStrdup (center);
+			IntPtr native_right = GLib.Marshaller.StringToPtrGStrdup (right);
+			gtk_source_print_compositor_set_header_format(Handle, separator, native_left, native_center, native_right);
+			GLib.Marshaller.Free (native_left);
+			GLib.Marshaller.Free (native_center);
+			GLib.Marshaller.Free (native_right);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_left_margin(IntPtr raw, double margin, int unit);
+		static d_gtk_source_print_compositor_set_left_margin gtk_source_print_compositor_set_left_margin = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_left_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_left_margin"));
+
+		public void SetLeftMargin(double margin, Gtk.Unit unit) {
+			gtk_source_print_compositor_set_left_margin(Handle, margin, (int) unit);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_right_margin(IntPtr raw, double margin, int unit);
+		static d_gtk_source_print_compositor_set_right_margin gtk_source_print_compositor_set_right_margin = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_right_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_right_margin"));
+
+		public void SetRightMargin(double margin, Gtk.Unit unit) {
+			gtk_source_print_compositor_set_right_margin(Handle, margin, (int) unit);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_print_compositor_set_top_margin(IntPtr raw, double margin, int unit);
+		static d_gtk_source_print_compositor_set_top_margin gtk_source_print_compositor_set_top_margin = FuncLoader.LoadFunction<d_gtk_source_print_compositor_set_top_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_print_compositor_set_top_margin"));
+
+		public void SetTopMargin(double margin, Gtk.Unit unit) {
+			gtk_source_print_compositor_set_top_margin(Handle, margin, (int) unit);
+		}
+
+
+		static PrintCompositor ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/QueryTooltipMarkupHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void QueryTooltipMarkupHandler(object o, QueryTooltipMarkupArgs args);
+
+	public class QueryTooltipMarkupArgs : GLib.SignalArgs {
+		public GtkSource.Mark P0{
+			get {
+				return (GtkSource.Mark) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/QueryTooltipTextHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void QueryTooltipTextHandler(object o, QueryTooltipTextArgs args);
+
+	public class QueryTooltipTextArgs : GLib.SignalArgs {
+		public GtkSource.Mark P0{
+			get {
+				return (GtkSource.Mark) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Region.cs

@@ -0,0 +1,14 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Region {
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/RegionIter.cs

@@ -0,0 +1,100 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[StructLayout(LayoutKind.Sequential)]
+	public partial struct RegionIter : IEquatable<RegionIter> {
+
+		private IntPtr _dummy1;
+		private uint dummy2;
+		private IntPtr _dummy3;
+
+		public static GtkSource.RegionIter Zero = new GtkSource.RegionIter ();
+
+		public static GtkSource.RegionIter New(IntPtr raw) {
+			if (raw == IntPtr.Zero)
+				return GtkSource.RegionIter.Zero;
+			return (GtkSource.RegionIter) Marshal.PtrToStructure (raw, typeof (GtkSource.RegionIter));
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_region_iter_get_subregion(IntPtr raw, IntPtr start, IntPtr end);
+		static d_gtk_source_region_iter_get_subregion gtk_source_region_iter_get_subregion = FuncLoader.LoadFunction<d_gtk_source_region_iter_get_subregion>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_region_iter_get_subregion"));
+
+		public bool GetSubregion(Gtk.TextIter start, Gtk.TextIter end) {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<GtkSource.RegionIter>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
+			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
+			bool raw_ret = gtk_source_region_iter_get_subregion(this_as_native, native_start, native_end);
+			bool ret = raw_ret;
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			Marshal.FreeHGlobal (native_start);
+			Marshal.FreeHGlobal (native_end);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_region_iter_is_end(IntPtr raw);
+		static d_gtk_source_region_iter_is_end gtk_source_region_iter_is_end = FuncLoader.LoadFunction<d_gtk_source_region_iter_is_end>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_region_iter_is_end"));
+
+		public bool IsEnd { 
+			get {
+				IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<GtkSource.RegionIter>());
+				System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+				bool raw_ret = gtk_source_region_iter_is_end(this_as_native);
+				bool ret = raw_ret;
+				ReadNative (this_as_native, ref this);
+				System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_region_iter_next(IntPtr raw);
+		static d_gtk_source_region_iter_next gtk_source_region_iter_next = FuncLoader.LoadFunction<d_gtk_source_region_iter_next>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_region_iter_next"));
+
+		public bool Next() {
+			IntPtr this_as_native = System.Runtime.InteropServices.Marshal.AllocHGlobal (System.Runtime.InteropServices.Marshal.SizeOf<GtkSource.RegionIter>());
+			System.Runtime.InteropServices.Marshal.StructureToPtr (this, this_as_native, false);
+			bool raw_ret = gtk_source_region_iter_next(this_as_native);
+			bool ret = raw_ret;
+			ReadNative (this_as_native, ref this);
+			System.Runtime.InteropServices.Marshal.FreeHGlobal (this_as_native);
+			return ret;
+		}
+
+		static void ReadNative (IntPtr native, ref GtkSource.RegionIter target)
+		{
+			target = New (native);
+		}
+
+		public bool Equals (RegionIter other)
+		{
+			return true;
+		}
+
+		public override bool Equals (object other)
+		{
+			return other is RegionIter && Equals ((RegionIter) other);
+		}
+
+		public override int GetHashCode ()
+		{
+			return this.GetType ().FullName.GetHashCode ();
+		}
+
+		private static GLib.GType GType {
+			get { return GLib.GType.Pointer; }
+		}
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/RegionIterReal.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class RegionIterReal : GLib.Opaque {
+
+		public RegionIterReal(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/SearchContext.cs

@@ -0,0 +1,341 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class SearchContext : GLib.Object {
+
+		public SearchContext (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_search_context_new(IntPtr buffer, IntPtr settings);
+		static d_gtk_source_search_context_new gtk_source_search_context_new = FuncLoader.LoadFunction<d_gtk_source_search_context_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_new"));
+
+		public SearchContext (GtkSource.Buffer buffer, GtkSource.SearchSettings settings) : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (SearchContext)) {
+				var vals = new List<GLib.Value> ();
+				var names = new List<string> ();
+				if (buffer != null) {
+					names.Add ("buffer");
+					vals.Add (new GLib.Value (buffer));
+				}
+				if (settings != null) {
+					names.Add ("settings");
+					vals.Add (new GLib.Value (settings));
+				}
+				CreateNativeObject (names.ToArray (), vals.ToArray ());
+				return;
+			}
+			Raw = gtk_source_search_context_new(buffer == null ? IntPtr.Zero : buffer.Handle, settings == null ? IntPtr.Zero : settings.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_search_context_get_buffer(IntPtr raw);
+		static d_gtk_source_search_context_get_buffer gtk_source_search_context_get_buffer = FuncLoader.LoadFunction<d_gtk_source_search_context_get_buffer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_get_buffer"));
+
+		[GLib.Property ("buffer")]
+		public GtkSource.Buffer Buffer {
+			get  {
+				IntPtr raw_ret = gtk_source_search_context_get_buffer(Handle);
+				GtkSource.Buffer ret = GLib.Object.GetObject(raw_ret) as GtkSource.Buffer;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_search_context_get_settings(IntPtr raw);
+		static d_gtk_source_search_context_get_settings gtk_source_search_context_get_settings = FuncLoader.LoadFunction<d_gtk_source_search_context_get_settings>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_get_settings"));
+
+		[GLib.Property ("settings")]
+		public GtkSource.SearchSettings Settings {
+			get  {
+				IntPtr raw_ret = gtk_source_search_context_get_settings(Handle);
+				GtkSource.SearchSettings ret = GLib.Object.GetObject(raw_ret) as GtkSource.SearchSettings;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_search_context_get_highlight(IntPtr raw);
+		static d_gtk_source_search_context_get_highlight gtk_source_search_context_get_highlight = FuncLoader.LoadFunction<d_gtk_source_search_context_get_highlight>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_get_highlight"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_search_context_set_highlight(IntPtr raw, bool highlight);
+		static d_gtk_source_search_context_set_highlight gtk_source_search_context_set_highlight = FuncLoader.LoadFunction<d_gtk_source_search_context_set_highlight>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_set_highlight"));
+
+		[GLib.Property ("highlight")]
+		public bool Highlight {
+			get  {
+				bool raw_ret = gtk_source_search_context_get_highlight(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_search_context_set_highlight(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_search_context_get_match_style(IntPtr raw);
+		static d_gtk_source_search_context_get_match_style gtk_source_search_context_get_match_style = FuncLoader.LoadFunction<d_gtk_source_search_context_get_match_style>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_get_match_style"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_search_context_set_match_style(IntPtr raw, IntPtr match_style);
+		static d_gtk_source_search_context_set_match_style gtk_source_search_context_set_match_style = FuncLoader.LoadFunction<d_gtk_source_search_context_set_match_style>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_set_match_style"));
+
+		[GLib.Property ("match-style")]
+		public GtkSource.Style MatchStyle {
+			get  {
+				IntPtr raw_ret = gtk_source_search_context_get_match_style(Handle);
+				GtkSource.Style ret = GLib.Object.GetObject(raw_ret) as GtkSource.Style;
+				return ret;
+			}
+			set  {
+				gtk_source_search_context_set_match_style(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_search_context_get_occurrences_count(IntPtr raw);
+		static d_gtk_source_search_context_get_occurrences_count gtk_source_search_context_get_occurrences_count = FuncLoader.LoadFunction<d_gtk_source_search_context_get_occurrences_count>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_get_occurrences_count"));
+
+		[GLib.Property ("occurrences-count")]
+		public int OccurrencesCount {
+			get  {
+				int raw_ret = gtk_source_search_context_get_occurrences_count(Handle);
+				int ret = raw_ret;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_search_context_get_regex_error(IntPtr raw);
+		static d_gtk_source_search_context_get_regex_error gtk_source_search_context_get_regex_error = FuncLoader.LoadFunction<d_gtk_source_search_context_get_regex_error>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_get_regex_error"));
+
+		[GLib.Property ("regex-error")]
+		public IntPtr RegexError {
+			get  {
+				IntPtr raw_ret = gtk_source_search_context_get_regex_error(Handle);
+				IntPtr ret = raw_ret;
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_search_context_backward(IntPtr raw, IntPtr iter, IntPtr match_start, IntPtr match_end, out bool has_wrapped_around);
+		static d_gtk_source_search_context_backward gtk_source_search_context_backward = FuncLoader.LoadFunction<d_gtk_source_search_context_backward>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_backward"));
+
+		public bool Backward(Gtk.TextIter iter, out Gtk.TextIter match_start, out Gtk.TextIter match_end, out bool has_wrapped_around) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			IntPtr native_match_start = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
+			IntPtr native_match_end = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
+			bool raw_ret = gtk_source_search_context_backward(Handle, native_iter, native_match_start, native_match_end, out has_wrapped_around);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_iter);
+			match_start = Gtk.TextIter.New (native_match_start);
+			Marshal.FreeHGlobal (native_match_start);
+			match_end = Gtk.TextIter.New (native_match_end);
+			Marshal.FreeHGlobal (native_match_end);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_search_context_backward_async(IntPtr raw, IntPtr iter, IntPtr cancellable, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
+		static d_gtk_source_search_context_backward_async gtk_source_search_context_backward_async = FuncLoader.LoadFunction<d_gtk_source_search_context_backward_async>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_backward_async"));
+
+		public void BackwardAsync(Gtk.TextIter iter, GLib.Cancellable cancellable, GLib.AsyncReadyCallback cb) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
+			cb_wrapper.PersistUntilCalled ();
+			gtk_source_search_context_backward_async(Handle, native_iter, cancellable == null ? IntPtr.Zero : cancellable.Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
+			Marshal.FreeHGlobal (native_iter);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_search_context_backward_finish(IntPtr raw, IntPtr result, IntPtr match_start, IntPtr match_end, out bool has_wrapped_around, out IntPtr error);
+		static d_gtk_source_search_context_backward_finish gtk_source_search_context_backward_finish = FuncLoader.LoadFunction<d_gtk_source_search_context_backward_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_backward_finish"));
+
+		public unsafe bool BackwardFinish(GLib.IAsyncResult result, out Gtk.TextIter match_start, out Gtk.TextIter match_end, out bool has_wrapped_around) {
+			IntPtr native_match_start = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
+			IntPtr native_match_end = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = gtk_source_search_context_backward_finish(Handle, result == null ? IntPtr.Zero : ((result is GLib.Object) ? (result as GLib.Object).Handle : (result as GLib.AsyncResultAdapter).Handle), native_match_start, native_match_end, out has_wrapped_around, out error);
+			bool ret = raw_ret;
+			match_start = Gtk.TextIter.New (native_match_start);
+			Marshal.FreeHGlobal (native_match_start);
+			match_end = Gtk.TextIter.New (native_match_end);
+			Marshal.FreeHGlobal (native_match_end);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_search_context_forward(IntPtr raw, IntPtr iter, IntPtr match_start, IntPtr match_end, out bool has_wrapped_around);
+		static d_gtk_source_search_context_forward gtk_source_search_context_forward = FuncLoader.LoadFunction<d_gtk_source_search_context_forward>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_forward"));
+
+		public bool Forward(Gtk.TextIter iter, out Gtk.TextIter match_start, out Gtk.TextIter match_end, out bool has_wrapped_around) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			IntPtr native_match_start = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
+			IntPtr native_match_end = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
+			bool raw_ret = gtk_source_search_context_forward(Handle, native_iter, native_match_start, native_match_end, out has_wrapped_around);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_iter);
+			match_start = Gtk.TextIter.New (native_match_start);
+			Marshal.FreeHGlobal (native_match_start);
+			match_end = Gtk.TextIter.New (native_match_end);
+			Marshal.FreeHGlobal (native_match_end);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_search_context_forward_async(IntPtr raw, IntPtr iter, IntPtr cancellable, GLibSharp.AsyncReadyCallbackNative cb, IntPtr user_data);
+		static d_gtk_source_search_context_forward_async gtk_source_search_context_forward_async = FuncLoader.LoadFunction<d_gtk_source_search_context_forward_async>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_forward_async"));
+
+		public void ForwardAsync(Gtk.TextIter iter, GLib.Cancellable cancellable, GLib.AsyncReadyCallback cb) {
+			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
+			GLibSharp.AsyncReadyCallbackWrapper cb_wrapper = new GLibSharp.AsyncReadyCallbackWrapper (cb);
+			cb_wrapper.PersistUntilCalled ();
+			gtk_source_search_context_forward_async(Handle, native_iter, cancellable == null ? IntPtr.Zero : cancellable.Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
+			Marshal.FreeHGlobal (native_iter);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_search_context_forward_finish(IntPtr raw, IntPtr result, IntPtr match_start, IntPtr match_end, out bool has_wrapped_around, out IntPtr error);
+		static d_gtk_source_search_context_forward_finish gtk_source_search_context_forward_finish = FuncLoader.LoadFunction<d_gtk_source_search_context_forward_finish>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_forward_finish"));
+
+		public unsafe bool ForwardFinish(GLib.IAsyncResult result, out Gtk.TextIter match_start, out Gtk.TextIter match_end, out bool has_wrapped_around) {
+			IntPtr native_match_start = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
+			IntPtr native_match_end = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = gtk_source_search_context_forward_finish(Handle, result == null ? IntPtr.Zero : ((result is GLib.Object) ? (result as GLib.Object).Handle : (result as GLib.AsyncResultAdapter).Handle), native_match_start, native_match_end, out has_wrapped_around, out error);
+			bool ret = raw_ret;
+			match_start = Gtk.TextIter.New (native_match_start);
+			Marshal.FreeHGlobal (native_match_start);
+			match_end = Gtk.TextIter.New (native_match_end);
+			Marshal.FreeHGlobal (native_match_end);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_search_context_get_occurrence_position(IntPtr raw, IntPtr match_start, IntPtr match_end);
+		static d_gtk_source_search_context_get_occurrence_position gtk_source_search_context_get_occurrence_position = FuncLoader.LoadFunction<d_gtk_source_search_context_get_occurrence_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_get_occurrence_position"));
+
+		public int GetOccurrencePosition(Gtk.TextIter match_start, Gtk.TextIter match_end) {
+			IntPtr native_match_start = GLib.Marshaller.StructureToPtrAlloc (match_start);
+			IntPtr native_match_end = GLib.Marshaller.StructureToPtrAlloc (match_end);
+			int raw_ret = gtk_source_search_context_get_occurrence_position(Handle, native_match_start, native_match_end);
+			int ret = raw_ret;
+			Marshal.FreeHGlobal (native_match_start);
+			Marshal.FreeHGlobal (native_match_end);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_search_context_get_type();
+		static d_gtk_source_search_context_get_type gtk_source_search_context_get_type = FuncLoader.LoadFunction<d_gtk_source_search_context_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_search_context_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_search_context_replace(IntPtr raw, IntPtr match_start, IntPtr match_end, IntPtr replace, int replace_length, out IntPtr error);
+		static d_gtk_source_search_context_replace gtk_source_search_context_replace = FuncLoader.LoadFunction<d_gtk_source_search_context_replace>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_replace"));
+
+		public unsafe bool Replace(Gtk.TextIter match_start, Gtk.TextIter match_end, string replace) {
+			IntPtr native_match_start = GLib.Marshaller.StructureToPtrAlloc (match_start);
+			IntPtr native_match_end = GLib.Marshaller.StructureToPtrAlloc (match_end);
+			IntPtr native_replace = GLib.Marshaller.StringToPtrGStrdup (replace);
+			IntPtr error = IntPtr.Zero;
+			bool raw_ret = gtk_source_search_context_replace(Handle, native_match_start, native_match_end, native_replace, System.Text.Encoding.UTF8.GetByteCount (replace), out error);
+			bool ret = raw_ret;
+			Marshal.FreeHGlobal (native_match_start);
+			Marshal.FreeHGlobal (native_match_end);
+			GLib.Marshaller.Free (native_replace);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate uint d_gtk_source_search_context_replace_all(IntPtr raw, IntPtr replace, int replace_length, out IntPtr error);
+		static d_gtk_source_search_context_replace_all gtk_source_search_context_replace_all = FuncLoader.LoadFunction<d_gtk_source_search_context_replace_all>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_context_replace_all"));
+
+		public unsafe uint ReplaceAll(string replace) {
+			IntPtr native_replace = GLib.Marshaller.StringToPtrGStrdup (replace);
+			IntPtr error = IntPtr.Zero;
+			uint raw_ret = gtk_source_search_context_replace_all(Handle, native_replace, System.Text.Encoding.UTF8.GetByteCount (replace), out error);
+			uint ret = raw_ret;
+			GLib.Marshaller.Free (native_replace);
+			if (error != IntPtr.Zero) throw new GLib.GException (error);
+			return ret;
+		}
+
+
+		static SearchContext ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/SearchSettings.cs

@@ -0,0 +1,199 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class SearchSettings : GLib.Object {
+
+		public SearchSettings (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_search_settings_new();
+		static d_gtk_source_search_settings_new gtk_source_search_settings_new = FuncLoader.LoadFunction<d_gtk_source_search_settings_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_new"));
+
+		public SearchSettings () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (SearchSettings)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_search_settings_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_search_settings_get_search_text(IntPtr raw);
+		static d_gtk_source_search_settings_get_search_text gtk_source_search_settings_get_search_text = FuncLoader.LoadFunction<d_gtk_source_search_settings_get_search_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_get_search_text"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_search_settings_set_search_text(IntPtr raw, IntPtr search_text);
+		static d_gtk_source_search_settings_set_search_text gtk_source_search_settings_set_search_text = FuncLoader.LoadFunction<d_gtk_source_search_settings_set_search_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_set_search_text"));
+
+		[GLib.Property ("search-text")]
+		public string SearchText {
+			get  {
+				IntPtr raw_ret = gtk_source_search_settings_get_search_text(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+			set  {
+				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
+				gtk_source_search_settings_set_search_text(Handle, native_value);
+				GLib.Marshaller.Free (native_value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_search_settings_get_case_sensitive(IntPtr raw);
+		static d_gtk_source_search_settings_get_case_sensitive gtk_source_search_settings_get_case_sensitive = FuncLoader.LoadFunction<d_gtk_source_search_settings_get_case_sensitive>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_get_case_sensitive"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_search_settings_set_case_sensitive(IntPtr raw, bool case_sensitive);
+		static d_gtk_source_search_settings_set_case_sensitive gtk_source_search_settings_set_case_sensitive = FuncLoader.LoadFunction<d_gtk_source_search_settings_set_case_sensitive>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_set_case_sensitive"));
+
+		[GLib.Property ("case-sensitive")]
+		public bool CaseSensitive {
+			get  {
+				bool raw_ret = gtk_source_search_settings_get_case_sensitive(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_search_settings_set_case_sensitive(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_search_settings_get_at_word_boundaries(IntPtr raw);
+		static d_gtk_source_search_settings_get_at_word_boundaries gtk_source_search_settings_get_at_word_boundaries = FuncLoader.LoadFunction<d_gtk_source_search_settings_get_at_word_boundaries>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_get_at_word_boundaries"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_search_settings_set_at_word_boundaries(IntPtr raw, bool at_word_boundaries);
+		static d_gtk_source_search_settings_set_at_word_boundaries gtk_source_search_settings_set_at_word_boundaries = FuncLoader.LoadFunction<d_gtk_source_search_settings_set_at_word_boundaries>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_set_at_word_boundaries"));
+
+		[GLib.Property ("at-word-boundaries")]
+		public bool AtWordBoundaries {
+			get  {
+				bool raw_ret = gtk_source_search_settings_get_at_word_boundaries(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_search_settings_set_at_word_boundaries(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_search_settings_get_wrap_around(IntPtr raw);
+		static d_gtk_source_search_settings_get_wrap_around gtk_source_search_settings_get_wrap_around = FuncLoader.LoadFunction<d_gtk_source_search_settings_get_wrap_around>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_get_wrap_around"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_search_settings_set_wrap_around(IntPtr raw, bool wrap_around);
+		static d_gtk_source_search_settings_set_wrap_around gtk_source_search_settings_set_wrap_around = FuncLoader.LoadFunction<d_gtk_source_search_settings_set_wrap_around>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_set_wrap_around"));
+
+		[GLib.Property ("wrap-around")]
+		public bool WrapAround {
+			get  {
+				bool raw_ret = gtk_source_search_settings_get_wrap_around(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_search_settings_set_wrap_around(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_search_settings_get_regex_enabled(IntPtr raw);
+		static d_gtk_source_search_settings_get_regex_enabled gtk_source_search_settings_get_regex_enabled = FuncLoader.LoadFunction<d_gtk_source_search_settings_get_regex_enabled>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_get_regex_enabled"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_search_settings_set_regex_enabled(IntPtr raw, bool regex_enabled);
+		static d_gtk_source_search_settings_set_regex_enabled gtk_source_search_settings_set_regex_enabled = FuncLoader.LoadFunction<d_gtk_source_search_settings_set_regex_enabled>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_set_regex_enabled"));
+
+		[GLib.Property ("regex-enabled")]
+		public bool RegexEnabled {
+			get  {
+				bool raw_ret = gtk_source_search_settings_get_regex_enabled(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_search_settings_set_regex_enabled(Handle, value);
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_search_settings_get_type();
+		static d_gtk_source_search_settings_get_type gtk_source_search_settings_get_type = FuncLoader.LoadFunction<d_gtk_source_search_settings_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_search_settings_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_search_settings_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static SearchSettings ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Segment.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class Segment : GLib.Opaque {
+
+		public Segment(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/SmartHomeEndFiredHandler.cs

@@ -0,0 +1,24 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void SmartHomeEndFiredHandler(object o, SmartHomeEndFiredArgs args);
+
+	public class SmartHomeEndFiredArgs : GLib.SignalArgs {
+		public Gtk.TextIter P0{
+			get {
+				return (Gtk.TextIter) Args [0];
+			}
+		}
+
+		public int P1{
+			get {
+				return (int) Args [1];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/SmartHomeEndType.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public enum SmartHomeEndType {
+
+		Disabled,
+		Before,
+		After,
+		Always,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/SortFlags.cs

@@ -0,0 +1,19 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	public enum SortFlags {
+
+		None,
+		CaseSensitive = 1 << 0,
+		ReverseOrder = 1 << 1,
+		RemoveDuplicates = 1 << 2,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/SourceMarkUpdatedHandler.cs

@@ -0,0 +1,18 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+
+	public delegate void SourceMarkUpdatedHandler(object o, SourceMarkUpdatedArgs args);
+
+	public class SourceMarkUpdatedArgs : GLib.SignalArgs {
+		public Gtk.TextMark P0{
+			get {
+				return (Gtk.TextMark) Args [0];
+			}
+		}
+
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/SpaceDrawer.cs

@@ -0,0 +1,165 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class SpaceDrawer : GLib.Object {
+
+		public SpaceDrawer (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_space_drawer_new();
+		static d_gtk_source_space_drawer_new gtk_source_space_drawer_new = FuncLoader.LoadFunction<d_gtk_source_space_drawer_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_space_drawer_new"));
+
+		public SpaceDrawer () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (SpaceDrawer)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_space_drawer_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate bool d_gtk_source_space_drawer_get_enable_matrix(IntPtr raw);
+		static d_gtk_source_space_drawer_get_enable_matrix gtk_source_space_drawer_get_enable_matrix = FuncLoader.LoadFunction<d_gtk_source_space_drawer_get_enable_matrix>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_space_drawer_get_enable_matrix"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_space_drawer_set_enable_matrix(IntPtr raw, bool enable_matrix);
+		static d_gtk_source_space_drawer_set_enable_matrix gtk_source_space_drawer_set_enable_matrix = FuncLoader.LoadFunction<d_gtk_source_space_drawer_set_enable_matrix>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_space_drawer_set_enable_matrix"));
+
+		[GLib.Property ("enable-matrix")]
+		public bool EnableMatrix {
+			get  {
+				bool raw_ret = gtk_source_space_drawer_get_enable_matrix(Handle);
+				bool ret = raw_ret;
+				return ret;
+			}
+			set  {
+				gtk_source_space_drawer_set_enable_matrix(Handle, value);
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_space_drawer_get_matrix(IntPtr raw);
+		static d_gtk_source_space_drawer_get_matrix gtk_source_space_drawer_get_matrix = FuncLoader.LoadFunction<d_gtk_source_space_drawer_get_matrix>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_space_drawer_get_matrix"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_space_drawer_set_matrix(IntPtr raw, IntPtr matrix);
+		static d_gtk_source_space_drawer_set_matrix gtk_source_space_drawer_set_matrix = FuncLoader.LoadFunction<d_gtk_source_space_drawer_set_matrix>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_space_drawer_set_matrix"));
+
+		[GLib.Property ("matrix")]
+		public GLib.Variant Matrix {
+			get  {
+				IntPtr raw_ret = gtk_source_space_drawer_get_matrix(Handle);
+				GLib.Variant ret = new GLib.Variant(raw_ret);
+				return ret;
+			}
+			set  {
+				gtk_source_space_drawer_set_matrix(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 20 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_space_drawer_bind_matrix_setting(IntPtr raw, IntPtr settings, IntPtr key, int flags);
+		static d_gtk_source_space_drawer_bind_matrix_setting gtk_source_space_drawer_bind_matrix_setting = FuncLoader.LoadFunction<d_gtk_source_space_drawer_bind_matrix_setting>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_space_drawer_bind_matrix_setting"));
+
+		public void BindMatrixSetting(GLib.Settings settings, string key, GLib.SettingsBindFlags flags) {
+			IntPtr native_key = GLib.Marshaller.StringToPtrGStrdup (key);
+			gtk_source_space_drawer_bind_matrix_setting(Handle, settings == null ? IntPtr.Zero : settings.Handle, native_key, (int) flags);
+			GLib.Marshaller.Free (native_key);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_space_drawer_get_type();
+		static d_gtk_source_space_drawer_get_type gtk_source_space_drawer_get_type = FuncLoader.LoadFunction<d_gtk_source_space_drawer_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_space_drawer_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_space_drawer_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate int d_gtk_source_space_drawer_get_types_for_locations(IntPtr raw, int locations);
+		static d_gtk_source_space_drawer_get_types_for_locations gtk_source_space_drawer_get_types_for_locations = FuncLoader.LoadFunction<d_gtk_source_space_drawer_get_types_for_locations>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_space_drawer_get_types_for_locations"));
+
+		public GtkSource.SpaceTypeFlags GetTypesForLocations(GtkSource.SpaceLocationFlags locations) {
+			int raw_ret = gtk_source_space_drawer_get_types_for_locations(Handle, (int) locations);
+			GtkSource.SpaceTypeFlags ret = (GtkSource.SpaceTypeFlags) raw_ret;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_space_drawer_set_types_for_locations(IntPtr raw, int locations, int types);
+		static d_gtk_source_space_drawer_set_types_for_locations gtk_source_space_drawer_set_types_for_locations = FuncLoader.LoadFunction<d_gtk_source_space_drawer_set_types_for_locations>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_space_drawer_set_types_for_locations"));
+
+		public void SetTypesForLocations(GtkSource.SpaceLocationFlags locations, GtkSource.SpaceTypeFlags types) {
+			gtk_source_space_drawer_set_types_for_locations(Handle, (int) locations, (int) types);
+		}
+
+
+		static SpaceDrawer ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/SpaceLocationFlags.cs

@@ -0,0 +1,20 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	public enum SpaceLocationFlags {
+
+		None,
+		Leading = 1 << 0,
+		InsideText = 1 << 1,
+		Trailing = 1 << 2,
+		All = 0x7,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/SpaceTypeFlags.cs

@@ -0,0 +1,21 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	[Flags]
+	public enum SpaceTypeFlags {
+
+		None,
+		Space = 1 << 0,
+		Tab = 1 << 1,
+		Newline = 1 << 2,
+		Nbsp = 1 << 3,
+		All = 0xf,
+	}
+#endregion
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/Style.cs

@@ -0,0 +1,269 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class Style : GLib.Object {
+
+		public Style (IntPtr raw) : base(raw) {}
+
+		protected Style() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[GLib.Property ("line-background")]
+		public string LineBackground {
+			get {
+				GLib.Value val = GetProperty ("line-background");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("background")]
+		public string Background {
+			get {
+				GLib.Value val = GetProperty ("background");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("foreground")]
+		public string Foreground {
+			get {
+				GLib.Value val = GetProperty ("foreground");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("bold")]
+		public bool Bold {
+			get {
+				GLib.Value val = GetProperty ("bold");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("italic")]
+		public bool Italic {
+			get {
+				GLib.Value val = GetProperty ("italic");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("pango-underline")]
+		public Pango.Underline PangoUnderline {
+			get {
+				GLib.Value val = GetProperty ("pango-underline");
+				Pango.Underline ret = (Pango.Underline) (Enum) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("strikethrough")]
+		public bool Strikethrough {
+			get {
+				GLib.Value val = GetProperty ("strikethrough");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("scale")]
+		public string Scale {
+			get {
+				GLib.Value val = GetProperty ("scale");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("underline-color")]
+		public string UnderlineColor {
+			get {
+				GLib.Value val = GetProperty ("underline-color");
+				string ret = (string) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("line-background-set")]
+		public bool LineBackgroundSet {
+			get {
+				GLib.Value val = GetProperty ("line-background-set");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("foreground-set")]
+		public bool ForegroundSet {
+			get {
+				GLib.Value val = GetProperty ("foreground-set");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("background-set")]
+		public bool BackgroundSet {
+			get {
+				GLib.Value val = GetProperty ("background-set");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("bold-set")]
+		public bool BoldSet {
+			get {
+				GLib.Value val = GetProperty ("bold-set");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("italic-set")]
+		public bool ItalicSet {
+			get {
+				GLib.Value val = GetProperty ("italic-set");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("underline-set")]
+		public bool UnderlineSet {
+			get {
+				GLib.Value val = GetProperty ("underline-set");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("strikethrough-set")]
+		public bool StrikethroughSet {
+			get {
+				GLib.Value val = GetProperty ("strikethrough-set");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("scale-set")]
+		public bool ScaleSet {
+			get {
+				GLib.Value val = GetProperty ("scale-set");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+		[GLib.Property ("underline-color-set")]
+		public bool UnderlineColorSet {
+			get {
+				GLib.Value val = GetProperty ("underline-color-set");
+				bool ret = (bool) val;
+				val.Dispose ();
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (GLib.Object.class_abi.Fields);
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_style_apply(IntPtr raw, IntPtr tag);
+		static d_gtk_source_style_apply gtk_source_style_apply = FuncLoader.LoadFunction<d_gtk_source_style_apply>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_apply"));
+
+		public void Apply(Gtk.TextTag tag) {
+			gtk_source_style_apply(Handle, tag == null ? IntPtr.Zero : tag.Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_copy(IntPtr raw);
+		static d_gtk_source_style_copy gtk_source_style_copy = FuncLoader.LoadFunction<d_gtk_source_style_copy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_copy"));
+
+		public GtkSource.Style Copy() {
+			IntPtr raw_ret = gtk_source_style_copy(Handle);
+			GtkSource.Style ret = GLib.Object.GetObject(raw_ret, true) as GtkSource.Style;
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_get_type();
+		static d_gtk_source_style_get_type gtk_source_style_get_type = FuncLoader.LoadFunction<d_gtk_source_style_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_style_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static Style ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (GLib.Object.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/StyleInfo.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class StyleInfo : GLib.Opaque {
+
+		public StyleInfo(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/StyleScheme.cs

@@ -0,0 +1,165 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class StyleScheme : GLib.Object {
+
+		public StyleScheme (IntPtr raw) : base(raw) {}
+
+		protected StyleScheme() : base(IntPtr.Zero)
+		{
+			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_get_id(IntPtr raw);
+		static d_gtk_source_style_scheme_get_id gtk_source_style_scheme_get_id = FuncLoader.LoadFunction<d_gtk_source_style_scheme_get_id>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_get_id"));
+
+		[GLib.Property ("id")]
+		public string Id {
+			get  {
+				IntPtr raw_ret = gtk_source_style_scheme_get_id(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_get_name(IntPtr raw);
+		static d_gtk_source_style_scheme_get_name gtk_source_style_scheme_get_name = FuncLoader.LoadFunction<d_gtk_source_style_scheme_get_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_get_name"));
+
+		[GLib.Property ("name")]
+		public string Name {
+			get  {
+				IntPtr raw_ret = gtk_source_style_scheme_get_name(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_get_description(IntPtr raw);
+		static d_gtk_source_style_scheme_get_description gtk_source_style_scheme_get_description = FuncLoader.LoadFunction<d_gtk_source_style_scheme_get_description>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_get_description"));
+
+		[GLib.Property ("description")]
+		public string Description {
+			get  {
+				IntPtr raw_ret = gtk_source_style_scheme_get_description(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_get_filename(IntPtr raw);
+		static d_gtk_source_style_scheme_get_filename gtk_source_style_scheme_get_filename = FuncLoader.LoadFunction<d_gtk_source_style_scheme_get_filename>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_get_filename"));
+
+		[GLib.Property ("filename")]
+		public string Filename {
+			get  {
+				IntPtr raw_ret = gtk_source_style_scheme_get_filename(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_get_authors(IntPtr raw);
+		static d_gtk_source_style_scheme_get_authors gtk_source_style_scheme_get_authors = FuncLoader.LoadFunction<d_gtk_source_style_scheme_get_authors>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_get_authors"));
+
+		public string Authors { 
+			get {
+				IntPtr raw_ret = gtk_source_style_scheme_get_authors(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_get_style(IntPtr raw, IntPtr style_id);
+		static d_gtk_source_style_scheme_get_style gtk_source_style_scheme_get_style = FuncLoader.LoadFunction<d_gtk_source_style_scheme_get_style>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_get_style"));
+
+		public GtkSource.Style GetStyle(string style_id) {
+			IntPtr native_style_id = GLib.Marshaller.StringToPtrGStrdup (style_id);
+			IntPtr raw_ret = gtk_source_style_scheme_get_style(Handle, native_style_id);
+			GtkSource.Style ret = GLib.Object.GetObject(raw_ret) as GtkSource.Style;
+			GLib.Marshaller.Free (native_style_id);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_get_type();
+		static d_gtk_source_style_scheme_get_type gtk_source_style_scheme_get_type = FuncLoader.LoadFunction<d_gtk_source_style_scheme_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_style_scheme_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+
+		static StyleScheme ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/StyleSchemeChooserAdapter.cs

@@ -0,0 +1,168 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class StyleSchemeChooserAdapter : GLib.GInterfaceAdapter, GtkSource.IStyleSchemeChooser {
+
+		[StructLayout (LayoutKind.Sequential)]
+		struct GtkSourceStyleSchemeChooserInterface {
+			public GetStyleSchemeNativeDelegate GetStyleScheme;
+			public SetStyleSchemeNativeDelegate SetStyleScheme;
+			[MarshalAs (UnmanagedType.ByValArray, SizeConst=12)]
+			public IntPtr[] Padding;
+		}
+
+		static GtkSourceStyleSchemeChooserInterface iface;
+
+		static StyleSchemeChooserAdapter ()
+		{
+			GLib.GType.Register (_gtype, typeof (StyleSchemeChooserAdapter));
+			iface.GetStyleScheme = new GetStyleSchemeNativeDelegate (GetStyleScheme_cb);
+			iface.SetStyleScheme = new SetStyleSchemeNativeDelegate (SetStyleScheme_cb);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr GetStyleSchemeNativeDelegate (IntPtr inst);
+
+		static IntPtr GetStyleScheme_cb (IntPtr inst)
+		{
+			try {
+				IStyleSchemeChooserImplementor __obj = GLib.Object.GetObject (inst, false) as IStyleSchemeChooserImplementor;
+				GtkSource.StyleScheme __result;
+				__result = __obj.StyleScheme;
+				return __result == null ? IntPtr.Zero : __result.Handle;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, true);
+				// NOTREACHED: above call does not return.
+				throw;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void SetStyleSchemeNativeDelegate (IntPtr inst, IntPtr scheme);
+
+		static void SetStyleScheme_cb (IntPtr inst, IntPtr scheme)
+		{
+			try {
+				IStyleSchemeChooserImplementor __obj = GLib.Object.GetObject (inst, false) as IStyleSchemeChooserImplementor;
+				__obj.StyleScheme = GLib.Object.GetObject(scheme) as GtkSource.StyleScheme;
+			} catch (Exception e) {
+				GLib.ExceptionManager.RaiseUnhandledException (e, false);
+			}
+		}
+
+		static int class_offset = 2 * IntPtr.Size;
+
+		static void Initialize (IntPtr ptr, IntPtr data)
+		{
+			IntPtr ifaceptr = new IntPtr (ptr.ToInt64 () + class_offset);
+			GtkSourceStyleSchemeChooserInterface native_iface = (GtkSourceStyleSchemeChooserInterface) Marshal.PtrToStructure (ifaceptr, typeof (GtkSourceStyleSchemeChooserInterface));
+			native_iface.GetStyleScheme = iface.GetStyleScheme;
+			native_iface.SetStyleScheme = iface.SetStyleScheme;
+			Marshal.StructureToPtr (native_iface, ifaceptr, false);
+		}
+
+		GLib.Object implementor;
+
+		public StyleSchemeChooserAdapter ()
+		{
+			InitHandler = new GLib.GInterfaceInitHandler (Initialize);
+		}
+
+		public StyleSchemeChooserAdapter (IStyleSchemeChooserImplementor implementor)
+		{
+			if (implementor == null)
+				throw new ArgumentNullException ("implementor");
+			else if (!(implementor is GLib.Object))
+				throw new ArgumentException ("implementor must be a subclass of GLib.Object");
+			this.implementor = implementor as GLib.Object;
+		}
+
+		public StyleSchemeChooserAdapter (IntPtr handle)
+		{
+			if (!_gtype.IsInstance (handle))
+				throw new ArgumentException ("The gobject doesn't implement the GInterface of this adapter", "handle");
+			implementor = GLib.Object.GetObject (handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_chooser_get_type();
+		static d_gtk_source_style_scheme_chooser_get_type gtk_source_style_scheme_chooser_get_type = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_get_type"));
+
+		private static GLib.GType _gtype = new GLib.GType (gtk_source_style_scheme_chooser_get_type ());
+
+		public static GLib.GType GType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override GLib.GType GInterfaceGType {
+			get {
+				return _gtype;
+			}
+		}
+
+		public override IntPtr Handle {
+			get {
+				return implementor.Handle;
+			}
+		}
+
+		public IntPtr OwnedHandle {
+			get {
+				return implementor.OwnedHandle;
+			}
+		}
+
+		public static IStyleSchemeChooser GetObject (IntPtr handle, bool owned)
+		{
+			GLib.Object obj = GLib.Object.GetObject (handle, owned);
+			return GetObject (obj);
+		}
+
+		public static IStyleSchemeChooser GetObject (GLib.Object obj)
+		{
+			if (obj == null)
+				return null;
+			else if (obj is IStyleSchemeChooserImplementor)
+				return new StyleSchemeChooserAdapter (obj as IStyleSchemeChooserImplementor);
+			else if (obj as IStyleSchemeChooser == null)
+				return new StyleSchemeChooserAdapter (obj.Handle);
+			else
+				return obj as IStyleSchemeChooser;
+		}
+
+		public IStyleSchemeChooserImplementor Implementor {
+			get {
+				return implementor as IStyleSchemeChooserImplementor;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_chooser_get_style_scheme(IntPtr raw);
+		static d_gtk_source_style_scheme_chooser_get_style_scheme gtk_source_style_scheme_chooser_get_style_scheme = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_get_style_scheme>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_get_style_scheme"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_style_scheme_chooser_set_style_scheme(IntPtr raw, IntPtr scheme);
+		static d_gtk_source_style_scheme_chooser_set_style_scheme gtk_source_style_scheme_chooser_set_style_scheme = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_set_style_scheme>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_set_style_scheme"));
+
+		public GtkSource.StyleScheme StyleScheme { 
+			get {
+				IntPtr raw_ret = gtk_source_style_scheme_chooser_get_style_scheme(Handle);
+				GtkSource.StyleScheme ret = GLib.Object.GetObject(raw_ret) as GtkSource.StyleScheme;
+				return ret;
+			}
+			set {
+				gtk_source_style_scheme_chooser_set_style_scheme(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/StyleSchemeChooserButton.cs

@@ -0,0 +1,107 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class StyleSchemeChooserButton : Gtk.Button, GtkSource.IStyleSchemeChooser {
+
+		public StyleSchemeChooserButton (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_chooser_button_new();
+		static d_gtk_source_style_scheme_chooser_button_new gtk_source_style_scheme_chooser_button_new = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_button_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_button_new"));
+
+		public StyleSchemeChooserButton () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (StyleSchemeChooserButton)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_style_scheme_chooser_button_new();
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, Gtk.Button.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_chooser_button_get_type();
+		static d_gtk_source_style_scheme_chooser_button_get_type gtk_source_style_scheme_chooser_button_get_type = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_button_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_button_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_style_scheme_chooser_button_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_chooser_get_style_scheme(IntPtr raw);
+		static d_gtk_source_style_scheme_chooser_get_style_scheme gtk_source_style_scheme_chooser_get_style_scheme = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_get_style_scheme>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_get_style_scheme"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_style_scheme_chooser_set_style_scheme(IntPtr raw, IntPtr scheme);
+		static d_gtk_source_style_scheme_chooser_set_style_scheme gtk_source_style_scheme_chooser_set_style_scheme = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_set_style_scheme>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_set_style_scheme"));
+
+		public GtkSource.StyleScheme StyleScheme { 
+			get {
+				IntPtr raw_ret = gtk_source_style_scheme_chooser_get_style_scheme(Handle);
+				GtkSource.StyleScheme ret = GLib.Object.GetObject(raw_ret) as GtkSource.StyleScheme;
+				return ret;
+			}
+			set {
+				gtk_source_style_scheme_chooser_set_style_scheme(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+
+		static StyleSchemeChooserButton ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (Gtk.Button.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/StyleSchemeChooserWidget.cs

@@ -0,0 +1,107 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class StyleSchemeChooserWidget : Gtk.Bin, GtkSource.IStyleSchemeChooser {
+
+		public StyleSchemeChooserWidget (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_chooser_widget_new();
+		static d_gtk_source_style_scheme_chooser_widget_new gtk_source_style_scheme_chooser_widget_new = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_widget_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_widget_new"));
+
+		public StyleSchemeChooserWidget () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (StyleSchemeChooserWidget)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_style_scheme_chooser_widget_new();
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, Gtk.Bin.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_chooser_widget_get_type();
+		static d_gtk_source_style_scheme_chooser_widget_get_type gtk_source_style_scheme_chooser_widget_get_type = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_widget_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_widget_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_style_scheme_chooser_widget_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_chooser_get_style_scheme(IntPtr raw);
+		static d_gtk_source_style_scheme_chooser_get_style_scheme gtk_source_style_scheme_chooser_get_style_scheme = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_get_style_scheme>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_get_style_scheme"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_style_scheme_chooser_set_style_scheme(IntPtr raw, IntPtr scheme);
+		static d_gtk_source_style_scheme_chooser_set_style_scheme gtk_source_style_scheme_chooser_set_style_scheme = FuncLoader.LoadFunction<d_gtk_source_style_scheme_chooser_set_style_scheme>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_chooser_set_style_scheme"));
+
+		public GtkSource.StyleScheme StyleScheme { 
+			get {
+				IntPtr raw_ret = gtk_source_style_scheme_chooser_get_style_scheme(Handle);
+				GtkSource.StyleScheme ret = GLib.Object.GetObject(raw_ret) as GtkSource.StyleScheme;
+				return ret;
+			}
+			set {
+				gtk_source_style_scheme_chooser_set_style_scheme(Handle, value == null ? IntPtr.Zero : value.Handle);
+			}
+		}
+
+
+		static StyleSchemeChooserWidget ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (Gtk.Bin.abi_info.Fields);
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/StyleSchemeManager.cs

@@ -0,0 +1,182 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+	using static GLib.AbiStructExtension;
+
+#region Autogenerated code
+	public partial class StyleSchemeManager : GLib.Object {
+
+		public StyleSchemeManager (IntPtr raw) : base(raw) {}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_manager_new();
+		static d_gtk_source_style_scheme_manager_new gtk_source_style_scheme_manager_new = FuncLoader.LoadFunction<d_gtk_source_style_scheme_manager_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_manager_new"));
+
+		public StyleSchemeManager () : base (IntPtr.Zero)
+		{
+			if (GetType () != typeof (StyleSchemeManager)) {
+				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
+				return;
+			}
+			Raw = gtk_source_style_scheme_manager_new();
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_manager_get_search_path(IntPtr raw);
+		static d_gtk_source_style_scheme_manager_get_search_path gtk_source_style_scheme_manager_get_search_path = FuncLoader.LoadFunction<d_gtk_source_style_scheme_manager_get_search_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_manager_get_search_path"));
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_style_scheme_manager_set_search_path(IntPtr raw, IntPtr path);
+		static d_gtk_source_style_scheme_manager_set_search_path gtk_source_style_scheme_manager_set_search_path = FuncLoader.LoadFunction<d_gtk_source_style_scheme_manager_set_search_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_manager_set_search_path"));
+
+		[GLib.Property ("search-path")]
+		public string SearchPath {
+			get  {
+				IntPtr raw_ret = gtk_source_style_scheme_manager_get_search_path(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+			set  {
+				gtk_source_style_scheme_manager_set_search_path(Handle, GLib.Marshaller.StringToPtrGStrdup(value));
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_manager_get_scheme_ids(IntPtr raw);
+		static d_gtk_source_style_scheme_manager_get_scheme_ids gtk_source_style_scheme_manager_get_scheme_ids = FuncLoader.LoadFunction<d_gtk_source_style_scheme_manager_get_scheme_ids>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_manager_get_scheme_ids"));
+
+		[GLib.Property ("scheme-ids")]
+		public string SchemeIds {
+			get  {
+				IntPtr raw_ret = gtk_source_style_scheme_manager_get_scheme_ids(Handle);
+				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
+				return ret;
+			}
+		}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _class_abi = null;
+		static public unsafe new GLib.AbiStruct class_abi {
+			get {
+				if (_class_abi == null)
+					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("padding"
+							, GLib.Object.class_abi.Fields
+							, (uint) sizeof( IntPtr ) * 10 // padding
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _class_abi;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_style_scheme_manager_append_search_path(IntPtr raw, IntPtr path);
+		static d_gtk_source_style_scheme_manager_append_search_path gtk_source_style_scheme_manager_append_search_path = FuncLoader.LoadFunction<d_gtk_source_style_scheme_manager_append_search_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_manager_append_search_path"));
+
+		public void AppendSearchPath(string path) {
+			IntPtr native_path = GLib.Marshaller.StringToPtrGStrdup (path);
+			gtk_source_style_scheme_manager_append_search_path(Handle, native_path);
+			GLib.Marshaller.Free (native_path);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_style_scheme_manager_force_rescan(IntPtr raw);
+		static d_gtk_source_style_scheme_manager_force_rescan gtk_source_style_scheme_manager_force_rescan = FuncLoader.LoadFunction<d_gtk_source_style_scheme_manager_force_rescan>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_manager_force_rescan"));
+
+		public void ForceRescan() {
+			gtk_source_style_scheme_manager_force_rescan(Handle);
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_manager_get_default();
+		static d_gtk_source_style_scheme_manager_get_default gtk_source_style_scheme_manager_get_default = FuncLoader.LoadFunction<d_gtk_source_style_scheme_manager_get_default>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_manager_get_default"));
+
+		public static GtkSource.StyleSchemeManager Default { 
+			get {
+				IntPtr raw_ret = gtk_source_style_scheme_manager_get_default();
+				GtkSource.StyleSchemeManager ret = GLib.Object.GetObject(raw_ret) as GtkSource.StyleSchemeManager;
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_manager_get_scheme(IntPtr raw, IntPtr scheme_id);
+		static d_gtk_source_style_scheme_manager_get_scheme gtk_source_style_scheme_manager_get_scheme = FuncLoader.LoadFunction<d_gtk_source_style_scheme_manager_get_scheme>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_manager_get_scheme"));
+
+		public GtkSource.StyleScheme GetScheme(string scheme_id) {
+			IntPtr native_scheme_id = GLib.Marshaller.StringToPtrGStrdup (scheme_id);
+			IntPtr raw_ret = gtk_source_style_scheme_manager_get_scheme(Handle, native_scheme_id);
+			GtkSource.StyleScheme ret = GLib.Object.GetObject(raw_ret) as GtkSource.StyleScheme;
+			GLib.Marshaller.Free (native_scheme_id);
+			return ret;
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate IntPtr d_gtk_source_style_scheme_manager_get_type();
+		static d_gtk_source_style_scheme_manager_get_type gtk_source_style_scheme_manager_get_type = FuncLoader.LoadFunction<d_gtk_source_style_scheme_manager_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_manager_get_type"));
+
+		public static new GLib.GType GType { 
+			get {
+				IntPtr raw_ret = gtk_source_style_scheme_manager_get_type();
+				GLib.GType ret = new GLib.GType(raw_ret);
+				return ret;
+			}
+		}
+
+		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+		delegate void d_gtk_source_style_scheme_manager_prepend_search_path(IntPtr raw, IntPtr path);
+		static d_gtk_source_style_scheme_manager_prepend_search_path gtk_source_style_scheme_manager_prepend_search_path = FuncLoader.LoadFunction<d_gtk_source_style_scheme_manager_prepend_search_path>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_style_scheme_manager_prepend_search_path"));
+
+		public void PrependSearchPath(string path) {
+			IntPtr native_path = GLib.Marshaller.StringToPtrGStrdup (path);
+			gtk_source_style_scheme_manager_prepend_search_path(Handle, native_path);
+			GLib.Marshaller.Free (native_path);
+		}
+
+
+		static StyleSchemeManager ()
+		{
+			GtkSharp.GtkSourceSharp.ObjectManager.Initialize ();
+		}
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe new GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+						new GLib.AbiField("priv"
+							, GLib.Object.abi_info.Fields
+							, (uint) sizeof( IntPtr ) // priv
+							, null
+							, null
+							, (uint) sizeof(IntPtr)
+							, 0
+							),
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}

GtkSharp/Source/Libs/GtkSourceSharp/Generated/GtkSource/SubPattern.cs

@@ -0,0 +1,34 @@
+// This file was generated by the Gtk# code generator.
+// Any changes made will be lost if regenerated.
+
+namespace GtkSource {
+
+	using System;
+	using System.Collections;
+	using System.Collections.Generic;
+	using System.Runtime.InteropServices;
+
+#region Autogenerated code
+	public partial class SubPattern : GLib.Opaque {
+
+		public SubPattern(IntPtr raw) : base(raw) {}
+
+
+		// Internal representation of the wrapped structure ABI.
+		static GLib.AbiStruct _abi_info = null;
+		static public unsafe GLib.AbiStruct abi_info {
+			get {
+				if (_abi_info == null)
+					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
+					});
+
+				return _abi_info;
+			}
+		}
+
+
+		// End of the ABI representation.
+
+#endregion
+	}
+}