// 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 Container : Gtk.Widget {

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

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

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

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

		[Obsolete]
		[GLib.Property ("resize-mode")]
		public Gtk.ResizeMode ResizeMode {
			get  {
				int raw_ret = gtk_container_get_resize_mode(Handle);
				Gtk.ResizeMode ret = (Gtk.ResizeMode) raw_ret;
				return ret;
			}
			set  {
				gtk_container_set_resize_mode(Handle, (int) value);
			}
		}

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

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

		[GLib.Property ("border-width")]
		public uint BorderWidth {
			get  {
				uint raw_ret = gtk_container_get_border_width(Handle);
				uint ret = raw_ret;
				return ret;
			}
			set  {
				gtk_container_set_border_width(Handle, value);
			}
		}

		[GLib.Property ("child")]
		public Gtk.Widget Child {
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("child", val);
				val.Dispose ();
			}
		}

		[GLib.Signal("remove")]
		public event Gtk.RemovedHandler Removed {
			add {
				this.AddSignalHandler ("remove", value, typeof (Gtk.RemovedArgs));
			}
			remove {
				this.RemoveSignalHandler ("remove", value);
			}
		}

		[GLib.Signal("set-focus-child")]
		public event Gtk.FocusChildSetHandler FocusChildSet {
			add {
				this.AddSignalHandler ("set-focus-child", value, typeof (Gtk.FocusChildSetArgs));
			}
			remove {
				this.RemoveSignalHandler ("set-focus-child", value);
			}
		}

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

		[GLib.Signal("add")]
		public event Gtk.AddedHandler Added {
			add {
				this.AddSignalHandler ("add", value, typeof (Gtk.AddedArgs));
			}
			remove {
				this.RemoveSignalHandler ("add", value);
			}
		}

		static AddedNativeDelegate Added_cb_delegate;
		static AddedNativeDelegate AddedVMCallback {
			get {
				if (Added_cb_delegate == null)
					Added_cb_delegate = new AddedNativeDelegate (Added_cb);
				return Added_cb_delegate;
			}
		}

		static void OverrideAdded (GLib.GType gtype)
		{
			OverrideAdded (gtype, AddedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void AddedNativeDelegate (IntPtr inst, IntPtr widget);

		static void Added_cb (IntPtr inst, IntPtr widget)
		{
			try {
				Container __obj = GLib.Object.GetObject (inst, false) as Container;
				__obj.OnAdded (GLib.Object.GetObject(widget) as Gtk.Widget);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Container), ConnectionMethod="OverrideAdded")]
		protected virtual void OnAdded (Gtk.Widget widget)
		{
			InternalAdded (widget);
		}

		private void InternalAdded (Gtk.Widget widget)
		{
			AddedNativeDelegate unmanaged = class_abi.BaseOverride<AddedNativeDelegate>(this.LookupGType(), "add");
			if (unmanaged == null) return;

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

		static RemovedNativeDelegate Removed_cb_delegate;
		static RemovedNativeDelegate RemovedVMCallback {
			get {
				if (Removed_cb_delegate == null)
					Removed_cb_delegate = new RemovedNativeDelegate (Removed_cb);
				return Removed_cb_delegate;
			}
		}

		static void OverrideRemoved (GLib.GType gtype)
		{
			OverrideRemoved (gtype, RemovedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void RemovedNativeDelegate (IntPtr inst, IntPtr widget);

		static void Removed_cb (IntPtr inst, IntPtr widget)
		{
			try {
				Container __obj = GLib.Object.GetObject (inst, false) as Container;
				__obj.OnRemoved (GLib.Object.GetObject(widget) as Gtk.Widget);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Container), ConnectionMethod="OverrideRemoved")]
		protected virtual void OnRemoved (Gtk.Widget widget)
		{
			InternalRemoved (widget);
		}

		private void InternalRemoved (Gtk.Widget widget)
		{
			RemovedNativeDelegate unmanaged = class_abi.BaseOverride<RemovedNativeDelegate>(this.LookupGType(), "remove");
			if (unmanaged == null) return;

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

		static ResizeCheckedNativeDelegate ResizeChecked_cb_delegate;
		static ResizeCheckedNativeDelegate ResizeCheckedVMCallback {
			get {
				if (ResizeChecked_cb_delegate == null)
					ResizeChecked_cb_delegate = new ResizeCheckedNativeDelegate (ResizeChecked_cb);
				return ResizeChecked_cb_delegate;
			}
		}

		static void OverrideResizeChecked (GLib.GType gtype)
		{
			OverrideResizeChecked (gtype, ResizeCheckedVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Container), ConnectionMethod="OverrideResizeChecked")]
		protected virtual void OnResizeChecked ()
		{
			InternalResizeChecked ();
		}

		private void InternalResizeChecked ()
		{
			ResizeCheckedNativeDelegate unmanaged = class_abi.BaseOverride<ResizeCheckedNativeDelegate>(this.LookupGType(), "check_resize");
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static FocusChildSetNativeDelegate FocusChildSet_cb_delegate;
		static FocusChildSetNativeDelegate FocusChildSetVMCallback {
			get {
				if (FocusChildSet_cb_delegate == null)
					FocusChildSet_cb_delegate = new FocusChildSetNativeDelegate (FocusChildSet_cb);
				return FocusChildSet_cb_delegate;
			}
		}

		static void OverrideFocusChildSet (GLib.GType gtype)
		{
			OverrideFocusChildSet (gtype, FocusChildSetVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void FocusChildSetNativeDelegate (IntPtr inst, IntPtr child);

		static void FocusChildSet_cb (IntPtr inst, IntPtr child)
		{
			try {
				Container __obj = GLib.Object.GetObject (inst, false) as Container;
				__obj.OnFocusChildSet (GLib.Object.GetObject(child) as Gtk.Widget);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Container), ConnectionMethod="OverrideFocusChildSet")]
		protected virtual void OnFocusChildSet (Gtk.Widget child)
		{
			InternalFocusChildSet (child);
		}

		private void InternalFocusChildSet (Gtk.Widget child)
		{
			FocusChildSetNativeDelegate unmanaged = class_abi.BaseOverride<FocusChildSetNativeDelegate>(this.LookupGType(), "set_focus_child");
			if (unmanaged == null) return;

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

		static ChildTypeNativeDelegate ChildType_cb_delegate;
		static ChildTypeNativeDelegate ChildTypeVMCallback {
			get {
				if (ChildType_cb_delegate == null)
					ChildType_cb_delegate = new ChildTypeNativeDelegate (ChildType_cb);
				return ChildType_cb_delegate;
			}
		}

		static void OverrideChildType (GLib.GType gtype)
		{
			OverrideChildType (gtype, ChildTypeVMCallback);
		}

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

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

		static IntPtr ChildType_cb (IntPtr inst)
		{
			try {
				Container __obj = GLib.Object.GetObject (inst, false) as Container;
				GLib.GType __result;
				__result = __obj.OnChildType ();
				return __result.Val;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Container), ConnectionMethod="OverrideChildType")]
		protected virtual GLib.GType OnChildType ()
		{
			return InternalChildType ();
		}

		private GLib.GType InternalChildType ()
		{
			ChildTypeNativeDelegate unmanaged = class_abi.BaseOverride<ChildTypeNativeDelegate>(this.LookupGType(), "child_type");
			if (unmanaged == null) return GLib.GType.None;

			IntPtr __result = unmanaged (this.Handle);
			return new GLib.GType(__result);
		}

		static CompositeNameNativeDelegate CompositeName_cb_delegate;
		static CompositeNameNativeDelegate CompositeNameVMCallback {
			get {
				if (CompositeName_cb_delegate == null)
					CompositeName_cb_delegate = new CompositeNameNativeDelegate (CompositeName_cb);
				return CompositeName_cb_delegate;
			}
		}

		static void OverrideCompositeName (GLib.GType gtype)
		{
			OverrideCompositeName (gtype, CompositeNameVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr CompositeNameNativeDelegate (IntPtr inst, IntPtr child);

		static IntPtr CompositeName_cb (IntPtr inst, IntPtr child)
		{
			try {
				Container __obj = GLib.Object.GetObject (inst, false) as Container;
				string __result;
				__result = __obj.OnCompositeName (GLib.Object.GetObject(child) as Gtk.Widget);
				return GLib.Marshaller.StringToPtrGStrdup(__result);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Container), ConnectionMethod="OverrideCompositeName")]
		protected virtual string OnCompositeName (Gtk.Widget child)
		{
			return InternalCompositeName (child);
		}

		private string InternalCompositeName (Gtk.Widget child)
		{
			CompositeNameNativeDelegate unmanaged = class_abi.BaseOverride<CompositeNameNativeDelegate>(this.LookupGType(), "composite_name");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, child == null ? IntPtr.Zero : child.Handle);
			return GLib.Marshaller.PtrToStringGFree(__result);
		}

		static SetChildPropertyNativeDelegate SetChildProperty_cb_delegate;
		static SetChildPropertyNativeDelegate SetChildPropertyVMCallback {
			get {
				if (SetChildProperty_cb_delegate == null)
					SetChildProperty_cb_delegate = new SetChildPropertyNativeDelegate (SetChildProperty_cb);
				return SetChildProperty_cb_delegate;
			}
		}

		static void OverrideSetChildProperty (GLib.GType gtype)
		{
			OverrideSetChildProperty (gtype, SetChildPropertyVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetChildPropertyNativeDelegate (IntPtr inst, IntPtr child, uint property_id, IntPtr value, IntPtr pspec);

		static void SetChildProperty_cb (IntPtr inst, IntPtr child, uint property_id, IntPtr value, IntPtr pspec)
		{
			try {
				Container __obj = GLib.Object.GetObject (inst, false) as Container;
				__obj.OnSetChildProperty (GLib.Object.GetObject(child) as Gtk.Widget, property_id, (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value)), pspec);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Container), ConnectionMethod="OverrideSetChildProperty")]
		protected virtual void OnSetChildProperty (Gtk.Widget child, uint property_id, GLib.Value value, IntPtr pspec)
		{
			InternalSetChildProperty (child, property_id, value, pspec);
		}

		private void InternalSetChildProperty (Gtk.Widget child, uint property_id, GLib.Value value, IntPtr pspec)
		{
			SetChildPropertyNativeDelegate unmanaged = class_abi.BaseOverride<SetChildPropertyNativeDelegate>(this.LookupGType(), "set_child_property");
			if (unmanaged == null) return;

			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			unmanaged (this.Handle, child == null ? IntPtr.Zero : child.Handle, property_id, native_value, pspec);
			Marshal.FreeHGlobal (native_value);
		}

		static GetChildPropertyNativeDelegate GetChildProperty_cb_delegate;
		static GetChildPropertyNativeDelegate GetChildPropertyVMCallback {
			get {
				if (GetChildProperty_cb_delegate == null)
					GetChildProperty_cb_delegate = new GetChildPropertyNativeDelegate (GetChildProperty_cb);
				return GetChildProperty_cb_delegate;
			}
		}

		static void OverrideGetChildProperty (GLib.GType gtype)
		{
			OverrideGetChildProperty (gtype, GetChildPropertyVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void GetChildPropertyNativeDelegate (IntPtr inst, IntPtr child, uint property_id, IntPtr value, IntPtr pspec);

		static void GetChildProperty_cb (IntPtr inst, IntPtr child, uint property_id, IntPtr value, IntPtr pspec)
		{
			try {
				Container __obj = GLib.Object.GetObject (inst, false) as Container;
				__obj.OnGetChildProperty (GLib.Object.GetObject(child) as Gtk.Widget, property_id, (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value)), pspec);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Container), ConnectionMethod="OverrideGetChildProperty")]
		protected virtual void OnGetChildProperty (Gtk.Widget child, uint property_id, GLib.Value value, IntPtr pspec)
		{
			InternalGetChildProperty (child, property_id, value, pspec);
		}

		private void InternalGetChildProperty (Gtk.Widget child, uint property_id, GLib.Value value, IntPtr pspec)
		{
			GetChildPropertyNativeDelegate unmanaged = class_abi.BaseOverride<GetChildPropertyNativeDelegate>(this.LookupGType(), "get_child_property");
			if (unmanaged == null) return;

			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			unmanaged (this.Handle, child == null ? IntPtr.Zero : child.Handle, property_id, native_value, pspec);
			Marshal.FreeHGlobal (native_value);
		}

		static GetPathForChildNativeDelegate GetPathForChild_cb_delegate;
		static GetPathForChildNativeDelegate GetPathForChildVMCallback {
			get {
				if (GetPathForChild_cb_delegate == null)
					GetPathForChild_cb_delegate = new GetPathForChildNativeDelegate (GetPathForChild_cb);
				return GetPathForChild_cb_delegate;
			}
		}

		static void OverrideGetPathForChild (GLib.GType gtype)
		{
			OverrideGetPathForChild (gtype, GetPathForChildVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr GetPathForChildNativeDelegate (IntPtr inst, IntPtr child);

		static IntPtr GetPathForChild_cb (IntPtr inst, IntPtr child)
		{
			try {
				Container __obj = GLib.Object.GetObject (inst, false) as Container;
				Gtk.WidgetPath __result;
				__result = __obj.OnGetPathForChild (GLib.Object.GetObject(child) as Gtk.Widget);
				return __result == null ? IntPtr.Zero : __result.Handle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Container), ConnectionMethod="OverrideGetPathForChild")]
		protected virtual Gtk.WidgetPath OnGetPathForChild (Gtk.Widget child)
		{
			return InternalGetPathForChild (child);
		}

		private Gtk.WidgetPath InternalGetPathForChild (Gtk.Widget child)
		{
			GetPathForChildNativeDelegate unmanaged = class_abi.BaseOverride<GetPathForChildNativeDelegate>(this.LookupGType(), "get_path_for_child");
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle, child == null ? IntPtr.Zero : child.Handle);
			return __result == IntPtr.Zero ? null : (Gtk.WidgetPath) GLib.Opaque.GetOpaque (__result, typeof (Gtk.WidgetPath), false);
		}


		// 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("add"
							, Gtk.Widget.class_abi.Fields
							, (uint) sizeof( IntPtr ) // add
							, null
							, "remove"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("remove"
							, -1
							, (uint) sizeof( IntPtr ) // remove
							, "add"
							, "check_resize"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("check_resize"
							, -1
							, (uint) sizeof( IntPtr ) // check_resize
							, "remove"
							, "forall"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("forall"
							, -1
							, (uint) sizeof( IntPtr ) // forall
							, "check_resize"
							, "set_focus_child"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("set_focus_child"
							, -1
							, (uint) sizeof( IntPtr ) // set_focus_child
							, "forall"
							, "child_type"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("child_type"
							, -1
							, (uint) sizeof( IntPtr ) // child_type
							, "set_focus_child"
							, "composite_name"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("composite_name"
							, -1
							, (uint) sizeof( IntPtr ) // composite_name
							, "child_type"
							, "set_child_property"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("set_child_property"
							, -1
							, (uint) sizeof( IntPtr ) // set_child_property
							, "composite_name"
							, "get_child_property"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_child_property"
							, -1
							, (uint) sizeof( IntPtr ) // get_child_property
							, "set_child_property"
							, "get_path_for_child"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("get_path_for_child"
							, -1
							, (uint) sizeof( IntPtr ) // get_path_for_child
							, "get_child_property"
							, "_handle_border_width"
							, (uint) sizeof(IntPtr)
							, 0
							),
						new GLib.AbiField("_handle_border_width"
							, -1
							, (uint) Marshal.SizeOf<bool>() // _handle_border_width
							, "get_path_for_child"
							, "_gtk_reserved1"
							, 1
							, 1
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) sizeof( IntPtr ) // _gtk_reserved1
							, "_handle_border_width"
							, "_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 void d_gtk_container_add(IntPtr raw, IntPtr widget);
		static d_gtk_container_add gtk_container_add = FuncLoader.LoadFunction<d_gtk_container_add>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_container_add"));

		public void Add(Gtk.Widget widget) {
			gtk_container_add(Handle, widget == null ? IntPtr.Zero : widget.Handle);
		}

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

		public void CheckResize() {
			gtk_container_check_resize(Handle);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_container_child_get_valist(IntPtr raw, IntPtr child, IntPtr first_property_name, IntPtr var_args);
		static d_gtk_container_child_get_valist gtk_container_child_get_valist = FuncLoader.LoadFunction<d_gtk_container_child_get_valist>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_container_child_get_valist"));

		public void ChildGetValist(Gtk.Widget child, string first_property_name, IntPtr var_args) {
			IntPtr native_first_property_name = GLib.Marshaller.StringToPtrGStrdup (first_property_name);
			gtk_container_child_get_valist(Handle, child == null ? IntPtr.Zero : child.Handle, native_first_property_name, var_args);
			GLib.Marshaller.Free (native_first_property_name);
		}

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

		public void ChildNotify(Gtk.Widget child, string child_property) {
			IntPtr native_child_property = GLib.Marshaller.StringToPtrGStrdup (child_property);
			gtk_container_child_notify(Handle, child == null ? IntPtr.Zero : child.Handle, native_child_property);
			GLib.Marshaller.Free (native_child_property);
		}

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

		public void ChildNotifyByPspec(Gtk.Widget child, IntPtr pspec) {
			gtk_container_child_notify_by_pspec(Handle, child == null ? IntPtr.Zero : child.Handle, pspec);
		}

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

		public void ChildSetProperty(Gtk.Widget child, string property_name, GLib.Value value) {
			IntPtr native_property_name = GLib.Marshaller.StringToPtrGStrdup (property_name);
			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			gtk_container_child_set_property(Handle, child == null ? IntPtr.Zero : child.Handle, native_property_name, native_value);
			GLib.Marshaller.Free (native_property_name);
			Marshal.FreeHGlobal (native_value);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_container_child_set_valist(IntPtr raw, IntPtr child, IntPtr first_property_name, IntPtr var_args);
		static d_gtk_container_child_set_valist gtk_container_child_set_valist = FuncLoader.LoadFunction<d_gtk_container_child_set_valist>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_container_child_set_valist"));

		public void ChildSetValist(Gtk.Widget child, string first_property_name, IntPtr var_args) {
			IntPtr native_first_property_name = GLib.Marshaller.StringToPtrGStrdup (first_property_name);
			gtk_container_child_set_valist(Handle, child == null ? IntPtr.Zero : child.Handle, native_first_property_name, var_args);
			GLib.Marshaller.Free (native_first_property_name);
		}

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

		public GLib.GType SupportedChildType() {
			IntPtr raw_ret = gtk_container_child_type(Handle);
			GLib.GType ret = new GLib.GType(raw_ret);
			return ret;
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_container_forall(IntPtr raw, GtkSharp.CallbackNative cb, IntPtr callback_data);
		static d_gtk_container_forall gtk_container_forall = FuncLoader.LoadFunction<d_gtk_container_forall>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_container_forall"));

		public void Forall(Gtk.Callback cb) {
			GtkSharp.CallbackWrapper cb_wrapper = new GtkSharp.CallbackWrapper (cb);
			gtk_container_forall(Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void d_gtk_container_foreach(IntPtr raw, GtkSharp.CallbackNative cb, IntPtr callback_data);
		static d_gtk_container_foreach gtk_container_foreach = FuncLoader.LoadFunction<d_gtk_container_foreach>(FuncLoader.GetProcAddress(GLibrary.Load(Library.Gtk), "gtk_container_foreach"));

		public void Foreach(Gtk.Callback cb) {
			GtkSharp.CallbackWrapper cb_wrapper = new GtkSharp.CallbackWrapper (cb);
			gtk_container_foreach(Handle, cb_wrapper.NativeDelegate, IntPtr.Zero);
		}

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

		public Gtk.Widget[] Children { 
			get {
				IntPtr raw_ret = gtk_container_get_children(Handle);
				Gtk.Widget[] ret = GLib.Marshaller.ListPtrToArray<Gtk.Widget, Gtk.Widget> (raw_ret, true, false);
				return ret;
			}
		}

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

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

		public Gtk.Widget FocusChild { 
			get {
				IntPtr raw_ret = gtk_container_get_focus_child(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
			set {
				gtk_container_set_focus_child(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

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

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

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

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

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

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

		public Gtk.WidgetPath GetPathForChild(Gtk.Widget child) {
			IntPtr raw_ret = gtk_container_get_path_for_child(Handle, child == null ? IntPtr.Zero : child.Handle);
			Gtk.WidgetPath ret = raw_ret == IntPtr.Zero ? null : (Gtk.WidgetPath) GLib.Opaque.GetOpaque (raw_ret, typeof (Gtk.WidgetPath), false);
			return ret;
		}

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

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

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

		public void PropagateDraw(Gtk.Widget child, Cairo.Context cr) {
			gtk_container_propagate_draw(Handle, child == null ? IntPtr.Zero : child.Handle, cr == null ? IntPtr.Zero : cr.Handle);
		}

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

		public void Remove(Gtk.Widget widget) {
			gtk_container_remove(Handle, widget == null ? IntPtr.Zero : widget.Handle);
		}

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

		[Obsolete]
		public void ResizeChildren() {
			gtk_container_resize_children(Handle);
		}

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

		[Obsolete]
		public bool ReallocateRedraws { 
			set {
				gtk_container_set_reallocate_redraws(Handle, value);
			}
		}

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

		public void UnsetFocusChain() {
			gtk_container_unset_focus_chain(Handle);
		}


		// 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
	}
}
