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 Device : Gst.Object {
  
  		protected Device (IntPtr raw) : base(raw) {}
  
  		protected Device() : base(IntPtr.Zero)
  		{
  			CreateNativeObject (new string [0], new GLib.Value [0]);
  		}
  
  		[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gst_device_get_caps(IntPtr raw);
  
  		[GLib.Property ("caps")]
  		public Gst.Caps Caps {
  			get  {
  				IntPtr raw_ret = gst_device_get_caps(Handle);
  				Gst.Caps ret = raw_ret == IntPtr.Zero ? null : (Gst.Caps) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Caps), true);
  				return ret;
  			}
  		}
  
  		[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gst_device_get_device_class(IntPtr raw);
  
  		[GLib.Property ("device-class")]
  		public string DeviceClass {
  			get  {
  				IntPtr raw_ret = gst_device_get_device_class(Handle);
  				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
  				return ret;
  			}
  		}
  
  		[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gst_device_get_display_name(IntPtr raw);
  
  		[GLib.Property ("display-name")]
  		public string DisplayName {
  			get  {
  				IntPtr raw_ret = gst_device_get_display_name(Handle);
  				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
  				return ret;
  			}
  		}
  
  		[DllImport("gstreamer-1.0-0.dll", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr gst_device_get_properties(IntPtr raw);
  
  		[GLib.Property ("properties")]
  		public Gst.Structure Properties {
  			get  {
  				IntPtr raw_ret = gst_device_get_properties(Handle);
  				Gst.Structure ret = raw_ret == IntPtr.Zero ? null : (Gst.Structure) GLib.Opaque.GetOpaque (raw_ret, typeof (Gst.Structure), true);
  				return ret;
  			}
  		}
  
  		[GLib.Signal("removed")]
  		public event System.EventHandler Removed {
  			add {
  				this.AddSignalHandler ("removed", value);
  			}
  			remove {
  				this.RemoveSignalHandler ("removed", value);
  			}
  		}
  
  		static RemovedNativeDelegate Removed_cb_delegate;
  		static RemovedNativeDelegate RemovedVMCallback {
  			get {
  				if (Removed_cb_delegate == null)
  					Removed_cb_delegate = new RemovedNativeDelegate (Removed_cb);
  				return Removed_cb_delegate;
  			}
  		}
  
  		static void OverrideRemoved (GLib.GType gtype)
  		{
  			OverrideRemoved (gtype, RemovedVMCallback);
  		}
  
  		static void OverrideRemoved (GLib.GType gtype, RemovedNativeDelegate callback)
  		{
  			OverrideVirtualMethod (gtype, "removed", callback);
  		}
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void RemovedNativeDelegate (IntPtr inst);
  
  		static void Removed_cb (IntPtr inst)
  		{
  			try {
  				Device __obj = GLib.Object.GetObject (inst, false) as Device;
  				__obj.OnRemoved ();
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Device), ConnectionMethod="OverrideRemoved")]
  		protected virtual void OnRemoved ()
  		{
  			InternalRemoved ();
  		}
  
  		private void InternalRemoved ()
  		{
  			GLib.Value ret = GLib.Value.Empty;
  			GLib.ValueArray inst_and_params = new GLib.ValueArray (1);
  			GLib.Value[] vals = new GLib.Value [1];
  			vals [0] = new GLib.Value (this);
  			inst_and_params.Append (vals [0]);
  			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
  			foreach (GLib.Value v in vals)
  				v.Dispose ();
  		}
  
  		static CreateElementNativeDelegate CreateElement_cb_delegate;
  		static CreateElementNativeDelegate CreateElementVMCallback {
  			get {
  				if (CreateElement_cb_delegate == null)
  					CreateElement_cb_delegate = new CreateElementNativeDelegate (CreateElement_cb);
  				return CreateElement_cb_delegate;
  			}
  		}
  
  		static void OverrideCreateElement (GLib.GType gtype)
  		{
  			OverrideCreateElement (gtype, CreateElementVMCallback);
  		}
  
  		static void OverrideCreateElement (GLib.GType gtype, CreateElementNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("create_element"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate IntPtr CreateElementNativeDelegate (IntPtr inst, IntPtr name);
  
  		static IntPtr CreateElement_cb (IntPtr inst, IntPtr name)
  		{
  			try {
  				Device __obj = GLib.Object.GetObject (inst, false) as Device;
  				Gst.Element __result;
  				__result = __obj.OnCreateElement (GLib.Marshaller.Utf8PtrToString (name));
  				return __result == null ? IntPtr.Zero : __result.Handle;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Device), ConnectionMethod="OverrideCreateElement")]
  		protected virtual Gst.Element OnCreateElement (string name)
  		{
  			return InternalCreateElement (name);
  		}
  
  		private Gst.Element InternalCreateElement (string name)
  		{
  			CreateElementNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("create_element"));
  				unmanaged = (CreateElementNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(CreateElementNativeDelegate));
  			}
  			if (unmanaged == null) return null;
  
  			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
  			IntPtr __result = unmanaged (this.Handle, native_name);
  			GLib.Marshaller.Free (native_name);
  			return GLib.Object.GetObject(__result) as Gst.Element;
  		}
  
  		static ReconfigureElementNativeDelegate ReconfigureElement_cb_delegate;
  		static ReconfigureElementNativeDelegate ReconfigureElementVMCallback {
  			get {
  				if (ReconfigureElement_cb_delegate == null)
  					ReconfigureElement_cb_delegate = new ReconfigureElementNativeDelegate (ReconfigureElement_cb);
  				return ReconfigureElement_cb_delegate;
  			}
  		}
  
  		static void OverrideReconfigureElement (GLib.GType gtype)
  		{
  			OverrideReconfigureElement (gtype, ReconfigureElementVMCallback);
  		}
  
  		static void OverrideReconfigureElement (GLib.GType gtype, ReconfigureElementNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("reconfigure_element"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool ReconfigureElementNativeDelegate (IntPtr inst, IntPtr element);
  
  		static bool ReconfigureElement_cb (IntPtr inst, IntPtr element)
  		{
  			try {
  				Device __obj = GLib.Object.GetObject (inst, false) as Device;
  				bool __result;
  				__result = __obj.OnReconfigureElement (GLib.Object.GetObject(element) as Gst.Element);
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(Gst.Device), ConnectionMethod="OverrideReconfigureElement")]
  		protected virtual bool OnReconfigureElement (Gst.Element element)
  		{
  			return InternalReconfigureElement (element);
  		}
  
  		private bool InternalReconfigureElement (Gst.Element element)
  		{
  			ReconfigureElementNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("reconfigure_element"));
  				unmanaged = (ReconfigureElementNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ReconfigureElementNativeDelegate));
  			}
  
gt: 			if (unmanaged == null) return false;