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

#region Autogenerated code
	public partial class Paned : Gtk.Container, Gtk.IOrientable {

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gtk_paned_new(int orientation);

		public Paned (Gtk.Orientation orientation) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Paned)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				names.Add ("orientation");
				vals.Add (new GLib.Value (orientation));
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			Raw = gtk_paned_new((int) orientation);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gtk_paned_get_position(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_paned_set_position(IntPtr raw, int position);

		[GLib.Property ("position")]
		public int Position {
			get  {
				int raw_ret = gtk_paned_get_position(Handle);
				int ret = raw_ret;
				return ret;
			}
			set  {
				gtk_paned_set_position(Handle, value);
			}
		}

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

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

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gtk_paned_get_wide_handle(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_paned_set_wide_handle(IntPtr raw, bool wide);

		[GLib.Property ("wide-handle")]
		public bool WideHandle {
			get  {
				bool raw_ret = gtk_paned_get_wide_handle(Handle);
				bool ret = raw_ret;
				return ret;
			}
			set  {
				gtk_paned_set_wide_handle(Handle, value);
			}
		}

		[GLib.Property ("handle-size")]
		public int HandleSize {
			get {
				GLib.Value val = GetProperty ("handle-size");
				int ret = (int) val;
				val.Dispose ();
				return ret;
			}
		}

		public class PanedChild : Gtk.Container.ContainerChild {
			protected internal PanedChild (Gtk.Container parent, Gtk.Widget child) : base (parent, child) {}

			[Gtk.ChildProperty ("resize")]
			public bool Resize {
				get {
					GLib.Value val = parent.ChildGetProperty (child, "resize");
					bool ret = (bool) val;
					val.Dispose ();
					return ret;
				}
				set {
					GLib.Value val = new GLib.Value(value);
					parent.ChildSetProperty(child, "resize", val);
					val.Dispose ();
				}
			}

			[Gtk.ChildProperty ("shrink")]
			public bool Shrink {
				get {
					GLib.Value val = parent.ChildGetProperty (child, "shrink");
					bool ret = (bool) val;
					val.Dispose ();
					return ret;
				}
				set {
					GLib.Value val = new GLib.Value(value);
					parent.ChildSetProperty(child, "shrink", val);
					val.Dispose ();
				}
			}

		}

		public override Gtk.Container.ContainerChild this [Gtk.Widget child] {
			get {
				return new PanedChild (this, child);
			}
		}

		[GLib.Signal("move-handle")]
		public event Gtk.MoveHandleHandler MoveHandle {
			add {
				this.AddSignalHandler ("move-handle", value, typeof (Gtk.MoveHandleArgs));
			}
			remove {
				this.RemoveSignalHandler ("move-handle", value);
			}
		}

		[GLib.Signal("cancel-position")]
		public event Gtk.CancelPositionHandler CancelPosition {
			add {
				this.AddSignalHandler ("cancel-position", value, typeof (Gtk.CancelPositionArgs));
			}
			remove {
				this.RemoveSignalHandler ("cancel-position", value);
			}
		}

		[GLib.Signal("toggle-handle-focus")]
		public event Gtk.ToggleHandleFocusHandler ToggleHandleFocus {
			add {
				this.AddSignalHandler ("toggle-handle-focus", value, typeof (Gtk.ToggleHandleFocusArgs));
			}
			remove {
				this.RemoveSignalHandler ("toggle-handle-focus", value);
			}
		}

		[GLib.Signal("cycle-handle-focus")]
		public event Gtk.CycleHandleFocusHandler CycleHandleFocus {
			add {
				this.AddSignalHandler ("cycle-handle-focus", value, typeof (Gtk.CycleHandleFocusArgs));
			}
			remove {
				this.RemoveSignalHandler ("cycle-handle-focus", value);
			}
		}

		[GLib.Signal("cycle-child-focus")]
		public event Gtk.CycleChildFocusHandler CycleChildFocus {
			add {
				this.AddSignalHandler ("cycle-child-focus", value, typeof (Gtk.CycleChildFocusArgs));
			}
			remove {
				this.RemoveSignalHandler ("cycle-child-focus", value);
			}
		}

		[GLib.Signal("accept-position")]
		public event Gtk.AcceptPositionHandler AcceptPosition {
			add {
				this.AddSignalHandler ("accept-position", value, typeof (Gtk.AcceptPositionArgs));
			}
			remove {
				this.RemoveSignalHandler ("accept-position", value);
			}
		}

		static CycleChildFocusNativeDelegate CycleChildFocus_cb_delegate;
		static CycleChildFocusNativeDelegate CycleChildFocusVMCallback {
			get {
				if (CycleChildFocus_cb_delegate == null)
					CycleChildFocus_cb_delegate = new CycleChildFocusNativeDelegate (CycleChildFocus_cb);
				return CycleChildFocus_cb_delegate;
			}
		}

		static void OverrideCycleChildFocus (GLib.GType gtype)
		{
			OverrideCycleChildFocus (gtype, CycleChildFocusVMCallback);
		}

		static void OverrideCycleChildFocus (GLib.GType gtype, CycleChildFocusNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("cycle_child_focus"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool CycleChildFocusNativeDelegate (IntPtr inst, bool reverse);

		static bool CycleChildFocus_cb (IntPtr inst, bool reverse)
		{
			try {
				Paned __obj = GLib.Object.GetObject (inst, false) as Paned;
				bool __result;
				__result = __obj.OnCycleChildFocus (reverse);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Paned), ConnectionMethod="OverrideCycleChildFocus")]
		protected virtual bool OnCycleChildFocus (bool reverse)
		{
			return InternalCycleChildFocus (reverse);
		}

		private bool InternalCycleChildFocus (bool reverse)
		{
			CycleChildFocusNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("cycle_child_focus"));
				unmanaged = (CycleChildFocusNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CycleChildFocusNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, reverse);
			return __result;
		}

		static ToggleHandleFocusNativeDelegate ToggleHandleFocus_cb_delegate;
		static ToggleHandleFocusNativeDelegate ToggleHandleFocusVMCallback {
			get {
				if (ToggleHandleFocus_cb_delegate == null)
					ToggleHandleFocus_cb_delegate = new ToggleHandleFocusNativeDelegate (ToggleHandleFocus_cb);
				return ToggleHandleFocus_cb_delegate;
			}
		}

		static void OverrideToggleHandleFocus (GLib.GType gtype)
		{
			OverrideToggleHandleFocus (gtype, ToggleHandleFocusVMCallback);
		}

		static void OverrideToggleHandleFocus (GLib.GType gtype, ToggleHandleFocusNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("toggle_handle_focus"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static bool ToggleHandleFocus_cb (IntPtr inst)
		{
			try {
				Paned __obj = GLib.Object.GetObject (inst, false) as Paned;
				bool __result;
				__result = __obj.OnToggleHandleFocus ();
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Paned), ConnectionMethod="OverrideToggleHandleFocus")]
		protected virtual bool OnToggleHandleFocus ()
		{
			return InternalToggleHandleFocus ();
		}

		private bool InternalToggleHandleFocus ()
		{
			ToggleHandleFocusNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("toggle_handle_focus"));
				unmanaged = (ToggleHandleFocusNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ToggleHandleFocusNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle);
			return __result;
		}

		static MoveHandleNativeDelegate MoveHandle_cb_delegate;
		static MoveHandleNativeDelegate MoveHandleVMCallback {
			get {
				if (MoveHandle_cb_delegate == null)
					MoveHandle_cb_delegate = new MoveHandleNativeDelegate (MoveHandle_cb);
				return MoveHandle_cb_delegate;
			}
		}

		static void OverrideMoveHandle (GLib.GType gtype)
		{
			OverrideMoveHandle (gtype, MoveHandleVMCallback);
		}

		static void OverrideMoveHandle (GLib.GType gtype, MoveHandleNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("move_handle"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool MoveHandleNativeDelegate (IntPtr inst, int scroll);

		static bool MoveHandle_cb (IntPtr inst, int scroll)
		{
			try {
				Paned __obj = GLib.Object.GetObject (inst, false) as Paned;
				bool __result;
				__result = __obj.OnMoveHandle ((Gtk.ScrollType) scroll);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Paned), ConnectionMethod="OverrideMoveHandle")]
		protected virtual bool OnMoveHandle (Gtk.ScrollType scroll)
		{
			return InternalMoveHandle (scroll);
		}

		private bool InternalMoveHandle (Gtk.ScrollType scroll)
		{
			MoveHandleNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("move_handle"));
				unmanaged = (MoveHandleNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(MoveHandleNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, (int) scroll);
			return __result;
		}

		static CycleHandleFocusNativeDelegate CycleHandleFocus_cb_delegate;
		static CycleHandleFocusNativeDelegate CycleHandleFocusVMCallback {
			get {
				if (CycleHandleFocus_cb_delegate == null)
					CycleHandleFocus_cb_delegate = new CycleHandleFocusNativeDelegate (CycleHandleFocus_cb);
				return CycleHandleFocus_cb_delegate;
			}
		}

		static void OverrideCycleHandleFocus (GLib.GType gtype)
		{
			OverrideCycleHandleFocus (gtype, CycleHandleFocusVMCallback);
		}

		static void OverrideCycleHandleFocus (GLib.GType gtype, CycleHandleFocusNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("cycle_handle_focus"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool CycleHandleFocusNativeDelegate (IntPtr inst, bool reverse);

		static bool CycleHandleFocus_cb (IntPtr inst, bool reverse)
		{
			try {
				Paned __obj = GLib.Object.GetObject (inst, false) as Paned;
				bool __result;
				__result = __obj.OnCycleHandleFocus (reverse);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Paned), ConnectionMethod="OverrideCycleHandleFocus")]
		protected virtual bool OnCycleHandleFocus (bool reverse)
		{
			return InternalCycleHandleFocus (reverse);
		}

		private bool InternalCycleHandleFocus (bool reverse)
		{
			CycleHandleFocusNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("cycle_handle_focus"));
				unmanaged = (CycleHandleFocusNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CycleHandleFocusNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, reverse);
			return __result;
		}

		static AcceptPositionNativeDelegate AcceptPosition_cb_delegate;
		static AcceptPositionNativeDelegate AcceptPositionVMCallback {
			get {
				if (AcceptPosition_cb_delegate == null)
					AcceptPosition_cb_delegate = new AcceptPositionNativeDelegate (AcceptPosition_cb);
				return AcceptPosition_cb_delegate;
			}
		}

		static void OverrideAcceptPosition (GLib.GType gtype)
		{
			OverrideAcceptPosition (gtype, AcceptPositionVMCallback);
		}

		static void OverrideAcceptPosition (GLib.GType gtype, AcceptPositionNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("accept_position"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static bool AcceptPosition_cb (IntPtr inst)
		{
			try {
				Paned __obj = GLib.Object.GetObject (inst, false) as Paned;
				bool __result;
				__result = __obj.OnAcceptPosition ();
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Paned), ConnectionMethod="OverrideAcceptPosition")]
		protected virtual bool OnAcceptPosition ()
		{
			return InternalAcceptPosition ();
		}

		private bool InternalAcceptPosition ()
		{
			AcceptPositionNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("accept_position"));
				unmanaged = (AcceptPositionNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AcceptPositionNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle);
			return __result;
		}

		static CancelPositionNativeDelegate CancelPosition_cb_delegate;
		static CancelPositionNativeDelegate CancelPositionVMCallback {
			get {
				if (CancelPosition_cb_delegate == null)
					CancelPosition_cb_delegate = new CancelPositionNativeDelegate (CancelPosition_cb);
				return CancelPosition_cb_delegate;
			}
		}

		static void OverrideCancelPosition (GLib.GType gtype)
		{
			OverrideCancelPosition (gtype, CancelPositionVMCallback);
		}

		static void OverrideCancelPosition (GLib.GType gtype, CancelPositionNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("cancel_position"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

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

		static bool CancelPosition_cb (IntPtr inst)
		{
			try {
				Paned __obj = GLib.Object.GetObject (inst, false) as Paned;
				bool __result;
				__result = __obj.OnCancelPosition ();
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gtk.Paned), ConnectionMethod="OverrideCancelPosition")]
		protected virtual bool OnCancelPosition ()
		{
			return InternalCancelPosition ();
		}

		private bool InternalCancelPosition ()
		{
			CancelPositionNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("cancel_position"));
				unmanaged = (CancelPositionNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CancelPositionNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle);
			return __result;
		}


		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _class_abi = null;
		static public new GLib.AbiStruct class_abi {
			get {
				if (_class_abi == null)
					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("cycle_child_focus"
							, Gtk.Container.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // cycle_child_focus
							, null
							, "toggle_handle_focus"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("toggle_handle_focus"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // toggle_handle_focus
							, "cycle_child_focus"
							, "move_handle"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("move_handle"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // move_handle
							, "toggle_handle_focus"
							, "cycle_handle_focus"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("cycle_handle_focus"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // cycle_handle_focus
							, "move_handle"
							, "accept_position"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("accept_position"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // accept_position
							, "cycle_handle_focus"
							, "cancel_position"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("cancel_position"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // cancel_position
							, "accept_position"
							, "_gtk_reserved1"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved1"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved1
							, "cancel_position"
							, "_gtk_reserved2"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved2"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved2
							, "_gtk_reserved1"
							, "_gtk_reserved3"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved3"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved3
							, "_gtk_reserved2"
							, "_gtk_reserved4"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gtk_reserved4"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // _gtk_reserved4
							, "_gtk_reserved3"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_paned_add1(IntPtr raw, IntPtr child);

		public void Add1(Gtk.Widget child) {
			gtk_paned_add1(Handle, child == null ? IntPtr.Zero : child.Handle);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_paned_add2(IntPtr raw, IntPtr child);

		public void Add2(Gtk.Widget child) {
			gtk_paned_add2(Handle, child == null ? IntPtr.Zero : child.Handle);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gtk_paned_get_child1(IntPtr raw);

		public Gtk.Widget Child1 { 
			get {
				IntPtr raw_ret = gtk_paned_get_child1(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gtk_paned_get_child2(IntPtr raw);

		public Gtk.Widget Child2 { 
			get {
				IntPtr raw_ret = gtk_paned_get_child2(Handle);
				Gtk.Widget ret = GLib.Object.GetObject(raw_ret) as Gtk.Widget;
				return ret;
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gtk_paned_get_handle_window(IntPtr raw);

		public Gdk.Window HandleWindow { 
			get {
				IntPtr raw_ret = gtk_paned_get_handle_window(Handle);
				Gdk.Window ret = GLib.Object.GetObject(raw_ret) as Gdk.Window;
				return ret;
			}
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gtk_paned_get_type();

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

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_paned_pack1(IntPtr raw, IntPtr child, bool resize, bool shrink);

		public void Pack1(Gtk.Widget child, bool resize, bool shrink) {
			gtk_paned_pack1(Handle, child == null ? IntPtr.Zero : child.Handle, resize, shrink);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_paned_pack2(IntPtr raw, IntPtr child, bool resize, bool shrink);

		public void Pack2(Gtk.Widget child, bool resize, bool shrink) {
			gtk_paned_pack2(Handle, child == null ? IntPtr.Zero : child.Handle, resize, shrink);
		}

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gtk_orientable_get_orientation(IntPtr raw);

		[DllImport("gtk-3-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gtk_orientable_set_orientation(IntPtr raw, int orientation);

		[GLib.Property ("orientation")]
		public Gtk.Orientation Orientation {
			get  {
				int raw_ret = gtk_orientable_get_orientation(Handle);
				Gtk.Orientation ret = (Gtk.Orientation) raw_ret;
				return ret;
			}
			set  {
				gtk_orientable_set_orientation(Handle, (int) value);
			}
		}


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

				return _abi_info;
			}
		}


		// End of the ABI representation.

#endregion
	}
}