context: // This file was generated by the Gtk# code generator.
  // Any changes made will be lost if regenerated.
  
  namespace GES {
  
  	using System;
  	using System.Collections;
  	using System.Collections.Generic;
  	using System.Runtime.InteropServices;
  
  #region Autogenerated code
  	public partial class TimelineElement : GLib.InitiallyUnowned, GES.IExtractable, GES.IMetaContainer {
  
  		protected TimelineElement (IntPtr raw) : base(raw) {}
  
  		protected TimelineElement() : base(IntPtr.Zero)
  		{
  			CreateNativeObject (new string [0], new GLib.Value [0]);
  		}
  
  		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
  		static extern ulong ges_timeline_element_get_duration(IntPtr raw);
  
  		[GLib.Property ("duration")]
  		public ulong Duration {
  			get  {
  				ulong raw_ret = ges_timeline_element_get_duration(Handle);
  				ulong ret = raw_ret;
  				return ret;
  			}
  			set {
  				GLib.Value val = new GLib.Value(value);
  				SetProperty("duration", val);
  				val.Dispose ();
  			}
  		}
  
  		[GLib.Property ("in-point")]
  		public ulong InPoint {
  			get {
  				GLib.Value val = GetProperty ("in-point");
  				ulong ret = (ulong) val;
  				val.Dispose ();
  				return ret;
  			}
  			set {
  				GLib.Value val = new GLib.Value(value);
  				SetProperty("in-point", val);
  				val.Dispose ();
  			}
  		}
  
  		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
  		static extern ulong ges_timeline_element_get_max_duration(IntPtr raw);
  
  		[GLib.Property ("max-duration")]
  		public ulong MaxDuration {
  			get  {
  				ulong raw_ret = ges_timeline_element_get_max_duration(Handle);
  				ulong ret = raw_ret;
  				return ret;
  			}
  			set {
  				GLib.Value val = new GLib.Value(value);
  				SetProperty("max-duration", val);
  				val.Dispose ();
  			}
  		}
  
  		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr ges_timeline_element_get_name(IntPtr raw);
  
  		[GLib.Property ("name")]
  		public string Name {
  			get  {
  				IntPtr raw_ret = ges_timeline_element_get_name(Handle);
  				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
  				return ret;
  			}
  			set {
  				GLib.Value val = new GLib.Value(value);
  				SetProperty("name", val);
  				val.Dispose ();
  			}
  		}
  
  		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr ges_timeline_element_get_parent(IntPtr raw);
  
  		[GLib.Property ("parent")]
  		public GES.TimelineElement Parent {
  			get  {
  				IntPtr raw_ret = ges_timeline_element_get_parent(Handle);
  				GES.TimelineElement ret = GLib.Object.GetObject(raw_ret, true) as GES.TimelineElement;
  				return ret;
  			}
  			set {
  				GLib.Value val = new GLib.Value(value);
  				SetProperty("parent", val);
  				val.Dispose ();
  			}
  		}
  
  		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
  		static extern uint ges_timeline_element_get_priority(IntPtr raw);
  
  		[Obsolete]
  		[GLib.Property ("priority")]
  		public uint Priority {
  			get  {
  				uint raw_ret = ges_timeline_element_get_priority(Handle);
  				uint ret = raw_ret;
  				return ret;
  			}
  			set {
  				GLib.Value val = new GLib.Value(value);
  				SetProperty("priority", val);
  				val.Dispose ();
  			}
  		}
  
  		[GLib.Property ("serialize")]
  		public bool Serialize {
  			get {
  				GLib.Value val = GetProperty ("serialize");
  				bool ret = (bool) val;
  				val.Dispose ();
  				return ret;
  			}
  			set {
  				GLib.Value val = new GLib.Value(value);
  				SetProperty("serialize", val);
  				val.Dispose ();
  			}
  		}
  
  		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
  		static extern ulong ges_timeline_element_get_start(IntPtr raw);
  
  		[GLib.Property ("start")]
  		public ulong Start {
  			get  {
  				ulong raw_ret = ges_timeline_element_get_start(Handle);
  				ulong ret = raw_ret;
  				return ret;
  			}
  			set {
  				GLib.Value val = new GLib.Value(value);
  				SetProperty("start", val);
  				val.Dispose ();
  			}
  		}
  
  		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
  		static extern IntPtr ges_timeline_element_get_timeline(IntPtr raw);
  
  		[GLib.Property ("timeline")]
  		public GES.Timeline Timeline {
  			get  {
  				IntPtr raw_ret = ges_timeline_element_get_timeline(Handle);
  				GES.Timeline ret = GLib.Object.GetObject(raw_ret, true) as GES.Timeline;
  				return ret;
  			}
  			set {
  				GLib.Value val = new GLib.Value(value);
  				SetProperty("timeline", val);
  				val.Dispose ();
  			}
  		}
  
  		public ulong StartField {
  			get {
  				unsafe {
  					ulong* raw_ptr = (ulong*)(((byte*)Handle) + abi_info.GetFieldOffset("start"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
  		static extern ulong ges_timeline_element_get_inpoint(IntPtr raw);
  
  		public ulong Inpoint {
  			get  {
  				ulong raw_ret = ges_timeline_element_get_inpoint(Handle);
  				ulong ret = raw_ret;
  				return ret;
  			}
  		}
  
  		public ulong DurationField {
  			get {
  				unsafe {
  					ulong* raw_ptr = (ulong*)(((byte*)Handle) + abi_info.GetFieldOffset("duration"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public ulong Maxduration {
  			get {
  				unsafe {
  					ulong* raw_ptr = (ulong*)(((byte*)Handle) + abi_info.GetFieldOffset("maxduration"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public uint PriorityField {
  			get {
  				unsafe {
  					uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("priority"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public GES.Timeline TimelineField {
  			get {
  				unsafe {
  					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("timeline"));
  					return GLib.Object.GetObject((*raw_ptr)) as GES.Timeline;
  				}
  			}
  		}
  
  		public string NameField {
  			get {
  				unsafe {
  					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("name"));
  					return GLib.Marshaller.Utf8PtrToString ((*raw_ptr));
  				}
  			}
  		}
  
  		[GLib.Signal("child-property-removed")]
  		public event GES.ChildPropertyRemovedHandler ChildPropertyRemoved {
  			add {
  				this.AddSignalHandler ("child-property-removed", value, typeof (GES.ChildPropertyRemovedArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("child-property-removed", value);
  			}
  		}
  
  		[GLib.Signal("deep-notify")]
  		public event GES.DeepNotifyHandler DeepNotify {
  			add {
  				this.AddSignalHandler ("deep-notify", value, typeof (GES.DeepNotifyArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("deep-notify", value);
  			}
  		}
  
  		[GLib.Signal("child-property-added")]
  		public event GES.ChildPropertyAddedHandler ChildPropertyAdded {
  			add {
  				this.AddSignalHandler ("child-property-added", value, typeof (GES.ChildPropertyAddedArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("child-property-added", value);
  			}
  		}
  
  		static ChildPropertyAddedNativeDelegate ChildPropertyAdded_cb_delegate;
  		static ChildPropertyAddedNativeDelegate ChildPropertyAddedVMCallback {
  			get {
  				if (ChildPropertyAdded_cb_delegate == null)
  					ChildPropertyAdded_cb_delegate = new ChildPropertyAddedNativeDelegate (ChildPropertyAdded_cb);
  				return ChildPropertyAdded_cb_delegate;
  			}
  		}
  
  		static void OverrideChildPropertyAdded (GLib.GType gtype)
  		{
  			OverrideChildPropertyAdded (gtype, ChildPropertyAddedVMCallback);
  		}
  
  		static void OverrideChildPropertyAdded (GLib.GType gtype, ChildPropertyAddedNativeDelegate callback)
  		{
  			OverrideVirtualMethod (gtype, "child-property-added", callback);
  		}
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void ChildPropertyAddedNativeDelegate (IntPtr inst, IntPtr prop_object, IntPtr prop);
  
  		static void ChildPropertyAdded_cb (IntPtr inst, IntPtr prop_object, IntPtr prop)
  		{
  			try {
  				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
  				__obj.OnChildPropertyAdded (GLib.Object.GetObject (prop_object), prop);
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideChildPropertyAdded")]
  		protected virtual void OnChildPropertyAdded (GLib.Object prop_object, IntPtr prop)
  		{
  			InternalChildPropertyAdded (prop_object, prop);
  		}
  
  		private void InternalChildPropertyAdded (GLib.Object prop_object, IntPtr prop)
  		{
  			GLib.Value ret = GLib.Value.Empty;
  			GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
  			GLib.Value[] vals = new GLib.Value [3];
  			vals [0] = new GLib.Value (this);
  			inst_and_params.Append (vals [0]);
  			vals [1] = new GLib.Value (prop_object);
  			inst_and_params.Append (vals [1]);
  			vals [2] = new GLib.Value (prop);
  			inst_and_params.Append (vals [2]);
  			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
  			foreach (GLib.Value v in vals)
  				v.Dispose ();
  		}
  
  		static ChildPropertyRemovedNativeDelegate ChildPropertyRemoved_cb_delegate;
  		static ChildPropertyRemovedNativeDelegate ChildPropertyRemovedVMCallback {
  			get {
  				if (ChildPropertyRemoved_cb_delegate == null)
  					ChildPropertyRemoved_cb_delegate = new ChildPropertyRemovedNativeDelegate (ChildPropertyRemoved_cb);
  				return ChildPropertyRemoved_cb_delegate;
  			}
  		}
  
  		static void OverrideChildPropertyRemoved (GLib.GType gtype)
  		{
  			OverrideChildPropertyRemoved (gtype, ChildPropertyRemovedVMCallback);
  		}
  
  		static void OverrideChildPropertyRemoved (GLib.GType gtype, ChildPropertyRemovedNativeDelegate callback)
  		{
  			OverrideVirtualMethod (gtype, "child-property-removed", callback);
  		}
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void ChildPropertyRemovedNativeDelegate (IntPtr inst, IntPtr prop_object, IntPtr prop);
  
  		static void ChildPropertyRemoved_cb (IntPtr inst, IntPtr prop_object, IntPtr prop)
  		{
  			try {
  				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
  				__obj.OnChildPropertyRemoved (GLib.Object.GetObject (prop_object), prop);
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideChildPropertyRemoved")]
  		protected virtual void OnChildPropertyRemoved (GLib.Object prop_object, IntPtr prop)
  		{
  			InternalChildPropertyRemoved (prop_object, prop);
  		}
  
  		private void InternalChildPropertyRemoved (GLib.Object prop_object, IntPtr prop)
  		{
  			GLib.Value ret = GLib.Value.Empty;
  			GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
  			GLib.Value[] vals = new GLib.Value [3];
  			vals [0] = new GLib.Value (this);
  			inst_and_params.Append (vals [0]);
  			vals [1] = new GLib.Value (prop_object);
  			inst_and_params.Append (vals [1]);
  			vals [2] = new GLib.Value (prop);
  			inst_and_params.Append (vals [2]);
  			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
  			foreach (GLib.Value v in vals)
  				v.Dispose ();
  		}
  
  		static DeepNotifyNativeDelegate DeepNotify_cb_delegate;
  		static DeepNotifyNativeDelegate DeepNotifyVMCallback {
  			get {
  				if (DeepNotify_cb_delegate == null)
  					DeepNotify_cb_delegate = new DeepNotifyNativeDelegate (DeepNotify_cb);
  				return DeepNotify_cb_delegate;
  			}
  		}
  
  		static void OverrideDeepNotify (GLib.GType gtype)
  		{
  			OverrideDeepNotify (gtype, DeepNotifyVMCallback);
  		}
  
  		static void OverrideDeepNotify (GLib.GType gtype, DeepNotifyNativeDelegate callback)
  		{
  			OverrideVirtualMethod (gtype, "deep-notify", callback);
  		}
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void DeepNotifyNativeDelegate (IntPtr inst, IntPtr prop_object, IntPtr prop);
  
  		static void DeepNotify_cb (IntPtr inst, IntPtr prop_object, IntPtr prop)
  		{
  			try {
  				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
  				__obj.OnDeepNotify (GLib.Object.GetObject (prop_object), prop);
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideDeepNotify")]
  		protected virtual void OnDeepNotify (GLib.Object prop_object, IntPtr prop)
  		{
  			InternalDeepNotify (prop_object, prop);
  		}
  
  		private void InternalDeepNotify (GLib.Object prop_object, IntPtr prop)
  		{
  			GLib.Value ret = GLib.Value.Empty;
  			GLib.ValueArray inst_and_params = new GLib.ValueArray (3);
  			GLib.Value[] vals = new GLib.Value [3];
  			vals [0] = new GLib.Value (this);
  			inst_and_params.Append (vals [0]);
  			vals [1] = new GLib.Value (prop_object);
  			inst_and_params.Append (vals [1]);
  			vals [2] = new GLib.Value (prop);
  			inst_and_params.Append (vals [2]);
  			g_signal_chain_from_overridden (inst_and_params.ArrayPtr, ref ret);
  			foreach (GLib.Value v in vals)
  				v.Dispose ();
  		}
  
  		static SetParentNativeDelegate SetParent_cb_delegate;
  		static SetParentNativeDelegate SetParentVMCallback {
  			get {
  				if (SetParent_cb_delegate == null)
  					SetParent_cb_delegate = new SetParentNativeDelegate (SetParent_cb);
  				return SetParent_cb_delegate;
  			}
  		}
  
  		static void OverrideSetParent (GLib.GType gtype)
  		{
  			OverrideSetParent (gtype, SetParentVMCallback);
  		}
  
  		static void OverrideSetParent (GLib.GType gtype, SetParentNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_parent"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool SetParentNativeDelegate (IntPtr inst, IntPtr parent);
  
  		static bool SetParent_cb (IntPtr inst, IntPtr parent)
  		{
  			try {
  				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
  				bool __result;
  				__result = __obj.OnSetParent (GLib.Object.GetObject(parent) as GES.TimelineElement);
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideSetParent")]
  		protected virtual bool OnSetParent (GES.TimelineElement parent)
  		{
  			return InternalSetParent (parent);
  		}
  
  		private bool InternalSetParent (GES.TimelineElement parent)
  		{
  			SetParentNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_parent"));
  				unmanaged = (SetParentNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetParentNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle, parent == null ? IntPtr.Zero : parent.Handle);
  			return __result;
  		}
  
  		static SetStartNativeDelegate SetStart_cb_delegate;
  		static SetStartNativeDelegate SetStartVMCallback {
  			get {
  				if (SetStart_cb_delegate == null)
  					SetStart_cb_delegate = new SetStartNativeDelegate (SetStart_cb);
  				return SetStart_cb_delegate;
  			}
  		}
  
  		static void OverrideSetStart (GLib.GType gtype)
  		{
  			OverrideSetStart (gtype, SetStartVMCallback);
  		}
  
  		static void OverrideSetStart (GLib.GType gtype, SetStartNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_start"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool SetStartNativeDelegate (IntPtr inst, ulong start);
  
  		static bool SetStart_cb (IntPtr inst, ulong start)
  		{
  			try {
  				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
  				bool __result;
  				__result = __obj.OnSetStart (start);
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideSetStart")]
  		protected virtual bool OnSetStart (ulong start)
  		{
  			return InternalSetStart (start);
  		}
  
  		private bool InternalSetStart (ulong start)
  		{
  			SetStartNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_start"));
  				unmanaged = (SetStartNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetStartNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle, start);
  			return __result;
  		}
  
  		static SetInpointNativeDelegate SetInpoint_cb_delegate;
  		static SetInpointNativeDelegate SetInpointVMCallback {
  			get {
  				if (SetInpoint_cb_delegate == null)
  					SetInpoint_cb_delegate = new SetInpointNativeDelegate (SetInpoint_cb);
  				return SetInpoint_cb_delegate;
  			}
  		}
  
  		static void OverrideSetInpoint (GLib.GType gtype)
  		{
  			OverrideSetInpoint (gtype, SetInpointVMCallback);
  		}
  
  		static void OverrideSetInpoint (GLib.GType gtype, SetInpointNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_inpoint"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool SetInpointNativeDelegate (IntPtr inst, ulong inpoint);
  
  		static bool SetInpoint_cb (IntPtr inst, ulong inpoint)
  		{
  			try {
  				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
  				bool __result;
  				__result = __obj.OnSetInpoint (inpoint);
  				return __result;
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, true);
  				// NOTREACHED: above call does not return.
  				throw e;
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideSetInpoint")]
  		protected virtual bool OnSetInpoint (ulong inpoint)
  		{
  			return InternalSetInpoint (inpoint);
  		}
  
  		private bool InternalSetInpoint (ulong inpoint)
  		{
  			SetInpointNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_inpoint"));
  				unmanaged = (SetInpointNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetInpointNativeDelegate));
  			}
  
gt: 			if (unmanaged == null) return false;