context: // This file was generated by the Gtk# code generator.
  // Any changes made will be lost if regenerated.
  
  namespace Gst.Base {
  
  	using System;
  	using System.Collections;
  	using System.Collections.Generic;
  	using System.Runtime.InteropServices;
  
  #region Autogenerated code
  	public partial class AggregatorPad : Gst.Pad {
  
  		public AggregatorPad (IntPtr raw) : base(raw) {}
  
  		protected AggregatorPad() : base(IntPtr.Zero)
  		{
  			CreateNativeObject (new string [0], new GLib.Value [0]);
  		}
  
  		[GLib.Property ("emit-signals")]
  		public bool EmitSignals {
  			get {
  				GLib.Value val = GetProperty ("emit-signals");
  				bool ret = (bool) val;
  				val.Dispose ();
  				return ret;
  			}
  			set {
  				GLib.Value val = new GLib.Value(value);
  				SetProperty("emit-signals", val);
  				val.Dispose ();
  			}
  		}
  
  		public Gst.Segment Segment {
  			get {
  				unsafe {
  					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("segment"));
  					return Gst.Segment.New ((*raw_ptr));
  				}
  			}
  		}
  
  		[GLib.Signal("buffer-consumed")]
  		public event Gst.Base.BufferConsumedHandler BufferConsumed {
  			add {
  				this.AddSignalHandler ("buffer-consumed", value, typeof (Gst.Base.BufferConsumedArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("buffer-consumed", value);
  			}
  		}
  
  		static BufferConsumedNativeDelegate BufferConsumed_cb_delegate;
  		static BufferConsumedNativeDelegate BufferConsumedVMCallback {
  			get {
  				if (BufferConsumed_cb_delegate == null)
  					BufferConsumed_cb_delegate = new BufferConsumedNativeDelegate (BufferConsumed_cb);
  				return BufferConsumed_cb_delegate;
  			}
  		}
  
  		static void OverrideBufferConsumed (GLib.GType gtype)
  		{
  			OverrideBufferConsumed (gtype, BufferConsumedVMCallback);
  		}
  
  		static void OverrideBufferConsumed (GLib.GType gtype, BufferConsumedNativeDelegate callback)
  		{
  			OverrideVirtualMethod (gtype, "buffer-consumed", callback);
  		}
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void BufferConsumedNativeDelegate (IntPtr inst, IntPtr _object);
  
  		static void BufferConsumed_cb (IntPtr inst, IntPtr _object)
  		{
  			try {
  				AggregatorPad __obj = GLib.Object.GetObject (inst, false) as AggregatorPad;
  				__obj.OnBufferConsumed (_object == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (_object, typeof (Gst.Buffer), false));
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.AggregatorPad), ConnectionMethod="OverrideBufferConsumed")]
  		protected virtual void OnBufferConsumed (Gst.Buffer _object)
  		{
  			InternalBufferConsumed (_object);
  		}
  
  		private void InternalBufferConsumed (Gst.Buffer _object)
  		{
  			GLib.Value ret = GLib.Value.Empty;
  			GLib.ValueArray inst_and_params = new GLib.ValueArray (2);
  			GLib.Value[] vals = new GLib.Value [2];
  			vals [0] = new GLib.Value (this);
  			inst_and_params.Append (vals [0]);
  			vals [1] = new GLib.Value (_object);
  			inst_and_params.Append (vals [1]);
  			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
  			foreach (GLib.Value v in vals)
  				v.Dispose ();
  		}
  
  		static FlushNativeDelegate Flush_cb_delegate;
  		static FlushNativeDelegate FlushVMCallback {
  			get {
  				if (Flush_cb_delegate == null)
  					Flush_cb_delegate = new FlushNativeDelegate (Flush_cb);
  				return Flush_cb_delegate;
  			}
  		}
  
  		static void OverrideFlush (GLib.GType gtype)
  		{
  			OverrideFlush (gtype, FlushVMCallback);
  		}
  
  		static void OverrideFlush (GLib.GType gtype, FlushNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("flush"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate int FlushNativeDelegate (IntPtr inst, IntPtr aggregator);
  
  		static int Flush_cb (IntPtr inst, IntPtr aggregator)
  		{
  			try {
  				AggregatorPad __obj = GLib.Object.GetObject (inst, false) as AggregatorPad;
  				Gst.FlowReturn __result;
  				__result = __obj.OnFlush (GLib.Object.GetObject(aggregator) as Gst.Base.Aggregator);
  				return (int) __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.AggregatorPad), ConnectionMethod="OverrideFlush")]
  		protected virtual Gst.FlowReturn OnFlush (Gst.Base.Aggregator aggregator)
  		{
  			return InternalFlush (aggregator);
  		}
  
  		private Gst.FlowReturn InternalFlush (Gst.Base.Aggregator aggregator)
  		{
  			FlushNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("flush"));
  				unmanaged = (FlushNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(FlushNativeDelegate));
  			}
  			if (unmanaged == null) return (Gst.FlowReturn) 0;
  
  			int __result = unmanaged (this.Handle, aggregator == null ? IntPtr.Zero : aggregator.Handle);
  			return (Gst.FlowReturn) __result;
  		}
  
  		static SkipBufferNativeDelegate SkipBuffer_cb_delegate;
  		static SkipBufferNativeDelegate SkipBufferVMCallback {
  			get {
  				if (SkipBuffer_cb_delegate == null)
  					SkipBuffer_cb_delegate = new SkipBufferNativeDelegate (SkipBuffer_cb);
  				return SkipBuffer_cb_delegate;
  			}
  		}
  
  		static void OverrideSkipBuffer (GLib.GType gtype)
  		{
  			OverrideSkipBuffer (gtype, SkipBufferVMCallback);
  		}
  
  		static void OverrideSkipBuffer (GLib.GType gtype, SkipBufferNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("skip_buffer"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool SkipBufferNativeDelegate (IntPtr inst, IntPtr aggregator, IntPtr buffer);
  
  		static bool SkipBuffer_cb (IntPtr inst, IntPtr aggregator, IntPtr buffer)
  		{
  			try {
  				AggregatorPad __obj = GLib.Object.GetObject (inst, false) as AggregatorPad;
  				bool __result;
  				__result = __obj.OnSkipBuffer (GLib.Object.GetObject(aggregator) as Gst.Base.Aggregator, buffer == IntPtr.Zero ? null : (Gst.Buffer) GLib.Opaque.GetOpaque (buffer, typeof (Gst.Buffer), false));
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Base.AggregatorPad), ConnectionMethod="OverrideSkipBuffer")]
  		protected virtual bool OnSkipBuffer (Gst.Base.Aggregator aggregator, Gst.Buffer buffer)
  		{
  			return InternalSkipBuffer (aggregator, buffer);
  		}
  
  		private bool InternalSkipBuffer (Gst.Base.Aggregator aggregator, Gst.Buffer buffer)
  		{
  			SkipBufferNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("skip_buffer"));
  				unmanaged = (SkipBufferNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SkipBufferNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle, aggregator == null ? IntPtr.Zero : aggregator.Handle, buffer == null ? IntPtr.Zero : buffer.Handle);
  			return __result;
  		}
  
  
  		// Internal representation of the wrapped structure ABI.
  		static GLib.AbiStruct _class_abi = null;
  		static public new GLib.AbiStruct class_abi {
  			get {
  				if (_class_abi == null)
  					_class_abi = new GLib.AbiStruct (new List<GLib.AbiField>{ 
  						new GLib.AbiField("flush"
  							, Gst.Pad.class_abi.Fields
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // flush
  							, null
  							, "skip_buffer"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("skip_buffer"
  							, -1
  							, (uint) Marshal.SizeOf(typeof(IntPtr)) // skip_buffer
  							, "flush"
  							, "_gst_reserved"
  							, (uint) Marshal.SizeOf(typeof(IntPtr))
  							, 0
  							),
  						new GLib.AbiField("_gst_reserved"
  							, -1
  
gt: 							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // _gst_reserved