gstreamer/sources/generated/Gst/Pad.cs

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

namespace Gst {

	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Runtime.InteropServices;

#region Autogenerated code
	public partial class Pad : Gst.Object {

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

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_new(IntPtr name, int direction);

		public Pad (string name, Gst.PadDirection direction) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Pad)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				names.Add ("name");
				vals.Add (new GLib.Value (name));
				names.Add ("direction");
				vals.Add (new GLib.Value (direction));
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			Raw = gst_pad_new(native_name, (int) direction);
			GLib.Marshaller.Free (native_name);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_new_from_static_template(IntPtr templ, IntPtr name);

		public Pad (Gst.StaticPadTemplate templ, string name) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Pad)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				names.Add ("name");
				vals.Add (new GLib.Value (name));
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			IntPtr native_templ = GLib.Marshaller.StructureToPtrAlloc (templ);
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			Raw = gst_pad_new_from_static_template(native_templ, native_name);
			Marshal.FreeHGlobal (native_templ);
			GLib.Marshaller.Free (native_name);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_new_from_template(IntPtr templ, IntPtr name);

		public Pad (Gst.PadTemplate templ, string name) : base (IntPtr.Zero)
		{
			if (GetType () != typeof (Pad)) {
				var vals = new List<GLib.Value> ();
				var names = new List<string> ();
				if (templ != null) {
					names.Add ("name");
					vals.Add (new GLib.Value (name));
				}
				CreateNativeObject (names.ToArray (), vals.ToArray ());
				return;
			}
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			Raw = gst_pad_new_from_template(templ == null ? IntPtr.Zero : templ.Handle, native_name);
			GLib.Marshaller.Free (native_name);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_get_direction(IntPtr raw);

		[GLib.Property ("direction")]
		public Gst.PadDirection Direction {
			get  {
				int raw_ret = gst_pad_get_direction(Handle);
				Gst.PadDirection ret = (Gst.PadDirection) raw_ret;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern long gst_pad_get_offset(IntPtr raw);

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_offset(IntPtr raw, long offset);

		[GLib.Property ("offset")]
		public long Offset {
			get  {
				long raw_ret = gst_pad_get_offset(Handle);
				long ret = raw_ret;
				return ret;
			}
			set  {
				gst_pad_set_offset(Handle, value);
			}
		}

		[GLib.Property ("template")]
		public Gst.PadTemplate Template {
			get {
				GLib.Value val = GetProperty ("template");
				Gst.PadTemplate ret = (Gst.PadTemplate) val;
				val.Dispose ();
				return ret;
			}
			set {
				GLib.Value val = new GLib.Value(value);
				SetProperty("template", val);
				val.Dispose ();
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_element_private(IntPtr raw);

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_element_private(IntPtr raw, IntPtr priv);

		public IntPtr ElementPrivate {
			get  {
				IntPtr raw_ret = gst_pad_get_element_private(Handle);
				IntPtr ret = raw_ret;
				return ret;
			}
			set  {
				gst_pad_set_element_private(Handle, value);
			}
		}

		public Gst.PadTemplate Padtemplate {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("padtemplate"));
					return GLib.Object.GetObject((*raw_ptr)) as Gst.PadTemplate;
				}
			}
		}

		public Gst.PadDirection DirectionField {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("direction"));
					return (Gst.PadDirection) (*raw_ptr);
				}
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_peer(IntPtr raw);

		public Gst.Pad Peer {
			get  {
				IntPtr raw_ret = gst_pad_get_peer(Handle);
				Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
				return ret;
			}
		}

		[GLib.Signal("unlinked")]
		public event Gst.UnlinkedHandler Unlinked {
			add {
				this.AddSignalHandler ("unlinked", value, typeof (Gst.UnlinkedArgs));
			}
			remove {
				this.RemoveSignalHandler ("unlinked", value);
			}
		}

		[GLib.Signal("linked")]
		public event Gst.LinkedHandler Linked {
			add {
				this.AddSignalHandler ("linked", value, typeof (Gst.LinkedArgs));
			}
			remove {
				this.RemoveSignalHandler ("linked", value);
			}
		}

		static LinkedNativeDelegate Linked_cb_delegate;
		static LinkedNativeDelegate LinkedVMCallback {
			get {
				if (Linked_cb_delegate == null)
					Linked_cb_delegate = new LinkedNativeDelegate (Linked_cb);
				return Linked_cb_delegate;
			}
		}

		static void OverrideLinked (GLib.GType gtype)
		{
			OverrideLinked (gtype, LinkedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void LinkedNativeDelegate (IntPtr inst, IntPtr peer);

		static void Linked_cb (IntPtr inst, IntPtr peer)
		{
			try {
				Pad __obj = GLib.Object.GetObject (inst, false) as Pad;
				__obj.OnLinked (GLib.Object.GetObject(peer) as Gst.Pad);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Pad), ConnectionMethod="OverrideLinked")]
		protected virtual void OnLinked (Gst.Pad peer)
		{
			InternalLinked (peer);
		}

		private void InternalLinked (Gst.Pad peer)
		{
			LinkedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("linked"));
				unmanaged = (LinkedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(LinkedNativeDelegate));
			}
			if (unmanaged == null) return;

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

		static UnlinkedNativeDelegate Unlinked_cb_delegate;
		static UnlinkedNativeDelegate UnlinkedVMCallback {
			get {
				if (Unlinked_cb_delegate == null)
					Unlinked_cb_delegate = new UnlinkedNativeDelegate (Unlinked_cb);
				return Unlinked_cb_delegate;
			}
		}

		static void OverrideUnlinked (GLib.GType gtype)
		{
			OverrideUnlinked (gtype, UnlinkedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void UnlinkedNativeDelegate (IntPtr inst, IntPtr peer);

		static void Unlinked_cb (IntPtr inst, IntPtr peer)
		{
			try {
				Pad __obj = GLib.Object.GetObject (inst, false) as Pad;
				__obj.OnUnlinked (GLib.Object.GetObject(peer) as Gst.Pad);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Pad), ConnectionMethod="OverrideUnlinked")]
		protected virtual void OnUnlinked (Gst.Pad peer)
		{
			InternalUnlinked (peer);
		}

		private void InternalUnlinked (Gst.Pad peer)
		{
			UnlinkedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("unlinked"));
				unmanaged = (UnlinkedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(UnlinkedNativeDelegate));
			}
			if (unmanaged == null) return;

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


		// 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("linked"
							, Gst.Object.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // linked
							, null
							, "unlinked"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("unlinked"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // unlinked
							, "linked"
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
							, "unlinked"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_type();

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

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_link_get_name(int _ret);

		public static string LinkGetName(Gst.PadLinkReturn _ret) {
			IntPtr raw_ret = gst_pad_link_get_name((int) _ret);
			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_activate_mode(IntPtr raw, int mode, bool active);

		public bool ActivateMode(Gst.PadMode mode, bool active) {
			bool raw_ret = gst_pad_activate_mode(Handle, (int) mode, active);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern UIntPtr gst_pad_add_probe(IntPtr raw, int mask, GstSharp.PadProbeCallbackNative cb, IntPtr user_data, GLib.DestroyNotify destroy_data);

		public ulong AddProbe(Gst.PadProbeType mask, Gst.PadProbeCallback cb) {
			GstSharp.PadProbeCallbackWrapper cb_wrapper = new GstSharp.PadProbeCallbackWrapper (cb);
			IntPtr user_data;
			GLib.DestroyNotify destroy_data;
			if (cb == null) {
				user_data = IntPtr.Zero;
				destroy_data = null;
			} else {
				user_data = (IntPtr) GCHandle.Alloc (cb_wrapper);
				destroy_data = GLib.DestroyHelper.NotifyHandler;
			}
			UIntPtr raw_ret = gst_pad_add_probe(Handle, (int) mask, cb_wrapper.NativeDelegate, user_data, destroy_data);
			ulong ret = (ulong) raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_can_link(IntPtr raw, IntPtr sinkpad);

		public bool CanLink(Gst.Pad sinkpad) {
			bool raw_ret = gst_pad_can_link(Handle, sinkpad == null ? IntPtr.Zero : sinkpad.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_chain(IntPtr raw, IntPtr buffer);

		public Gst.FlowReturn Chain(Gst.Buffer buffer) {
			buffer.Owned = false;
			int raw_ret = gst_pad_chain(Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_chain_list(IntPtr raw, IntPtr list);

		public Gst.FlowReturn ChainList(Gst.BufferList list) {
			list.Owned = false;
			int raw_ret = gst_pad_chain_list(Handle, list == null ? IntPtr.Zero : list.Handle);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_check_reconfigure(IntPtr raw);

		public bool CheckReconfigure() {
			bool raw_ret = gst_pad_check_reconfigure(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_create_stream_id(IntPtr raw, IntPtr parent, IntPtr stream_id);

		public string CreateStreamId(Gst.Element parent, string stream_id) {
			IntPtr native_stream_id = GLib.Marshaller.StringToPtrGStrdup (stream_id);
			IntPtr raw_ret = gst_pad_create_stream_id(Handle, parent == null ? IntPtr.Zero : parent.Handle, native_stream_id);
			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
			GLib.Marshaller.Free (native_stream_id);
			return ret;
		}

		public string CreateStreamId(Gst.Element parent) {
			return CreateStreamId (parent, null);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_event_default(IntPtr raw, IntPtr parent, IntPtr evnt);

		public bool EventDefault(Gst.Object parent, Gst.Event evnt) {
			evnt.Owned = false;
			bool raw_ret = gst_pad_event_default(Handle, parent == null ? IntPtr.Zero : parent.Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			return ret;
		}

		public bool EventDefault(Gst.Event evnt) {
			return EventDefault (null, evnt);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_forward(IntPtr raw, GstSharp.PadForwardFunctionNative forward, IntPtr user_data);

		public bool Forward(Gst.PadForwardFunction forward) {
			GstSharp.PadForwardFunctionWrapper forward_wrapper = new GstSharp.PadForwardFunctionWrapper (forward);
			bool raw_ret = gst_pad_forward(Handle, forward_wrapper.NativeDelegate, IntPtr.Zero);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_allowed_caps(IntPtr raw);

		public Gst.Caps AllowedCaps { 
			get {
				IntPtr raw_ret = gst_pad_get_allowed_caps(Handle);
				Gst.Caps ret = raw_ret == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Caps), true);
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_current_caps(IntPtr raw);

		public Gst.Caps CurrentCaps { 
			get {
				IntPtr raw_ret = gst_pad_get_current_caps(Handle);
				Gst.Caps ret = raw_ret == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Caps), true);
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_get_last_flow_return(IntPtr raw);

		public Gst.FlowReturn LastFlowReturn { 
			get {
				int raw_ret = gst_pad_get_last_flow_return(Handle);
				Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_pad_template(IntPtr raw);

		public Gst.PadTemplate PadTemplate { 
			get {
				IntPtr raw_ret = gst_pad_get_pad_template(Handle);
				Gst.PadTemplate ret = GLib.Object.GetObject(raw_ret, true) as Gst.PadTemplate;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_pad_template_caps(IntPtr raw);

		public Gst.Caps PadTemplateCaps { 
			get {
				IntPtr raw_ret = gst_pad_get_pad_template_caps(Handle);
				Gst.Caps ret = raw_ret == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Caps), true);
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_parent_element(IntPtr raw);

		public Gst.Element ParentElement { 
			get {
				IntPtr raw_ret = gst_pad_get_parent_element(Handle);
				Gst.Element ret = GLib.Object.GetObject(raw_ret, true) as Gst.Element;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_get_range(IntPtr raw, ulong offset, uint size, out IntPtr buffer);

		public Gst.FlowReturn GetRange(ulong offset, uint size, out Gst.Buffer buffer) {
			IntPtr native_buffer;
			int raw_ret = gst_pad_get_range(Handle, offset, size, out native_buffer);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			buffer = native_buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (native_buffer, typeof (Gst.Buffer), true);
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_sticky_event(IntPtr raw, int event_type, uint idx);

		public Gst.Event GetStickyEvent(Gst.EventType event_type, uint idx) {
			IntPtr raw_ret = gst_pad_get_sticky_event(Handle, (int) event_type, idx);
			Gst.Event ret = raw_ret == IntPtr.Zero ? null : (Gst.Event) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Event), true);
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_stream(IntPtr raw);

		public Gst.Stream Stream { 
			get {
				IntPtr raw_ret = gst_pad_get_stream(Handle);
				Gst.Stream ret = GLib.Object.GetObject(raw_ret, true) as Gst.Stream;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_get_stream_id(IntPtr raw);

		public string StreamId { 
			get {
				IntPtr raw_ret = gst_pad_get_stream_id(Handle);
				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_get_task_state(IntPtr raw);

		public Gst.TaskState TaskState { 
			get {
				int raw_ret = gst_pad_get_task_state(Handle);
				Gst.TaskState ret = (Gst.TaskState) raw_ret;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_has_current_caps(IntPtr raw);

		public bool HasCurrentCaps { 
			get {
				bool raw_ret = gst_pad_has_current_caps(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_is_active(IntPtr raw);

		public bool IsActive { 
			get {
				bool raw_ret = gst_pad_is_active(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_is_blocked(IntPtr raw);

		public bool IsBlocked { 
			get {
				bool raw_ret = gst_pad_is_blocked(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_is_blocking(IntPtr raw);

		public bool IsBlocking { 
			get {
				bool raw_ret = gst_pad_is_blocking(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_is_linked(IntPtr raw);

		public bool IsLinked { 
			get {
				bool raw_ret = gst_pad_is_linked(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_iterate_internal_links(IntPtr raw);

		public Gst.Iterator IterateInternalLinks() {
			IntPtr raw_ret = gst_pad_iterate_internal_links(Handle);
			Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_iterate_internal_links_default(IntPtr raw, IntPtr parent);

		public Gst.Iterator IterateInternalLinksDefault(Gst.Object parent) {
			IntPtr raw_ret = gst_pad_iterate_internal_links_default(Handle, parent == null ? IntPtr.Zero : parent.Handle);
			Gst.Iterator ret = raw_ret == IntPtr.Zero ? null : (Gst.Iterator) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Iterator), true);
			return ret;
		}

		public Gst.Iterator IterateInternalLinksDefault() {
			return IterateInternalLinksDefault (null);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_link(IntPtr raw, IntPtr sinkpad);

		public Gst.PadLinkReturn Link(Gst.Pad sinkpad) {
			int raw_ret = gst_pad_link(Handle, sinkpad == null ? IntPtr.Zero : sinkpad.Handle);
			Gst.PadLinkReturn ret = (Gst.PadLinkReturn) raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_link_full(IntPtr raw, IntPtr sinkpad, int flags);

		public Gst.PadLinkReturn LinkFull(Gst.Pad sinkpad, Gst.PadLinkCheck flags) {
			int raw_ret = gst_pad_link_full(Handle, sinkpad == null ? IntPtr.Zero : sinkpad.Handle, (int) flags);
			Gst.PadLinkReturn ret = (Gst.PadLinkReturn) raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_link_maybe_ghosting(IntPtr raw, IntPtr sink);

		public bool LinkMaybeGhosting(Gst.Pad sink) {
			bool raw_ret = gst_pad_link_maybe_ghosting(Handle, sink == null ? IntPtr.Zero : sink.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_link_maybe_ghosting_full(IntPtr raw, IntPtr sink, int flags);

		public bool LinkMaybeGhostingFull(Gst.Pad sink, Gst.PadLinkCheck flags) {
			bool raw_ret = gst_pad_link_maybe_ghosting_full(Handle, sink == null ? IntPtr.Zero : sink.Handle, (int) flags);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_mark_reconfigure(IntPtr raw);

		public void MarkReconfigure() {
			gst_pad_mark_reconfigure(Handle);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_needs_reconfigure(IntPtr raw);

		public bool NeedsReconfigure() {
			bool raw_ret = gst_pad_needs_reconfigure(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_pause_task(IntPtr raw);

		public bool PauseTask() {
			bool raw_ret = gst_pad_pause_task(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_peer_query(IntPtr raw, IntPtr query);

		public bool PeerQuery(Gst.Query query) {
			bool raw_ret = gst_pad_peer_query(Handle, query == null ? IntPtr.Zero : query.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_peer_query_accept_caps(IntPtr raw, IntPtr caps);

		public bool PeerQueryAcceptCaps(Gst.Caps caps) {
			bool raw_ret = gst_pad_peer_query_accept_caps(Handle, caps == null ? IntPtr.Zero : caps.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_peer_query_caps(IntPtr raw, IntPtr filter);

		public Gst.Caps PeerQueryCaps(Gst.Caps filter) {
			IntPtr raw_ret = gst_pad_peer_query_caps(Handle, filter == null ? IntPtr.Zero : filter.Handle);
			Gst.Caps ret = raw_ret == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Caps), true);
			return ret;
		}

		public Gst.Caps PeerQueryCaps() {
			return PeerQueryCaps (null);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_peer_query_convert(IntPtr raw, int src_format, long src_val, int dest_format, out long dest_val);

		public bool PeerQueryConvert(Gst.Format src_format, long src_val, Gst.Format dest_format, out long dest_val) {
			bool raw_ret = gst_pad_peer_query_convert(Handle, (int) src_format, src_val, (int) dest_format, out dest_val);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_peer_query_duration(IntPtr raw, int format, out long duration);

		public bool PeerQueryDuration(Gst.Format format, out long duration) {
			bool raw_ret = gst_pad_peer_query_duration(Handle, (int) format, out duration);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_peer_query_position(IntPtr raw, int format, out long cur);

		public bool PeerQueryPosition(Gst.Format format, out long cur) {
			bool raw_ret = gst_pad_peer_query_position(Handle, (int) format, out cur);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_proxy_query_accept_caps(IntPtr raw, IntPtr query);

		public bool ProxyQueryAcceptCaps(Gst.Query query) {
			bool raw_ret = gst_pad_proxy_query_accept_caps(Handle, query == null ? IntPtr.Zero : query.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_proxy_query_caps(IntPtr raw, IntPtr query);

		public bool ProxyQueryCaps(Gst.Query query) {
			bool raw_ret = gst_pad_proxy_query_caps(Handle, query == null ? IntPtr.Zero : query.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_pull_range(IntPtr raw, ulong offset, uint size, out IntPtr buffer);

		public Gst.FlowReturn PullRange(ulong offset, uint size, out Gst.Buffer buffer) {
			IntPtr native_buffer;
			int raw_ret = gst_pad_pull_range(Handle, offset, size, out native_buffer);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			buffer = native_buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (native_buffer, typeof (Gst.Buffer), true);
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_push(IntPtr raw, IntPtr buffer);

		public Gst.FlowReturn Push(Gst.Buffer buffer) {
			buffer.Owned = false;
			int raw_ret = gst_pad_push(Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_push_event(IntPtr raw, IntPtr evnt);

		public bool PushEvent(Gst.Event evnt) {
			evnt.Owned = false;
			bool raw_ret = gst_pad_push_event(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_push_list(IntPtr raw, IntPtr list);

		public Gst.FlowReturn PushList(Gst.BufferList list) {
			list.Owned = false;
			int raw_ret = gst_pad_push_list(Handle, list == null ? IntPtr.Zero : list.Handle);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_query(IntPtr raw, IntPtr query);

		public bool Query(Gst.Query query) {
			bool raw_ret = gst_pad_query(Handle, query == null ? IntPtr.Zero : query.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_query_accept_caps(IntPtr raw, IntPtr caps);

		public bool QueryAcceptCaps(Gst.Caps caps) {
			bool raw_ret = gst_pad_query_accept_caps(Handle, caps == null ? IntPtr.Zero : caps.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_query_caps(IntPtr raw, IntPtr filter);

		public Gst.Caps QueryCaps(Gst.Caps filter) {
			IntPtr raw_ret = gst_pad_query_caps(Handle, filter == null ? IntPtr.Zero : filter.Handle);
			Gst.Caps ret = raw_ret == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Caps), true);
			return ret;
		}

		public Gst.Caps QueryCaps() {
			return QueryCaps (null);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_query_convert(IntPtr raw, int src_format, long src_val, int dest_format, out long dest_val);

		public bool QueryConvert(Gst.Format src_format, long src_val, Gst.Format dest_format, out long dest_val) {
			bool raw_ret = gst_pad_query_convert(Handle, (int) src_format, src_val, (int) dest_format, out dest_val);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_query_default(IntPtr raw, IntPtr parent, IntPtr query);

		public bool QueryDefault(Gst.Object parent, Gst.Query query) {
			bool raw_ret = gst_pad_query_default(Handle, parent == null ? IntPtr.Zero : parent.Handle, query == null ? IntPtr.Zero : query.Handle);
			bool ret = raw_ret;
			return ret;
		}

		public bool QueryDefault(Gst.Query query) {
			return QueryDefault (null, query);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_query_duration(IntPtr raw, int format, out long duration);

		public bool QueryDuration(Gst.Format format, out long duration) {
			bool raw_ret = gst_pad_query_duration(Handle, (int) format, out duration);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_query_position(IntPtr raw, int format, out long cur);

		public bool QueryPosition(Gst.Format format, out long cur) {
			bool raw_ret = gst_pad_query_position(Handle, (int) format, out cur);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_remove_probe(IntPtr raw, UIntPtr id);

		public void RemoveProbe(ulong id) {
			gst_pad_remove_probe(Handle, new UIntPtr (id));
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_send_event(IntPtr raw, IntPtr evnt);

		public bool SendEvent(Gst.Event evnt) {
			evnt.Owned = false;
			bool raw_ret = gst_pad_send_event(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_activate_function_full(IntPtr raw, GstSharp.PadActivateFunctionNative activate, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadActivateFunction ActivateFunctionFull { 
			set {
				GstSharp.PadActivateFunctionWrapper value_wrapper = new GstSharp.PadActivateFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_activate_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_activatemode_function_full(IntPtr raw, GstSharp.PadActivateModeFunctionNative activatemode, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadActivateModeFunction ActivatemodeFunctionFull { 
			set {
				GstSharp.PadActivateModeFunctionWrapper value_wrapper = new GstSharp.PadActivateModeFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_activatemode_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_set_active(IntPtr raw, bool active);

		public bool SetActive(bool active) {
			bool raw_ret = gst_pad_set_active(Handle, active);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_chain_function_full(IntPtr raw, GstSharp.PadChainFunctionNative chain, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadChainFunction ChainFunctionFull { 
			set {
				GstSharp.PadChainFunctionWrapper value_wrapper = new GstSharp.PadChainFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_chain_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_chain_list_function_full(IntPtr raw, GstSharp.PadChainListFunctionNative chainlist, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadChainListFunction ChainListFunctionFull { 
			set {
				GstSharp.PadChainListFunctionWrapper value_wrapper = new GstSharp.PadChainListFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_chain_list_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_event_full_function_full(IntPtr raw, GstSharp.PadEventFullFunctionNative evnt, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadEventFullFunction EventFullFunctionFull { 
			set {
				GstSharp.PadEventFullFunctionWrapper value_wrapper = new GstSharp.PadEventFullFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_event_full_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_event_function_full(IntPtr raw, GstSharp.PadEventFunctionNative evnt, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadEventFunction EventFunctionFull { 
			set {
				GstSharp.PadEventFunctionWrapper value_wrapper = new GstSharp.PadEventFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_event_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_getrange_function_full(IntPtr raw, GstSharp.PadGetRangeFunctionNative get, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadGetRangeFunction GetrangeFunctionFull { 
			set {
				GstSharp.PadGetRangeFunctionWrapper value_wrapper = new GstSharp.PadGetRangeFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_getrange_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_iterate_internal_links_function_full(IntPtr raw, GstSharp.PadIterIntLinkFunctionNative iterintlink, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadIterIntLinkFunction IterateInternalLinksFunctionFull { 
			set {
				GstSharp.PadIterIntLinkFunctionWrapper value_wrapper = new GstSharp.PadIterIntLinkFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_iterate_internal_links_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_link_function_full(IntPtr raw, GstSharp.PadLinkFunctionNative link, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadLinkFunction LinkFunctionFull { 
			set {
				GstSharp.PadLinkFunctionWrapper value_wrapper = new GstSharp.PadLinkFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_link_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_query_function_full(IntPtr raw, GstSharp.PadQueryFunctionNative query, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadQueryFunction QueryFunctionFull { 
			set {
				GstSharp.PadQueryFunctionWrapper value_wrapper = new GstSharp.PadQueryFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_query_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_set_unlink_function_full(IntPtr raw, GstSharp.PadUnlinkFunctionNative unlink, IntPtr user_data, GLib.DestroyNotify notify);

		public Gst.PadUnlinkFunction UnlinkFunctionFull { 
			set {
				GstSharp.PadUnlinkFunctionWrapper value_wrapper = new GstSharp.PadUnlinkFunctionWrapper (value);
				IntPtr user_data;
				GLib.DestroyNotify notify;
				if (value == null) {
					user_data = IntPtr.Zero;
					notify = null;
				} else {
					user_data = (IntPtr) GCHandle.Alloc (value_wrapper);
					notify = GLib.DestroyHelper.NotifyHandler;
				}
				gst_pad_set_unlink_function_full(Handle, value_wrapper.NativeDelegate, user_data, notify);
			}
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_start_task(IntPtr raw, GstSharp.TaskFunctionNative func, IntPtr user_data, GLib.DestroyNotify notify);

		public bool StartTask(Gst.TaskFunction func) {
			GstSharp.TaskFunctionWrapper func_wrapper = new GstSharp.TaskFunctionWrapper (func);
			IntPtr user_data;
			GLib.DestroyNotify notify;
			if (func == null) {
				user_data = IntPtr.Zero;
				notify = null;
			} else {
				user_data = (IntPtr) GCHandle.Alloc (func_wrapper);
				notify = GLib.DestroyHelper.NotifyHandler;
			}
			bool raw_ret = gst_pad_start_task(Handle, func_wrapper.NativeDelegate, user_data, notify);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_sticky_events_foreach(IntPtr raw, GstSharp.PadStickyEventsForeachFunctionNative foreach_func, IntPtr user_data);

		public void StickyEventsForeach(Gst.PadStickyEventsForeachFunction foreach_func) {
			GstSharp.PadStickyEventsForeachFunctionWrapper foreach_func_wrapper = new GstSharp.PadStickyEventsForeachFunctionWrapper (foreach_func);
			gst_pad_sticky_events_foreach(Handle, foreach_func_wrapper.NativeDelegate, IntPtr.Zero);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_stop_task(IntPtr raw);

		public bool StopTask() {
			bool raw_ret = gst_pad_stop_task(Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_pad_store_sticky_event(IntPtr raw, IntPtr evnt);

		public Gst.FlowReturn StoreStickyEvent(Gst.Event evnt) {
			int raw_ret = gst_pad_store_sticky_event(Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			Gst.FlowReturn ret = (Gst.FlowReturn) raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_pad_unlink(IntPtr raw, IntPtr sinkpad);

		public bool Unlink(Gst.Pad sinkpad) {
			bool raw_ret = gst_pad_unlink(Handle, sinkpad == null ? IntPtr.Zero : sinkpad.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_pad_use_fixed_caps(IntPtr raw);

		public void UseFixedCaps() {
			gst_pad_use_fixed_caps(Handle);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr gst_pad_mode_get_name(int mode);

		public static string ModeGetName(Gst.PadMode mode) {
			IntPtr raw_ret = gst_pad_mode_get_name((int) mode);
			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
			return ret;
		}


		// 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("element_private"
							, Gst.Object.abi_info.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // element_private
							, null
							, "padtemplate"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("padtemplate"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // padtemplate
							, "element_private"
							, "direction"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("direction"
							, -1
							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.PadDirection))) // direction
							, "padtemplate"
							, "stream_rec_lock"
							, (long) Marshal.OffsetOf(typeof(GstPad_directionAlign), "direction")
							, 0
							),
						new GLib.AbiField("stream_rec_lock"
							, -1
							, (uint) Marshal.SizeOf(typeof(GLib.RecMutex.ABI)) // stream_rec_lock
							, "direction"
							, "task"
							, (long) Marshal.OffsetOf(typeof(GstPad_stream_rec_lockAlign), "stream_rec_lock")
							, 0
							),
						new GLib.AbiField("task"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // task
							, "stream_rec_lock"
							, "block_cond"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("block_cond"
							, -1
							, (uint) Marshal.SizeOf(typeof(GLib.Cond.ABI)) // block_cond
							, "task"
							, "probes"
							, (long) Marshal.OffsetOf(typeof(GstPad_block_condAlign), "block_cond")
							, 0
							),
						new GLib.AbiField("probes"
							, -1
							, GLib.HookList.abi_info.Size // probes
							, "block_cond"
							, "mode"
							, (long) Marshal.OffsetOf(typeof(GstPad_probesAlign), "probes")
							, 0
							),
						new GLib.AbiField("mode"
							, -1
							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.PadMode))) // mode
							, "probes"
							, "activatefunc"
							, (long) Marshal.OffsetOf(typeof(GstPad_modeAlign), "mode")
							, 0
							),
						new GLib.AbiField("activatefunc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // activatefunc
							, "mode"
							, "activatedata"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("activatedata"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // activatedata
							, "activatefunc"
							, "activatenotify"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("activatenotify"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // activatenotify
							, "activatedata"
							, "activatemodefunc"
							, (long) Marshal.OffsetOf(typeof(GstPad_activatenotifyAlign), "activatenotify")
							, 0
							),
						new GLib.AbiField("activatemodefunc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // activatemodefunc
							, "activatenotify"
							, "activatemodedata"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("activatemodedata"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // activatemodedata
							, "activatemodefunc"
							, "activatemodenotify"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("activatemodenotify"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // activatemodenotify
							, "activatemodedata"
							, "peer"
							, (long) Marshal.OffsetOf(typeof(GstPad_activatemodenotifyAlign), "activatemodenotify")
							, 0
							),
						new GLib.AbiField("peer"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // peer
							, "activatemodenotify"
							, "linkfunc"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("linkfunc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // linkfunc
							, "peer"
							, "linkdata"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("linkdata"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // linkdata
							, "linkfunc"
							, "linknotify"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("linknotify"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // linknotify
							, "linkdata"
							, "unlinkfunc"
							, (long) Marshal.OffsetOf(typeof(GstPad_linknotifyAlign), "linknotify")
							, 0
							),
						new GLib.AbiField("unlinkfunc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // unlinkfunc
							, "linknotify"
							, "unlinkdata"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("unlinkdata"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // unlinkdata
							, "unlinkfunc"
							, "unlinknotify"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("unlinknotify"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // unlinknotify
							, "unlinkdata"
							, "chainfunc"
							, (long) Marshal.OffsetOf(typeof(GstPad_unlinknotifyAlign), "unlinknotify")
							, 0
							),
						new GLib.AbiField("chainfunc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // chainfunc
							, "unlinknotify"
							, "chaindata"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("chaindata"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // chaindata
							, "chainfunc"
							, "chainnotify"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("chainnotify"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // chainnotify
							, "chaindata"
							, "chainlistfunc"
							, (long) Marshal.OffsetOf(typeof(GstPad_chainnotifyAlign), "chainnotify")
							, 0
							),
						new GLib.AbiField("chainlistfunc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // chainlistfunc
							, "chainnotify"
							, "chainlistdata"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("chainlistdata"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // chainlistdata
							, "chainlistfunc"
							, "chainlistnotify"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("chainlistnotify"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // chainlistnotify
							, "chainlistdata"
							, "getrangefunc"
							, (long) Marshal.OffsetOf(typeof(GstPad_chainlistnotifyAlign), "chainlistnotify")
							, 0
							),
						new GLib.AbiField("getrangefunc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // getrangefunc
							, "chainlistnotify"
							, "getrangedata"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("getrangedata"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // getrangedata
							, "getrangefunc"
							, "getrangenotify"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("getrangenotify"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // getrangenotify
							, "getrangedata"
							, "eventfunc"
							, (long) Marshal.OffsetOf(typeof(GstPad_getrangenotifyAlign), "getrangenotify")
							, 0
							),
						new GLib.AbiField("eventfunc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // eventfunc
							, "getrangenotify"
							, "eventdata"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("eventdata"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // eventdata
							, "eventfunc"
							, "eventnotify"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("eventnotify"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // eventnotify
							, "eventdata"
							, "offset"
							, (long) Marshal.OffsetOf(typeof(GstPad_eventnotifyAlign), "eventnotify")
							, 0
							),
						new GLib.AbiField("offset"
							, -1
							, (uint) Marshal.SizeOf(typeof(long)) // offset
							, "eventnotify"
							, "queryfunc"
							, (long) Marshal.OffsetOf(typeof(GstPad_offsetAlign), "offset")
							, 0
							),
						new GLib.AbiField("queryfunc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // queryfunc
							, "offset"
							, "querydata"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("querydata"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // querydata
							, "queryfunc"
							, "querynotify"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("querynotify"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // querynotify
							, "querydata"
							, "iterintlinkfunc"
							, (long) Marshal.OffsetOf(typeof(GstPad_querynotifyAlign), "querynotify")
							, 0
							),
						new GLib.AbiField("iterintlinkfunc"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // iterintlinkfunc
							, "querynotify"
							, "iterintlinkdata"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("iterintlinkdata"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // iterintlinkdata
							, "iterintlinkfunc"
							, "iterintlinknotify"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("iterintlinknotify"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // iterintlinknotify
							, "iterintlinkdata"
							, "num_probes"
							, (long) Marshal.OffsetOf(typeof(GstPad_iterintlinknotifyAlign), "iterintlinknotify")
							, 0
							),
						new GLib.AbiField("num_probes"
							, -1
							, (uint) Marshal.SizeOf(typeof(int)) // num_probes
							, "iterintlinknotify"
							, "num_blocked"
							, (long) Marshal.OffsetOf(typeof(GstPad_num_probesAlign), "num_probes")
							, 0
							),
						new GLib.AbiField("num_blocked"
							, -1
							, (uint) Marshal.SizeOf(typeof(int)) // num_blocked
							, "num_probes"
							, "priv"
							, (long) Marshal.OffsetOf(typeof(GstPad_num_blockedAlign), "num_blocked")
							, 0
							),
						new GLib.AbiField("priv"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
							, "num_blocked"
							, "ABI"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						// union struct ABI
							new GLib.AbiField("ABI._gst_reserved"
								, -1
								, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // ABI._gst_reserved
								, "priv"
								, null
								, (uint) Marshal.SizeOf(typeof(IntPtr))
								, 0
								),
						// End ABI

						// union struct ABI.abi
							new GLib.AbiField("ABI.abi.last_flowret"
								, -1
								, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.FlowReturn))) // ABI.abi.last_flowret
								, "priv"
								, "ABI.abi.eventfullfunc"
								, (long) Marshal.OffsetOf(typeof(GstPad_ABI_abi_last_flowretAlign), "ABI_abi_last_flowret")
								, 0
								),
							new GLib.AbiField("ABI.abi.eventfullfunc"
								, -1
								, (uint) Marshal.SizeOf(typeof(IntPtr)) // ABI.abi.eventfullfunc
								, "ABI.abi.last_flowret"
								, null
								, (uint) Marshal.SizeOf(typeof(IntPtr))
								, 0
								),
						// End ABI.abi

						new GLib.AbiField("ABI"
							, -1
							, new List<List<string>>() {  // union ABI
						new List<string>() {"ABI._gst_reserved"},
						new List<string>() {"ABI.abi.last_flowret","ABI.abi.eventfullfunc"}
					  }
							, "priv"
							, null
							, 0
							),
					});

				return _abi_info;
			}
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_directionAlign
		{
			sbyte f1;
			private Gst.PadDirection direction;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_stream_rec_lockAlign
		{
			sbyte f1;
			private GLib.RecMutex.ABI stream_rec_lock;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_block_condAlign
		{
			sbyte f1;
			private GLib.Cond.ABI block_cond;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_probesAlign
		{
			sbyte f1;
			private GLib.HookList probes;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_modeAlign
		{
			sbyte f1;
			private Gst.PadMode mode;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_activatenotifyAlign
		{
			sbyte f1;
			private GLib.DestroyNotify activatenotify;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_activatemodenotifyAlign
		{
			sbyte f1;
			private GLib.DestroyNotify activatemodenotify;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_linknotifyAlign
		{
			sbyte f1;
			private GLib.DestroyNotify linknotify;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_unlinknotifyAlign
		{
			sbyte f1;
			private GLib.DestroyNotify unlinknotify;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_chainnotifyAlign
		{
			sbyte f1;
			private GLib.DestroyNotify chainnotify;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_chainlistnotifyAlign
		{
			sbyte f1;
			private GLib.DestroyNotify chainlistnotify;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_getrangenotifyAlign
		{
			sbyte f1;
			private GLib.DestroyNotify getrangenotify;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_eventnotifyAlign
		{
			sbyte f1;
			private GLib.DestroyNotify eventnotify;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_offsetAlign
		{
			sbyte f1;
			private long offset;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_querynotifyAlign
		{
			sbyte f1;
			private GLib.DestroyNotify querynotify;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_iterintlinknotifyAlign
		{
			sbyte f1;
			private GLib.DestroyNotify iterintlinknotify;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_num_probesAlign
		{
			sbyte f1;
			private int num_probes;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_num_blockedAlign
		{
			sbyte f1;
			private int num_blocked;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstPad_ABI_abi_last_flowretAlign
		{
			sbyte f1;
			private Gst.FlowReturn ABI_abi_last_flowret;
		}


		// End of the ABI representation.

#endregion
	}
}