gstreamer/sources/generated/Gst/Element.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 Element : Gst.Object {

		protected Element (IntPtr raw) : base(raw) {}

		protected Element() : base(IntPtr.Zero)
		{
			CreateNativeObject (new string [0], new GLib.Value [0]);
		}

		public GLib.RecMutex StateLock {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("state_lock"));
					return new GLib.RecMutex((*raw_ptr));
				}
			}
		}

		public GLib.Cond StateCond {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("state_cond"));
					return new GLib.Cond((*raw_ptr));
				}
			}
		}

		public uint StateCookie {
			get {
				unsafe {
					uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("state_cookie"));
					return (*raw_ptr);
				}
			}
		}

		public Gst.State TargetState {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("target_state"));
					return (Gst.State) (*raw_ptr);
				}
			}
		}

		public Gst.State CurrentState {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("current_state"));
					return (Gst.State) (*raw_ptr);
				}
			}
		}

		public Gst.State NextState {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("next_state"));
					return (Gst.State) (*raw_ptr);
				}
			}
		}

		public Gst.State PendingState {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("pending_state"));
					return (Gst.State) (*raw_ptr);
				}
			}
		}

		public Gst.StateChangeReturn LastReturn {
			get {
				unsafe {
					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("last_return"));
					return (Gst.StateChangeReturn) (*raw_ptr);
				}
			}
		}

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

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

		public Gst.Bus Bus {
			get  {
				IntPtr raw_ret = gst_element_get_bus(Handle);
				Gst.Bus ret = GLib.Object.GetObject(raw_ret, true) as Gst.Bus;
				return ret;
			}
			set  {
				gst_element_set_bus(Handle, value == null ? IntPtr.Zero : value.Handle);
			}
		}

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

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

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

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

		public ulong BaseTime {
			get  {
				ulong raw_ret = gst_element_get_base_time(Handle);
				ulong ret = raw_ret;
				return ret;
			}
			set  {
				gst_element_set_base_time(Handle, value);
			}
		}

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

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

		public ulong StartTime {
			get  {
				ulong raw_ret = gst_element_get_start_time(Handle);
				ulong ret = raw_ret;
				return ret;
			}
			set  {
				gst_element_set_start_time(Handle, value);
			}
		}

		public ushort Numpads {
			get {
				unsafe {
					ushort* raw_ptr = (ushort*)(((byte*)Handle) + abi_info.GetFieldOffset("numpads"));
					return (*raw_ptr);
				}
			}
		}

		public GLib.List Pads {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("pads"));
					return new GLib.List((*raw_ptr));
				}
			}
		}

		public ushort Numsrcpads {
			get {
				unsafe {
					ushort* raw_ptr = (ushort*)(((byte*)Handle) + abi_info.GetFieldOffset("numsrcpads"));
					return (*raw_ptr);
				}
			}
		}

		public GLib.List Srcpads {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("srcpads"));
					return new GLib.List((*raw_ptr));
				}
			}
		}

		public ushort Numsinkpads {
			get {
				unsafe {
					ushort* raw_ptr = (ushort*)(((byte*)Handle) + abi_info.GetFieldOffset("numsinkpads"));
					return (*raw_ptr);
				}
			}
		}

		public GLib.List Sinkpads {
			get {
				unsafe {
					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("sinkpads"));
					return new GLib.List((*raw_ptr));
				}
			}
		}

		public uint PadsCookie {
			get {
				unsafe {
					uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("pads_cookie"));
					return (*raw_ptr);
				}
			}
		}

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

		public GLib.List[] Contexts {
			get  {
				IntPtr raw_ret = gst_element_get_contexts(Handle);
				GLib.List[] ret = (GLib.List[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(GLib.List));
				return ret;
			}
		}

		[GLib.Signal("no-more-pads")]
		public event System.EventHandler NoMorePadsEvent {
			add {
				this.AddSignalHandler ("no-more-pads", value);
			}
			remove {
				this.RemoveSignalHandler ("no-more-pads", value);
			}
		}

		[GLib.Signal("pad-removed")]
		public event Gst.PadRemovedHandler PadRemoved {
			add {
				this.AddSignalHandler ("pad-removed", value, typeof (Gst.PadRemovedArgs));
			}
			remove {
				this.RemoveSignalHandler ("pad-removed", value);
			}
		}

		[GLib.Signal("pad-added")]
		public event Gst.PadAddedHandler PadAdded {
			add {
				this.AddSignalHandler ("pad-added", value, typeof (Gst.PadAddedArgs));
			}
			remove {
				this.RemoveSignalHandler ("pad-added", value);
			}
		}

		static PadAddedNativeDelegate PadAdded_cb_delegate;
		static PadAddedNativeDelegate PadAddedVMCallback {
			get {
				if (PadAdded_cb_delegate == null)
					PadAdded_cb_delegate = new PadAddedNativeDelegate (PadAdded_cb);
				return PadAdded_cb_delegate;
			}
		}

		static void OverridePadAdded (GLib.GType gtype)
		{
			OverridePadAdded (gtype, PadAddedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PadAddedNativeDelegate (IntPtr inst, IntPtr new_pad);

		static void PadAdded_cb (IntPtr inst, IntPtr new_pad)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				__obj.OnPadAdded (GLib.Object.GetObject(new_pad) as Gst.Pad);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverridePadAdded")]
		protected virtual void OnPadAdded (Gst.Pad new_pad)
		{
			InternalPadAdded (new_pad);
		}

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

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

		static PadRemovedNativeDelegate PadRemoved_cb_delegate;
		static PadRemovedNativeDelegate PadRemovedVMCallback {
			get {
				if (PadRemoved_cb_delegate == null)
					PadRemoved_cb_delegate = new PadRemovedNativeDelegate (PadRemoved_cb);
				return PadRemoved_cb_delegate;
			}
		}

		static void OverridePadRemoved (GLib.GType gtype)
		{
			OverridePadRemoved (gtype, PadRemovedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void PadRemovedNativeDelegate (IntPtr inst, IntPtr old_pad);

		static void PadRemoved_cb (IntPtr inst, IntPtr old_pad)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				__obj.OnPadRemoved (GLib.Object.GetObject(old_pad) as Gst.Pad);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverridePadRemoved")]
		protected virtual void OnPadRemoved (Gst.Pad old_pad)
		{
			InternalPadRemoved (old_pad);
		}

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

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

		static NoMorePadsEventNativeDelegate NoMorePadsEvent_cb_delegate;
		static NoMorePadsEventNativeDelegate NoMorePadsEventVMCallback {
			get {
				if (NoMorePadsEvent_cb_delegate == null)
					NoMorePadsEvent_cb_delegate = new NoMorePadsEventNativeDelegate (NoMorePadsEvent_cb);
				return NoMorePadsEvent_cb_delegate;
			}
		}

		static void OverrideNoMorePadsEvent (GLib.GType gtype)
		{
			OverrideNoMorePadsEvent (gtype, NoMorePadsEventVMCallback);
		}

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

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

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

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideNoMorePadsEvent")]
		protected virtual void OnNoMorePadsEvent ()
		{
			InternalNoMorePadsEvent ();
		}

		private void InternalNoMorePadsEvent ()
		{
			NoMorePadsEventNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("no_more_pads"));
				unmanaged = (NoMorePadsEventNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(NoMorePadsEventNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle);
		}

		static RequestNewPadNativeDelegate RequestNewPad_cb_delegate;
		static RequestNewPadNativeDelegate RequestNewPadVMCallback {
			get {
				if (RequestNewPad_cb_delegate == null)
					RequestNewPad_cb_delegate = new RequestNewPadNativeDelegate (RequestNewPad_cb);
				return RequestNewPad_cb_delegate;
			}
		}

		static void OverrideRequestNewPad (GLib.GType gtype)
		{
			OverrideRequestNewPad (gtype, RequestNewPadVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate IntPtr RequestNewPadNativeDelegate (IntPtr inst, IntPtr templ, IntPtr name, IntPtr caps);

		static IntPtr RequestNewPad_cb (IntPtr inst, IntPtr templ, IntPtr name, IntPtr caps)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				Gst.Pad __result;
				__result = __obj.OnRequestNewPad (GLib.Object.GetObject(templ) as Gst.PadTemplate, GLib.Marshaller.Utf8PtrToString (name), caps == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (caps, typeof (Gst.Caps), false));
				return __result == null ? IntPtr.Zero : __result.OwnedHandle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideRequestNewPad")]
		protected virtual Gst.Pad OnRequestNewPad (Gst.PadTemplate templ, string name, Gst.Caps caps)
		{
			return InternalRequestNewPad (templ, name, caps);
		}

		private Gst.Pad InternalRequestNewPad (Gst.PadTemplate templ, string name, Gst.Caps caps)
		{
			RequestNewPadNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("request_new_pad"));
				unmanaged = (RequestNewPadNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RequestNewPadNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			IntPtr __result = unmanaged (this.Handle, templ == null ? IntPtr.Zero : templ.Handle, native_name, caps == null ? IntPtr.Zero : caps.Handle);
			GLib.Marshaller.Free (native_name);
			return GLib.Object.GetObject(__result, true) as Gst.Pad;
		}

		static ReleasePadNativeDelegate ReleasePad_cb_delegate;
		static ReleasePadNativeDelegate ReleasePadVMCallback {
			get {
				if (ReleasePad_cb_delegate == null)
					ReleasePad_cb_delegate = new ReleasePadNativeDelegate (ReleasePad_cb);
				return ReleasePad_cb_delegate;
			}
		}

		static void OverrideReleasePad (GLib.GType gtype)
		{
			OverrideReleasePad (gtype, ReleasePadVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void ReleasePadNativeDelegate (IntPtr inst, IntPtr pad);

		static void ReleasePad_cb (IntPtr inst, IntPtr pad)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				__obj.OnReleasePad (GLib.Object.GetObject(pad) as Gst.Pad);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideReleasePad")]
		protected virtual void OnReleasePad (Gst.Pad pad)
		{
			InternalReleasePad (pad);
		}

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

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

		static GetStateNativeDelegate GetState_cb_delegate;
		static GetStateNativeDelegate GetStateVMCallback {
			get {
				if (GetState_cb_delegate == null)
					GetState_cb_delegate = new GetStateNativeDelegate (GetState_cb);
				return GetState_cb_delegate;
			}
		}

		static void OverrideGetState (GLib.GType gtype)
		{
			OverrideGetState (gtype, GetStateVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int GetStateNativeDelegate (IntPtr inst, out int state, out int pending, ulong timeout);

		static int GetState_cb (IntPtr inst, out int state, out int pending, ulong timeout)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				Gst.StateChangeReturn __result;
				Gst.State mystate;
				Gst.State mypending;
				__result = __obj.OnGetState (out mystate, out mypending, timeout);
				state = (int) mystate;
				pending = (int) mypending;
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideGetState")]
		protected virtual Gst.StateChangeReturn OnGetState (out Gst.State state, out Gst.State pending, ulong timeout)
		{
			return InternalGetState (out state, out pending, timeout);
		}

		private Gst.StateChangeReturn InternalGetState (out Gst.State state, out Gst.State pending, ulong timeout)
		{
			GetStateNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_state"));
				unmanaged = (GetStateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetStateNativeDelegate));
			}
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			int native_state;
			int native_pending;
			int __result = unmanaged (this.Handle, out native_state, out native_pending, timeout);
			state = (Gst.State) native_state;
			pending = (Gst.State) native_pending;
			return (Gst.StateChangeReturn) __result;
		}

		static SetStateNativeDelegate SetState_cb_delegate;
		static SetStateNativeDelegate SetStateVMCallback {
			get {
				if (SetState_cb_delegate == null)
					SetState_cb_delegate = new SetStateNativeDelegate (SetState_cb);
				return SetState_cb_delegate;
			}
		}

		static void OverrideSetState (GLib.GType gtype)
		{
			OverrideSetState (gtype, SetStateVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int SetStateNativeDelegate (IntPtr inst, int state);

		static int SetState_cb (IntPtr inst, int state)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				Gst.StateChangeReturn __result;
				__result = __obj.OnSetState ((Gst.State) state);
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideSetState")]
		protected virtual Gst.StateChangeReturn OnSetState (Gst.State state)
		{
			return InternalSetState (state);
		}

		private Gst.StateChangeReturn InternalSetState (Gst.State state)
		{
			SetStateNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_state"));
				unmanaged = (SetStateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetStateNativeDelegate));
			}
			if (unmanaged == null) return (Gst.StateChangeReturn) 0;

			int __result = unmanaged (this.Handle, (int) state);
			return (Gst.StateChangeReturn) __result;
		}

		static ChangeStateNativeDelegate ChangeState_cb_delegate;
		static ChangeStateNativeDelegate ChangeStateVMCallback {
			get {
				if (ChangeState_cb_delegate == null)
					ChangeState_cb_delegate = new ChangeStateNativeDelegate (ChangeState_cb);
				return ChangeState_cb_delegate;
			}
		}

		static void OverrideChangeState (GLib.GType gtype)
		{
			OverrideChangeState (gtype, ChangeStateVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int ChangeStateNativeDelegate (IntPtr inst, int transition);

		static int ChangeState_cb (IntPtr inst, int transition)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				Gst.StateChangeReturn __result;
				__result = __obj.OnChangeState ((Gst.StateChange) transition);
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideChangeState")]
		protected virtual Gst.StateChangeReturn OnChangeState (Gst.StateChange transition)
		{
			return InternalChangeState (transition);
		}

		private Gst.StateChangeReturn InternalChangeState (Gst.StateChange transition)
		{
			ChangeStateNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("change_state"));
				unmanaged = (ChangeStateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ChangeStateNativeDelegate));
			}
			if (unmanaged == null) return (Gst.StateChangeReturn) 0;

			int __result = unmanaged (this.Handle, (int) transition);
			return (Gst.StateChangeReturn) __result;
		}

		static StateChangedNativeDelegate StateChanged_cb_delegate;
		static StateChangedNativeDelegate StateChangedVMCallback {
			get {
				if (StateChanged_cb_delegate == null)
					StateChanged_cb_delegate = new StateChangedNativeDelegate (StateChanged_cb);
				return StateChanged_cb_delegate;
			}
		}

		static void OverrideStateChanged (GLib.GType gtype)
		{
			OverrideStateChanged (gtype, StateChangedVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void StateChangedNativeDelegate (IntPtr inst, int oldstate, int newstate, int pending);

		static void StateChanged_cb (IntPtr inst, int oldstate, int newstate, int pending)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				__obj.OnStateChanged ((Gst.State) oldstate, (Gst.State) newstate, (Gst.State) pending);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideStateChanged")]
		protected virtual void OnStateChanged (Gst.State oldstate, Gst.State newstate, Gst.State pending)
		{
			InternalStateChanged (oldstate, newstate, pending);
		}

		private void InternalStateChanged (Gst.State oldstate, Gst.State newstate, Gst.State pending)
		{
			StateChangedNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("state_changed"));
				unmanaged = (StateChangedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(StateChangedNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, (int) oldstate, (int) newstate, (int) pending);
		}

		static SetBusNativeDelegate SetBus_cb_delegate;
		static SetBusNativeDelegate SetBusVMCallback {
			get {
				if (SetBus_cb_delegate == null)
					SetBus_cb_delegate = new SetBusNativeDelegate (SetBus_cb);
				return SetBus_cb_delegate;
			}
		}

		static void OverrideSetBus (GLib.GType gtype)
		{
			OverrideSetBus (gtype, SetBusVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetBusNativeDelegate (IntPtr inst, IntPtr bus);

		static void SetBus_cb (IntPtr inst, IntPtr bus)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				__obj.OnSetBus (GLib.Object.GetObject(bus) as Gst.Bus);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideSetBus")]
		protected virtual void OnSetBus (Gst.Bus bus)
		{
			InternalSetBus (bus);
		}

		private void InternalSetBus (Gst.Bus bus)
		{
			SetBusNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_bus"));
				unmanaged = (SetBusNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetBusNativeDelegate));
			}
			if (unmanaged == null) return;

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

		static ProvideClockNativeDelegate ProvideClock_cb_delegate;
		static ProvideClockNativeDelegate ProvideClockVMCallback {
			get {
				if (ProvideClock_cb_delegate == null)
					ProvideClock_cb_delegate = new ProvideClockNativeDelegate (ProvideClock_cb);
				return ProvideClock_cb_delegate;
			}
		}

		static void OverrideProvideClock (GLib.GType gtype)
		{
			OverrideProvideClock (gtype, ProvideClockVMCallback);
		}

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

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

		static IntPtr ProvideClock_cb (IntPtr inst)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				Gst.Clock __result;
				__result = __obj.OnProvideClock ();
				return __result == null ? IntPtr.Zero : __result.OwnedHandle;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideProvideClock")]
		protected virtual Gst.Clock OnProvideClock ()
		{
			return InternalProvideClock ();
		}

		private Gst.Clock InternalProvideClock ()
		{
			ProvideClockNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("provide_clock"));
				unmanaged = (ProvideClockNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ProvideClockNativeDelegate));
			}
			if (unmanaged == null) return null;

			IntPtr __result = unmanaged (this.Handle);
			return GLib.Object.GetObject(__result, true) as Gst.Clock;
		}

		static SetClockNativeDelegate SetClock_cb_delegate;
		static SetClockNativeDelegate SetClockVMCallback {
			get {
				if (SetClock_cb_delegate == null)
					SetClock_cb_delegate = new SetClockNativeDelegate (SetClock_cb);
				return SetClock_cb_delegate;
			}
		}

		static void OverrideSetClock (GLib.GType gtype)
		{
			OverrideSetClock (gtype, SetClockVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetClockNativeDelegate (IntPtr inst, IntPtr clock);

		static bool SetClock_cb (IntPtr inst, IntPtr clock)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				bool __result;
				__result = __obj.OnSetClock (GLib.Object.GetObject(clock) as Gst.Clock);
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideSetClock")]
		protected virtual bool OnSetClock (Gst.Clock clock)
		{
			return InternalSetClock (clock);
		}

		private bool InternalSetClock (Gst.Clock clock)
		{
			SetClockNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_clock"));
				unmanaged = (SetClockNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetClockNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, clock == null ? IntPtr.Zero : clock.Handle);
			return __result;
		}

		static SendEventNativeDelegate SendEvent_cb_delegate;
		static SendEventNativeDelegate SendEventVMCallback {
			get {
				if (SendEvent_cb_delegate == null)
					SendEvent_cb_delegate = new SendEventNativeDelegate (SendEvent_cb);
				return SendEvent_cb_delegate;
			}
		}

		static void OverrideSendEvent (GLib.GType gtype)
		{
			OverrideSendEvent (gtype, SendEventVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SendEventNativeDelegate (IntPtr inst, IntPtr evnt);

		static bool SendEvent_cb (IntPtr inst, IntPtr evnt)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				bool __result;
				__result = __obj.OnSendEvent (evnt == IntPtr.Zero ? null : (Gst.Event) GLib.Opaque.GetOpaque (evnt, typeof (Gst.Event), true));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideSendEvent")]
		protected virtual bool OnSendEvent (Gst.Event evnt)
		{
			return InternalSendEvent (evnt);
		}

		private bool InternalSendEvent (Gst.Event evnt)
		{
			SendEventNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("send_event"));
				unmanaged = (SendEventNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SendEventNativeDelegate));
			}
			if (unmanaged == null) return false;

			evnt.Owned = false;
			bool __result = unmanaged (this.Handle, evnt == null ? IntPtr.Zero : evnt.Handle);
			return __result;
		}

		static QueryNativeDelegate Query_cb_delegate;
		static QueryNativeDelegate QueryVMCallback {
			get {
				if (Query_cb_delegate == null)
					Query_cb_delegate = new QueryNativeDelegate (Query_cb);
				return Query_cb_delegate;
			}
		}

		static void OverrideQuery (GLib.GType gtype)
		{
			OverrideQuery (gtype, QueryVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool QueryNativeDelegate (IntPtr inst, IntPtr query);

		static bool Query_cb (IntPtr inst, IntPtr query)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				bool __result;
				__result = __obj.OnQuery (query == IntPtr.Zero ? null : (Gst.Query) GLib.Opaque.GetOpaque (query, typeof (Gst.Query), false));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideQuery")]
		protected virtual bool OnQuery (Gst.Query query)
		{
			return InternalQuery (query);
		}

		private bool InternalQuery (Gst.Query query)
		{
			QueryNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("query"));
				unmanaged = (QueryNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(QueryNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, query == null ? IntPtr.Zero : query.Handle);
			return __result;
		}

		static PostMessageNativeDelegate PostMessage_cb_delegate;
		static PostMessageNativeDelegate PostMessageVMCallback {
			get {
				if (PostMessage_cb_delegate == null)
					PostMessage_cb_delegate = new PostMessageNativeDelegate (PostMessage_cb);
				return PostMessage_cb_delegate;
			}
		}

		static void OverridePostMessage (GLib.GType gtype)
		{
			OverridePostMessage (gtype, PostMessageVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool PostMessageNativeDelegate (IntPtr inst, IntPtr message);

		static bool PostMessage_cb (IntPtr inst, IntPtr message)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				bool __result;
				__result = __obj.OnPostMessage (message == IntPtr.Zero ? null : (Gst.Message) GLib.Opaque.GetOpaque (message, typeof (Gst.Message), true));
				return __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverridePostMessage")]
		protected virtual bool OnPostMessage (Gst.Message message)
		{
			return InternalPostMessage (message);
		}

		private bool InternalPostMessage (Gst.Message message)
		{
			PostMessageNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("post_message"));
				unmanaged = (PostMessageNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PostMessageNativeDelegate));
			}
			if (unmanaged == null) return false;

			message.Owned = false;
			bool __result = unmanaged (this.Handle, message == null ? IntPtr.Zero : message.Handle);
			return __result;
		}

		static SetContextNativeDelegate SetContext_cb_delegate;
		static SetContextNativeDelegate SetContextVMCallback {
			get {
				if (SetContext_cb_delegate == null)
					SetContext_cb_delegate = new SetContextNativeDelegate (SetContext_cb);
				return SetContext_cb_delegate;
			}
		}

		static void OverrideSetContext (GLib.GType gtype)
		{
			OverrideSetContext (gtype, SetContextVMCallback);
		}

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

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetContextNativeDelegate (IntPtr inst, IntPtr context);

		static void SetContext_cb (IntPtr inst, IntPtr context)
		{
			try {
				Element __obj = GLib.Object.GetObject (inst, false) as Element;
				__obj.OnSetContext (Gst.Context.New (context));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(Gst.Element), ConnectionMethod="OverrideSetContext")]
		protected virtual void OnSetContext (Gst.Context context)
		{
			InternalSetContext (context);
		}

		private void InternalSetContext (Gst.Context context)
		{
			SetContextNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_context"));
				unmanaged = (SetContextNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetContextNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_context = GLib.Marshaller.StructureToPtrAlloc (context);
			unmanaged (this.Handle, native_context);
			Marshal.FreeHGlobal (native_context);
		}


		// 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("metadata"
							, Gst.Object.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // metadata
							, null
							, "elementfactory"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("elementfactory"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // elementfactory
							, "metadata"
							, "padtemplates"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("padtemplates"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // padtemplates
							, "elementfactory"
							, "numpadtemplates"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("numpadtemplates"
							, -1
							, (uint) Marshal.SizeOf(typeof(int)) // numpadtemplates
							, "padtemplates"
							, "pad_templ_cookie"
							, (long) Marshal.OffsetOf(typeof(GstElement_numpadtemplatesAlign), "numpadtemplates")
							, 0
							),
						new GLib.AbiField("pad_templ_cookie"
							, -1
							, (uint) Marshal.SizeOf(typeof(uint)) // pad_templ_cookie
							, "numpadtemplates"
							, "pad_added"
							, (long) Marshal.OffsetOf(typeof(GstElement_pad_templ_cookieAlign), "pad_templ_cookie")
							, 0
							),
						new GLib.AbiField("pad_added"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pad_added
							, "pad_templ_cookie"
							, "pad_removed"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pad_removed"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pad_removed
							, "pad_added"
							, "no_more_pads"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("no_more_pads"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // no_more_pads
							, "pad_removed"
							, "request_new_pad"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("request_new_pad"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // request_new_pad
							, "no_more_pads"
							, "release_pad"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("release_pad"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // release_pad
							, "request_new_pad"
							, "get_state"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_state"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_state
							, "release_pad"
							, "set_state"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_state"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_state
							, "get_state"
							, "change_state"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("change_state"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // change_state
							, "set_state"
							, "state_changed"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("state_changed"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // state_changed
							, "change_state"
							, "set_bus"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_bus"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_bus
							, "state_changed"
							, "provide_clock"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("provide_clock"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // provide_clock
							, "set_bus"
							, "set_clock"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_clock"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_clock
							, "provide_clock"
							, "send_event"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("send_event"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // send_event
							, "set_clock"
							, "query"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("query"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // query
							, "send_event"
							, "post_message"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("post_message"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // post_message
							, "query"
							, "set_context"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_context"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_context
							, "post_message"
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 18 // _gst_reserved
							, "set_context"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}

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

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_pad_templ_cookieAlign
		{
			sbyte f1;
			private uint pad_templ_cookie;
		}


		// End of the ABI representation.

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

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

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern unsafe IntPtr gst_element_make_from_uri(int type, IntPtr uri, IntPtr elementname, out IntPtr error);

		public static unsafe Gst.Element MakeFromUri(Gst.URIType type, string uri, string elementname) {
			IntPtr native_uri = GLib.Marshaller.StringToPtrGStrdup (uri);
			IntPtr native_elementname = GLib.Marshaller.StringToPtrGStrdup (elementname);
			IntPtr error = IntPtr.Zero;
			IntPtr raw_ret = gst_element_make_from_uri((int) type, native_uri, native_elementname, out error);
			Gst.Element ret = GLib.Object.GetObject(raw_ret) as Gst.Element;
			GLib.Marshaller.Free (native_uri);
			GLib.Marshaller.Free (native_elementname);
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		public static Gst.Element MakeFromUri(Gst.URIType type, string uri) {
			return MakeFromUri (type, uri, null);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_element_register(IntPtr plugin, IntPtr name, uint rank, IntPtr type);

		public static bool Register(Gst.Plugin plugin, string name, uint rank, GLib.GType type) {
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			bool raw_ret = gst_element_register(plugin == null ? IntPtr.Zero : plugin.Handle, native_name, rank, type.Val);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_name);
			return ret;
		}

		public static bool Register(string name, uint rank, GLib.GType type) {
			return Register (null, name, rank, type);
		}

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

		public static string StateChangeReturnGetName(Gst.StateChangeReturn state_ret) {
			IntPtr raw_ret = gst_element_state_change_return_get_name((int) state_ret);
			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
			return ret;
		}

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

		public static string StateGetName(Gst.State state) {
			IntPtr raw_ret = gst_element_state_get_name((int) state);
			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
			return ret;
		}

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

		public void AbortState() {
			gst_element_abort_state(Handle);
		}

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

		public bool AddPad(Gst.Pad pad) {
			bool raw_ret = gst_element_add_pad(Handle, pad == null ? IntPtr.Zero : pad.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public ulong AddPropertyDeepNotifyWatch(string property_name, bool include_value) {
			IntPtr native_property_name = GLib.Marshaller.StringToPtrGStrdup (property_name);
			UIntPtr raw_ret = gst_element_add_property_deep_notify_watch(Handle, native_property_name, include_value);
			ulong ret = (ulong) raw_ret;
			GLib.Marshaller.Free (native_property_name);
			return ret;
		}

		public ulong AddPropertyDeepNotifyWatch(bool include_value) {
			return AddPropertyDeepNotifyWatch (null, include_value);
		}

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

		public ulong AddPropertyNotifyWatch(string property_name, bool include_value) {
			IntPtr native_property_name = GLib.Marshaller.StringToPtrGStrdup (property_name);
			UIntPtr raw_ret = gst_element_add_property_notify_watch(Handle, native_property_name, include_value);
			ulong ret = (ulong) raw_ret;
			GLib.Marshaller.Free (native_property_name);
			return ret;
		}

		public ulong AddPropertyNotifyWatch(bool include_value) {
			return AddPropertyNotifyWatch (null, include_value);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_element_call_async(IntPtr raw, GstSharp.ElementCallAsyncFuncNative func, IntPtr user_data, GLib.DestroyNotify destroy_notify);

		public void CallAsync(Gst.ElementCallAsyncFunc func) {
			GstSharp.ElementCallAsyncFuncWrapper func_wrapper = new GstSharp.ElementCallAsyncFuncWrapper (func);
			IntPtr user_data;
			GLib.DestroyNotify destroy_notify;
			if (func == null) {
				user_data = IntPtr.Zero;
				destroy_notify = null;
			} else {
				user_data = (IntPtr) GCHandle.Alloc (func_wrapper);
				destroy_notify = GLib.DestroyHelper.NotifyHandler;
			}
			gst_element_call_async(Handle, func_wrapper.NativeDelegate, user_data, destroy_notify);
		}

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

		public Gst.StateChangeReturn ChangeState(Gst.StateChange transition) {
			int raw_ret = gst_element_change_state(Handle, (int) transition);
			Gst.StateChangeReturn ret = (Gst.StateChangeReturn) raw_ret;
			return ret;
		}

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

		public Gst.StateChangeReturn ContinueState(Gst.StateChangeReturn _ret) {
			int raw_ret = gst_element_continue_state(Handle, (int) _ret);
			Gst.StateChangeReturn ret = (Gst.StateChangeReturn) raw_ret;
			return ret;
		}

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

		public void CreateAllPads() {
			gst_element_create_all_pads(Handle);
		}

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

		public bool ForeachPad(Gst.ElementForeachPadFunc func) {
			GstSharp.ElementForeachPadFuncWrapper func_wrapper = new GstSharp.ElementForeachPadFuncWrapper (func);
			bool raw_ret = gst_element_foreach_pad(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool ForeachSinkPad(Gst.ElementForeachPadFunc func) {
			GstSharp.ElementForeachPadFuncWrapper func_wrapper = new GstSharp.ElementForeachPadFuncWrapper (func);
			bool raw_ret = gst_element_foreach_sink_pad(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool ForeachSrcPad(Gst.ElementForeachPadFunc func) {
			GstSharp.ElementForeachPadFuncWrapper func_wrapper = new GstSharp.ElementForeachPadFuncWrapper (func);
			bool raw_ret = gst_element_foreach_src_pad(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
			bool ret = raw_ret;
			return ret;
		}

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

		public Gst.Pad GetCompatiblePad(Gst.Pad pad, Gst.Caps caps) {
			IntPtr raw_ret = gst_element_get_compatible_pad(Handle, pad == null ? IntPtr.Zero : pad.Handle, caps == null ? IntPtr.Zero : caps.Handle);
			Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
			return ret;
		}

		public Gst.Pad GetCompatiblePad(Gst.Pad pad) {
			return GetCompatiblePad (pad, null);
		}

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

		public Gst.PadTemplate GetCompatiblePadTemplate(Gst.PadTemplate compattempl) {
			IntPtr raw_ret = gst_element_get_compatible_pad_template(Handle, compattempl == null ? IntPtr.Zero : compattempl.Handle);
			Gst.PadTemplate ret = GLib.Object.GetObject(raw_ret) as Gst.PadTemplate;
			return ret;
		}

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

		public Gst.Context GetContext(string context_type) {
			IntPtr native_context_type = GLib.Marshaller.StringToPtrGStrdup (context_type);
			IntPtr raw_ret = gst_element_get_context(Handle, native_context_type);
			Gst.Context ret = Gst.Context.New (raw_ret);
			GLib.Marshaller.Free (native_context_type);
			return ret;
		}

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

		public Gst.Context GetContextUnlocked(string context_type) {
			IntPtr native_context_type = GLib.Marshaller.StringToPtrGStrdup (context_type);
			IntPtr raw_ret = gst_element_get_context_unlocked(Handle, native_context_type);
			Gst.Context ret = Gst.Context.New (raw_ret);
			GLib.Marshaller.Free (native_context_type);
			return ret;
		}

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

		public Gst.ElementFactory Factory { 
			get {
				IntPtr raw_ret = gst_element_get_factory(Handle);
				Gst.ElementFactory ret = GLib.Object.GetObject(raw_ret) as Gst.ElementFactory;
				return ret;
			}
		}

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

		public string GetMetadata(string key) {
			IntPtr native_key = GLib.Marshaller.StringToPtrGStrdup (key);
			IntPtr raw_ret = gst_element_get_metadata(Handle, native_key);
			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
			GLib.Marshaller.Free (native_key);
			return ret;
		}

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

		public Gst.PadTemplate GetPadTemplate(string name) {
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			IntPtr raw_ret = gst_element_get_pad_template(Handle, native_name);
			Gst.PadTemplate ret = GLib.Object.GetObject(raw_ret) as Gst.PadTemplate;
			GLib.Marshaller.Free (native_name);
			return ret;
		}

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

		public Gst.PadTemplate[] PadTemplateList { 
			get {
				IntPtr raw_ret = gst_element_get_pad_template_list(Handle);
				Gst.PadTemplate[] ret = (Gst.PadTemplate[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), false, false, typeof(Gst.PadTemplate));
				return ret;
			}
		}

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

		public Gst.Pad GetRequestPad(string name) {
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			IntPtr raw_ret = gst_element_get_request_pad(Handle, native_name);
			Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
			GLib.Marshaller.Free (native_name);
			return ret;
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern int gst_element_get_state(IntPtr raw, out int state, out int pending, ulong timeout);

		public Gst.StateChangeReturn GetState(out Gst.State state, out Gst.State pending, ulong timeout) {
			int native_state;
			int native_pending;
			int raw_ret = gst_element_get_state(Handle, out native_state, out native_pending, timeout);
			Gst.StateChangeReturn ret = (Gst.StateChangeReturn) raw_ret;
			state = (Gst.State) native_state;
			pending = (Gst.State) native_pending;
			return ret;
		}

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

		public Gst.Pad GetStaticPad(string name) {
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			IntPtr raw_ret = gst_element_get_static_pad(Handle, native_name);
			Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
			GLib.Marshaller.Free (native_name);
			return ret;
		}

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

		public bool IsLockedState { 
			get {
				bool raw_ret = gst_element_is_locked_state(Handle);
				bool ret = raw_ret;
				return ret;
			}
		}

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

		public Gst.Iterator IteratePads() {
			IntPtr raw_ret = gst_element_iterate_pads(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_element_iterate_sink_pads(IntPtr raw);

		public Gst.Iterator IterateSinkPads() {
			IntPtr raw_ret = gst_element_iterate_sink_pads(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_element_iterate_src_pads(IntPtr raw);

		public Gst.Iterator IterateSrcPads() {
			IntPtr raw_ret = gst_element_iterate_src_pads(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 bool gst_element_link(IntPtr raw, IntPtr dest);

		public bool Link(Gst.Element dest) {
			bool raw_ret = gst_element_link(Handle, dest == null ? IntPtr.Zero : dest.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool LinkFiltered(Gst.Element dest, Gst.Caps filter) {
			bool raw_ret = gst_element_link_filtered(Handle, dest == null ? IntPtr.Zero : dest.Handle, filter == null ? IntPtr.Zero : filter.Handle);
			bool ret = raw_ret;
			return ret;
		}

		public bool LinkFiltered(Gst.Element dest) {
			return LinkFiltered (dest, null);
		}

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

		public bool LinkPads(string srcpadname, Gst.Element dest, string destpadname) {
			IntPtr native_srcpadname = GLib.Marshaller.StringToPtrGStrdup (srcpadname);
			IntPtr native_destpadname = GLib.Marshaller.StringToPtrGStrdup (destpadname);
			bool raw_ret = gst_element_link_pads(Handle, native_srcpadname, dest == null ? IntPtr.Zero : dest.Handle, native_destpadname);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_srcpadname);
			GLib.Marshaller.Free (native_destpadname);
			return ret;
		}

		public bool LinkPads(Gst.Element dest) {
			return LinkPads (null, dest, null);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_element_link_pads_filtered(IntPtr raw, IntPtr srcpadname, IntPtr dest, IntPtr destpadname, IntPtr filter);

		public bool LinkPadsFiltered(string srcpadname, Gst.Element dest, string destpadname, Gst.Caps filter) {
			IntPtr native_srcpadname = GLib.Marshaller.StringToPtrGStrdup (srcpadname);
			IntPtr native_destpadname = GLib.Marshaller.StringToPtrGStrdup (destpadname);
			bool raw_ret = gst_element_link_pads_filtered(Handle, native_srcpadname, dest == null ? IntPtr.Zero : dest.Handle, native_destpadname, filter == null ? IntPtr.Zero : filter.Handle);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_srcpadname);
			GLib.Marshaller.Free (native_destpadname);
			return ret;
		}

		public bool LinkPadsFiltered(Gst.Element dest) {
			return LinkPadsFiltered (null, dest, null, null);
		}

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

		public bool LinkPadsFull(string srcpadname, Gst.Element dest, string destpadname, Gst.PadLinkCheck flags) {
			IntPtr native_srcpadname = GLib.Marshaller.StringToPtrGStrdup (srcpadname);
			IntPtr native_destpadname = GLib.Marshaller.StringToPtrGStrdup (destpadname);
			bool raw_ret = gst_element_link_pads_full(Handle, native_srcpadname, dest == null ? IntPtr.Zero : dest.Handle, native_destpadname, (int) flags);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_srcpadname);
			GLib.Marshaller.Free (native_destpadname);
			return ret;
		}

		public bool LinkPadsFull(Gst.Element dest, Gst.PadLinkCheck flags) {
			return LinkPadsFull (null, dest, null, flags);
		}

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

		public void LostState() {
			gst_element_lost_state(Handle);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_element_message_full(IntPtr raw, int type, uint domain, int code, IntPtr text, IntPtr debug, IntPtr file, IntPtr function, int line);

		public void MessageFull(Gst.MessageType type, uint domain, int code, string text, string debug, string file, string function, int line) {
			IntPtr native_file = GLib.Marshaller.StringToPtrGStrdup (file);
			IntPtr native_function = GLib.Marshaller.StringToPtrGStrdup (function);
			gst_element_message_full(Handle, (int) type, domain, code, GLib.Marshaller.StringToPtrGStrdup(text), GLib.Marshaller.StringToPtrGStrdup(debug), native_file, native_function, line);
			GLib.Marshaller.Free (native_file);
			GLib.Marshaller.Free (native_function);
		}

		public void MessageFull(Gst.MessageType type, uint domain, int code, string file, string function, int line) {
			MessageFull (type, domain, code, null, null, file, function, line);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern void gst_element_message_full_with_details(IntPtr raw, int type, uint domain, int code, IntPtr text, IntPtr debug, IntPtr file, IntPtr function, int line, IntPtr structure);

		public void MessageFullWithDetails(Gst.MessageType type, uint domain, int code, string text, string debug, string file, string function, int line, Gst.Structure structure) {
			IntPtr native_file = GLib.Marshaller.StringToPtrGStrdup (file);
			IntPtr native_function = GLib.Marshaller.StringToPtrGStrdup (function);
			structure.Owned = false;
			gst_element_message_full_with_details(Handle, (int) type, domain, code, GLib.Marshaller.StringToPtrGStrdup(text), GLib.Marshaller.StringToPtrGStrdup(debug), native_file, native_function, line, structure == null ? IntPtr.Zero : structure.Handle);
			GLib.Marshaller.Free (native_file);
			GLib.Marshaller.Free (native_function);
		}

		public void MessageFullWithDetails(Gst.MessageType type, uint domain, int code, string file, string function, int line, Gst.Structure structure) {
			MessageFullWithDetails (type, domain, code, null, null, file, function, line, structure);
		}

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

		public void NoMorePads() {
			gst_element_no_more_pads(Handle);
		}

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

		public bool PostMessage(Gst.Message message) {
			message.Owned = false;
			bool raw_ret = gst_element_post_message(Handle, message == null ? IntPtr.Zero : message.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public Gst.Clock ProvideClock() {
			IntPtr raw_ret = gst_element_provide_clock(Handle);
			Gst.Clock ret = GLib.Object.GetObject(raw_ret, true) as Gst.Clock;
			return ret;
		}

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

		public bool Query(Gst.Query query) {
			bool raw_ret = gst_element_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_element_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_element_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_element_query_duration(IntPtr raw, int format, out long duration);

		public bool QueryDuration(Gst.Format format, out long duration) {
			bool raw_ret = gst_element_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_element_query_position(IntPtr raw, int format, out long cur);

		public bool QueryPosition(Gst.Format format, out long cur) {
			bool raw_ret = gst_element_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_element_release_request_pad(IntPtr raw, IntPtr pad);

		public void ReleaseRequestPad(Gst.Pad pad) {
			gst_element_release_request_pad(Handle, pad == null ? IntPtr.Zero : pad.Handle);
		}

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

		public bool RemovePad(Gst.Pad pad) {
			bool raw_ret = gst_element_remove_pad(Handle, pad == null ? IntPtr.Zero : pad.Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public void RemovePropertyNotifyWatch(ulong watch_id) {
			gst_element_remove_property_notify_watch(Handle, new UIntPtr (watch_id));
		}

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

		public Gst.Pad RequestPad(Gst.PadTemplate templ, string name, Gst.Caps caps) {
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			IntPtr raw_ret = gst_element_request_pad(Handle, templ == null ? IntPtr.Zero : templ.Handle, native_name, caps == null ? IntPtr.Zero : caps.Handle);
			Gst.Pad ret = GLib.Object.GetObject(raw_ret, true) as Gst.Pad;
			GLib.Marshaller.Free (native_name);
			return ret;
		}

		public Gst.Pad RequestPad(Gst.PadTemplate templ) {
			return RequestPad (templ, null, null);
		}

		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
		static extern bool gst_element_seek(IntPtr raw, double rate, int format, int flags, int start_type, long start, int stop_type, long stop);

		public bool Seek(double rate, Gst.Format format, Gst.SeekFlags flags, Gst.SeekType start_type, long start, Gst.SeekType stop_type, long stop) {
			bool raw_ret = gst_element_seek(Handle, rate, (int) format, (int) flags, (int) start_type, start, (int) stop_type, stop);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool SeekSimple(Gst.Format format, Gst.SeekFlags seek_flags, long seek_pos) {
			bool raw_ret = gst_element_seek_simple(Handle, (int) format, (int) seek_flags, seek_pos);
			bool ret = raw_ret;
			return ret;
		}

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

		public bool SendEvent(Gst.Event evnt) {
			evnt.Owned = false;
			bool raw_ret = gst_element_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 bool gst_element_set_clock(IntPtr raw, IntPtr clock);

		public bool SetClock(Gst.Clock clock) {
			bool raw_ret = gst_element_set_clock(Handle, clock == null ? IntPtr.Zero : clock.Handle);
			bool ret = raw_ret;
			return ret;
		}

		public bool SetClock() {
			return SetClock (null);
		}

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

		public bool SetLockedState(bool locked_state) {
			bool raw_ret = gst_element_set_locked_state(Handle, locked_state);
			bool ret = raw_ret;
			return ret;
		}

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

		public Gst.StateChangeReturn SetState(Gst.State state) {
			int raw_ret = gst_element_set_state(Handle, (int) state);
			Gst.StateChangeReturn ret = (Gst.StateChangeReturn) raw_ret;
			return ret;
		}

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

		public bool SyncStateWithParent() {
			bool raw_ret = gst_element_sync_state_with_parent(Handle);
			bool ret = raw_ret;
			return ret;
		}

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

		public void Unlink(Gst.Element dest) {
			gst_element_unlink(Handle, dest == null ? IntPtr.Zero : dest.Handle);
		}

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

		public void UnlinkPads(string srcpadname, Gst.Element dest, string destpadname) {
			IntPtr native_srcpadname = GLib.Marshaller.StringToPtrGStrdup (srcpadname);
			IntPtr native_destpadname = GLib.Marshaller.StringToPtrGStrdup (destpadname);
			gst_element_unlink_pads(Handle, native_srcpadname, dest == null ? IntPtr.Zero : dest.Handle, native_destpadname);
			GLib.Marshaller.Free (native_srcpadname);
			GLib.Marshaller.Free (native_destpadname);
		}


		// 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("state_lock"
							, Gst.Object.abi_info.Fields
							, (uint) Marshal.SizeOf(typeof(GLib.RecMutex.ABI)) // state_lock
							, null
							, "state_cond"
							, (long) Marshal.OffsetOf(typeof(GstElement_state_lockAlign), "state_lock")
							, 0
							),
						new GLib.AbiField("state_cond"
							, -1
							, (uint) Marshal.SizeOf(typeof(GLib.Cond.ABI)) // state_cond
							, "state_lock"
							, "state_cookie"
							, (long) Marshal.OffsetOf(typeof(GstElement_state_condAlign), "state_cond")
							, 0
							),
						new GLib.AbiField("state_cookie"
							, -1
							, (uint) Marshal.SizeOf(typeof(uint)) // state_cookie
							, "state_cond"
							, "target_state"
							, (long) Marshal.OffsetOf(typeof(GstElement_state_cookieAlign), "state_cookie")
							, 0
							),
						new GLib.AbiField("target_state"
							, -1
							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.State))) // target_state
							, "state_cookie"
							, "current_state"
							, (long) Marshal.OffsetOf(typeof(GstElement_target_stateAlign), "target_state")
							, 0
							),
						new GLib.AbiField("current_state"
							, -1
							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.State))) // current_state
							, "target_state"
							, "next_state"
							, (long) Marshal.OffsetOf(typeof(GstElement_current_stateAlign), "current_state")
							, 0
							),
						new GLib.AbiField("next_state"
							, -1
							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.State))) // next_state
							, "current_state"
							, "pending_state"
							, (long) Marshal.OffsetOf(typeof(GstElement_next_stateAlign), "next_state")
							, 0
							),
						new GLib.AbiField("pending_state"
							, -1
							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.State))) // pending_state
							, "next_state"
							, "last_return"
							, (long) Marshal.OffsetOf(typeof(GstElement_pending_stateAlign), "pending_state")
							, 0
							),
						new GLib.AbiField("last_return"
							, -1
							, (uint) Marshal.SizeOf(System.Enum.GetUnderlyingType(typeof(Gst.StateChangeReturn))) // last_return
							, "pending_state"
							, "bus"
							, (long) Marshal.OffsetOf(typeof(GstElement_last_returnAlign), "last_return")
							, 0
							),
						new GLib.AbiField("bus"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // bus
							, "last_return"
							, "clock"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("clock"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // clock
							, "bus"
							, "base_time"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("base_time"
							, -1
							, (uint) Marshal.SizeOf(typeof(long)) // base_time
							, "clock"
							, "start_time"
							, (long) Marshal.OffsetOf(typeof(GstElement_base_timeAlign), "base_time")
							, 0
							),
						new GLib.AbiField("start_time"
							, -1
							, (uint) Marshal.SizeOf(typeof(ulong)) // start_time
							, "base_time"
							, "numpads"
							, (long) Marshal.OffsetOf(typeof(GstElement_start_timeAlign), "start_time")
							, 0
							),
						new GLib.AbiField("numpads"
							, -1
							, (uint) Marshal.SizeOf(typeof(ushort)) // numpads
							, "start_time"
							, "pads"
							, (long) Marshal.OffsetOf(typeof(GstElement_numpadsAlign), "numpads")
							, 0
							),
						new GLib.AbiField("pads"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // pads
							, "numpads"
							, "numsrcpads"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("numsrcpads"
							, -1
							, (uint) Marshal.SizeOf(typeof(ushort)) // numsrcpads
							, "pads"
							, "srcpads"
							, (long) Marshal.OffsetOf(typeof(GstElement_numsrcpadsAlign), "numsrcpads")
							, 0
							),
						new GLib.AbiField("srcpads"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // srcpads
							, "numsrcpads"
							, "numsinkpads"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("numsinkpads"
							, -1
							, (uint) Marshal.SizeOf(typeof(ushort)) // numsinkpads
							, "srcpads"
							, "sinkpads"
							, (long) Marshal.OffsetOf(typeof(GstElement_numsinkpadsAlign), "numsinkpads")
							, 0
							),
						new GLib.AbiField("sinkpads"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // sinkpads
							, "numsinkpads"
							, "pads_cookie"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("pads_cookie"
							, -1
							, (uint) Marshal.SizeOf(typeof(uint)) // pads_cookie
							, "sinkpads"
							, "contexts"
							, (long) Marshal.OffsetOf(typeof(GstElement_pads_cookieAlign), "pads_cookie")
							, 0
							),
						new GLib.AbiField("contexts"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // contexts
							, "pads_cookie"
							, "_gst_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_gst_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 3 // _gst_reserved
							, "contexts"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _abi_info;
			}
		}

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

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

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_state_cookieAlign
		{
			sbyte f1;
			private uint state_cookie;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_target_stateAlign
		{
			sbyte f1;
			private Gst.State target_state;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_current_stateAlign
		{
			sbyte f1;
			private Gst.State current_state;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_next_stateAlign
		{
			sbyte f1;
			private Gst.State next_state;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_pending_stateAlign
		{
			sbyte f1;
			private Gst.State pending_state;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_last_returnAlign
		{
			sbyte f1;
			private Gst.StateChangeReturn last_return;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_base_timeAlign
		{
			sbyte f1;
			private ulong base_time;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_start_timeAlign
		{
			sbyte f1;
			private ulong start_time;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_numpadsAlign
		{
			sbyte f1;
			private ushort numpads;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_numsrcpadsAlign
		{
			sbyte f1;
			private ushort numsrcpads;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_numsinkpadsAlign
		{
			sbyte f1;
			private ushort numsinkpads;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GstElement_pads_cookieAlign
		{
			sbyte f1;
			private uint pads_cookie;
		}


		// End of the ABI representation.

#endregion
	}
}