// 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 Label : Gtk.Misc {

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

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

		public static Label New(string str)
		{
			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
			Label result = new Label (gtk_label_new(native_str));
			GLib.Marshaller.Free (native_str);
			return result;
		}

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

		public Label (string str) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Label)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				names.Add ("label");
				vals.Add (new GLib.Value (str));
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
			Raw = gtk_label_new_with_mnemonic(native_str);
			GLib.Marshaller.Free (native_str);
		}

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

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

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

		[GLib.Property ("attributes")]
		public Pango.AttrList Attributes {
			get  {
				IntPtr raw_ret = gtk_label_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_label_set_attributes(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

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

		[GLib.Property ("use-markup")]
		public bool UseMarkup {
			get  {
				bool raw_ret = gtk_label_get_use_markup(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_use_markup(Handle, value);
			}
		}

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

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

		[GLib.Property ("use-underline")]
		public bool UseUnderline {
			get  {
				bool raw_ret = gtk_label_get_use_underline(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_use_underline(Handle, value);
			}
		}

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

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

		[GLib.Property ("justify")]
		public Gtk.Justification Justify {
			get  {
				int raw_ret = gtk_label_get_justify(Handle);
				Gtk.Justification ret = (Gtk.Justification) raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_justify(Handle, (int) value);
			}
		}

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

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

		[GLib.Property ("xalign")]
		public new float Xalign {
			get  {
				float raw_ret = gtk_label_get_xalign(Handle);
				float ret = raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_xalign(Handle, value);
			}
		}

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

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

		[GLib.Property ("yalign")]
		public new float Yalign {
			get  {
				float raw_ret = gtk_label_get_yalign(Handle);
				float ret = raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_yalign(Handle, value);
			}
		}

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

		[GLib.Property ("pattern")]
		public string Pattern {
			set  {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_label_set_pattern(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

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

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

		[GLib.Property ("wrap-mode")]
		public Pango.WrapMode LineWrapMode {
			get  {
				int raw_ret = gtk_label_get_line_wrap_mode(Handle);
				Pango.WrapMode ret = (Pango.WrapMode) raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_line_wrap_mode(Handle, (int) value);
			}
		}

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

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

		[GLib.Property ("selectable")]
		public bool Selectable {
			get  {
				bool raw_ret = gtk_label_get_selectable(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_selectable(Handle, value);
			}
		}

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

		[GLib.Property ("mnemonic-keyval")]
		public uint MnemonicKeyval {
			get  {
				uint raw_ret = gtk_label_get_mnemonic_keyval(Handle);
				uint ret = raw_ret;
				return ret;
			}
		}

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

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

		[GLib.Property ("mnemonic-widget")]
		public Gtk.Widget MnemonicWidget {
			get  {
				IntPtr raw_ret = gtk_label_get_mnemonic_widget(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
			set  {
				gtk_label_set_mnemonic_widget(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_label_get_ellipsize(IntPtr raw);
		static d_gtk_label_get_ellipsize gtk_label_get_ellipsize = FuncLoader.LoadFunction<d_gtk_label_get_ellipsize>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_label_get_ellipsize"));

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

		[GLib.Property ("ellipsize")]
		public Pango.EllipsizeMode Ellipsize {
			get  {
				int raw_ret = gtk_label_get_ellipsize(Handle);
				Pango.EllipsizeMode ret = (Pango.EllipsizeMode) raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_ellipsize(Handle, (int) value);
			}
		}

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

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

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

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

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

		[GLib.Property ("single-line-mode")]
		public bool SingleLineMode {
			get  {
				bool raw_ret = gtk_label_get_single_line_mode(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_single_line_mode(Handle, value);
			}
		}

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

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

		[GLib.Property ("angle")]
		public double Angle {
			get  {
				double raw_ret = gtk_label_get_angle(Handle);
				double ret = raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_angle(Handle, value);
			}
		}

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

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

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

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

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

		[GLib.Property ("track-visited-links")]
		public bool TrackVisitedLinks {
			get  {
				bool raw_ret = gtk_label_get_track_visited_links(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_track_visited_links(Handle, value);
			}
		}

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

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

		[GLib.Property ("lines")]
		public int Lines {
			get  {
				int raw_ret = gtk_label_get_lines(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_label_set_lines(Handle, value);
			}
		}

		[GLib.Signal("activate-current-link")]
		public event System.EventHandler ActivateCurrentLink {
			add {
				this.AddSignalHandler ("activate-current-link", value);
			}
			remove {
				this.RemoveSignalHandler ("activate-current-link", 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("activate-link")]
		public event Gtk.ActivateLinkHandler ActivateLink {
			add {
				this.AddSignalHandler ("activate-link", value, typeof (Gtk.ActivateLinkArgs));
			}
			remove {
				this.RemoveSignalHandler ("activate-link", value);
			}
		}

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

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

		static ActivateCurrentLinkNativeDelegate ActivateCurrentLink_cb_delegate;
		static ActivateCurrentLinkNativeDelegate ActivateCurrentLinkVMCallback {
			get {
				if (ActivateCurrentLink_cb_delegate == null)
					ActivateCurrentLink_cb_delegate = new ActivateCurrentLinkNativeDelegate (ActivateCurrentLink_cb);
				return ActivateCurrentLink_cb_delegate;
			}
		}

		static void OverrideActivateCurrentLink (GLib.GType gtype)
		{
			OverrideActivateCurrentLink (gtype, ActivateCurrentLinkVMCallback);
		}

		static void OverrideActivateCurrentLink (GLib.GType gtype, ActivateCurrentLinkNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "activate-current-link", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ActivateCurrentLinkNativeDelegate (IntPtr inst);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Label), ConnectionMethod="OverrideActivateCurrentLink")]
		protected virtual void OnActivateCurrentLink ()
		{
			InternalActivateCurrentLink ();
		}

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Label), 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 CopyClipboardNativeDelegate CopyClipboard_cb_delegate;
		static CopyClipboardNativeDelegate CopyClipboardVMCallback {
			get {
				if (CopyClipboard_cb_delegate == null)
					CopyClipboard_cb_delegate = new CopyClipboardNativeDelegate (CopyClipboard_cb);
				return CopyClipboard_cb_delegate;
			}
		}

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

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

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

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

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

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

			unmanaged (this.Handle);
		}

		static 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 menu);

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Label), ConnectionMethod="OverridePopulatePopup")]
		protected virtual void OnPopulatePopup (Gtk.Menu menu)
		{
			InternalPopulatePopup (menu);
		}

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

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

		static ActivateLinkNativeDelegate ActivateLink_cb_delegate;
		static ActivateLinkNativeDelegate ActivateLinkVMCallback {
			get {
				if (ActivateLink_cb_delegate == null)
					ActivateLink_cb_delegate = new ActivateLinkNativeDelegate (ActivateLink_cb);
				return ActivateLink_cb_delegate;
			}
		}

		static void OverrideActivateLink (GLib.GType gtype)
		{
			OverrideActivateLink (gtype, ActivateLinkVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool ActivateLinkNativeDelegate (IntPtr inst, IntPtr uri);

		static bool ActivateLink_cb (IntPtr inst, IntPtr uri)
		{
			try {
				Label __obj = GLib.Object.GetObject (inst, false) as Label;
				bool __result;
				__result = __obj.OnActivateLink (GLib.Marshaller.Utf8PtrToString (uri));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Label), ConnectionMethod="OverrideActivateLink")]
		protected virtual bool OnActivateLink (string uri)
		{
			return InternalActivateLink (uri);
		}

		private bool InternalActivateLink (string uri)
		{
			ActivateLinkNativeDelegate unmanaged = class_abi.BaseOverride<ActivateLinkNativeDelegate>(this.LookupGType(), "activate_link");
			if (unmanaged == null) return false;

			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
			bool __result = unmanaged (this.Handle, native_uri);
			GLib.Marshaller.Free (native_uri);
			return __result;
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public unsafe new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("move_cursor"
							, Gtk.Misc.class_abi.Fields
							, (uint) sizeof( IntPtr ) // move_cursor
							, null
							, "copy_clipboard"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("copy_clipboard"
							, -1
							, (uint) sizeof( IntPtr ) // copy_clipboard
							, "move_cursor"
							, "populate_popup"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("populate_popup"
							, -1
							, (uint) sizeof( IntPtr ) // populate_popup
							, "copy_clipboard"
							, "activate_link"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("activate_link"
							, -1
							, (uint) sizeof( IntPtr ) // activate_link
							, "populate_popup"
							, "_gtk_reserved1"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "activate_link"
							, "_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"
							, "_gtk_reserved8"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_gtk_reserved8"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved8
							, "_gtk_reserved7"
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

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

		public string CurrentUri { 
			get {
				IntPtr raw_ret = gtk_label_get_current_uri(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
		}

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

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

		public string LabelMarkup { 
			get {
				IntPtr raw_ret = gtk_label_get_label(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_label_set_label(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

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

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

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

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

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

		public bool LineWrap { 
			get {
				bool raw_ret = gtk_label_get_line_wrap(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set {
				gtk_label_set_line_wrap(Handle, value);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool d_gtk_label_get_selection_bounds(IntPtr raw, out int start, out int end);
		static d_gtk_label_get_selection_bounds gtk_label_get_selection_bounds = FuncLoader.LoadFunction<d_gtk_label_get_selection_bounds>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_label_get_selection_bounds"));

		public bool GetSelectionBounds(out int start, out int end) {
			bool raw_ret = gtk_label_get_selection_bounds(Handle, out start, out end);
			bool ret = raw_ret;
			return ret;
		}

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

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

		public string Text { 
			get {
				IntPtr raw_ret = gtk_label_get_text(Handle);
				string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
				return ret;
			}
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_label_set_text(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_label_select_region(IntPtr raw, int start_offset, int end_offset);
		static d_gtk_label_select_region gtk_label_select_region = FuncLoader.LoadFunction<d_gtk_label_select_region>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_label_select_region"));

		public void SelectRegion(int start_offset, int end_offset) {
			gtk_label_select_region(Handle, start_offset, end_offset);
		}

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

		public string Markup { 
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_label_set_markup(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		public string MarkupWithMnemonic { 
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_label_set_markup_with_mnemonic(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}

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

		public string TextWithMnemonic { 
			set {
				IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
				gtk_label_set_text_with_mnemonic(Handle, native_value);
				GLib.Marshaller.Free (native_value);
			}
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public unsafe new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("priv"
							, Gtk.Misc.abi_info.Fields
							, (uint) sizeof( IntPtr ) // priv
							, null
							, null
							, (uint) sizeof(IntPtr)
							, 0
							),
					});

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}
