// This file was generated by the Gtk# code generator.
// Any changes made will be lost if regenerated.

namespace Gtk {

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Runtime.InteropServices;
	using static GLib.AbiStructExtension;

#region Autogenerated code
	public partial class TextView : Gtk.Container, Gtk.IScrollable {

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_text_view_new();
		static d_gtk_text_view_new gtk_text_view_new = FuncLoader.LoadFunction<d_gtk_text_view_new>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_new"));

		public TextView () : base (IntPtr.Zero)
		{
			if (GetType () != typeof (TextView)) {
				CreateNativeObject (Array.Empty<string> (), Array.Empty<GLib.Value> ());
				return;
			}
			Raw = gtk_text_view_new();
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_pixels_above_lines(IntPtr raw, int pixels_above_lines);
		static d_gtk_text_view_set_pixels_above_lines gtk_text_view_set_pixels_above_lines = FuncLoader.LoadFunction<d_gtk_text_view_set_pixels_above_lines>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_pixels_above_lines"));

		[GLib.Property ("pixels-above-lines")]
		public int PixelsAboveLines {
			get  {
				int raw_ret = gtk_text_view_get_pixels_above_lines(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_pixels_above_lines(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_pixels_below_lines(IntPtr raw, int pixels_below_lines);
		static d_gtk_text_view_set_pixels_below_lines gtk_text_view_set_pixels_below_lines = FuncLoader.LoadFunction<d_gtk_text_view_set_pixels_below_lines>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_pixels_below_lines"));

		[GLib.Property ("pixels-below-lines")]
		public int PixelsBelowLines {
			get  {
				int raw_ret = gtk_text_view_get_pixels_below_lines(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_pixels_below_lines(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_pixels_inside_wrap(IntPtr raw, int pixels_inside_wrap);
		static d_gtk_text_view_set_pixels_inside_wrap gtk_text_view_set_pixels_inside_wrap = FuncLoader.LoadFunction<d_gtk_text_view_set_pixels_inside_wrap>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_pixels_inside_wrap"));

		[GLib.Property ("pixels-inside-wrap")]
		public int PixelsInsideWrap {
			get  {
				int raw_ret = gtk_text_view_get_pixels_inside_wrap(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_pixels_inside_wrap(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_editable(IntPtr raw, bool setting);
		static d_gtk_text_view_set_editable gtk_text_view_set_editable = FuncLoader.LoadFunction<d_gtk_text_view_set_editable>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_editable"));

		[GLib.Property ("editable")]
		public bool Editable {
			get  {
				bool raw_ret = gtk_text_view_get_editable(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_editable(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_wrap_mode(IntPtr raw, int wrap_mode);
		static d_gtk_text_view_set_wrap_mode gtk_text_view_set_wrap_mode = FuncLoader.LoadFunction<d_gtk_text_view_set_wrap_mode>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_wrap_mode"));

		[GLib.Property ("wrap-mode")]
		public Gtk.WrapMode WrapMode {
			get  {
				int raw_ret = gtk_text_view_get_wrap_mode(Handle);
				Gtk.WrapMode ret = (Gtk.WrapMode) raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_wrap_mode(Handle, (int) value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_justification(IntPtr raw, int justification);
		static d_gtk_text_view_set_justification gtk_text_view_set_justification = FuncLoader.LoadFunction<d_gtk_text_view_set_justification>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_justification"));

		[GLib.Property ("justification")]
		public Gtk.Justification Justification {
			get  {
				int raw_ret = gtk_text_view_get_justification(Handle);
				Gtk.Justification ret = (Gtk.Justification) raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_justification(Handle, (int) value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_left_margin(IntPtr raw, int left_margin);
		static d_gtk_text_view_set_left_margin gtk_text_view_set_left_margin = FuncLoader.LoadFunction<d_gtk_text_view_set_left_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_left_margin"));

		[GLib.Property ("left-margin")]
		public int LeftMargin {
			get  {
				int raw_ret = gtk_text_view_get_left_margin(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_left_margin(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_right_margin(IntPtr raw, int right_margin);
		static d_gtk_text_view_set_right_margin gtk_text_view_set_right_margin = FuncLoader.LoadFunction<d_gtk_text_view_set_right_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_right_margin"));

		[GLib.Property ("right-margin")]
		public int RightMargin {
			get  {
				int raw_ret = gtk_text_view_get_right_margin(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_right_margin(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_top_margin(IntPtr raw, int top_margin);
		static d_gtk_text_view_set_top_margin gtk_text_view_set_top_margin = FuncLoader.LoadFunction<d_gtk_text_view_set_top_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_top_margin"));

		[GLib.Property ("top-margin")]
		public int TopMargin {
			get  {
				int raw_ret = gtk_text_view_get_top_margin(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_top_margin(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_bottom_margin(IntPtr raw, int bottom_margin);
		static d_gtk_text_view_set_bottom_margin gtk_text_view_set_bottom_margin = FuncLoader.LoadFunction<d_gtk_text_view_set_bottom_margin>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_bottom_margin"));

		[GLib.Property ("bottom-margin")]
		public int BottomMargin {
			get  {
				int raw_ret = gtk_text_view_get_bottom_margin(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_bottom_margin(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_indent(IntPtr raw, int indent);
		static d_gtk_text_view_set_indent gtk_text_view_set_indent = FuncLoader.LoadFunction<d_gtk_text_view_set_indent>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_indent"));

		[GLib.Property ("indent")]
		public int Indent {
			get  {
				int raw_ret = gtk_text_view_get_indent(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_indent(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_tabs(IntPtr raw, IntPtr tabs);
		static d_gtk_text_view_set_tabs gtk_text_view_set_tabs = FuncLoader.LoadFunction<d_gtk_text_view_set_tabs>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_tabs"));

		[GLib.Property ("tabs")]
		public Pango.TabArray Tabs {
			get  {
				IntPtr raw_ret = gtk_text_view_get_tabs(Handle);
				Pango.TabArray ret = raw_ret == IntPtr.Zero ? null : (Pango.TabArray) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.TabArray), false);
				return ret;
			}
			set  {
				gtk_text_view_set_tabs(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_cursor_visible(IntPtr raw, bool setting);
		static d_gtk_text_view_set_cursor_visible gtk_text_view_set_cursor_visible = FuncLoader.LoadFunction<d_gtk_text_view_set_cursor_visible>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_cursor_visible"));

		[GLib.Property ("cursor-visible")]
		public bool CursorVisible {
			get  {
				bool raw_ret = gtk_text_view_get_cursor_visible(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_cursor_visible(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_buffer(IntPtr raw, IntPtr buffer);
		static d_gtk_text_view_set_buffer gtk_text_view_set_buffer = FuncLoader.LoadFunction<d_gtk_text_view_set_buffer>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_buffer"));

		[GLib.Property ("buffer")]
		public Gtk.TextBuffer Buffer {
			get  {
				IntPtr raw_ret = gtk_text_view_get_buffer(Handle);
				Gtk.TextBuffer ret = GLib.Object.GetObject(raw_ret) as Gtk.TextBuffer;
				return ret;
			}
			set  {
				gtk_text_view_set_buffer(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_overwrite(IntPtr raw, bool overwrite);
		static d_gtk_text_view_set_overwrite gtk_text_view_set_overwrite = FuncLoader.LoadFunction<d_gtk_text_view_set_overwrite>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_overwrite"));

		[GLib.Property ("overwrite")]
		public bool Overwrite {
			get  {
				bool raw_ret = gtk_text_view_get_overwrite(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_overwrite(Handle, value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_accepts_tab(IntPtr raw, bool accepts_tab);
		static d_gtk_text_view_set_accepts_tab gtk_text_view_set_accepts_tab = FuncLoader.LoadFunction<d_gtk_text_view_set_accepts_tab>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_accepts_tab"));

		[GLib.Property ("accepts-tab")]
		public bool AcceptsTab {
			get  {
				bool raw_ret = gtk_text_view_get_accepts_tab(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_accepts_tab(Handle, value);
			}
		}

		[GLib.Property ("im-module")]
		public string ImModule {
			get {
				GLib.Value val = GetProperty ("im-module");
				string ret = (string) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("im-module", val);
				val.Dispose ();
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_input_purpose(IntPtr raw, int purpose);
		static d_gtk_text_view_set_input_purpose gtk_text_view_set_input_purpose = FuncLoader.LoadFunction<d_gtk_text_view_set_input_purpose>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_input_purpose"));

		[GLib.Property ("input-purpose")]
		public Gtk.InputPurpose InputPurpose {
			get  {
				int raw_ret = gtk_text_view_get_input_purpose(Handle);
				Gtk.InputPurpose ret = (Gtk.InputPurpose) raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_input_purpose(Handle, (int) value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_input_hints(IntPtr raw, int hints);
		static d_gtk_text_view_set_input_hints gtk_text_view_set_input_hints = FuncLoader.LoadFunction<d_gtk_text_view_set_input_hints>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_input_hints"));

		[GLib.Property ("input-hints")]
		public Gtk.InputHints InputHints {
			get  {
				int raw_ret = gtk_text_view_get_input_hints(Handle);
				Gtk.InputHints ret = (Gtk.InputHints) raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_input_hints(Handle, (int) value);
			}
		}

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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_monospace(IntPtr raw, bool monospace);
		static d_gtk_text_view_set_monospace gtk_text_view_set_monospace = FuncLoader.LoadFunction<d_gtk_text_view_set_monospace>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_monospace"));

		[GLib.Property ("monospace")]
		public bool Monospace {
			get  {
				bool raw_ret = gtk_text_view_get_monospace(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_text_view_set_monospace(Handle, value);
			}
		}

		public Gdk.Color? ErrorUnderlineColor {
			get {
				var val = (Gdk.Color?)StyleGetProperty("error-underline-color");
				return val;
			}
		}

		[GLib.Signal("toggle-cursor-visible")]
		public event System.EventHandler ToggleCursorVisible {
			add {
				this.AddSignalHandler ("toggle-cursor-visible", value);
			}
			remove {
				this.RemoveSignalHandler ("toggle-cursor-visible", value);
			}
		}

		[GLib.Signal("set-anchor")]
		public event System.EventHandler SetAnchor {
			add {
				this.AddSignalHandler ("set-anchor", value);
			}
			remove {
				this.RemoveSignalHandler ("set-anchor", value);
			}
		}

		[GLib.Signal("toggle-overwrite")]
		public event System.EventHandler ToggleOverwrite {
			add {
				this.AddSignalHandler ("toggle-overwrite", value);
			}
			remove {
				this.RemoveSignalHandler ("toggle-overwrite", value);
			}
		}

		[GLib.Signal("backspace")]
		public event System.EventHandler Backspace {
			add {
				this.AddSignalHandler ("backspace", value);
			}
			remove {
				this.RemoveSignalHandler ("backspace", value);
			}
		}

		[GLib.Signal("copy-clipboard")]
		public event System.EventHandler CopyClipboard {
			add {
				this.AddSignalHandler ("copy-clipboard", value);
			}
			remove {
				this.RemoveSignalHandler ("copy-clipboard", value);
			}
		}

		[GLib.Signal("populate-popup")]
		public event Gtk.PopulatePopupHandler PopulatePopup {
			add {
				this.AddSignalHandler ("populate-popup", value, typeof (Gtk.PopulatePopupArgs));
			}
			remove {
				this.RemoveSignalHandler ("populate-popup", value);
			}
		}

		[GLib.Signal("insert-at-cursor")]
		public event Gtk.InsertAtCursorHandler InsertAtCursor {
			add {
				this.AddSignalHandler ("insert-at-cursor", value, typeof (Gtk.InsertAtCursorArgs));
			}
			remove {
				this.RemoveSignalHandler ("insert-at-cursor", value);
			}
		}

		[GLib.Signal("preedit-changed")]
		public event Gtk.PreeditChangedHandler PreeditChanged {
			add {
				this.AddSignalHandler ("preedit-changed", value, typeof (Gtk.PreeditChangedArgs));
			}
			remove {
				this.RemoveSignalHandler ("preedit-changed", value);
			}
		}

		[GLib.Signal("select-all")]
		public event Gtk.SelectAllHandler SelectAll {
			add {
				this.AddSignalHandler ("select-all", value, typeof (Gtk.SelectAllArgs));
			}
			remove {
				this.RemoveSignalHandler ("select-all", value);
			}
		}

		[GLib.Signal("move-viewport")]
		public event Gtk.MoveViewportHandler MoveViewport {
			add {
				this.AddSignalHandler ("move-viewport", value, typeof (Gtk.MoveViewportArgs));
			}
			remove {
				this.RemoveSignalHandler ("move-viewport", value);
			}
		}

		[GLib.Signal("extend-selection")]
		public event Gtk.ExtendSelectionHandler ExtendSelection {
			add {
				this.AddSignalHandler ("extend-selection", value, typeof (Gtk.ExtendSelectionArgs));
			}
			remove {
				this.RemoveSignalHandler ("extend-selection", value);
			}
		}

		[GLib.Signal("delete-from-cursor")]
		public event Gtk.DeleteFromCursorHandler DeleteFromCursor {
			add {
				this.AddSignalHandler ("delete-from-cursor", value, typeof (Gtk.DeleteFromCursorArgs));
			}
			remove {
				this.RemoveSignalHandler ("delete-from-cursor", value);
			}
		}

		[GLib.Signal("cut-clipboard")]
		public event System.EventHandler CutClipboard {
			add {
				this.AddSignalHandler ("cut-clipboard", value);
			}
			remove {
				this.RemoveSignalHandler ("cut-clipboard", value);
			}
		}

		[GLib.Signal("move-cursor")]
		public event Gtk.MoveCursorHandler MoveCursor {
			add {
				this.AddSignalHandler ("move-cursor", value, typeof (Gtk.MoveCursorArgs));
			}
			remove {
				this.RemoveSignalHandler ("move-cursor", value);
			}
		}

		[GLib.Signal("paste-clipboard")]
		public event System.EventHandler PasteClipboard {
			add {
				this.AddSignalHandler ("paste-clipboard", value);
			}
			remove {
				this.RemoveSignalHandler ("paste-clipboard", value);
			}
		}

		static MoveViewportNativeDelegate MoveViewport_cb_delegate;
		static MoveViewportNativeDelegate MoveViewportVMCallback {
			get {
				if (MoveViewport_cb_delegate == null)
					MoveViewport_cb_delegate = new MoveViewportNativeDelegate (MoveViewport_cb);
				return MoveViewport_cb_delegate;
			}
		}

		static void OverrideMoveViewport (GLib.GType gtype)
		{
			OverrideMoveViewport (gtype, MoveViewportVMCallback);
		}

		static void OverrideMoveViewport (GLib.GType gtype, MoveViewportNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "move-viewport", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void MoveViewportNativeDelegate (IntPtr inst, int p0, int p1);

		static void MoveViewport_cb (IntPtr inst, int p0, int p1)
		{
			try {
				TextView __obj = GLib.Object.GetObject (inst, false) as TextView;
				__obj.OnMoveViewport ((Gtk.ScrollStep) p0, p1);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideMoveViewport")]
		protected virtual void OnMoveViewport (Gtk.ScrollStep p0, int p1)
		{
			InternalMoveViewport (p0, p1);
		}

		private void InternalMoveViewport (Gtk.ScrollStep p0, int 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 SelectAllNativeDelegate SelectAll_cb_delegate;
		static SelectAllNativeDelegate SelectAllVMCallback {
			get {
				if (SelectAll_cb_delegate == null)
					SelectAll_cb_delegate = new SelectAllNativeDelegate (SelectAll_cb);
				return SelectAll_cb_delegate;
			}
		}

		static void OverrideSelectAll (GLib.GType gtype)
		{
			OverrideSelectAll (gtype, SelectAllVMCallback);
		}

		static void OverrideSelectAll (GLib.GType gtype, SelectAllNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "select-all", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SelectAllNativeDelegate (IntPtr inst, bool p0);

		static void SelectAll_cb (IntPtr inst, bool p0)
		{
			try {
				TextView __obj = GLib.Object.GetObject (inst, false) as TextView;
				__obj.OnSelectAll (p0);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideSelectAll")]
		protected virtual void OnSelectAll (bool p0)
		{
			InternalSelectAll (p0);
		}

		private void InternalSelectAll (bool 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 ToggleCursorVisibleNativeDelegate ToggleCursorVisible_cb_delegate;
		static ToggleCursorVisibleNativeDelegate ToggleCursorVisibleVMCallback {
			get {
				if (ToggleCursorVisible_cb_delegate == null)
					ToggleCursorVisible_cb_delegate = new ToggleCursorVisibleNativeDelegate (ToggleCursorVisible_cb);
				return ToggleCursorVisible_cb_delegate;
			}
		}

		static void OverrideToggleCursorVisible (GLib.GType gtype)
		{
			OverrideToggleCursorVisible (gtype, ToggleCursorVisibleVMCallback);
		}

		static void OverrideToggleCursorVisible (GLib.GType gtype, ToggleCursorVisibleNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "toggle-cursor-visible", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ToggleCursorVisibleNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideToggleCursorVisible")]
		protected virtual void OnToggleCursorVisible ()
		{
			InternalToggleCursorVisible ();
		}

		private void InternalToggleCursorVisible ()
		{
			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 PreeditChangedNativeDelegate PreeditChanged_cb_delegate;
		static PreeditChangedNativeDelegate PreeditChangedVMCallback {
			get {
				if (PreeditChanged_cb_delegate == null)
					PreeditChanged_cb_delegate = new PreeditChangedNativeDelegate (PreeditChanged_cb);
				return PreeditChanged_cb_delegate;
			}
		}

		static void OverridePreeditChanged (GLib.GType gtype)
		{
			OverridePreeditChanged (gtype, PreeditChangedVMCallback);
		}

		static void OverridePreeditChanged (GLib.GType gtype, PreeditChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "preedit-changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PreeditChangedNativeDelegate (IntPtr inst, IntPtr p0);

		static void PreeditChanged_cb (IntPtr inst, IntPtr p0)
		{
			try {
				TextView __obj = GLib.Object.GetObject (inst, false) as TextView;
				__obj.OnPreeditChanged (GLib.Marshaller.PtrToStringGFree(p0));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverridePreeditChanged")]
		protected virtual void OnPreeditChanged (string p0)
		{
			InternalPreeditChanged (p0);
		}

		private void InternalPreeditChanged (string 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 PopulatePopupNativeDelegate PopulatePopup_cb_delegate;
		static PopulatePopupNativeDelegate PopulatePopupVMCallback {
			get {
				if (PopulatePopup_cb_delegate == null)
					PopulatePopup_cb_delegate = new PopulatePopupNativeDelegate (PopulatePopup_cb);
				return PopulatePopup_cb_delegate;
			}
		}

		static void OverridePopulatePopup (GLib.GType gtype)
		{
			OverridePopulatePopup (gtype, PopulatePopupVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PopulatePopupNativeDelegate (IntPtr inst, IntPtr popup);

		static void PopulatePopup_cb (IntPtr inst, IntPtr popup)
		{
			try {
				TextView __obj = GLib.Object.GetObject (inst, false) as TextView;
				__obj.OnPopulatePopup (GLib.Object.GetObject(popup) as Gtk.Widget);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverridePopulatePopup")]
		protected virtual void OnPopulatePopup (Gtk.Widget popup)
		{
			InternalPopulatePopup (popup);
		}

		private void InternalPopulatePopup (Gtk.Widget popup)
		{
			PopulatePopupNativeDelegate unmanaged = class_abi.BaseOverride<PopulatePopupNativeDelegate>(this.LookupGType(), "populate_popup");
			if (unmanaged == null) return;

			unmanaged (this.Handle, popup == null ? IntPtr.Zero : popup.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 count, bool extend_selection);

		static void MoveCursor_cb (IntPtr inst, int step, int count, bool extend_selection)
		{
			try {
				TextView __obj = GLib.Object.GetObject (inst, false) as TextView;
				__obj.OnMoveCursor ((Gtk.MovementStep) step, count, extend_selection);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideMoveCursor")]
		protected virtual void OnMoveCursor (Gtk.MovementStep step, int count, bool extend_selection)
		{
			InternalMoveCursor (step, count, extend_selection);
		}

		private void InternalMoveCursor (Gtk.MovementStep step, int count, bool extend_selection)
		{
			MoveCursorNativeDelegate unmanaged = class_abi.BaseOverride<MoveCursorNativeDelegate>(this.LookupGType(), "move_cursor");
			if (unmanaged == null) return;

			unmanaged (this.Handle, (int) step, count, extend_selection);
		}

		static SetAnchorNativeDelegate SetAnchor_cb_delegate;
		static SetAnchorNativeDelegate SetAnchorVMCallback {
			get {
				if (SetAnchor_cb_delegate == null)
					SetAnchor_cb_delegate = new SetAnchorNativeDelegate (SetAnchor_cb);
				return SetAnchor_cb_delegate;
			}
		}

		static void OverrideSetAnchor (GLib.GType gtype)
		{
			OverrideSetAnchor (gtype, SetAnchorVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideSetAnchor")]
		protected virtual void OnSetAnchor ()
		{
			InternalSetAnchor ();
		}

		private void InternalSetAnchor ()
		{
			SetAnchorNativeDelegate unmanaged = class_abi.BaseOverride<SetAnchorNativeDelegate>(this.LookupGType(), "set_anchor");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static InsertAtCursorNativeDelegate InsertAtCursor_cb_delegate;
		static InsertAtCursorNativeDelegate InsertAtCursorVMCallback {
			get {
				if (InsertAtCursor_cb_delegate == null)
					InsertAtCursor_cb_delegate = new InsertAtCursorNativeDelegate (InsertAtCursor_cb);
				return InsertAtCursor_cb_delegate;
			}
		}

		static void OverrideInsertAtCursor (GLib.GType gtype)
		{
			OverrideInsertAtCursor (gtype, InsertAtCursorVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void InsertAtCursorNativeDelegate (IntPtr inst, IntPtr str);

		static void InsertAtCursor_cb (IntPtr inst, IntPtr str)
		{
			try {
				TextView __obj = GLib.Object.GetObject (inst, false) as TextView;
				__obj.OnInsertAtCursor (GLib.Marshaller.Utf8PtrToString (str));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideInsertAtCursor")]
		protected virtual void OnInsertAtCursor (string str)
		{
			InternalInsertAtCursor (str);
		}

		private void InternalInsertAtCursor (string str)
		{
			InsertAtCursorNativeDelegate unmanaged = class_abi.BaseOverride<InsertAtCursorNativeDelegate>(this.LookupGType(), "insert_at_cursor");
			if (unmanaged == null) return;

			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
			unmanaged (this.Handle, native_str);
			GLib.Marshaller.Free (native_str);
		}

		static DeleteFromCursorNativeDelegate DeleteFromCursor_cb_delegate;
		static DeleteFromCursorNativeDelegate DeleteFromCursorVMCallback {
			get {
				if (DeleteFromCursor_cb_delegate == null)
					DeleteFromCursor_cb_delegate = new DeleteFromCursorNativeDelegate (DeleteFromCursor_cb);
				return DeleteFromCursor_cb_delegate;
			}
		}

		static void OverrideDeleteFromCursor (GLib.GType gtype)
		{
			OverrideDeleteFromCursor (gtype, DeleteFromCursorVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DeleteFromCursorNativeDelegate (IntPtr inst, int type, int count);

		static void DeleteFromCursor_cb (IntPtr inst, int type, int count)
		{
			try {
				TextView __obj = GLib.Object.GetObject (inst, false) as TextView;
				__obj.OnDeleteFromCursor ((Gtk.DeleteType) type, count);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideDeleteFromCursor")]
		protected virtual void OnDeleteFromCursor (Gtk.DeleteType type, int count)
		{
			InternalDeleteFromCursor (type, count);
		}

		private void InternalDeleteFromCursor (Gtk.DeleteType type, int count)
		{
			DeleteFromCursorNativeDelegate unmanaged = class_abi.BaseOverride<DeleteFromCursorNativeDelegate>(this.LookupGType(), "delete_from_cursor");
			if (unmanaged == null) return;

			unmanaged (this.Handle, (int) type, count);
		}

		static BackspaceNativeDelegate Backspace_cb_delegate;
		static BackspaceNativeDelegate BackspaceVMCallback {
			get {
				if (Backspace_cb_delegate == null)
					Backspace_cb_delegate = new BackspaceNativeDelegate (Backspace_cb);
				return Backspace_cb_delegate;
			}
		}

		static void OverrideBackspace (GLib.GType gtype)
		{
			OverrideBackspace (gtype, BackspaceVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideBackspace")]
		protected virtual void OnBackspace ()
		{
			InternalBackspace ();
		}

		private void InternalBackspace ()
		{
			BackspaceNativeDelegate unmanaged = class_abi.BaseOverride<BackspaceNativeDelegate>(this.LookupGType(), "backspace");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static CutClipboardNativeDelegate CutClipboard_cb_delegate;
		static CutClipboardNativeDelegate CutClipboardVMCallback {
			get {
				if (CutClipboard_cb_delegate == null)
					CutClipboard_cb_delegate = new CutClipboardNativeDelegate (CutClipboard_cb);
				return CutClipboard_cb_delegate;
			}
		}

		static void OverrideCutClipboard (GLib.GType gtype)
		{
			OverrideCutClipboard (gtype, CutClipboardVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideCutClipboard")]
		protected virtual void OnCutClipboard ()
		{
			InternalCutClipboard ();
		}

		private void InternalCutClipboard ()
		{
			CutClipboardNativeDelegate unmanaged = class_abi.BaseOverride<CutClipboardNativeDelegate>(this.LookupGType(), "cut_clipboard");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static CopyClipboardNativeDelegate CopyClipboard_cb_delegate;
		static CopyClipboardNativeDelegate CopyClipboardVMCallback {
			get {
				if (CopyClipboard_cb_delegate == null)
					CopyClipboard_cb_delegate = new CopyClipboardNativeDelegate (CopyClipboard_cb);
				return CopyClipboard_cb_delegate;
			}
		}

		static void OverrideCopyClipboard (GLib.GType gtype)
		{
			OverrideCopyClipboard (gtype, CopyClipboardVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideCopyClipboard")]
		protected virtual void OnCopyClipboard ()
		{
			InternalCopyClipboard ();
		}

		private void InternalCopyClipboard ()
		{
			CopyClipboardNativeDelegate unmanaged = class_abi.BaseOverride<CopyClipboardNativeDelegate>(this.LookupGType(), "copy_clipboard");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static PasteClipboardNativeDelegate PasteClipboard_cb_delegate;
		static PasteClipboardNativeDelegate PasteClipboardVMCallback {
			get {
				if (PasteClipboard_cb_delegate == null)
					PasteClipboard_cb_delegate = new PasteClipboardNativeDelegate (PasteClipboard_cb);
				return PasteClipboard_cb_delegate;
			}
		}

		static void OverridePasteClipboard (GLib.GType gtype)
		{
			OverridePasteClipboard (gtype, PasteClipboardVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverridePasteClipboard")]
		protected virtual void OnPasteClipboard ()
		{
			InternalPasteClipboard ();
		}

		private void InternalPasteClipboard ()
		{
			PasteClipboardNativeDelegate unmanaged = class_abi.BaseOverride<PasteClipboardNativeDelegate>(this.LookupGType(), "paste_clipboard");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static ToggleOverwriteNativeDelegate ToggleOverwrite_cb_delegate;
		static ToggleOverwriteNativeDelegate ToggleOverwriteVMCallback {
			get {
				if (ToggleOverwrite_cb_delegate == null)
					ToggleOverwrite_cb_delegate = new ToggleOverwriteNativeDelegate (ToggleOverwrite_cb);
				return ToggleOverwrite_cb_delegate;
			}
		}

		static void OverrideToggleOverwrite (GLib.GType gtype)
		{
			OverrideToggleOverwrite (gtype, ToggleOverwriteVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideToggleOverwrite")]
		protected virtual void OnToggleOverwrite ()
		{
			InternalToggleOverwrite ();
		}

		private void InternalToggleOverwrite ()
		{
			ToggleOverwriteNativeDelegate unmanaged = class_abi.BaseOverride<ToggleOverwriteNativeDelegate>(this.LookupGType(), "toggle_overwrite");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static CreateBufferNativeDelegate CreateBuffer_cb_delegate;
		static CreateBufferNativeDelegate CreateBufferVMCallback {
			get {
				if (CreateBuffer_cb_delegate == null)
					CreateBuffer_cb_delegate = new CreateBufferNativeDelegate (CreateBuffer_cb);
				return CreateBuffer_cb_delegate;
			}
		}

		static void OverrideCreateBuffer (GLib.GType gtype)
		{
			OverrideCreateBuffer (gtype, CreateBufferVMCallback);
		}

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

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

		static IntPtr CreateBuffer_cb (IntPtr inst)
		{
			try {
				TextView __obj = GLib.Object.GetObject (inst, false) as TextView;
				Gtk.TextBuffer __result;
				__result = __obj.OnCreateBuffer ();
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideCreateBuffer")]
		protected virtual Gtk.TextBuffer OnCreateBuffer ()
		{
			return InternalCreateBuffer ();
		}

		private Gtk.TextBuffer InternalCreateBuffer ()
		{
			CreateBufferNativeDelegate unmanaged = class_abi.BaseOverride<CreateBufferNativeDelegate>(this.LookupGType(), "create_buffer");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle);
			return GLib.Object.GetObject(__result) as Gtk.TextBuffer;
		}

		static DrawLayerNativeDelegate DrawLayer_cb_delegate;
		static DrawLayerNativeDelegate DrawLayerVMCallback {
			get {
				if (DrawLayer_cb_delegate == null)
					DrawLayer_cb_delegate = new DrawLayerNativeDelegate (DrawLayer_cb);
				return DrawLayer_cb_delegate;
			}
		}

		static void OverrideDrawLayer (GLib.GType gtype)
		{
			OverrideDrawLayer (gtype, DrawLayerVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DrawLayerNativeDelegate (IntPtr inst, int layer, IntPtr cr);

		static void DrawLayer_cb (IntPtr inst, int layer, IntPtr cr)
		{
			Cairo.Context mycr = null;

			try {
				TextView __obj = GLib.Object.GetObject (inst, false) as TextView;
				mycr = new Cairo.Context (cr, false);
				__obj.OnDrawLayer ((Gtk.TextViewLayer) layer, mycr);
			} 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(Gtk.TextView), ConnectionMethod="OverrideDrawLayer")]
		protected virtual void OnDrawLayer (Gtk.TextViewLayer layer, Cairo.Context cr)
		{
			InternalDrawLayer (layer, cr);
		}

		private void InternalDrawLayer (Gtk.TextViewLayer layer, Cairo.Context cr)
		{
			DrawLayerNativeDelegate unmanaged = class_abi.BaseOverride<DrawLayerNativeDelegate>(this.LookupGType(), "draw_layer");
			if (unmanaged == null) return;

			unmanaged (this.Handle, (int) layer, cr == null ? IntPtr.Zero : cr.Handle);
		}

		static ExtendSelectionNativeDelegate ExtendSelection_cb_delegate;
		static ExtendSelectionNativeDelegate ExtendSelectionVMCallback {
			get {
				if (ExtendSelection_cb_delegate == null)
					ExtendSelection_cb_delegate = new ExtendSelectionNativeDelegate (ExtendSelection_cb);
				return ExtendSelection_cb_delegate;
			}
		}

		static void OverrideExtendSelection (GLib.GType gtype)
		{
			OverrideExtendSelection (gtype, ExtendSelectionVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ExtendSelectionNativeDelegate (IntPtr inst, int granularity, IntPtr location, IntPtr start, IntPtr end);

		static bool ExtendSelection_cb (IntPtr inst, int granularity, IntPtr location, IntPtr start, IntPtr end)
		{
			try {
				TextView __obj = GLib.Object.GetObject (inst, false) as TextView;
				bool __result;
				__result = __obj.OnExtendSelection ((Gtk.TextExtendSelection) granularity, Gtk.TextIter.New (location), Gtk.TextIter.New (start), Gtk.TextIter.New (end));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.TextView), ConnectionMethod="OverrideExtendSelection")]
		protected virtual bool OnExtendSelection (Gtk.TextExtendSelection granularity, Gtk.TextIter location, Gtk.TextIter start, Gtk.TextIter end)
		{
			return InternalExtendSelection (granularity, location, start, end);
		}

		private bool InternalExtendSelection (Gtk.TextExtendSelection granularity, Gtk.TextIter location, Gtk.TextIter start, Gtk.TextIter end)
		{
			ExtendSelectionNativeDelegate unmanaged = class_abi.BaseOverride<ExtendSelectionNativeDelegate>(this.LookupGType(), "extend_selection");
			if (unmanaged == null) return false;

			IntPtr native_location = GLib.Marshaller.StructureToPtrAlloc (location);
			IntPtr native_start = GLib.Marshaller.StructureToPtrAlloc (start);
			IntPtr native_end = GLib.Marshaller.StructureToPtrAlloc (end);
			bool __result = unmanaged (this.Handle, (int) granularity, native_location, native_start, native_end);
			Marshal.FreeHGlobal (native_location);
			Marshal.FreeHGlobal (native_start);
			Marshal.FreeHGlobal (native_end);
			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("populate_popup"
							, Gtk.Container.class_abi.Fields
							, (uint) sizeof( IntPtr ) // populate_popup
							, null
							, "move_cursor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("move_cursor"
							, -1
							, (uint) sizeof( IntPtr ) // move_cursor
							, "populate_popup"
							, "set_anchor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("set_anchor"
							, -1
							, (uint) sizeof( IntPtr ) // set_anchor
							, "move_cursor"
							, "insert_at_cursor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("insert_at_cursor"
							, -1
							, (uint) sizeof( IntPtr ) // insert_at_cursor
							, "set_anchor"
							, "delete_from_cursor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("delete_from_cursor"
							, -1
							, (uint) sizeof( IntPtr ) // delete_from_cursor
							, "insert_at_cursor"
							, "backspace"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("backspace"
							, -1
							, (uint) sizeof( IntPtr ) // backspace
							, "delete_from_cursor"
							, "cut_clipboard"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("cut_clipboard"
							, -1
							, (uint) sizeof( IntPtr ) // cut_clipboard
							, "backspace"
							, "copy_clipboard"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("copy_clipboard"
							, -1
							, (uint) sizeof( IntPtr ) // copy_clipboard
							, "cut_clipboard"
							, "paste_clipboard"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("paste_clipboard"
							, -1
							, (uint) sizeof( IntPtr ) // paste_clipboard
							, "copy_clipboard"
							, "toggle_overwrite"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("toggle_overwrite"
							, -1
							, (uint) sizeof( IntPtr ) // toggle_overwrite
							, "paste_clipboard"
							, "create_buffer"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("create_buffer"
							, -1
							, (uint) sizeof( IntPtr ) // create_buffer
							, "toggle_overwrite"
							, "draw_layer"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("draw_layer"
							, -1
							, (uint) sizeof( IntPtr ) // draw_layer
							, "create_buffer"
							, "extend_selection"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("extend_selection"
							, -1
							, (uint) sizeof( IntPtr ) // extend_selection
							, "draw_layer"
							, "_gtk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "extend_selection"
							, "_gtk_reserved2"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved2"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved2
							, "_gtk_reserved1"
							, "_gtk_reserved3"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved3"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved3
							, "_gtk_reserved2"
							, "_gtk_reserved4"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved4"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved4
							, "_gtk_reserved3"
							, "_gtk_reserved5"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved5"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved5
							, "_gtk_reserved4"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_add_child_at_anchor(IntPtr raw, IntPtr child, IntPtr anchor);
		static d_gtk_text_view_add_child_at_anchor gtk_text_view_add_child_at_anchor = FuncLoader.LoadFunction<d_gtk_text_view_add_child_at_anchor>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_add_child_at_anchor"));

		public void AddChildAtAnchor(Gtk.Widget child, Gtk.TextChildAnchor anchor) {
			gtk_text_view_add_child_at_anchor(Handle, child == null ? IntPtr.Zero : child.Handle, anchor == null ? IntPtr.Zero : anchor.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_add_child_in_window(IntPtr raw, IntPtr child, int which_window, int xpos, int ypos);
		static d_gtk_text_view_add_child_in_window gtk_text_view_add_child_in_window = FuncLoader.LoadFunction<d_gtk_text_view_add_child_in_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_add_child_in_window"));

		public void AddChildInWindow(Gtk.Widget child, Gtk.TextWindowType which_window, int xpos, int ypos) {
			gtk_text_view_add_child_in_window(Handle, child == null ? IntPtr.Zero : child.Handle, (int) which_window, xpos, ypos);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_backward_display_line(IntPtr raw, IntPtr iter);
		static d_gtk_text_view_backward_display_line gtk_text_view_backward_display_line = FuncLoader.LoadFunction<d_gtk_text_view_backward_display_line>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_backward_display_line"));

		public bool BackwardDisplayLine(ref Gtk.TextIter iter) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			bool raw_ret = gtk_text_view_backward_display_line(Handle, native_iter);
			bool ret = raw_ret;
			iter = Gtk.TextIter.New (native_iter);
			Marshal.FreeHGlobal (native_iter);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_backward_display_line_start(IntPtr raw, IntPtr iter);
		static d_gtk_text_view_backward_display_line_start gtk_text_view_backward_display_line_start = FuncLoader.LoadFunction<d_gtk_text_view_backward_display_line_start>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_backward_display_line_start"));

		public bool BackwardDisplayLineStart(ref Gtk.TextIter iter) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			bool raw_ret = gtk_text_view_backward_display_line_start(Handle, native_iter);
			bool ret = raw_ret;
			iter = Gtk.TextIter.New (native_iter);
			Marshal.FreeHGlobal (native_iter);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_buffer_to_window_coords(IntPtr raw, int win, int buffer_x, int buffer_y, out int window_x, out int window_y);
		static d_gtk_text_view_buffer_to_window_coords gtk_text_view_buffer_to_window_coords = FuncLoader.LoadFunction<d_gtk_text_view_buffer_to_window_coords>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_buffer_to_window_coords"));

		public void BufferToWindowCoords(Gtk.TextWindowType win, int buffer_x, int buffer_y, out int window_x, out int window_y) {
			gtk_text_view_buffer_to_window_coords(Handle, (int) win, buffer_x, buffer_y, out window_x, out window_y);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_forward_display_line(IntPtr raw, IntPtr iter);
		static d_gtk_text_view_forward_display_line gtk_text_view_forward_display_line = FuncLoader.LoadFunction<d_gtk_text_view_forward_display_line>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_forward_display_line"));

		public bool ForwardDisplayLine(ref Gtk.TextIter iter) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			bool raw_ret = gtk_text_view_forward_display_line(Handle, native_iter);
			bool ret = raw_ret;
			iter = Gtk.TextIter.New (native_iter);
			Marshal.FreeHGlobal (native_iter);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_forward_display_line_end(IntPtr raw, IntPtr iter);
		static d_gtk_text_view_forward_display_line_end gtk_text_view_forward_display_line_end = FuncLoader.LoadFunction<d_gtk_text_view_forward_display_line_end>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_forward_display_line_end"));

		public bool ForwardDisplayLineEnd(ref Gtk.TextIter iter) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			bool raw_ret = gtk_text_view_forward_display_line_end(Handle, native_iter);
			bool ret = raw_ret;
			iter = Gtk.TextIter.New (native_iter);
			Marshal.FreeHGlobal (native_iter);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gtk_text_view_get_border_window_size(IntPtr raw, int type);
		static d_gtk_text_view_get_border_window_size gtk_text_view_get_border_window_size = FuncLoader.LoadFunction<d_gtk_text_view_get_border_window_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_border_window_size"));

		public int GetBorderWindowSize(Gtk.TextWindowType type) {
			int raw_ret = gtk_text_view_get_border_window_size(Handle, (int) type);
			int ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_get_cursor_locations(IntPtr raw, IntPtr iter, IntPtr strong, IntPtr weak);
		static d_gtk_text_view_get_cursor_locations gtk_text_view_get_cursor_locations = FuncLoader.LoadFunction<d_gtk_text_view_get_cursor_locations>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_cursor_locations"));

		public void GetCursorLocations(Gtk.TextIter iter, Gdk.Rectangle strong, Gdk.Rectangle weak) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			IntPtr native_strong = GLib.Marshaller.StructureToPtrAlloc (strong);
			IntPtr native_weak = GLib.Marshaller.StructureToPtrAlloc (weak);
			gtk_text_view_get_cursor_locations(Handle, native_iter, native_strong, native_weak);
			Marshal.FreeHGlobal (native_iter);
			Marshal.FreeHGlobal (native_strong);
			Marshal.FreeHGlobal (native_weak);
		}

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

		public Gtk.TextAttributes DefaultAttributes { 
			get {
				IntPtr raw_ret = gtk_text_view_get_default_attributes(Handle);
				Gtk.TextAttributes ret = raw_ret == IntPtr.Zero ? null : (Gtk.TextAttributes) GLib.Opaque.GetOpaque (raw_ret, typeof (Gtk.TextAttributes), true);
				return ret;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_get_iter_at_location(IntPtr raw, IntPtr iter, int x, int y);
		static d_gtk_text_view_get_iter_at_location gtk_text_view_get_iter_at_location = FuncLoader.LoadFunction<d_gtk_text_view_get_iter_at_location>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_iter_at_location"));

		public bool GetIterAtLocation(out Gtk.TextIter iter, int x, int y) {
			IntPtr native_iter = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
			bool raw_ret = gtk_text_view_get_iter_at_location(Handle, native_iter, x, y);
			bool ret = raw_ret;
			iter = Gtk.TextIter.New (native_iter);
			Marshal.FreeHGlobal (native_iter);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_get_iter_at_position(IntPtr raw, IntPtr iter, out int trailing, int x, int y);
		static d_gtk_text_view_get_iter_at_position gtk_text_view_get_iter_at_position = FuncLoader.LoadFunction<d_gtk_text_view_get_iter_at_position>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_iter_at_position"));

		public bool GetIterAtPosition(out Gtk.TextIter iter, out int trailing, int x, int y) {
			IntPtr native_iter = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
			bool raw_ret = gtk_text_view_get_iter_at_position(Handle, native_iter, out trailing, x, y);
			bool ret = raw_ret;
			iter = Gtk.TextIter.New (native_iter);
			Marshal.FreeHGlobal (native_iter);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_get_iter_location(IntPtr raw, IntPtr iter, IntPtr location);
		static d_gtk_text_view_get_iter_location gtk_text_view_get_iter_location = FuncLoader.LoadFunction<d_gtk_text_view_get_iter_location>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_iter_location"));

		public Gdk.Rectangle GetIterLocation(Gtk.TextIter iter) {
			Gdk.Rectangle location;
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			IntPtr native_location = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
			gtk_text_view_get_iter_location(Handle, native_iter, native_location);
			Marshal.FreeHGlobal (native_iter);
			location = (Gdk.Rectangle) Marshal.PtrToStructure (native_location, typeof (Gdk.Rectangle));
			Marshal.FreeHGlobal (native_location);
			return location;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_get_line_at_y(IntPtr raw, IntPtr target_iter, int y, out int line_top);
		static d_gtk_text_view_get_line_at_y gtk_text_view_get_line_at_y = FuncLoader.LoadFunction<d_gtk_text_view_get_line_at_y>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_line_at_y"));

		public void GetLineAtY(out Gtk.TextIter target_iter, int y, out int line_top) {
			IntPtr native_target_iter = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.TextIter>());
			gtk_text_view_get_line_at_y(Handle, native_target_iter, y, out line_top);
			target_iter = Gtk.TextIter.New (native_target_iter);
			Marshal.FreeHGlobal (native_target_iter);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_get_line_yrange(IntPtr raw, IntPtr iter, out int y, out int height);
		static d_gtk_text_view_get_line_yrange gtk_text_view_get_line_yrange = FuncLoader.LoadFunction<d_gtk_text_view_get_line_yrange>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_line_yrange"));

		public void GetLineYrange(Gtk.TextIter iter, out int y, out int height) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			gtk_text_view_get_line_yrange(Handle, native_iter, out y, out height);
			Marshal.FreeHGlobal (native_iter);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_text_view_get_type();
		static d_gtk_text_view_get_type gtk_text_view_get_type = FuncLoader.LoadFunction<d_gtk_text_view_get_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_type"));

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_get_visible_rect(IntPtr raw, IntPtr visible_rect);
		static d_gtk_text_view_get_visible_rect gtk_text_view_get_visible_rect = FuncLoader.LoadFunction<d_gtk_text_view_get_visible_rect>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_visible_rect"));

		public Gdk.Rectangle VisibleRect { 
			get {
				Gdk.Rectangle visible_rect;
				IntPtr native_visible_rect = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
				gtk_text_view_get_visible_rect(Handle, native_visible_rect);
				visible_rect = (Gdk.Rectangle) Marshal.PtrToStructure (native_visible_rect, typeof (Gdk.Rectangle));
				Marshal.FreeHGlobal (native_visible_rect);
				return visible_rect;
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr d_gtk_text_view_get_window(IntPtr raw, int win);
		static d_gtk_text_view_get_window gtk_text_view_get_window = FuncLoader.LoadFunction<d_gtk_text_view_get_window>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_window"));

		public Gdk.Window GetWindow(Gtk.TextWindowType win) {
			IntPtr raw_ret = gtk_text_view_get_window(Handle, (int) win);
			Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int d_gtk_text_view_get_window_type(IntPtr raw, IntPtr window);
		static d_gtk_text_view_get_window_type gtk_text_view_get_window_type = FuncLoader.LoadFunction<d_gtk_text_view_get_window_type>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_get_window_type"));

		public Gtk.TextWindowType GetWindowType(Gdk.Window window) {
			int raw_ret = gtk_text_view_get_window_type(Handle, window == null ? IntPtr.Zero : window.Handle);
			Gtk.TextWindowType ret = (Gtk.TextWindowType) raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_im_context_filter_keypress(IntPtr raw, IntPtr evnt);
		static d_gtk_text_view_im_context_filter_keypress gtk_text_view_im_context_filter_keypress = FuncLoader.LoadFunction<d_gtk_text_view_im_context_filter_keypress>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_im_context_filter_keypress"));

		public bool ImContextFilterKeypress(Gdk.EventKey evnt) {
			bool raw_ret = gtk_text_view_im_context_filter_keypress(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_move_child(IntPtr raw, IntPtr child, int xpos, int ypos);
		static d_gtk_text_view_move_child gtk_text_view_move_child = FuncLoader.LoadFunction<d_gtk_text_view_move_child>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_move_child"));

		public void MoveChild(Gtk.Widget child, int xpos, int ypos) {
			gtk_text_view_move_child(Handle, child == null ? IntPtr.Zero : child.Handle, xpos, ypos);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_move_mark_onscreen(IntPtr raw, IntPtr mark);
		static d_gtk_text_view_move_mark_onscreen gtk_text_view_move_mark_onscreen = FuncLoader.LoadFunction<d_gtk_text_view_move_mark_onscreen>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_move_mark_onscreen"));

		public bool MoveMarkOnscreen(Gtk.TextMark mark) {
			bool raw_ret = gtk_text_view_move_mark_onscreen(Handle, mark == null ? IntPtr.Zero : mark.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_move_visually(IntPtr raw, IntPtr iter, int count);
		static d_gtk_text_view_move_visually gtk_text_view_move_visually = FuncLoader.LoadFunction<d_gtk_text_view_move_visually>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_move_visually"));

		public bool MoveVisually(ref Gtk.TextIter iter, int count) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			bool raw_ret = gtk_text_view_move_visually(Handle, native_iter, count);
			bool ret = raw_ret;
			iter = Gtk.TextIter.New (native_iter);
			Marshal.FreeHGlobal (native_iter);
			return ret;
		}

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

		public bool PlaceCursorOnscreen() {
			bool raw_ret = gtk_text_view_place_cursor_onscreen(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public void ResetCursorBlink() {
			gtk_text_view_reset_cursor_blink(Handle);
		}

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

		public void ResetImContext() {
			gtk_text_view_reset_im_context(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_scroll_mark_onscreen(IntPtr raw, IntPtr mark);
		static d_gtk_text_view_scroll_mark_onscreen gtk_text_view_scroll_mark_onscreen = FuncLoader.LoadFunction<d_gtk_text_view_scroll_mark_onscreen>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_scroll_mark_onscreen"));

		public void ScrollMarkOnscreen(Gtk.TextMark mark) {
			gtk_text_view_scroll_mark_onscreen(Handle, mark == null ? IntPtr.Zero : mark.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_scroll_to_iter(IntPtr raw, IntPtr iter, double within_margin, bool use_align, double xalign, double yalign);
		static d_gtk_text_view_scroll_to_iter gtk_text_view_scroll_to_iter = FuncLoader.LoadFunction<d_gtk_text_view_scroll_to_iter>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_scroll_to_iter"));

		public bool ScrollToIter(Gtk.TextIter iter, double within_margin, bool use_align, double xalign, double yalign) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			bool raw_ret = gtk_text_view_scroll_to_iter(Handle, native_iter, within_margin, use_align, xalign, yalign);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_iter);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_scroll_to_mark(IntPtr raw, IntPtr mark, double within_margin, bool use_align, double xalign, double yalign);
		static d_gtk_text_view_scroll_to_mark gtk_text_view_scroll_to_mark = FuncLoader.LoadFunction<d_gtk_text_view_scroll_to_mark>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_scroll_to_mark"));

		public void ScrollToMark(Gtk.TextMark mark, double within_margin, bool use_align, double xalign, double yalign) {
			gtk_text_view_scroll_to_mark(Handle, mark == null ? IntPtr.Zero : mark.Handle, within_margin, use_align, xalign, yalign);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_set_border_window_size(IntPtr raw, int type, int size);
		static d_gtk_text_view_set_border_window_size gtk_text_view_set_border_window_size = FuncLoader.LoadFunction<d_gtk_text_view_set_border_window_size>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_set_border_window_size"));

		public void SetBorderWindowSize(Gtk.TextWindowType type, int size) {
			gtk_text_view_set_border_window_size(Handle, (int) type, size);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_text_view_starts_display_line(IntPtr raw, IntPtr iter);
		static d_gtk_text_view_starts_display_line gtk_text_view_starts_display_line = FuncLoader.LoadFunction<d_gtk_text_view_starts_display_line>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_starts_display_line"));

		public bool StartsDisplayLine(Gtk.TextIter iter) {
			IntPtr native_iter = GLib.Marshaller.StructureToPtrAlloc (iter);
			bool raw_ret = gtk_text_view_starts_display_line(Handle, native_iter);
			bool ret = raw_ret;
			Marshal.FreeHGlobal (native_iter);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_text_view_window_to_buffer_coords(IntPtr raw, int win, int window_x, int window_y, out int buffer_x, out int buffer_y);
		static d_gtk_text_view_window_to_buffer_coords gtk_text_view_window_to_buffer_coords = FuncLoader.LoadFunction<d_gtk_text_view_window_to_buffer_coords>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_text_view_window_to_buffer_coords"));

		public void WindowToBufferCoords(Gtk.TextWindowType win, int window_x, int window_y, out int buffer_x, out int buffer_y) {
			gtk_text_view_window_to_buffer_coords(Handle, (int) win, window_x, window_y, out buffer_x, out buffer_y);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_scrollable_get_border(IntPtr raw, IntPtr border);
		static d_gtk_scrollable_get_border gtk_scrollable_get_border = FuncLoader.LoadFunction<d_gtk_scrollable_get_border>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_scrollable_get_border"));

		public bool GetBorder(out Gtk.Border border) {
			IntPtr native_border = Marshal.AllocHGlobal (Marshal.SizeOf<Gtk.Border>());
			bool raw_ret = gtk_scrollable_get_border(Handle, native_border);
			bool ret = raw_ret;
			border = Gtk.Border.New (native_border);
			Marshal.FreeHGlobal (native_border);
			return ret;
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_scrollable_set_hadjustment(IntPtr raw, IntPtr hadjustment);
		static d_gtk_scrollable_set_hadjustment gtk_scrollable_set_hadjustment = FuncLoader.LoadFunction<d_gtk_scrollable_set_hadjustment>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_scrollable_set_hadjustment"));

		[GLib.Property ("hadjustment")]
		public Gtk.Adjustment Hadjustment {
			get  {
				IntPtr raw_ret = gtk_scrollable_get_hadjustment(Handle);
				Gtk.Adjustment ret = GLib.Object.GetObject(raw_ret) as Gtk.Adjustment;
				return ret;
			}
			set  {
				gtk_scrollable_set_hadjustment(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_scrollable_set_vadjustment(IntPtr raw, IntPtr vadjustment);
		static d_gtk_scrollable_set_vadjustment gtk_scrollable_set_vadjustment = FuncLoader.LoadFunction<d_gtk_scrollable_set_vadjustment>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_scrollable_set_vadjustment"));

		[GLib.Property ("vadjustment")]
		public Gtk.Adjustment Vadjustment {
			get  {
				IntPtr raw_ret = gtk_scrollable_get_vadjustment(Handle);
				Gtk.Adjustment ret = GLib.Object.GetObject(raw_ret) as Gtk.Adjustment;
				return ret;
			}
			set  {
				gtk_scrollable_set_vadjustment(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_scrollable_set_hscroll_policy(IntPtr raw, int policy);
		static d_gtk_scrollable_set_hscroll_policy gtk_scrollable_set_hscroll_policy = FuncLoader.LoadFunction<d_gtk_scrollable_set_hscroll_policy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_scrollable_set_hscroll_policy"));

		[GLib.Property ("hscroll-policy")]
		public Gtk.ScrollablePolicy HscrollPolicy {
			get  {
				int raw_ret = gtk_scrollable_get_hscroll_policy(Handle);
				Gtk.ScrollablePolicy ret = (Gtk.ScrollablePolicy) raw_ret;
				return ret;
			}
			set  {
				gtk_scrollable_set_hscroll_policy(Handle, (int) value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_scrollable_set_vscroll_policy(IntPtr raw, int policy);
		static d_gtk_scrollable_set_vscroll_policy gtk_scrollable_set_vscroll_policy = FuncLoader.LoadFunction<d_gtk_scrollable_set_vscroll_policy>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_scrollable_set_vscroll_policy"));

		[GLib.Property ("vscroll-policy")]
		public Gtk.ScrollablePolicy VscrollPolicy {
			get  {
				int raw_ret = gtk_scrollable_get_vscroll_policy(Handle);
				Gtk.ScrollablePolicy ret = (Gtk.ScrollablePolicy) raw_ret;
				return ret;
			}
			set  {
				gtk_scrollable_set_vscroll_policy(Handle, (int) value);
			}
		}


		// 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.Container.abi_info.Fields
							, (uint) sizeof( IntPtr ) // priv
							, null
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
