// 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 Entry : Gtk.Widget, Gtk.IEditable, Gtk.ICellEditable {

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

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

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

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

		public Entry (Gtk.EntryBuffer buffer) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Entry)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				if (buffer != null) {
					names.Add ("buffer");
					vals.Add (new GLib.Value (buffer));
				}
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			Raw = gtk_entry_new_with_buffer(buffer == null ? IntPtr.Zero : buffer.Handle);
		}

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

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

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

		[GLib.Property ("cursor-position")]
		public int CursorPosition {
			get {
				GLib.Value val = GetProperty ("cursor-position");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("selection-bound")]
		public int SelectionBound {
			get {
				GLib.Value val = GetProperty ("selection-bound");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

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

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

		[GLib.Property ("max-length")]
		public int MaxLength {
			get  {
				int raw_ret = gtk_entry_get_max_length(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_entry_set_max_length(Handle, value);
			}
		}

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

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

		[GLib.Property ("visibility")]
		public bool Visibility {
			get  {
				bool raw_ret = gtk_entry_get_visibility(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_entry_set_visibility(Handle, value);
			}
		}

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

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

		[GLib.Property ("has-frame")]
		public bool HasFrame {
			get  {
				bool raw_ret = gtk_entry_get_has_frame(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_entry_set_has_frame(Handle, value);
			}
		}

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

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

		[GLib.Property ("activates-default")]
		public bool ActivatesDefault {
			get  {
				bool raw_ret = gtk_entry_get_activates_default(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_entry_set_activates_default(Handle, value);
			}
		}

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

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

		[GLib.Property ("width-chars")]
		public int WidthChars {
			get  {
				int raw_ret = gtk_entry_get_width_chars(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_entry_set_width_chars(Handle, value);
			}
		}

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

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

		[GLib.Property ("max-width-chars")]
		public int MaxWidthChars {
			get  {
				int raw_ret = gtk_entry_get_max_width_chars(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_entry_set_max_width_chars(Handle, value);
			}
		}

		[GLib.Property ("scroll-offset")]
		public int ScrollOffset {
			get {
				GLib.Value val = GetProperty ("scroll-offset");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

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

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

		[GLib.Property ("text")]
		public string Text {
			get  {
				IntPtr raw_ret = gtk_entry_get_text(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_entry_set_text(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[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 ("truncate-multiline")]
		public bool TruncateMultiline {
			get {
				GLib.Value val = GetProperty ("truncate-multiline");
				bool ret = (bool) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("truncate-multiline", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("shadow-type")]
		public Gtk.ShadowType ShadowType {
			get {
				GLib.Value val = GetProperty ("shadow-type");
				Gtk.ShadowType ret = (Gtk.ShadowType) (Enum) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value((Enum) value);
				SetProperty("shadow-type", val);
				val.Dispose ();
			}
		}

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

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

		[GLib.Property ("overwrite-mode")]
		public bool OverwriteMode {
			get  {
				bool raw_ret = gtk_entry_get_overwrite_mode(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_entry_set_overwrite_mode(Handle, value);
			}
		}

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

		[GLib.Property ("text-length")]
		public ushort TextLength {
			get  {
				ushort raw_ret = gtk_entry_get_text_length(Handle);
				ushort ret = raw_ret;
				return ret;
			}
		}

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

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

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

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

		[GLib.Property ("progress-fraction")]
		public double ProgressFraction {
			get  {
				double raw_ret = gtk_entry_get_progress_fraction(Handle);
				double ret = raw_ret;
				return ret;
			}
			set  {
				gtk_entry_set_progress_fraction(Handle, value);
			}
		}

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

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

		[GLib.Property ("progress-pulse-step")]
		public double ProgressPulseStep {
			get  {
				double raw_ret = gtk_entry_get_progress_pulse_step(Handle);
				double ret = raw_ret;
				return ret;
			}
			set  {
				gtk_entry_set_progress_pulse_step(Handle, value);
			}
		}

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

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

		[GLib.Property ("placeholder-text")]
		public string PlaceholderText {
			get  {
				IntPtr raw_ret = gtk_entry_get_placeholder_text(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_entry_set_placeholder_text(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

		[GLib.Property ("primary-icon-pixbuf")]
		public Gdk.Pixbuf PrimaryIconPixbuf {
			get {
				GLib.Value val = GetProperty ("primary-icon-pixbuf");
				Gdk.Pixbuf ret = (Gdk.Pixbuf) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("primary-icon-pixbuf", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("secondary-icon-pixbuf")]
		public Gdk.Pixbuf SecondaryIconPixbuf {
			get {
				GLib.Value val = GetProperty ("secondary-icon-pixbuf");
				Gdk.Pixbuf ret = (Gdk.Pixbuf) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("secondary-icon-pixbuf", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("primary-icon-stock")]
		public string PrimaryIconStock {
			get {
				GLib.Value val = GetProperty ("primary-icon-stock");
				string ret = (string) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("primary-icon-stock", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("secondary-icon-stock")]
		public string SecondaryIconStock {
			get {
				GLib.Value val = GetProperty ("secondary-icon-stock");
				string ret = (string) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("secondary-icon-stock", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("primary-icon-name")]
		public string PrimaryIconName {
			get {
				GLib.Value val = GetProperty ("primary-icon-name");
				string ret = (string) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("primary-icon-name", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("secondary-icon-name")]
		public string SecondaryIconName {
			get {
				GLib.Value val = GetProperty ("secondary-icon-name");
				string ret = (string) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("secondary-icon-name", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("primary-icon-gicon")]
		public GLib.IIcon PrimaryIconGicon {
			get {
				GLib.Value val = GetProperty ("primary-icon-gicon");
				GLib.IIcon ret = GLib.IconAdapter.GetObject ((GLib.Object) val);
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("primary-icon-gicon", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("secondary-icon-gicon")]
		public GLib.IIcon SecondaryIconGicon {
			get {
				GLib.Value val = GetProperty ("secondary-icon-gicon");
				GLib.IIcon ret = GLib.IconAdapter.GetObject ((GLib.Object) val);
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("secondary-icon-gicon", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("primary-icon-storage-type")]
		public Gtk.ImageType PrimaryIconStorageType {
			get {
				GLib.Value val = GetProperty ("primary-icon-storage-type");
				Gtk.ImageType ret = (Gtk.ImageType) (Enum) val;
				val.Dispose ();
				return ret;
			}
		}

		[GLib.Property ("secondary-icon-storage-type")]
		public Gtk.ImageType SecondaryIconStorageType {
			get {
				GLib.Value val = GetProperty ("secondary-icon-storage-type");
				Gtk.ImageType ret = (Gtk.ImageType) (Enum) val;
				val.Dispose ();
				return ret;
			}
		}

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

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

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

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

		[GLib.Property ("primary-icon-tooltip-text")]
		public string PrimaryIconTooltipText {
			get {
				GLib.Value val = GetProperty ("primary-icon-tooltip-text");
				string ret = (string) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("primary-icon-tooltip-text", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("secondary-icon-tooltip-text")]
		public string SecondaryIconTooltipText {
			get {
				GLib.Value val = GetProperty ("secondary-icon-tooltip-text");
				string ret = (string) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("secondary-icon-tooltip-text", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("primary-icon-tooltip-markup")]
		public string PrimaryIconTooltipMarkup {
			get {
				GLib.Value val = GetProperty ("primary-icon-tooltip-markup");
				string ret = (string) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("primary-icon-tooltip-markup", val);
				val.Dispose ();
			}
		}

		[GLib.Property ("secondary-icon-tooltip-markup")]
		public string SecondaryIconTooltipMarkup {
			get {
				GLib.Value val = GetProperty ("secondary-icon-tooltip-markup");
				string ret = (string) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("secondary-icon-tooltip-markup", val);
				val.Dispose ();
			}
		}

		[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 IntPtr d_gtk_entry_get_completion(IntPtr raw);
		static d_gtk_entry_get_completion gtk_entry_get_completion = FuncLoader.LoadFunction<d_gtk_entry_get_completion>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_get_completion"));

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

		[GLib.Property ("completion")]
		public Gtk.EntryCompletion Completion {
			get  {
				IntPtr raw_ret = gtk_entry_get_completion(Handle);
				Gtk.EntryCompletion ret = GLib.Object.GetObject(raw_ret) as Gtk.EntryCompletion;
				return ret;
			}
			set  {
				gtk_entry_set_completion(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

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

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

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

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

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

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

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

		[GLib.Property ("attributes")]
		public Pango.AttrList Attributes {
			get  {
				IntPtr raw_ret = gtk_entry_get_attributes(Handle);
				Pango.AttrList ret = raw_ret == IntPtr.Zero ? null : (Pango.AttrList) GLib.Opaque.GetOpaque (raw_ret, typeof (Pango.AttrList), false);
				return ret;
			}
			set  {
				gtk_entry_set_attributes(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[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 IntPtr d_gtk_entry_get_tabs(IntPtr raw);
		static d_gtk_entry_get_tabs gtk_entry_get_tabs = FuncLoader.LoadFunction<d_gtk_entry_get_tabs>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_get_tabs"));

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

		[GLib.Property ("tabs")]
		public Pango.TabArray Tabs {
			get  {
				IntPtr raw_ret = gtk_entry_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_entry_set_tabs(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

		[Obsolete]
		public bool IconPrelight {
			get {
				var val = (bool)StyleGetProperty("icon-prelight");
				return val;
			}
		}

		[Obsolete]
		public Gtk.Border? ProgressBorder {
			get {
				var val = (Gtk.Border?)StyleGetProperty("progress-border");
				return val;
			}
		}

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

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

		public char InvisibleChar {
			get  {
				uint raw_ret = gtk_entry_get_invisible_char(Handle);
				char ret = GLib.Marshaller.GUnicharToChar (raw_ret);
				return ret;
			}
			set  {
				gtk_entry_set_invisible_char(Handle, GLib.Marshaller.CharToGUnichar (value));
			}
		}

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

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

		[Obsolete]
		[GLib.Property ("inner-border")]
		public Gtk.Border InnerBorder {
			get  {
				IntPtr raw_ret = gtk_entry_get_inner_border(Handle);
				Gtk.Border ret = Gtk.Border.New (raw_ret);
				return ret;
			}
			set  {
				IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
				gtk_entry_set_inner_border(Handle, native_value);
				Marshal.FreeHGlobal (native_value);
			}
		}

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

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

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

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

		[GLib.Signal("backspace")]
		public event System.EventHandler Backspace {
			add {
				this.AddSignalHandler ("backspace", value);
			}
			remove {
				this.RemoveSignalHandler ("backspace", 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("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("icon-press")]
		public event Gtk.IconPressHandler IconPress {
			add {
				this.AddSignalHandler ("icon-press", value, typeof (Gtk.IconPressArgs));
			}
			remove {
				this.RemoveSignalHandler ("icon-press", value);
			}
		}

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

		[GLib.Signal("icon-release")]
		public event Gtk.IconReleaseHandler IconRelease {
			add {
				this.AddSignalHandler ("icon-release", value, typeof (Gtk.IconReleaseArgs));
			}
			remove {
				this.RemoveSignalHandler ("icon-release", 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);
			}
		}

		static IconPressNativeDelegate IconPress_cb_delegate;
		static IconPressNativeDelegate IconPressVMCallback {
			get {
				if (IconPress_cb_delegate == null)
					IconPress_cb_delegate = new IconPressNativeDelegate (IconPress_cb);
				return IconPress_cb_delegate;
			}
		}

		static void OverrideIconPress (GLib.GType gtype)
		{
			OverrideIconPress (gtype, IconPressVMCallback);
		}

		static void OverrideIconPress (GLib.GType gtype, IconPressNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "icon-press", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void IconPressNativeDelegate (IntPtr inst, int p0, IntPtr p1);

		static void IconPress_cb (IntPtr inst, int p0, IntPtr p1)
		{
			try {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnIconPress ((Gtk.EntryIconPosition) p0, Gdk.Event.GetEvent (p1));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideIconPress")]
		protected virtual void OnIconPress (Gtk.EntryIconPosition p0, Gdk.Event p1)
		{
			InternalIconPress (p0, p1);
		}

		private void InternalIconPress (Gtk.EntryIconPosition p0, Gdk.Event 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 IconReleaseNativeDelegate IconRelease_cb_delegate;
		static IconReleaseNativeDelegate IconReleaseVMCallback {
			get {
				if (IconRelease_cb_delegate == null)
					IconRelease_cb_delegate = new IconReleaseNativeDelegate (IconRelease_cb);
				return IconRelease_cb_delegate;
			}
		}

		static void OverrideIconRelease (GLib.GType gtype)
		{
			OverrideIconRelease (gtype, IconReleaseVMCallback);
		}

		static void OverrideIconRelease (GLib.GType gtype, IconReleaseNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "icon-release", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void IconReleaseNativeDelegate (IntPtr inst, int p0, IntPtr p1);

		static void IconRelease_cb (IntPtr inst, int p0, IntPtr p1)
		{
			try {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnIconRelease ((Gtk.EntryIconPosition) p0, Gdk.Event.GetEvent (p1));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideIconRelease")]
		protected virtual void OnIconRelease (Gtk.EntryIconPosition p0, Gdk.Event p1)
		{
			InternalIconRelease (p0, p1);
		}

		private void InternalIconRelease (Gtk.EntryIconPosition p0, Gdk.Event 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 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 {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnPreeditChanged (GLib.Marshaller.PtrToStringGFree(p0));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), 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 {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnPopulatePopup (GLib.Object.GetObject(popup) as Gtk.Widget);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), 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 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);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideActivated")]
		protected virtual void OnActivated ()
		{
			InternalActivated ();
		}

		private void InternalActivated ()
		{
			ActivatedNativeDelegate unmanaged = class_abi.BaseOverride<ActivatedNativeDelegate>(this.LookupGType(), "activate");
			if (unmanaged == null) return;

			unmanaged (this.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 {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnMoveCursor ((Gtk.MovementStep) step, count, extend_selection);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), 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 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 {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnInsertAtCursor (GLib.Marshaller.Utf8PtrToString (str));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), 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 {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnDeleteFromCursor ((Gtk.DeleteType) type, count);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), 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 {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnBackspace ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), 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 ClipboardCutNativeDelegate ClipboardCut_cb_delegate;
		static ClipboardCutNativeDelegate ClipboardCutVMCallback {
			get {
				if (ClipboardCut_cb_delegate == null)
					ClipboardCut_cb_delegate = new ClipboardCutNativeDelegate (ClipboardCut_cb);
				return ClipboardCut_cb_delegate;
			}
		}

		static void OverrideClipboardCut (GLib.GType gtype)
		{
			OverrideClipboardCut (gtype, ClipboardCutVMCallback);
		}

		static void OverrideClipboardCut (GLib.GType gtype, ClipboardCutNativeDelegate 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 ClipboardCutNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideClipboardCut")]
		protected virtual void OnClipboardCut ()
		{
			InternalClipboardCut ();
		}

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

			unmanaged (this.Handle);
		}

		static ClipboardCopiedNativeDelegate ClipboardCopied_cb_delegate;
		static ClipboardCopiedNativeDelegate ClipboardCopiedVMCallback {
			get {
				if (ClipboardCopied_cb_delegate == null)
					ClipboardCopied_cb_delegate = new ClipboardCopiedNativeDelegate (ClipboardCopied_cb);
				return ClipboardCopied_cb_delegate;
			}
		}

		static void OverrideClipboardCopied (GLib.GType gtype)
		{
			OverrideClipboardCopied (gtype, ClipboardCopiedVMCallback);
		}

		static void OverrideClipboardCopied (GLib.GType gtype, ClipboardCopiedNativeDelegate 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 ClipboardCopiedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideClipboardCopied")]
		protected virtual void OnClipboardCopied ()
		{
			InternalClipboardCopied ();
		}

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

			unmanaged (this.Handle);
		}

		static ClipboardPastedNativeDelegate ClipboardPasted_cb_delegate;
		static ClipboardPastedNativeDelegate ClipboardPastedVMCallback {
			get {
				if (ClipboardPasted_cb_delegate == null)
					ClipboardPasted_cb_delegate = new ClipboardPastedNativeDelegate (ClipboardPasted_cb);
				return ClipboardPasted_cb_delegate;
			}
		}

		static void OverrideClipboardPasted (GLib.GType gtype)
		{
			OverrideClipboardPasted (gtype, ClipboardPastedVMCallback);
		}

		static void OverrideClipboardPasted (GLib.GType gtype, ClipboardPastedNativeDelegate 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 ClipboardPastedNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideClipboardPasted")]
		protected virtual void OnClipboardPasted ()
		{
			InternalClipboardPasted ();
		}

		private void InternalClipboardPasted ()
		{
			ClipboardPastedNativeDelegate unmanaged = class_abi.BaseOverride<ClipboardPastedNativeDelegate>(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 {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnToggleOverwrite ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), 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 GetTextAreaSizeNativeDelegate GetTextAreaSize_cb_delegate;
		static GetTextAreaSizeNativeDelegate GetTextAreaSizeVMCallback {
			get {
				if (GetTextAreaSize_cb_delegate == null)
					GetTextAreaSize_cb_delegate = new GetTextAreaSizeNativeDelegate (GetTextAreaSize_cb);
				return GetTextAreaSize_cb_delegate;
			}
		}

		static void OverrideGetTextAreaSize (GLib.GType gtype)
		{
			OverrideGetTextAreaSize (gtype, GetTextAreaSizeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetTextAreaSizeNativeDelegate (IntPtr inst, out int x, out int y, out int width, out int height);

		static void GetTextAreaSize_cb (IntPtr inst, out int x, out int y, out int width, out int height)
		{
			try {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnGetTextAreaSize (out x, out y, out width, out height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideGetTextAreaSize")]
		protected virtual void OnGetTextAreaSize (out int x, out int y, out int width, out int height)
		{
			InternalGetTextAreaSize (out x, out y, out width, out height);
		}

		private void InternalGetTextAreaSize (out int x, out int y, out int width, out int height)
		{
			GetTextAreaSizeNativeDelegate unmanaged = class_abi.BaseOverride<GetTextAreaSizeNativeDelegate>(this.LookupGType(), "get_text_area_size");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, out x, out y, out width, out height);
		}

		static GetFrameSizeNativeDelegate GetFrameSize_cb_delegate;
		static GetFrameSizeNativeDelegate GetFrameSizeVMCallback {
			get {
				if (GetFrameSize_cb_delegate == null)
					GetFrameSize_cb_delegate = new GetFrameSizeNativeDelegate (GetFrameSize_cb);
				return GetFrameSize_cb_delegate;
			}
		}

		static void OverrideGetFrameSize (GLib.GType gtype)
		{
			OverrideGetFrameSize (gtype, GetFrameSizeVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetFrameSizeNativeDelegate (IntPtr inst, out int x, out int y, out int width, out int height);

		static void GetFrameSize_cb (IntPtr inst, out int x, out int y, out int width, out int height)
		{
			try {
				Entry __obj = GLib.Object.GetObject (inst, false) as Entry;
				__obj.OnGetFrameSize (out x, out y, out width, out height);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideGetFrameSize")]
		protected virtual void OnGetFrameSize (out int x, out int y, out int width, out int height)
		{
			InternalGetFrameSize (out x, out y, out width, out height);
		}

		private void InternalGetFrameSize (out int x, out int y, out int width, out int height)
		{
			GetFrameSizeNativeDelegate unmanaged = class_abi.BaseOverride<GetFrameSizeNativeDelegate>(this.LookupGType(), "get_frame_size");
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			unmanaged (this.Handle, out x, out y, out width, out height);
		}


		// 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.Widget.class_abi.Fields
							, (uint) sizeof( IntPtr ) // populate_popup
							, null
							, "activate"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("activate"
							, -1
							, (uint) sizeof( IntPtr ) // activate
							, "populate_popup"
							, "move_cursor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("move_cursor"
							, -1
							, (uint) sizeof( IntPtr ) // move_cursor
							, "activate"
							, "insert_at_cursor"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("insert_at_cursor"
							, -1
							, (uint) sizeof( IntPtr ) // insert_at_cursor
							, "move_cursor"
							, "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"
							, "get_text_area_size"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_text_area_size"
							, -1
							, (uint) sizeof( IntPtr ) // get_text_area_size
							, "toggle_overwrite"
							, "get_frame_size"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_frame_size"
							, -1
							, (uint) sizeof( IntPtr ) // get_frame_size
							, "get_text_area_size"
							, "_gtk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "get_frame_size"
							, "_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"
							, "_gtk_reserved6"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved6"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved6
							, "_gtk_reserved5"
							, "_gtk_reserved7"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved7"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved7
							, "_gtk_reserved6"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

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

		public float Alignment { 
			get {
				float raw_ret = gtk_entry_get_alignment(Handle);
				float ret = raw_ret;
				return ret;
			}
			set {
				gtk_entry_set_alignment(Handle, value);
			}
		}

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

		public int CurrentIconDragSource { 
			get {
				int raw_ret = gtk_entry_get_current_icon_drag_source(Handle);
				int ret = raw_ret;
				return ret;
			}
		}

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

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

		public Gtk.Adjustment CursorHadjustment { 
			get {
				IntPtr raw_ret = gtk_entry_get_cursor_hadjustment(Handle);
				Gtk.Adjustment ret = GLib.Object.GetObject(raw_ret) as Gtk.Adjustment;
				return ret;
			}
			set {
				gtk_entry_set_cursor_hadjustment(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

		public bool GetIconActivatable(Gtk.EntryIconPosition icon_pos) {
			bool raw_ret = gtk_entry_get_icon_activatable(Handle, (int) icon_pos);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_entry_get_icon_area(IntPtr raw, int icon_pos, IntPtr icon_area);
		static d_gtk_entry_get_icon_area gtk_entry_get_icon_area = FuncLoader.LoadFunction<d_gtk_entry_get_icon_area>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_get_icon_area"));

		public Gdk.Rectangle GetIconArea(Gtk.EntryIconPosition icon_pos) {
			Gdk.Rectangle icon_area;
			IntPtr native_icon_area = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
			gtk_entry_get_icon_area(Handle, (int) icon_pos, native_icon_area);
			icon_area = (Gdk.Rectangle) Marshal.PtrToStructure (native_icon_area, typeof (Gdk.Rectangle));
			Marshal.FreeHGlobal (native_icon_area);
			return icon_area;
		}

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

		public int GetIconAtPos(int x, int y) {
			int raw_ret = gtk_entry_get_icon_at_pos(Handle, x, y);
			int ret = raw_ret;
			return ret;
		}

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

		public GLib.IIcon GetIconGicon(Gtk.EntryIconPosition icon_pos) {
			IntPtr raw_ret = gtk_entry_get_icon_gicon(Handle, (int) icon_pos);
			GLib.IIcon ret = GLib.IconAdapter.GetObject (raw_ret, false);
			return ret;
		}

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

		public string GetIconName(Gtk.EntryIconPosition icon_pos) {
			IntPtr raw_ret = gtk_entry_get_icon_name(Handle, (int) icon_pos);
			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
			return ret;
		}

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

		public Gdk.Pixbuf GetIconPixbuf(Gtk.EntryIconPosition icon_pos) {
			IntPtr raw_ret = gtk_entry_get_icon_pixbuf(Handle, (int) icon_pos);
			Gdk.Pixbuf ret = GLib.Object.GetObject(raw_ret) as Gdk.Pixbuf;
			return ret;
		}

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

		public bool GetIconSensitive(Gtk.EntryIconPosition icon_pos) {
			bool raw_ret = gtk_entry_get_icon_sensitive(Handle, (int) icon_pos);
			bool ret = raw_ret;
			return ret;
		}

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

		[Obsolete]
		public string GetIconStock(Gtk.EntryIconPosition icon_pos) {
			IntPtr raw_ret = gtk_entry_get_icon_stock(Handle, (int) icon_pos);
			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
			return ret;
		}

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

		public Gtk.ImageType GetIconStorageType(Gtk.EntryIconPosition icon_pos) {
			int raw_ret = gtk_entry_get_icon_storage_type(Handle, (int) icon_pos);
			Gtk.ImageType ret = (Gtk.ImageType) raw_ret;
			return ret;
		}

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

		public string GetIconTooltipMarkup(Gtk.EntryIconPosition icon_pos) {
			IntPtr raw_ret = gtk_entry_get_icon_tooltip_markup(Handle, (int) icon_pos);
			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
			return ret;
		}

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

		public string GetIconTooltipText(Gtk.EntryIconPosition icon_pos) {
			IntPtr raw_ret = gtk_entry_get_icon_tooltip_text(Handle, (int) icon_pos);
			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
			return ret;
		}

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

		public Pango.Layout Layout { 
			get {
				IntPtr raw_ret = gtk_entry_get_layout(Handle);
				Pango.Layout ret = GLib.Object.GetObject(raw_ret) as Pango.Layout;
				return ret;
			}
		}

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

		public void GetLayoutOffsets(out int x, out int y) {
			gtk_entry_get_layout_offsets(Handle, out x, out y);
		}

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

		public Gdk.Rectangle TextArea { 
			get {
				Gdk.Rectangle text_area;
				IntPtr native_text_area = Marshal.AllocHGlobal (Marshal.SizeOf<Gdk.Rectangle>());
				gtk_entry_get_text_area(Handle, native_text_area);
				text_area = (Gdk.Rectangle) Marshal.PtrToStructure (native_text_area, typeof (Gdk.Rectangle));
				Marshal.FreeHGlobal (native_text_area);
				return text_area;
			}
		}

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

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

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

		public void GrabFocusWithoutSelecting() {
			gtk_entry_grab_focus_without_selecting(Handle);
		}

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

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

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

		public int LayoutIndexToTextIndex(int layout_index) {
			int raw_ret = gtk_entry_layout_index_to_text_index(Handle, layout_index);
			int ret = raw_ret;
			return ret;
		}

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

		public void ProgressPulse() {
			gtk_entry_progress_pulse(Handle);
		}

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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_entry_set_icon_activatable(IntPtr raw, int icon_pos, bool activatable);
		static d_gtk_entry_set_icon_activatable gtk_entry_set_icon_activatable = FuncLoader.LoadFunction<d_gtk_entry_set_icon_activatable>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_set_icon_activatable"));

		public void SetIconActivatable(Gtk.EntryIconPosition icon_pos, bool activatable) {
			gtk_entry_set_icon_activatable(Handle, (int) icon_pos, activatable);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_entry_set_icon_drag_source(IntPtr raw, int icon_pos, IntPtr target_list, int actions);
		static d_gtk_entry_set_icon_drag_source gtk_entry_set_icon_drag_source = FuncLoader.LoadFunction<d_gtk_entry_set_icon_drag_source>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_set_icon_drag_source"));

		public void SetIconDragSource(Gtk.EntryIconPosition icon_pos, Gtk.TargetList target_list, Gdk.DragAction actions) {
			gtk_entry_set_icon_drag_source(Handle, (int) icon_pos, target_list == null ? IntPtr.Zero : target_list.Handle, (int) actions);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_entry_set_icon_from_gicon(IntPtr raw, int icon_pos, IntPtr icon);
		static d_gtk_entry_set_icon_from_gicon gtk_entry_set_icon_from_gicon = FuncLoader.LoadFunction<d_gtk_entry_set_icon_from_gicon>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_set_icon_from_gicon"));

		public void SetIconFromGicon(Gtk.EntryIconPosition icon_pos, GLib.IIcon icon) {
			gtk_entry_set_icon_from_gicon(Handle, (int) icon_pos, icon == null ? IntPtr.Zero : ((icon is GLib.Object) ? (icon as GLib.Object).Handle : (icon as GLib.IconAdapter).Handle));
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_entry_set_icon_from_icon_name(IntPtr raw, int icon_pos, IntPtr icon_name);
		static d_gtk_entry_set_icon_from_icon_name gtk_entry_set_icon_from_icon_name = FuncLoader.LoadFunction<d_gtk_entry_set_icon_from_icon_name>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_set_icon_from_icon_name"));

		public void SetIconFromIconName(Gtk.EntryIconPosition icon_pos, string icon_name) {
			IntPtr native_icon_name = GLib.Marshaller.StringToPtrGStrdup (icon_name);
			gtk_entry_set_icon_from_icon_name(Handle, (int) icon_pos, native_icon_name);
			GLib.Marshaller.Free (native_icon_name);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_entry_set_icon_from_pixbuf(IntPtr raw, int icon_pos, IntPtr pixbuf);
		static d_gtk_entry_set_icon_from_pixbuf gtk_entry_set_icon_from_pixbuf = FuncLoader.LoadFunction<d_gtk_entry_set_icon_from_pixbuf>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_set_icon_from_pixbuf"));

		public void SetIconFromPixbuf(Gtk.EntryIconPosition icon_pos, Gdk.Pixbuf pixbuf) {
			gtk_entry_set_icon_from_pixbuf(Handle, (int) icon_pos, pixbuf == null ? IntPtr.Zero : pixbuf.Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_entry_set_icon_from_stock(IntPtr raw, int icon_pos, IntPtr stock_id);
		static d_gtk_entry_set_icon_from_stock gtk_entry_set_icon_from_stock = FuncLoader.LoadFunction<d_gtk_entry_set_icon_from_stock>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_set_icon_from_stock"));

		[Obsolete]
		public void SetIconFromStock(Gtk.EntryIconPosition icon_pos, string stock_id) {
			IntPtr native_stock_id = GLib.Marshaller.StringToPtrGStrdup (stock_id);
			gtk_entry_set_icon_from_stock(Handle, (int) icon_pos, native_stock_id);
			GLib.Marshaller.Free (native_stock_id);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_entry_set_icon_sensitive(IntPtr raw, int icon_pos, bool sensitive);
		static d_gtk_entry_set_icon_sensitive gtk_entry_set_icon_sensitive = FuncLoader.LoadFunction<d_gtk_entry_set_icon_sensitive>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_set_icon_sensitive"));

		public void SetIconSensitive(Gtk.EntryIconPosition icon_pos, bool sensitive) {
			gtk_entry_set_icon_sensitive(Handle, (int) icon_pos, sensitive);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_entry_set_icon_tooltip_markup(IntPtr raw, int icon_pos, IntPtr tooltip);
		static d_gtk_entry_set_icon_tooltip_markup gtk_entry_set_icon_tooltip_markup = FuncLoader.LoadFunction<d_gtk_entry_set_icon_tooltip_markup>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_set_icon_tooltip_markup"));

		public void SetIconTooltipMarkup(Gtk.EntryIconPosition icon_pos, string tooltip) {
			IntPtr native_tooltip = GLib.Marshaller.StringToPtrGStrdup (tooltip);
			gtk_entry_set_icon_tooltip_markup(Handle, (int) icon_pos, native_tooltip);
			GLib.Marshaller.Free (native_tooltip);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_entry_set_icon_tooltip_text(IntPtr raw, int icon_pos, IntPtr tooltip);
		static d_gtk_entry_set_icon_tooltip_text gtk_entry_set_icon_tooltip_text = FuncLoader.LoadFunction<d_gtk_entry_set_icon_tooltip_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_entry_set_icon_tooltip_text"));

		public void SetIconTooltipText(Gtk.EntryIconPosition icon_pos, string tooltip) {
			IntPtr native_tooltip = GLib.Marshaller.StringToPtrGStrdup (tooltip);
			gtk_entry_set_icon_tooltip_text(Handle, (int) icon_pos, native_tooltip);
			GLib.Marshaller.Free (native_tooltip);
		}

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

		public int TextIndexToLayoutIndex(int text_index) {
			int raw_ret = gtk_entry_text_index_to_layout_index(Handle, text_index);
			int ret = raw_ret;
			return ret;
		}

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

		public void UnsetInvisibleChar() {
			gtk_entry_unset_invisible_char(Handle);
		}

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

		public void CopyClipboard() {
			gtk_editable_copy_clipboard(Handle);
		}

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

		public void CutClipboard() {
			gtk_editable_cut_clipboard(Handle);
		}

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

		public void DeleteSelection() {
			gtk_editable_delete_selection(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_editable_delete_text(IntPtr raw, int start_pos, int end_pos);
		static d_gtk_editable_delete_text gtk_editable_delete_text = FuncLoader.LoadFunction<d_gtk_editable_delete_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_editable_delete_text"));

		public void DeleteText(int start_pos, int end_pos) {
			gtk_editable_delete_text(Handle, start_pos, end_pos);
		}

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

		public string GetChars(int start_pos, int end_pos) {
			IntPtr raw_ret = gtk_editable_get_chars(Handle, start_pos, end_pos);
			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
			return ret;
		}

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

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

		public bool IsEditable { 
			get {
				bool raw_ret = gtk_editable_get_editable(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_editable_set_editable(Handle, value);
			}
		}

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

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

		public int Position { 
			get {
				int raw_ret = gtk_editable_get_position(Handle);
				int ret = raw_ret;
				return ret;
			}
			set {
				gtk_editable_set_position(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_editable_get_selection_bounds(IntPtr raw, out int start_pos, out int end_pos);
		static d_gtk_editable_get_selection_bounds gtk_editable_get_selection_bounds = FuncLoader.LoadFunction<d_gtk_editable_get_selection_bounds>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_editable_get_selection_bounds"));

		public bool GetSelectionBounds(out int start_pos, out int end_pos) {
			bool raw_ret = gtk_editable_get_selection_bounds(Handle, out start_pos, out end_pos);
			bool ret = raw_ret;
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_editable_insert_text(IntPtr raw, IntPtr new_text, int new_text_length, ref int position);
		static d_gtk_editable_insert_text gtk_editable_insert_text = FuncLoader.LoadFunction<d_gtk_editable_insert_text>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_editable_insert_text"));

		public void InsertText(string new_text, ref int position) {
			IntPtr native_new_text = GLib.Marshaller.StringToPtrGStrdup (new_text);
			gtk_editable_insert_text(Handle, native_new_text, System.Text.Encoding.UTF8.GetByteCount (new_text), ref position);
			GLib.Marshaller.Free (native_new_text);
		}

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

		public void PasteClipboard() {
			gtk_editable_paste_clipboard(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_editable_select_region(IntPtr raw, int start_pos, int end_pos);
		static d_gtk_editable_select_region gtk_editable_select_region = FuncLoader.LoadFunction<d_gtk_editable_select_region>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_editable_select_region"));

		public void SelectRegion(int start_pos, int end_pos) {
			gtk_editable_select_region(Handle, start_pos, end_pos);
		}

		[GLib.Signal("delete-text")]
		public event Gtk.TextDeletedHandler TextDeleted {
			add {
				this.AddSignalHandler ("delete-text", value, typeof (Gtk.TextDeletedArgs));
			}
			remove {
				this.RemoveSignalHandler ("delete-text", value);
			}
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TextInsertedSignalDelegate (IntPtr inst, IntPtr arg0, int arg1, ref int arg2, IntPtr gch);

		static void TextInsertedSignalCallback (IntPtr inst, IntPtr arg0, int arg1, ref int arg2, IntPtr gch)
		{
			Gtk.TextInsertedArgs args = new Gtk.TextInsertedArgs ();
			try {
				GLib.Signal sig = ((GCHandle) gch).Target as GLib.Signal;
				if (sig == null)
					throw new Exception("Unknown signal GC handle received " + gch);

				args.Args = new object[3];
				args.Args[0] = GLib.Marshaller.Utf8PtrToString (arg0);
				args.Args[1] = arg1;
				args.Args[2] = arg2;
				Gtk.TextInsertedHandler handler = (Gtk.TextInsertedHandler) sig.Handler;
				handler (GLib.Object.GetObject (inst), args);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}

			try {
				arg2 = ((int)args.Args[2]);
			} catch (Exception) {
				Exception ex = new Exception ("args.RetVal or 'out' property unset or set to incorrect type in Gtk.TextInsertedHandler callback");
				GLib.ExceptionManager.RaiseUnhandledException (ex, true);
				// NOTREACHED: above call doesn't return.
				throw ex;
			}
		}

		[GLib.Signal("insert-text")]
		public event Gtk.TextInsertedHandler TextInserted {
			add {
				this.AddSignalHandler ("insert-text", value, new TextInsertedSignalDelegate(TextInsertedSignalCallback));
			}
			remove {
				this.RemoveSignalHandler ("insert-text", value);
			}
		}

		static TextInsertedNativeDelegate TextInserted_cb_delegate;
		static TextInsertedNativeDelegate TextInsertedVMCallback {
			get {
				if (TextInserted_cb_delegate == null)
					TextInserted_cb_delegate = new TextInsertedNativeDelegate (TextInserted_cb);
				return TextInserted_cb_delegate;
			}
		}

		static void OverrideTextInserted (GLib.GType gtype)
		{
			OverrideTextInserted (gtype, TextInsertedVMCallback);
		}

		static void OverrideTextInserted (GLib.GType gtype, TextInsertedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "insert-text", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TextInsertedNativeDelegate (IntPtr inst, IntPtr new_text, int new_text_length, ref int position);

		static void TextInserted_cb (IntPtr inst, IntPtr new_text, int new_text_length, ref int position)
		{
			try {
				Gtk.Entry __obj = GLib.Object.GetObject (inst, false) as Gtk.Entry;
				__obj.OnTextInserted (GLib.Marshaller.Utf8PtrToString (new_text), ref position);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideTextInserted")]
		protected virtual void OnTextInserted (string new_text, ref int position)
		{
			InternalTextInserted (new_text, ref position);
		}

		private void InternalTextInserted (string new_text, ref int position)
		{
			GLib.Value ret = GLib.Value.Empty;
			GLib.ValueArray inst_and_params = new GLib.ValueArray (4);
			GLib.Value[] vals = new GLib.Value [4];
			vals [0] = new GLib.Value (this);
			inst_and_params.Append (vals [0]);
			vals [1] = new GLib.Value (new_text);
			inst_and_params.Append (vals [1]);
			vals [2] = new GLib.Value (System.Text.Encoding.UTF8.GetByteCount (new_text));
			inst_and_params.Append (vals [2]);
			IntPtr position_ptr = GLib.Marshaller.StructureToPtrAlloc (position);
			vals [3] = new GLib.Value (position_ptr);
			inst_and_params.Append (vals [3]);
			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
			position = (int) Marshal.PtrToStructure (position_ptr, typeof (int));
			Marshal.FreeHGlobal (position_ptr);

			foreach (GLib.Value v in vals)
				v.Dispose ();
		}

		static TextDeletedNativeDelegate TextDeleted_cb_delegate;
		static TextDeletedNativeDelegate TextDeletedVMCallback {
			get {
				if (TextDeleted_cb_delegate == null)
					TextDeleted_cb_delegate = new TextDeletedNativeDelegate (TextDeleted_cb);
				return TextDeleted_cb_delegate;
			}
		}

		static void OverrideTextDeleted (GLib.GType gtype)
		{
			OverrideTextDeleted (gtype, TextDeletedVMCallback);
		}

		static void OverrideTextDeleted (GLib.GType gtype, TextDeletedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "delete-text", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void TextDeletedNativeDelegate (IntPtr inst, int start_pos, int end_pos);

		static void TextDeleted_cb (IntPtr inst, int start_pos, int end_pos)
		{
			try {
				Gtk.Entry __obj = GLib.Object.GetObject (inst, false) as Gtk.Entry;
				__obj.OnTextDeleted (start_pos, end_pos);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideTextDeleted")]
		protected virtual void OnTextDeleted (int start_pos, int end_pos)
		{
			InternalTextDeleted (start_pos, end_pos);
		}

		private void InternalTextDeleted (int start_pos, int end_pos)
		{
			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 (start_pos);
			inst_and_params.Append (vals [1]);
			vals [2] = new GLib.Value (end_pos);
			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 ChangedNativeDelegate Changed_cb_delegate;
		static ChangedNativeDelegate ChangedVMCallback {
			get {
				if (Changed_cb_delegate == null)
					Changed_cb_delegate = new ChangedNativeDelegate (Changed_cb);
				return Changed_cb_delegate;
			}
		}

		static void OverrideChanged (GLib.GType gtype)
		{
			OverrideChanged (gtype, ChangedVMCallback);
		}

		static void OverrideChanged (GLib.GType gtype, ChangedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "changed", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ChangedNativeDelegate (IntPtr inst);

		static void Changed_cb (IntPtr inst)
		{
			try {
				Gtk.Entry __obj = GLib.Object.GetObject (inst, false) as Gtk.Entry;
				__obj.OnChanged ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideChanged")]
		protected virtual void OnChanged ()
		{
			InternalChanged ();
		}

		private void InternalChanged ()
		{
			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 ();
		}

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

		public void FinishEditing() {
			gtk_cell_editable_editing_done(Handle);
		}

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

		public void RemoveWidget() {
			gtk_cell_editable_remove_widget(Handle);
		}

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

		public void StartEditing(Gdk.Event evnt) {
			gtk_cell_editable_start_editing(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
		}

		[GLib.Signal("editing-done")]
		public event System.EventHandler EditingDone {
			add {
				this.AddSignalHandler ("editing-done", value);
			}
			remove {
				this.RemoveSignalHandler ("editing-done", value);
			}
		}

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

		static EditingDoneNativeDelegate EditingDone_cb_delegate;
		static EditingDoneNativeDelegate EditingDoneVMCallback {
			get {
				if (EditingDone_cb_delegate == null)
					EditingDone_cb_delegate = new EditingDoneNativeDelegate (EditingDone_cb);
				return EditingDone_cb_delegate;
			}
		}

		static void OverrideEditingDone (GLib.GType gtype)
		{
			OverrideEditingDone (gtype, EditingDoneVMCallback);
		}

		static void OverrideEditingDone (GLib.GType gtype, EditingDoneNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "editing-done", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void EditingDoneNativeDelegate (IntPtr inst);

		static void EditingDone_cb (IntPtr inst)
		{
			try {
				Gtk.Entry __obj = GLib.Object.GetObject (inst, false) as Gtk.Entry;
				__obj.OnEditingDone ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideEditingDone")]
		protected virtual void OnEditingDone ()
		{
			InternalEditingDone ();
		}

		private void InternalEditingDone ()
		{
			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 WidgetRemovedNativeDelegate WidgetRemoved_cb_delegate;
		static WidgetRemovedNativeDelegate WidgetRemovedVMCallback {
			get {
				if (WidgetRemoved_cb_delegate == null)
					WidgetRemoved_cb_delegate = new WidgetRemovedNativeDelegate (WidgetRemoved_cb);
				return WidgetRemoved_cb_delegate;
			}
		}

		static void OverrideWidgetRemoved (GLib.GType gtype)
		{
			OverrideWidgetRemoved (gtype, WidgetRemovedVMCallback);
		}

		static void OverrideWidgetRemoved (GLib.GType gtype, WidgetRemovedNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "remove-widget", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void WidgetRemovedNativeDelegate (IntPtr inst);

		static void WidgetRemoved_cb (IntPtr inst)
		{
			try {
				Gtk.Entry __obj = GLib.Object.GetObject (inst, false) as Gtk.Entry;
				__obj.OnWidgetRemoved ();
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Entry), ConnectionMethod="OverrideWidgetRemoved")]
		protected virtual void OnWidgetRemoved ()
		{
			InternalWidgetRemoved ();
		}

		private void InternalWidgetRemoved ()
		{
			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 ();
		}


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

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
