context: // 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 TaskPool : Gst.Object {
  
  		public TaskPool (IntPtr raw) : base(raw) {}
  
  		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gst_task_pool_new();
  
  		public TaskPool () : base (IntPtr.Zero)
  		{
  			if (GetType () != typeof (TaskPool)) {
  				CreateNativeObject (new string [0], new GLib.Value[0]);
  				return;
  			}
  			Raw = gst_task_pool_new();
  		}
  
  		static PrepareNativeDelegate Prepare_cb_delegate;
  		static PrepareNativeDelegate PrepareVMCallback {
  			get {
  				if (Prepare_cb_delegate == null)
  					Prepare_cb_delegate = new PrepareNativeDelegate (Prepare_cb);
  				return Prepare_cb_delegate;
  			}
  		}
  
  		static void OverridePrepare (GLib.GType gtype)
  		{
  			OverridePrepare (gtype, PrepareVMCallback);
  		}
  
  		static void OverridePrepare (GLib.GType gtype, PrepareNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void PrepareNativeDelegate (IntPtr inst, out IntPtr error);
  
  		static void Prepare_cb (IntPtr inst, out IntPtr error)
  		{
  			error = IntPtr.Zero;
  
  			try {
  				TaskPool __obj = GLib.Object.GetObject (inst, false) as TaskPool;
  				__obj.OnPrepare ();
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.TaskPool), ConnectionMethod="OverridePrepare")]
  		protected virtual void OnPrepare ()
  		{
  			InternalPrepare ();
  		}
  
  		private void InternalPrepare ()
  		{
  			PrepareNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("prepare"));
  				unmanaged = (PrepareNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PrepareNativeDelegate));
  			}
  			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
  
  			IntPtr error = IntPtr.Zero;
  			unmanaged (this.Handle, out error);
  		}
  
  		static CleanupNativeDelegate Cleanup_cb_delegate;
  		static CleanupNativeDelegate CleanupVMCallback {
  			get {
  				if (Cleanup_cb_delegate == null)
  					Cleanup_cb_delegate = new CleanupNativeDelegate (Cleanup_cb);
  				return Cleanup_cb_delegate;
  			}
  		}
  
  		static void OverrideCleanup (GLib.GType gtype)
  		{
  			OverrideCleanup (gtype, CleanupVMCallback);
  		}
  
  		static void OverrideCleanup (GLib.GType gtype, CleanupNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("cleanup"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void CleanupNativeDelegate (IntPtr inst);
  
  		static void Cleanup_cb (IntPtr inst)
  		{
  			try {
  				TaskPool __obj = GLib.Object.GetObject (inst, false) as TaskPool;
  				__obj.OnCleanup ();
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.TaskPool), ConnectionMethod="OverrideCleanup")]
  		protected virtual void OnCleanup ()
  		{
  			InternalCleanup ();
  		}
  
  		private void InternalCleanup ()
  		{
  			CleanupNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("cleanup"));
  				unmanaged = (CleanupNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CleanupNativeDelegate));
  			}
  			if (unmanaged == null) return;
  
  			unmanaged (this.Handle);
  		}
  
  		static PushNativeDelegate Push_cb_delegate;
  		static PushNativeDelegate PushVMCallback {
  			get {
  				if (Push_cb_delegate == null)
  					Push_cb_delegate = new PushNativeDelegate (Push_cb);
  				return Push_cb_delegate;
  			}
  		}
  
  		static void OverridePush (GLib.GType gtype)
  		{
  			OverridePush (gtype, PushVMCallback);
  		}
  
  		static void OverridePush (GLib.GType gtype, PushNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("push"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate IntPtr PushNativeDelegate (IntPtr inst, GstSharp.TaskPoolFunctionNative func, IntPtr user_data, out IntPtr error);
  
  		static IntPtr Push_cb (IntPtr inst, GstSharp.TaskPoolFunctionNative func, IntPtr user_data, out IntPtr error)
  		{
  			error = IntPtr.Zero;
  
  			try {
  				TaskPool __obj = GLib.Object.GetObject (inst, false) as TaskPool;
  				IntPtr __result;
  				GstSharp.TaskPoolFunctionInvoker func_invoker = new GstSharp.TaskPoolFunctionInvoker (func, user_data);
  				__result = __obj.OnPush (func_invoker.Handler);
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.TaskPool), ConnectionMethod="OverridePush")]
  		protected virtual IntPtr OnPush (Gst.TaskPoolFunction func)
  		{
  			return InternalPush (func);
  		}
  
  		private IntPtr InternalPush (Gst.TaskPoolFunction func)
  		{
  			PushNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("push"));
  				unmanaged = (PushNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(PushNativeDelegate));
  			}
  			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");
  
  			GstSharp.TaskPoolFunctionWrapper func_wrapper = new GstSharp.TaskPoolFunctionWrapper (func);
  			func_wrapper.PersistUntilCalled ();
  			IntPtr error = IntPtr.Zero;
  			IntPtr __result = unmanaged (this.Handle, func_wrapper.NativeDelegate, IntPtr.Zero, out error);
  			return __result;
  		}
  
  		static JoinNativeDelegate Join_cb_delegate;
  		static JoinNativeDelegate JoinVMCallback {
  			get {
  				if (Join_cb_delegate == null)
  					Join_cb_delegate = new JoinNativeDelegate (Join_cb);
  				return Join_cb_delegate;
  			}
  		}
  
  		static void OverrideJoin (GLib.GType gtype)
  		{
  			OverrideJoin (gtype, JoinVMCallback);
  		}
  
  		static void OverrideJoin (GLib.GType gtype, JoinNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("join"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void JoinNativeDelegate (IntPtr inst, IntPtr id);
  
  		static void Join_cb (IntPtr inst, IntPtr id)
  		{
  			try {
  				TaskPool __obj = GLib.Object.GetObject (inst, false) as TaskPool;
  				__obj.OnJoin (id);
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.TaskPool), ConnectionMethod="OverrideJoin")]
  		protected virtual void OnJoin (IntPtr id)
  		{
  			InternalJoin (id);
  		}
  
  		private void InternalJoin (IntPtr id)
  		{
  			JoinNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("join"));
  				unmanaged = (JoinNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(JoinNativeDelegate));
  			}
  			if (unmanaged == null) return;
  
  			unmanaged (this.Handle, id);
  		}
  
  
  		// 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("prepare"
  							, Gst.Object.class_abi.Fields
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // prepare
  							, null
  							, "cleanup"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("cleanup"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // cleanup
  							, "prepare"
  							, "push"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("push"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // push
  							, "cleanup"
  							, "join"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("join"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // join
  							, "push"
  							, "_gst_reserved"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("_gst_reserved"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 4 // _gst_reserved
  							, "join"
  							, 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_task_pool_get_type();
  
  		public static new GLib.GType GType { 
  			get {
  
gt: 				IntPtr raw_ret = gst_task_pool_get_type();