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 DeviceProvider : Gst.Object {
  
  		protected DeviceProvider (IntPtr raw) : base(raw) {}
  
  		protected DeviceProvider() : base(IntPtr.Zero)
  		{
  			CreateNativeObject (new string [0], new GLib.Value [0]);
  		}
  
  		[DllImport("libgstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gst_device_provider_get_devices(IntPtr raw);
  
  		public Gst.Device[] Devices {
  			get  {
  				IntPtr raw_ret = gst_device_provider_get_devices(Handle);
  				Gst.Device[] ret = (Gst.Device[]) GLib.Marshaller.ListPtrToArray (raw_ret, typeof(GLib.List), true, true, typeof(Gst.Device));
  				return ret;
  			}
  		}
  
  		[GLib.Signal("provider-unhidden")]
  		public event Gst.ProviderUnhiddenHandler ProviderUnhidden {
  			add {
  				this.AddSignalHandler ("provider-unhidden", value, typeof (Gst.ProviderUnhiddenArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("provider-unhidden", value);
  			}
  		}
  
  		[GLib.Signal("provider-hidden")]
  		public event Gst.ProviderHiddenHandler ProviderHidden {
  			add {
  				this.AddSignalHandler ("provider-hidden", value, typeof (Gst.ProviderHiddenArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("provider-hidden", value);
  			}
  		}
  
  		static ProviderHiddenNativeDelegate ProviderHidden_cb_delegate;
  		static ProviderHiddenNativeDelegate ProviderHiddenVMCallback {
  			get {
  				if (ProviderHidden_cb_delegate == null)
  					ProviderHidden_cb_delegate = new ProviderHiddenNativeDelegate (ProviderHidden_cb);
  				return ProviderHidden_cb_delegate;
  			}
  		}
  
  		static void OverrideProviderHidden (GLib.GType gtype)
  		{
  			OverrideProviderHidden (gtype, ProviderHiddenVMCallback);
  		}
  
  		static void OverrideProviderHidden (GLib.GType gtype, ProviderHiddenNativeDelegate callback)
  		{
  			OverrideVirtualMethod (gtype, "provider-hidden", callback);
  		}
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void ProviderHiddenNativeDelegate (IntPtr inst, IntPtr _object);
  
  		static void ProviderHidden_cb (IntPtr inst, IntPtr _object)
  		{
  			try {
  				DeviceProvider __obj = GLib.Object.GetObject (inst, false) as DeviceProvider;
  				__obj.OnProviderHidden (GLib.Marshaller.Utf8PtrToString (_object));
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.DeviceProvider), ConnectionMethod="OverrideProviderHidden")]
  		protected virtual void OnProviderHidden (string _object)
  		{
  			InternalProviderHidden (_object);
  		}
  
  		private void InternalProviderHidden (string _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 ProviderUnhiddenNativeDelegate ProviderUnhidden_cb_delegate;
  		static ProviderUnhiddenNativeDelegate ProviderUnhiddenVMCallback {
  			get {
  				if (ProviderUnhidden_cb_delegate == null)
  					ProviderUnhidden_cb_delegate = new ProviderUnhiddenNativeDelegate (ProviderUnhidden_cb);
  				return ProviderUnhidden_cb_delegate;
  			}
  		}
  
  		static void OverrideProviderUnhidden (GLib.GType gtype)
  		{
  			OverrideProviderUnhidden (gtype, ProviderUnhiddenVMCallback);
  		}
  
  		static void OverrideProviderUnhidden (GLib.GType gtype, ProviderUnhiddenNativeDelegate callback)
  		{
  			OverrideVirtualMethod (gtype, "provider-unhidden", callback);
  		}
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void ProviderUnhiddenNativeDelegate (IntPtr inst, IntPtr _object);
  
  		static void ProviderUnhidden_cb (IntPtr inst, IntPtr _object)
  		{
  			try {
  				DeviceProvider __obj = GLib.Object.GetObject (inst, false) as DeviceProvider;
  				__obj.OnProviderUnhidden (GLib.Marshaller.Utf8PtrToString (_object));
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.DeviceProvider), ConnectionMethod="OverrideProviderUnhidden")]
  		protected virtual void OnProviderUnhidden (string _object)
  		{
  			InternalProviderUnhidden (_object);
  		}
  
  		private void InternalProviderUnhidden (string _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 StartNativeDelegate Start_cb_delegate;
  		static StartNativeDelegate StartVMCallback {
  			get {
  				if (Start_cb_delegate == null)
  					Start_cb_delegate = new StartNativeDelegate (Start_cb);
  				return Start_cb_delegate;
  			}
  		}
  
  		static void OverrideStart (GLib.GType gtype)
  		{
  			OverrideStart (gtype, StartVMCallback);
  		}
  
  		static void OverrideStart (GLib.GType gtype, StartNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("start"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool StartNativeDelegate (IntPtr inst);
  
  		static bool Start_cb (IntPtr inst)
  		{
  			try {
  				DeviceProvider __obj = GLib.Object.GetObject (inst, false) as DeviceProvider;
  				bool __result;
  				__result = __obj.OnStart ();
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.DeviceProvider), ConnectionMethod="OverrideStart")]
  		protected virtual bool OnStart ()
  		{
  			return InternalStart ();
  		}
  
  		private bool InternalStart ()
  		{
  			StartNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("start"));
  				unmanaged = (StartNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(StartNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle);
  			return __result;
  		}
  
  		static StopNativeDelegate Stop_cb_delegate;
  		static StopNativeDelegate StopVMCallback {
  			get {
  				if (Stop_cb_delegate == null)
  					Stop_cb_delegate = new StopNativeDelegate (Stop_cb);
  				return Stop_cb_delegate;
  			}
  		}
  
  		static void OverrideStop (GLib.GType gtype)
  		{
  
gt: 			OverrideStop (gtype, StopVMCallback);