// 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 GutterRenderer : GLib.InitiallyUnowned {

		public GutterRenderer (IntPtr raw) : base(raw) {}

		protected GutterRenderer() : base(IntPtr.Zero)
		{
			CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_source_gutter_renderer_get_visible(IntPtr raw);
		static d_gtk_source_gutter_renderer_get_visible gtk_source_gutter_renderer_get_visible = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_get_visible>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_get_visible"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_set_visible(IntPtr raw, bool visible);
		static d_gtk_source_gutter_renderer_set_visible gtk_source_gutter_renderer_set_visible = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_set_visible>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_set_visible"));

		[GLib.Property ("visible")]
		public bool Visible {
			get  {
				bool raw_ret = gtk_source_gutter_renderer_get_visible(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_source_gutter_renderer_set_visible(Handle, value);
			}
		}

		[GLib.Property ("xpad")]
		public int Xpad {
			get {
				GLib.Value val = GetProperty ("xpad");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("xpad", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("ypad")]
		public int Ypad {
			get {
				GLib.Value val = GetProperty ("ypad");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("ypad", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("xalign")]
		public float Xalign {
			get {
				GLib.Value val = GetProperty ("xalign");
				float ret = (float) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("xalign", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("yalign")]
		public float Yalign {
			get {
				GLib.Value val = GetProperty ("yalign");
				float ret = (float) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("yalign", val);
				val.Dispose ();
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_source_gutter_renderer_get_view(IntPtr raw);
		static d_gtk_source_gutter_renderer_get_view gtk_source_gutter_renderer_get_view = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_get_view>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_get_view"));

		[GLib.Property ("view")]
		public Gtk.TextView View {
			get  {
				IntPtr raw_ret = gtk_source_gutter_renderer_get_view(Handle);
				Gtk.TextView ret = GLib.Object.GetObject(raw_ret) as Gtk.TextView;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gtk_source_gutter_renderer_get_alignment_mode(IntPtr raw);
		static d_gtk_source_gutter_renderer_get_alignment_mode gtk_source_gutter_renderer_get_alignment_mode = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_get_alignment_mode>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_get_alignment_mode"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_set_alignment_mode(IntPtr raw, int mode);
		static d_gtk_source_gutter_renderer_set_alignment_mode gtk_source_gutter_renderer_set_alignment_mode = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_set_alignment_mode>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_set_alignment_mode"));

		[GLib.Property ("alignment-mode")]
		public GtkSource.GutterRendererAlignmentMode AlignmentMode {
			get  {
				int raw_ret = gtk_source_gutter_renderer_get_alignment_mode(Handle);
				GtkSource.GutterRendererAlignmentMode ret = (GtkSource.GutterRendererAlignmentMode) raw_ret;
				return ret;
			}
			set  {
				gtk_source_gutter_renderer_set_alignment_mode(Handle, (int) value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gtk_source_gutter_renderer_get_window_type(IntPtr raw);
		static d_gtk_source_gutter_renderer_get_window_type gtk_source_gutter_renderer_get_window_type = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_get_window_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_get_window_type"));

		[GLib.Property ("window-type")]
		public Gtk.TextWindowType WindowType {
			get  {
				int raw_ret = gtk_source_gutter_renderer_get_window_type(Handle);
				Gtk.TextWindowType ret = (Gtk.TextWindowType) raw_ret;
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gtk_source_gutter_renderer_get_size(IntPtr raw);
		static d_gtk_source_gutter_renderer_get_size gtk_source_gutter_renderer_get_size = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_get_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_get_size"));

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_set_size(IntPtr raw, int size);
		static d_gtk_source_gutter_renderer_set_size gtk_source_gutter_renderer_set_size = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_set_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_set_size"));

		[GLib.Property ("size")]
		public int Size {
			get  {
				int raw_ret = gtk_source_gutter_renderer_get_size(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_source_gutter_renderer_set_size(Handle, value);
			}
		}

		[GLib.Property ("background-rgba")]
		public Gdk.RGBA BackgroundRgba {
			get {
				GLib.Value val = GetProperty ("background-rgba");
				Gdk.RGBA ret = (Gdk.RGBA) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("background-rgba", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("background-set")]
		public bool BackgroundSet {
			get {
				GLib.Value val = GetProperty ("background-set");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("background-set", val);
				val.Dispose ();
			}
		}

		[GLib.Signal("query-tooltip")]
		public event GtkSource.TooltipQueriedHandler TooltipQueried {
			add {
				this.AddSignalHandler ("query-tooltip", value, typeof (GtkSource.TooltipQueriedArgs));
			}
			remove {
				this.RemoveSignalHandler ("query-tooltip", value);
			}
		}

		[GLib.Signal("queue-draw")]
		public event System.EventHandler DrawQueued {
			add {
				this.AddSignalHandler ("queue-draw", value);
			}
			remove {
				this.RemoveSignalHandler ("queue-draw", value);
			}
		}

		[GLib.Signal("query-activatable")]
		public event GtkSource.ActivatableQueriedHandler ActivatableQueried {
			add {
				this.AddSignalHandler ("query-activatable", value, typeof (GtkSource.ActivatableQueriedArgs));
			}
			remove {
				this.RemoveSignalHandler ("query-activatable", value);
			}
		}

		[GLib.Signal("query-data")]
		public event GtkSource.DataQueriedHandler DataQueried {
			add {
				this.AddSignalHandler ("query-data", value, typeof (GtkSource.DataQueriedArgs));
			}
			remove {
				this.RemoveSignalHandler ("query-data", value);
			}
		}

		[GLib.Signal("activate")]
		public event GtkSource.ActivatedHandler Activated {
			add {
				this.AddSignalHandler ("activate", value, typeof (GtkSource.ActivatedArgs));
			}
			remove {
				this.RemoveSignalHandler ("activate", value);
			}
		}

		static BeginNativeDelegate Begin_cb_delegate;
		static BeginNativeDelegate BeginVMCallback {
			get {
				if (Begin_cb_delegate == null)
					Begin_cb_delegate = new BeginNativeDelegate (Begin_cb);
				return Begin_cb_delegate;
			}
		}

		static void OverrideBegin (GLib.GType gtype)
		{
			OverrideBegin (gtype, BeginVMCallback);
		}

		static void OverrideBegin (GLib.GType gtype, BeginNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("begin"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void BeginNativeDelegate (IntPtr inst, IntPtr cr, IntPtr background_area, IntPtr cell_area, IntPtr start, IntPtr end);

		static void Begin_cb (IntPtr inst, IntPtr cr, IntPtr background_area, IntPtr cell_area, IntPtr start, IntPtr end)
		{
			Cairo.Context mycr = null;

			try {
				GutterRenderer __obj = GLib.Object.GetObject (inst, false) as GutterRenderer;
				mycr = new Cairo.Context (cr, false);
				__obj.OnBegin (mycr, (Gdk.Rectangle) Marshal.PtrToStructure (background_area, typeof (Gdk.Rectangle)), (Gdk.Rectangle) Marshal.PtrToStructure (cell_area, typeof (Gdk.Rectangle)), Gtk.TextIter.New (start), Gtk.TextIter.New (end));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.GutterRenderer), ConnectionMethod="OverrideBegin")]
		protected virtual void OnBegin (Cairo.Context cr, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.TextIter start, Gtk.TextIter end)
		{
			InternalBegin (cr, background_area, cell_area, start, end);
		}

		private void InternalBegin (Cairo.Context cr, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.TextIter start, Gtk.TextIter end)
		{
			BeginNativeDelegate unmanaged = class_abi.BaseOverride<BeginNativeDelegate>(this.LookupGType(), "begin");
			if (unmanaged == null) return;

			IntPtr native_background_area = GLib.Marshaller.StructureToPtrAlloc (background_area);
			IntPtr native_cell_area = GLib.Marshaller.StructureToPtrAlloc (cell_area);
			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, native_background_area, native_cell_area, native_start, native_end);
			Marshal.FreeHGlobal (native_background_area);
			Marshal.FreeHGlobal (native_cell_area);
			Marshal.FreeHGlobal (native_start);
			Marshal.FreeHGlobal (native_end);
		}

		static DrawNativeDelegate Draw_cb_delegate;
		static DrawNativeDelegate DrawVMCallback {
			get {
				if (Draw_cb_delegate == null)
					Draw_cb_delegate = new DrawNativeDelegate (Draw_cb);
				return Draw_cb_delegate;
			}
		}

		static void OverrideDraw (GLib.GType gtype)
		{
			OverrideDraw (gtype, DrawVMCallback);
		}

		static void OverrideDraw (GLib.GType gtype, DrawNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("draw"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawNativeDelegate (IntPtr inst, IntPtr cr, IntPtr background_area, IntPtr cell_area, IntPtr start, IntPtr end, int state);

		static void Draw_cb (IntPtr inst, IntPtr cr, IntPtr background_area, IntPtr cell_area, IntPtr start, IntPtr end, int state)
		{
			Cairo.Context mycr = null;

			try {
				GutterRenderer __obj = GLib.Object.GetObject (inst, false) as GutterRenderer;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDraw (mycr, (Gdk.Rectangle) Marshal.PtrToStructure (background_area, typeof (Gdk.Rectangle)), (Gdk.Rectangle) Marshal.PtrToStructure (cell_area, typeof (Gdk.Rectangle)), Gtk.TextIter.New (start), Gtk.TextIter.New (end), (GtkSource.GutterRendererState) state);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			} finally {
				var disposable_cr = mycr as IDisposable;
				if (disposable_cr != null)
					disposable_cr.Dispose ();
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.GutterRenderer), ConnectionMethod="OverrideDraw")]
		protected virtual void OnDraw (Cairo.Context cr, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.TextIter start, Gtk.TextIter end, GtkSource.GutterRendererState state)
		{
			InternalDraw (cr, background_area, cell_area, start, end, state);
		}

		private void InternalDraw (Cairo.Context cr, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.TextIter start, Gtk.TextIter end, GtkSource.GutterRendererState state)
		{
			DrawNativeDelegate unmanaged = class_abi.BaseOverride<DrawNativeDelegate>(this.LookupGType(), "draw");
			if (unmanaged == null) return;

			IntPtr native_background_area = GLib.Marshaller.StructureToPtrAlloc (background_area);
			IntPtr native_cell_area = GLib.Marshaller.StructureToPtrAlloc (cell_area);
			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
			unmanaged (this.Handle, cr == null ? IntPtr.Zero : cr.Handle, native_background_area, native_cell_area, native_start, native_end, (int) state);
			Marshal.FreeHGlobal (native_background_area);
			Marshal.FreeHGlobal (native_cell_area);
			Marshal.FreeHGlobal (native_start);
			Marshal.FreeHGlobal (native_end);
		}

		static EndNativeDelegate End_cb_delegate;
		static EndNativeDelegate EndVMCallback {
			get {
				if (End_cb_delegate == null)
					End_cb_delegate = new EndNativeDelegate (End_cb);
				return End_cb_delegate;
			}
		}

		static void OverrideEnd (GLib.GType gtype)
		{
			OverrideEnd (gtype, EndVMCallback);
		}

		static void OverrideEnd (GLib.GType gtype, EndNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("end"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void EndNativeDelegate (IntPtr inst);

		static void End_cb (IntPtr inst)
		{
			try {
				GutterRenderer __obj = GLib.Object.GetObject (inst, false) as GutterRenderer;
				__obj.OnEnd ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.GutterRenderer), ConnectionMethod="OverrideEnd")]
		protected virtual void OnEnd ()
		{
			InternalEnd ();
		}

		private void InternalEnd ()
		{
			EndNativeDelegate unmanaged = class_abi.BaseOverride<EndNativeDelegate>(this.LookupGType(), "end");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static ChangeViewNativeDelegate ChangeView_cb_delegate;
		static ChangeViewNativeDelegate ChangeViewVMCallback {
			get {
				if (ChangeView_cb_delegate == null)
					ChangeView_cb_delegate = new ChangeViewNativeDelegate (ChangeView_cb);
				return ChangeView_cb_delegate;
			}
		}

		static void OverrideChangeView (GLib.GType gtype)
		{
			OverrideChangeView (gtype, ChangeViewVMCallback);
		}

		static void OverrideChangeView (GLib.GType gtype, ChangeViewNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("change_view"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ChangeViewNativeDelegate (IntPtr inst, IntPtr old_view);

		static void ChangeView_cb (IntPtr inst, IntPtr old_view)
		{
			try {
				GutterRenderer __obj = GLib.Object.GetObject (inst, false) as GutterRenderer;
				__obj.OnChangeView (GLib.Object.GetObject(old_view) as Gtk.TextView);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.GutterRenderer), ConnectionMethod="OverrideChangeView")]
		protected virtual void OnChangeView (Gtk.TextView old_view)
		{
			InternalChangeView (old_view);
		}

		private void InternalChangeView (Gtk.TextView old_view)
		{
			ChangeViewNativeDelegate unmanaged = class_abi.BaseOverride<ChangeViewNativeDelegate>(this.LookupGType(), "change_view");
			if (unmanaged == null) return;

			unmanaged (this.Handle, old_view == null ? IntPtr.Zero : old_view.Handle);
		}

		static ChangeBufferNativeDelegate ChangeBuffer_cb_delegate;
		static ChangeBufferNativeDelegate ChangeBufferVMCallback {
			get {
				if (ChangeBuffer_cb_delegate == null)
					ChangeBuffer_cb_delegate = new ChangeBufferNativeDelegate (ChangeBuffer_cb);
				return ChangeBuffer_cb_delegate;
			}
		}

		static void OverrideChangeBuffer (GLib.GType gtype)
		{
			OverrideChangeBuffer (gtype, ChangeBufferVMCallback);
		}

		static void OverrideChangeBuffer (GLib.GType gtype, ChangeBufferNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("change_buffer"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ChangeBufferNativeDelegate (IntPtr inst, IntPtr old_buffer);

		static void ChangeBuffer_cb (IntPtr inst, IntPtr old_buffer)
		{
			try {
				GutterRenderer __obj = GLib.Object.GetObject (inst, false) as GutterRenderer;
				__obj.OnChangeBuffer (GLib.Object.GetObject(old_buffer) as Gtk.TextBuffer);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.GutterRenderer), ConnectionMethod="OverrideChangeBuffer")]
		protected virtual void OnChangeBuffer (Gtk.TextBuffer old_buffer)
		{
			InternalChangeBuffer (old_buffer);
		}

		private void InternalChangeBuffer (Gtk.TextBuffer old_buffer)
		{
			ChangeBufferNativeDelegate unmanaged = class_abi.BaseOverride<ChangeBufferNativeDelegate>(this.LookupGType(), "change_buffer");
			if (unmanaged == null) return;

			unmanaged (this.Handle, old_buffer == null ? IntPtr.Zero : old_buffer.Handle);
		}

		static ActivatableQueriedNativeDelegate ActivatableQueried_cb_delegate;
		static ActivatableQueriedNativeDelegate ActivatableQueriedVMCallback {
			get {
				if (ActivatableQueried_cb_delegate == null)
					ActivatableQueried_cb_delegate = new ActivatableQueriedNativeDelegate (ActivatableQueried_cb);
				return ActivatableQueried_cb_delegate;
			}
		}

		static void OverrideActivatableQueried (GLib.GType gtype)
		{
			OverrideActivatableQueried (gtype, ActivatableQueriedVMCallback);
		}

		static void OverrideActivatableQueried (GLib.GType gtype, ActivatableQueriedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("query_activatable"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ActivatableQueriedNativeDelegate (IntPtr inst, IntPtr iter, IntPtr area, IntPtr evnt);

		static bool ActivatableQueried_cb (IntPtr inst, IntPtr iter, IntPtr area, IntPtr evnt)
		{
			try {
				GutterRenderer __obj = GLib.Object.GetObject (inst, false) as GutterRenderer;
				bool __result;
				__result = __obj.OnActivatableQueried (Gtk.TextIter.New (iter), (Gdk.Rectangle) Marshal.PtrToStructure (area, typeof (Gdk.Rectangle)), Gdk.Event.GetEvent (evnt));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.GutterRenderer), ConnectionMethod="OverrideActivatableQueried")]
		protected virtual bool OnActivatableQueried (Gtk.TextIter iter, Gdk.Rectangle area, Gdk.Event evnt)
		{
			return InternalActivatableQueried (iter, area, evnt);
		}

		private bool InternalActivatableQueried (Gtk.TextIter iter, Gdk.Rectangle area, Gdk.Event evnt)
		{
			ActivatableQueriedNativeDelegate unmanaged = class_abi.BaseOverride<ActivatableQueriedNativeDelegate>(this.LookupGType(), "query_activatable");
			if (unmanaged == null) return false;

			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			IntPtr native_area = GLib.Marshaller.StructureToPtrAlloc (area);
			bool __result = unmanaged (this.Handle, native_iter, native_area, evnt == null ? IntPtr.Zero : evnt.Handle);
			Marshal.FreeHGlobal (native_iter);
			Marshal.FreeHGlobal (native_area);
			return __result;
		}

		static ActivatedNativeDelegate Activated_cb_delegate;
		static ActivatedNativeDelegate ActivatedVMCallback {
			get {
				if (Activated_cb_delegate == null)
					Activated_cb_delegate = new ActivatedNativeDelegate (Activated_cb);
				return Activated_cb_delegate;
			}
		}

		static void OverrideActivated (GLib.GType gtype)
		{
			OverrideActivated (gtype, ActivatedVMCallback);
		}

		static void OverrideActivated (GLib.GType gtype, ActivatedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("activate"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ActivatedNativeDelegate (IntPtr inst, IntPtr iter, IntPtr area, IntPtr evnt);

		static void Activated_cb (IntPtr inst, IntPtr iter, IntPtr area, IntPtr evnt)
		{
			try {
				GutterRenderer __obj = GLib.Object.GetObject (inst, false) as GutterRenderer;
				__obj.OnActivated (Gtk.TextIter.New (iter), (Gdk.Rectangle) Marshal.PtrToStructure (area, typeof (Gdk.Rectangle)), Gdk.Event.GetEvent (evnt));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.GutterRenderer), ConnectionMethod="OverrideActivated")]
		protected virtual void OnActivated (Gtk.TextIter iter, Gdk.Rectangle area, Gdk.Event evnt)
		{
			InternalActivated (iter, area, evnt);
		}

		private void InternalActivated (Gtk.TextIter iter, Gdk.Rectangle area, Gdk.Event evnt)
		{
			ActivatedNativeDelegate unmanaged = class_abi.BaseOverride<ActivatedNativeDelegate>(this.LookupGType(), "activate");
			if (unmanaged == null) return;

			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			IntPtr native_area = GLib.Marshaller.StructureToPtrAlloc (area);
			unmanaged (this.Handle, native_iter, native_area, evnt == null ? IntPtr.Zero : evnt.Handle);
			Marshal.FreeHGlobal (native_iter);
			Marshal.FreeHGlobal (native_area);
		}

		static DrawQueuedNativeDelegate DrawQueued_cb_delegate;
		static DrawQueuedNativeDelegate DrawQueuedVMCallback {
			get {
				if (DrawQueued_cb_delegate == null)
					DrawQueued_cb_delegate = new DrawQueuedNativeDelegate (DrawQueued_cb);
				return DrawQueued_cb_delegate;
			}
		}

		static void OverrideDrawQueued (GLib.GType gtype)
		{
			OverrideDrawQueued (gtype, DrawQueuedVMCallback);
		}

		static void OverrideDrawQueued (GLib.GType gtype, DrawQueuedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("queue_draw"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawQueuedNativeDelegate (IntPtr inst);

		static void DrawQueued_cb (IntPtr inst)
		{
			try {
				GutterRenderer __obj = GLib.Object.GetObject (inst, false) as GutterRenderer;
				__obj.OnDrawQueued ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.GutterRenderer), ConnectionMethod="OverrideDrawQueued")]
		protected virtual void OnDrawQueued ()
		{
			InternalDrawQueued ();
		}

		private void InternalDrawQueued ()
		{
			DrawQueuedNativeDelegate unmanaged = class_abi.BaseOverride<DrawQueuedNativeDelegate>(this.LookupGType(), "queue_draw");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static TooltipQueriedNativeDelegate TooltipQueried_cb_delegate;
		static TooltipQueriedNativeDelegate TooltipQueriedVMCallback {
			get {
				if (TooltipQueried_cb_delegate == null)
					TooltipQueried_cb_delegate = new TooltipQueriedNativeDelegate (TooltipQueried_cb);
				return TooltipQueried_cb_delegate;
			}
		}

		static void OverrideTooltipQueried (GLib.GType gtype)
		{
			OverrideTooltipQueried (gtype, TooltipQueriedVMCallback);
		}

		static void OverrideTooltipQueried (GLib.GType gtype, TooltipQueriedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("query_tooltip"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool TooltipQueriedNativeDelegate (IntPtr inst, IntPtr iter, IntPtr area, int x, int y, IntPtr tooltip);

		static bool TooltipQueried_cb (IntPtr inst, IntPtr iter, IntPtr area, int x, int y, IntPtr tooltip)
		{
			try {
				GutterRenderer __obj = GLib.Object.GetObject (inst, false) as GutterRenderer;
				bool __result;
				__result = __obj.OnTooltipQueried (Gtk.TextIter.New (iter), (Gdk.Rectangle) Marshal.PtrToStructure (area, typeof (Gdk.Rectangle)), x, y, GLib.Object.GetObject(tooltip) as Gtk.Tooltip);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.GutterRenderer), ConnectionMethod="OverrideTooltipQueried")]
		protected virtual bool OnTooltipQueried (Gtk.TextIter iter, Gdk.Rectangle area, int x, int y, Gtk.Tooltip tooltip)
		{
			return InternalTooltipQueried (iter, area, x, y, tooltip);
		}

		private bool InternalTooltipQueried (Gtk.TextIter iter, Gdk.Rectangle area, int x, int y, Gtk.Tooltip tooltip)
		{
			TooltipQueriedNativeDelegate unmanaged = class_abi.BaseOverride<TooltipQueriedNativeDelegate>(this.LookupGType(), "query_tooltip");
			if (unmanaged == null) return false;

			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			IntPtr native_area = GLib.Marshaller.StructureToPtrAlloc (area);
			bool __result = unmanaged (this.Handle, native_iter, native_area, x, y, tooltip == null ? IntPtr.Zero : tooltip.Handle);
			Marshal.FreeHGlobal (native_iter);
			Marshal.FreeHGlobal (native_area);
			return __result;
		}

		static DataQueriedNativeDelegate DataQueried_cb_delegate;
		static DataQueriedNativeDelegate DataQueriedVMCallback {
			get {
				if (DataQueried_cb_delegate == null)
					DataQueried_cb_delegate = new DataQueriedNativeDelegate (DataQueried_cb);
				return DataQueried_cb_delegate;
			}
		}

		static void OverrideDataQueried (GLib.GType gtype)
		{
			OverrideDataQueried (gtype, DataQueriedVMCallback);
		}

		static void OverrideDataQueried (GLib.GType gtype, DataQueriedNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("query_data"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate(callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DataQueriedNativeDelegate (IntPtr inst, IntPtr start, IntPtr end, int state);

		static void DataQueried_cb (IntPtr inst, IntPtr start, IntPtr end, int state)
		{
			try {
				GutterRenderer __obj = GLib.Object.GetObject (inst, false) as GutterRenderer;
				__obj.OnDataQueried (Gtk.TextIter.New (start), Gtk.TextIter.New (end), (GtkSource.GutterRendererState) state);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GtkSource.GutterRenderer), ConnectionMethod="OverrideDataQueried")]
		protected virtual void OnDataQueried (Gtk.TextIter start, Gtk.TextIter end, GtkSource.GutterRendererState state)
		{
			InternalDataQueried (start, end, state);
		}

		private void InternalDataQueried (Gtk.TextIter start, Gtk.TextIter end, GtkSource.GutterRendererState state)
		{
			DataQueriedNativeDelegate unmanaged = class_abi.BaseOverride<DataQueriedNativeDelegate>(this.LookupGType(), "query_data");
			if (unmanaged == null) return;

			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
			unmanaged (this.Handle, native_start, native_end, (int) state);
			Marshal.FreeHGlobal (native_start);
			Marshal.FreeHGlobal (native_end);
		}


		// 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("begin"
							, GLib.Object.class_abi.Fields
							, (uint) sizeof( IntPtr ) // begin
							, null
							, "draw"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw"
							, -1
							, (uint) sizeof( IntPtr ) // draw
							, "begin"
							, "end"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("end"
							, -1
							, (uint) sizeof( IntPtr ) // end
							, "draw"
							, "change_view"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("change_view"
							, -1
							, (uint) sizeof( IntPtr ) // change_view
							, "end"
							, "change_buffer"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("change_buffer"
							, -1
							, (uint) sizeof( IntPtr ) // change_buffer
							, "change_view"
							, "query_activatable"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("query_activatable"
							, -1
							, (uint) sizeof( IntPtr ) // query_activatable
							, "change_buffer"
							, "activate"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("activate"
							, -1
							, (uint) sizeof( IntPtr ) // activate
							, "query_activatable"
							, "queue_draw"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("queue_draw"
							, -1
							, (uint) sizeof( IntPtr ) // queue_draw
							, "activate"
							, "query_tooltip"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("query_tooltip"
							, -1
							, (uint) sizeof( IntPtr ) // query_tooltip
							, "queue_draw"
							, "query_data"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("query_data"
							, -1
							, (uint) sizeof( IntPtr ) // query_data
							, "query_tooltip"
							, "padding"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("padding"
							, -1
							, (uint) sizeof( IntPtr ) * 20 // padding
							, "query_data"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_activate(IntPtr raw, IntPtr iter, IntPtr area, IntPtr evnt);
		static d_gtk_source_gutter_renderer_activate gtk_source_gutter_renderer_activate = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_activate>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_activate"));

		public void Activate(Gtk.TextIter iter, Gdk.Rectangle area, Gdk.Event evnt) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			IntPtr native_area = GLib.Marshaller.StructureToPtrAlloc (area);
			gtk_source_gutter_renderer_activate(Handle, native_iter, native_area, evnt == null ? IntPtr.Zero : evnt.Handle);
			Marshal.FreeHGlobal (native_iter);
			Marshal.FreeHGlobal (native_area);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_begin(IntPtr raw, IntPtr cr, IntPtr background_area, IntPtr cell_area, IntPtr start, IntPtr end);
		static d_gtk_source_gutter_renderer_begin gtk_source_gutter_renderer_begin = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_begin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_begin"));

		public void Begin(Cairo.Context cr, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.TextIter start, Gtk.TextIter end) {
			IntPtr native_background_area = GLib.Marshaller.StructureToPtrAlloc (background_area);
			IntPtr native_cell_area = GLib.Marshaller.StructureToPtrAlloc (cell_area);
			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
			gtk_source_gutter_renderer_begin(Handle, cr == null ? IntPtr.Zero : cr.Handle, native_background_area, native_cell_area, native_start, native_end);
			Marshal.FreeHGlobal (native_background_area);
			Marshal.FreeHGlobal (native_cell_area);
			Marshal.FreeHGlobal (native_start);
			Marshal.FreeHGlobal (native_end);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_draw(IntPtr raw, IntPtr cr, IntPtr background_area, IntPtr cell_area, IntPtr start, IntPtr end, int state);
		static d_gtk_source_gutter_renderer_draw gtk_source_gutter_renderer_draw = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_draw>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_draw"));

		public void Draw(Cairo.Context cr, Gdk.Rectangle background_area, Gdk.Rectangle cell_area, Gtk.TextIter start, Gtk.TextIter end, GtkSource.GutterRendererState state) {
			IntPtr native_background_area = GLib.Marshaller.StructureToPtrAlloc (background_area);
			IntPtr native_cell_area = GLib.Marshaller.StructureToPtrAlloc (cell_area);
			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
			gtk_source_gutter_renderer_draw(Handle, cr == null ? IntPtr.Zero : cr.Handle, native_background_area, native_cell_area, native_start, native_end, (int) state);
			Marshal.FreeHGlobal (native_background_area);
			Marshal.FreeHGlobal (native_cell_area);
			Marshal.FreeHGlobal (native_start);
			Marshal.FreeHGlobal (native_end);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_end(IntPtr raw);
		static d_gtk_source_gutter_renderer_end gtk_source_gutter_renderer_end = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_end>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_end"));

		public void End() {
			gtk_source_gutter_renderer_end(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_get_alignment(IntPtr raw, out float xalign, out float yalign);
		static d_gtk_source_gutter_renderer_get_alignment gtk_source_gutter_renderer_get_alignment = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_get_alignment>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_get_alignment"));

		public void GetAlignment(out float xalign, out float yalign) {
			gtk_source_gutter_renderer_get_alignment(Handle, out xalign, out yalign);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_source_gutter_renderer_get_background(IntPtr raw, IntPtr color);
		static d_gtk_source_gutter_renderer_get_background gtk_source_gutter_renderer_get_background = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_get_background>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_get_background"));

		public bool GetBackground(Gdk.RGBA color) {
			IntPtr native_color = GLib.Marshaller.StructureToPtrAlloc (color);
			bool raw_ret = gtk_source_gutter_renderer_get_background(Handle, native_color);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_color);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_get_padding(IntPtr raw, out int xpad, out int ypad);
		static d_gtk_source_gutter_renderer_get_padding gtk_source_gutter_renderer_get_padding = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_get_padding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_get_padding"));

		public void GetPadding(out int xpad, out int ypad) {
			gtk_source_gutter_renderer_get_padding(Handle, out xpad, out ypad);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_source_gutter_renderer_get_type();
		static d_gtk_source_gutter_renderer_get_type gtk_source_gutter_renderer_get_type = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_get_type"));

		public static new GLib.GType GType { 
			get {
				IntPtr raw_ret = gtk_source_gutter_renderer_get_type();
				GLib.GType ret = new GLib.GType(raw_ret);
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_source_gutter_renderer_query_activatable(IntPtr raw, IntPtr iter, IntPtr area, IntPtr evnt);
		static d_gtk_source_gutter_renderer_query_activatable gtk_source_gutter_renderer_query_activatable = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_query_activatable>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_query_activatable"));

		public bool QueryActivatable(Gtk.TextIter iter, Gdk.Rectangle area, Gdk.Event evnt) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			IntPtr native_area = GLib.Marshaller.StructureToPtrAlloc (area);
			bool raw_ret = gtk_source_gutter_renderer_query_activatable(Handle, native_iter, native_area, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_iter);
			Marshal.FreeHGlobal (native_area);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_query_data(IntPtr raw, IntPtr start, IntPtr end, int state);
		static d_gtk_source_gutter_renderer_query_data gtk_source_gutter_renderer_query_data = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_query_data>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_query_data"));

		public void QueryData(Gtk.TextIter start, Gtk.TextIter end, GtkSource.GutterRendererState state) {
			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
			gtk_source_gutter_renderer_query_data(Handle, native_start, native_end, (int) state);
			Marshal.FreeHGlobal (native_start);
			Marshal.FreeHGlobal (native_end);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_source_gutter_renderer_query_tooltip(IntPtr raw, IntPtr iter, IntPtr area, int x, int y, IntPtr tooltip);
		static d_gtk_source_gutter_renderer_query_tooltip gtk_source_gutter_renderer_query_tooltip = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_query_tooltip>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_query_tooltip"));

		public bool QueryTooltip(Gtk.TextIter iter, Gdk.Rectangle area, int x, int y, Gtk.Tooltip tooltip) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			IntPtr native_area = GLib.Marshaller.StructureToPtrAlloc (area);
			bool raw_ret = gtk_source_gutter_renderer_query_tooltip(Handle, native_iter, native_area, x, y, tooltip == null ? IntPtr.Zero : tooltip.Handle);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_iter);
			Marshal.FreeHGlobal (native_area);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_queue_draw(IntPtr raw);
		static d_gtk_source_gutter_renderer_queue_draw gtk_source_gutter_renderer_queue_draw = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_queue_draw>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_queue_draw"));

		public void QueueDraw() {
			gtk_source_gutter_renderer_queue_draw(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_set_alignment(IntPtr raw, float xalign, float yalign);
		static d_gtk_source_gutter_renderer_set_alignment gtk_source_gutter_renderer_set_alignment = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_set_alignment>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_set_alignment"));

		public void SetAlignment(float xalign, float yalign) {
			gtk_source_gutter_renderer_set_alignment(Handle, xalign, yalign);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_set_background(IntPtr raw, IntPtr color);
		static d_gtk_source_gutter_renderer_set_background gtk_source_gutter_renderer_set_background = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_set_background>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_set_background"));

		public void SetBackground(Gdk.RGBA color) {
			IntPtr native_color = GLib.Marshaller.StructureToPtrAlloc (color);
			gtk_source_gutter_renderer_set_background(Handle, native_color);
			Marshal.FreeHGlobal (native_color);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_source_gutter_renderer_set_padding(IntPtr raw, int xpad, int ypad);
		static d_gtk_source_gutter_renderer_set_padding gtk_source_gutter_renderer_set_padding = FuncLoader.LoadFunction<d_gtk_source_gutter_renderer_set_padding>(FuncLoader.GetProcAddress(GLibrary.Load(Library.GtkSource), "gtk_source_gutter_renderer_set_padding"));

		public void SetPadding(int xpad, int ypad) {
			gtk_source_gutter_renderer_set_padding(Handle, xpad, ypad);
		}


		static GutterRenderer ()
		{
			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
	}
}