subprojects/gstreamer-sharp/ges/generated/GES/TimelineElement.cs

// 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));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, inpoint);
			return __result;
		}

		static SetDurationNativeDelegate SetDuration_cb_delegate;
		static SetDurationNativeDelegate SetDurationVMCallback {
			get {
				if (SetDuration_cb_delegate == null)
					SetDuration_cb_delegate = new SetDurationNativeDelegate (SetDuration_cb);
				return SetDuration_cb_delegate;
			}
		}

		static void OverrideSetDuration (GLib.GType gtype)
		{
			OverrideSetDuration (gtype, SetDurationVMCallback);
		}

		static void OverrideSetDuration (GLib.GType gtype, SetDurationNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_duration"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetDurationNativeDelegate (IntPtr inst, ulong duration);

		static bool SetDuration_cb (IntPtr inst, ulong duration)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				__result = __obj.OnSetDuration (duration);
				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="OverrideSetDuration")]
		protected virtual bool OnSetDuration (ulong duration)
		{
			return InternalSetDuration (duration);
		}

		private bool InternalSetDuration (ulong duration)
		{
			SetDurationNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_duration"));
				unmanaged = (SetDurationNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetDurationNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, duration);
			return __result;
		}

		static SetMaxDurationNativeDelegate SetMaxDuration_cb_delegate;
		static SetMaxDurationNativeDelegate SetMaxDurationVMCallback {
			get {
				if (SetMaxDuration_cb_delegate == null)
					SetMaxDuration_cb_delegate = new SetMaxDurationNativeDelegate (SetMaxDuration_cb);
				return SetMaxDuration_cb_delegate;
			}
		}

		static void OverrideSetMaxDuration (GLib.GType gtype)
		{
			OverrideSetMaxDuration (gtype, SetMaxDurationVMCallback);
		}

		static void OverrideSetMaxDuration (GLib.GType gtype, SetMaxDurationNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_max_duration"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetMaxDurationNativeDelegate (IntPtr inst, ulong maxduration);

		static bool SetMaxDuration_cb (IntPtr inst, ulong maxduration)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				__result = __obj.OnSetMaxDuration (maxduration);
				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="OverrideSetMaxDuration")]
		protected virtual bool OnSetMaxDuration (ulong maxduration)
		{
			return InternalSetMaxDuration (maxduration);
		}

		private bool InternalSetMaxDuration (ulong maxduration)
		{
			SetMaxDurationNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_max_duration"));
				unmanaged = (SetMaxDurationNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetMaxDurationNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, maxduration);
			return __result;
		}

		static SetPriorityNativeDelegate SetPriority_cb_delegate;
		static SetPriorityNativeDelegate SetPriorityVMCallback {
			get {
				if (SetPriority_cb_delegate == null)
					SetPriority_cb_delegate = new SetPriorityNativeDelegate (SetPriority_cb);
				return SetPriority_cb_delegate;
			}
		}

		static void OverrideSetPriority (GLib.GType gtype)
		{
			OverrideSetPriority (gtype, SetPriorityVMCallback);
		}

		static void OverrideSetPriority (GLib.GType gtype, SetPriorityNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_priority"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetPriorityNativeDelegate (IntPtr inst, uint priority);

		static bool SetPriority_cb (IntPtr inst, uint priority)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				__result = __obj.OnSetPriority (priority);
				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="OverrideSetPriority")]
		protected virtual bool OnSetPriority (uint priority)
		{
			return InternalSetPriority (priority);
		}

		private bool InternalSetPriority (uint priority)
		{
			SetPriorityNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_priority"));
				unmanaged = (SetPriorityNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetPriorityNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, priority);
			return __result;
		}

		static RippleNativeDelegate Ripple_cb_delegate;
		static RippleNativeDelegate RippleVMCallback {
			get {
				if (Ripple_cb_delegate == null)
					Ripple_cb_delegate = new RippleNativeDelegate (Ripple_cb);
				return Ripple_cb_delegate;
			}
		}

		static void OverrideRipple (GLib.GType gtype)
		{
			OverrideRipple (gtype, RippleVMCallback);
		}

		static void OverrideRipple (GLib.GType gtype, RippleNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("ripple"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool RippleNativeDelegate (IntPtr inst, ulong start);

		static bool Ripple_cb (IntPtr inst, ulong start)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				__result = __obj.OnRipple (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="OverrideRipple")]
		protected virtual bool OnRipple (ulong start)
		{
			return InternalRipple (start);
		}

		private bool InternalRipple (ulong start)
		{
			RippleNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("ripple"));
				unmanaged = (RippleNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RippleNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, start);
			return __result;
		}

		static RippleEndNativeDelegate RippleEnd_cb_delegate;
		static RippleEndNativeDelegate RippleEndVMCallback {
			get {
				if (RippleEnd_cb_delegate == null)
					RippleEnd_cb_delegate = new RippleEndNativeDelegate (RippleEnd_cb);
				return RippleEnd_cb_delegate;
			}
		}

		static void OverrideRippleEnd (GLib.GType gtype)
		{
			OverrideRippleEnd (gtype, RippleEndVMCallback);
		}

		static void OverrideRippleEnd (GLib.GType gtype, RippleEndNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("ripple_end"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool RippleEndNativeDelegate (IntPtr inst, ulong end);

		static bool RippleEnd_cb (IntPtr inst, ulong end)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				__result = __obj.OnRippleEnd (end);
				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="OverrideRippleEnd")]
		protected virtual bool OnRippleEnd (ulong end)
		{
			return InternalRippleEnd (end);
		}

		private bool InternalRippleEnd (ulong end)
		{
			RippleEndNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("ripple_end"));
				unmanaged = (RippleEndNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RippleEndNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, end);
			return __result;
		}

		static RollStartNativeDelegate RollStart_cb_delegate;
		static RollStartNativeDelegate RollStartVMCallback {
			get {
				if (RollStart_cb_delegate == null)
					RollStart_cb_delegate = new RollStartNativeDelegate (RollStart_cb);
				return RollStart_cb_delegate;
			}
		}

		static void OverrideRollStart (GLib.GType gtype)
		{
			OverrideRollStart (gtype, RollStartVMCallback);
		}

		static void OverrideRollStart (GLib.GType gtype, RollStartNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("roll_start"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool RollStartNativeDelegate (IntPtr inst, ulong start);

		static bool RollStart_cb (IntPtr inst, ulong start)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				__result = __obj.OnRollStart (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="OverrideRollStart")]
		protected virtual bool OnRollStart (ulong start)
		{
			return InternalRollStart (start);
		}

		private bool InternalRollStart (ulong start)
		{
			RollStartNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("roll_start"));
				unmanaged = (RollStartNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RollStartNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, start);
			return __result;
		}

		static RollEndNativeDelegate RollEnd_cb_delegate;
		static RollEndNativeDelegate RollEndVMCallback {
			get {
				if (RollEnd_cb_delegate == null)
					RollEnd_cb_delegate = new RollEndNativeDelegate (RollEnd_cb);
				return RollEnd_cb_delegate;
			}
		}

		static void OverrideRollEnd (GLib.GType gtype)
		{
			OverrideRollEnd (gtype, RollEndVMCallback);
		}

		static void OverrideRollEnd (GLib.GType gtype, RollEndNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("roll_end"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool RollEndNativeDelegate (IntPtr inst, ulong end);

		static bool RollEnd_cb (IntPtr inst, ulong end)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				__result = __obj.OnRollEnd (end);
				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="OverrideRollEnd")]
		protected virtual bool OnRollEnd (ulong end)
		{
			return InternalRollEnd (end);
		}

		private bool InternalRollEnd (ulong end)
		{
			RollEndNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("roll_end"));
				unmanaged = (RollEndNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(RollEndNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, end);
			return __result;
		}

		static TrimNativeDelegate Trim_cb_delegate;
		static TrimNativeDelegate TrimVMCallback {
			get {
				if (Trim_cb_delegate == null)
					Trim_cb_delegate = new TrimNativeDelegate (Trim_cb);
				return Trim_cb_delegate;
			}
		}

		static void OverrideTrim (GLib.GType gtype)
		{
			OverrideTrim (gtype, TrimVMCallback);
		}

		static void OverrideTrim (GLib.GType gtype, TrimNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("trim"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool TrimNativeDelegate (IntPtr inst, ulong start);

		static bool Trim_cb (IntPtr inst, ulong start)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				__result = __obj.OnTrim (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="OverrideTrim")]
		protected virtual bool OnTrim (ulong start)
		{
			return InternalTrim (start);
		}

		private bool InternalTrim (ulong start)
		{
			TrimNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("trim"));
				unmanaged = (TrimNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(TrimNativeDelegate));
			}
			if (unmanaged == null) return false;

			bool __result = unmanaged (this.Handle, start);
			return __result;
		}

		static DeepCopyNativeDelegate DeepCopy_cb_delegate;
		static DeepCopyNativeDelegate DeepCopyVMCallback {
			get {
				if (DeepCopy_cb_delegate == null)
					DeepCopy_cb_delegate = new DeepCopyNativeDelegate (DeepCopy_cb);
				return DeepCopy_cb_delegate;
			}
		}

		static void OverrideDeepCopy (GLib.GType gtype)
		{
			OverrideDeepCopy (gtype, DeepCopyVMCallback);
		}

		static void OverrideDeepCopy (GLib.GType gtype, DeepCopyNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("deep_copy"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void DeepCopyNativeDelegate (IntPtr inst, IntPtr copy);

		static void DeepCopy_cb (IntPtr inst, IntPtr copy)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				__obj.OnDeepCopy (GLib.Object.GetObject(copy) as GES.TimelineElement);
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideDeepCopy")]
		protected virtual void OnDeepCopy (GES.TimelineElement copy)
		{
			InternalDeepCopy (copy);
		}

		private void InternalDeepCopy (GES.TimelineElement copy)
		{
			DeepCopyNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("deep_copy"));
				unmanaged = (DeepCopyNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(DeepCopyNativeDelegate));
			}
			if (unmanaged == null) return;

			unmanaged (this.Handle, copy == null ? IntPtr.Zero : copy.Handle);
		}

		static LookupChildNativeDelegate LookupChild_cb_delegate;
		static LookupChildNativeDelegate LookupChildVMCallback {
			get {
				if (LookupChild_cb_delegate == null)
					LookupChild_cb_delegate = new LookupChildNativeDelegate (LookupChild_cb);
				return LookupChild_cb_delegate;
			}
		}

		static void OverrideLookupChild (GLib.GType gtype)
		{
			OverrideLookupChild (gtype, LookupChildVMCallback);
		}

		static void OverrideLookupChild (GLib.GType gtype, LookupChildNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("lookup_child"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool LookupChildNativeDelegate (IntPtr inst, IntPtr prop_name, out IntPtr child, out IntPtr pspec);

		static bool LookupChild_cb (IntPtr inst, IntPtr prop_name, out IntPtr child, out IntPtr pspec)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				GLib.Object mychild;
				__result = __obj.OnLookupChild (GLib.Marshaller.Utf8PtrToString (prop_name), out mychild, out pspec);
				child = mychild == null ? IntPtr.Zero : mychild.Handle;
				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="OverrideLookupChild")]
		protected virtual bool OnLookupChild (string prop_name, out GLib.Object child, out IntPtr pspec)
		{
			return InternalLookupChild (prop_name, out child, out pspec);
		}

		private bool InternalLookupChild (string prop_name, out GLib.Object child, out IntPtr pspec)
		{
			LookupChildNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("lookup_child"));
				unmanaged = (LookupChildNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(LookupChildNativeDelegate));
			}
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			IntPtr native_prop_name = GLib.Marshaller.StringToPtrGStrdup (prop_name);
			IntPtr native_child;
			bool __result = unmanaged (this.Handle, native_prop_name, out native_child, out pspec);
			GLib.Marshaller.Free (native_prop_name);
			child = GLib.Object.GetObject (native_child);
			return __result;
		}

		static GetTrackTypesNativeDelegate GetTrackTypes_cb_delegate;
		static GetTrackTypesNativeDelegate GetTrackTypesVMCallback {
			get {
				if (GetTrackTypes_cb_delegate == null)
					GetTrackTypes_cb_delegate = new GetTrackTypesNativeDelegate (GetTrackTypes_cb);
				return GetTrackTypes_cb_delegate;
			}
		}

		static void OverrideGetTrackTypes (GLib.GType gtype)
		{
			OverrideGetTrackTypes (gtype, GetTrackTypesVMCallback);
		}

		static void OverrideGetTrackTypes (GLib.GType gtype, GetTrackTypesNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_track_types"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate int GetTrackTypesNativeDelegate (IntPtr inst);

		static int GetTrackTypes_cb (IntPtr inst)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				GES.TrackType __result;
				__result = __obj.OnGetTrackTypes ();
				return (int) __result;
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, true);
				// NOTREACHED: above call does not return.
				throw e;
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideGetTrackTypes")]
		protected virtual GES.TrackType OnGetTrackTypes ()
		{
			return InternalGetTrackTypes ();
		}

		private GES.TrackType InternalGetTrackTypes ()
		{
			GetTrackTypesNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_track_types"));
				unmanaged = (GetTrackTypesNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetTrackTypesNativeDelegate));
			}
			if (unmanaged == null) return (GES.TrackType) 0;

			int __result = unmanaged (this.Handle);
			return (GES.TrackType) __result;
		}

		static SetChildPropertyNativeDelegate SetChildProperty_cb_delegate;
		static SetChildPropertyNativeDelegate SetChildPropertyVMCallback {
			get {
				if (SetChildProperty_cb_delegate == null)
					SetChildProperty_cb_delegate = new SetChildPropertyNativeDelegate (SetChildProperty_cb);
				return SetChildProperty_cb_delegate;
			}
		}

		static void OverrideSetChildProperty (GLib.GType gtype)
		{
			OverrideSetChildProperty (gtype, SetChildPropertyVMCallback);
		}

		static void OverrideSetChildProperty (GLib.GType gtype, SetChildPropertyNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_child_property"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void SetChildPropertyNativeDelegate (IntPtr inst, IntPtr child, IntPtr pspec, IntPtr value);

		static void SetChildProperty_cb (IntPtr inst, IntPtr child, IntPtr pspec, IntPtr value)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				__obj.OnSetChildProperty (GLib.Object.GetObject (child), pspec, (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value)));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideSetChildProperty")]
		protected virtual void OnSetChildProperty (GLib.Object child, IntPtr pspec, GLib.Value value)
		{
			InternalSetChildProperty (child, pspec, value);
		}

		private void InternalSetChildProperty (GLib.Object child, IntPtr pspec, GLib.Value value)
		{
			SetChildPropertyNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_child_property"));
				unmanaged = (SetChildPropertyNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetChildPropertyNativeDelegate));
			}
			if (unmanaged == null) return;

			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			unmanaged (this.Handle, child == null ? IntPtr.Zero : child.Handle, pspec, native_value);
			Marshal.FreeHGlobal (native_value);
		}

		static GetLayerPriorityNativeDelegate GetLayerPriority_cb_delegate;
		static GetLayerPriorityNativeDelegate GetLayerPriorityVMCallback {
			get {
				if (GetLayerPriority_cb_delegate == null)
					GetLayerPriority_cb_delegate = new GetLayerPriorityNativeDelegate (GetLayerPriority_cb);
				return GetLayerPriority_cb_delegate;
			}
		}

		static void OverrideGetLayerPriority (GLib.GType gtype)
		{
			OverrideGetLayerPriority (gtype, GetLayerPriorityVMCallback);
		}

		static void OverrideGetLayerPriority (GLib.GType gtype, GetLayerPriorityNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_layer_priority"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate uint GetLayerPriorityNativeDelegate (IntPtr inst);

		static uint GetLayerPriority_cb (IntPtr inst)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				uint __result;
				__result = __obj.OnGetLayerPriority ();
				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="OverrideGetLayerPriority")]
		protected virtual uint OnGetLayerPriority ()
		{
			return InternalGetLayerPriority ();
		}

		private uint InternalGetLayerPriority ()
		{
			GetLayerPriorityNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_layer_priority"));
				unmanaged = (GetLayerPriorityNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetLayerPriorityNativeDelegate));
			}
			if (unmanaged == null) return 0;

			uint __result = unmanaged (this.Handle);
			return __result;
		}

		static GetNaturalFramerateNativeDelegate GetNaturalFramerate_cb_delegate;
		static GetNaturalFramerateNativeDelegate GetNaturalFramerateVMCallback {
			get {
				if (GetNaturalFramerate_cb_delegate == null)
					GetNaturalFramerate_cb_delegate = new GetNaturalFramerateNativeDelegate (GetNaturalFramerate_cb);
				return GetNaturalFramerate_cb_delegate;
			}
		}

		static void OverrideGetNaturalFramerate (GLib.GType gtype)
		{
			OverrideGetNaturalFramerate (gtype, GetNaturalFramerateVMCallback);
		}

		static void OverrideGetNaturalFramerate (GLib.GType gtype, GetNaturalFramerateNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("get_natural_framerate"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool GetNaturalFramerateNativeDelegate (IntPtr inst, out int framerate_n, out int framerate_d);

		static bool GetNaturalFramerate_cb (IntPtr inst, out int framerate_n, out int framerate_d)
		{
			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				__result = __obj.OnGetNaturalFramerate (out framerate_n, out framerate_d);
				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="OverrideGetNaturalFramerate")]
		protected virtual bool OnGetNaturalFramerate (out int framerate_n, out int framerate_d)
		{
			return InternalGetNaturalFramerate (out framerate_n, out framerate_d);
		}

		private bool InternalGetNaturalFramerate (out int framerate_n, out int framerate_d)
		{
			GetNaturalFramerateNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("get_natural_framerate"));
				unmanaged = (GetNaturalFramerateNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(GetNaturalFramerateNativeDelegate));
			}
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			bool __result = unmanaged (this.Handle, out framerate_n, out framerate_d);
			return __result;
		}

		static SetChildPropertyFullNativeDelegate SetChildPropertyFull_cb_delegate;
		static SetChildPropertyFullNativeDelegate SetChildPropertyFullVMCallback {
			get {
				if (SetChildPropertyFull_cb_delegate == null)
					SetChildPropertyFull_cb_delegate = new SetChildPropertyFullNativeDelegate (SetChildPropertyFull_cb);
				return SetChildPropertyFull_cb_delegate;
			}
		}

		static void OverrideSetChildPropertyFull (GLib.GType gtype)
		{
			OverrideSetChildPropertyFull (gtype, SetChildPropertyFullVMCallback);
		}

		static void OverrideSetChildPropertyFull (GLib.GType gtype, SetChildPropertyFullNativeDelegate callback)
		{
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("set_child_property_full"));
				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
			}
		}

		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate bool SetChildPropertyFullNativeDelegate (IntPtr inst, IntPtr child, IntPtr pspec, IntPtr value, out IntPtr error);

		static bool SetChildPropertyFull_cb (IntPtr inst, IntPtr child, IntPtr pspec, IntPtr value, out IntPtr error)
		{
			error = IntPtr.Zero;

			try {
				TimelineElement __obj = GLib.Object.GetObject (inst, false) as TimelineElement;
				bool __result;
				__result = __obj.OnSetChildPropertyFull (GLib.Object.GetObject (child), pspec, (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value)));
				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="OverrideSetChildPropertyFull")]
		protected virtual bool OnSetChildPropertyFull (GLib.Object child, IntPtr pspec, GLib.Value value)
		{
			return InternalSetChildPropertyFull (child, pspec, value);
		}

		private bool InternalSetChildPropertyFull (GLib.Object child, IntPtr pspec, GLib.Value value)
		{
			SetChildPropertyFullNativeDelegate unmanaged = null;
			unsafe {
				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("set_child_property_full"));
				unmanaged = (SetChildPropertyFullNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(SetChildPropertyFullNativeDelegate));
			}
			if (unmanaged == null) throw new InvalidOperationException ("No base method to invoke");

			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			IntPtr error = IntPtr.Zero;
			bool __result = unmanaged (this.Handle, child == null ? IntPtr.Zero : child.Handle, pspec, native_value, out error);
			Marshal.FreeHGlobal (native_value);
			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("set_parent"
							, GLib.Object.class_abi.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_parent
							, null
							, "set_start"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_start"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_start
							, "set_parent"
							, "set_inpoint"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_inpoint"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_inpoint
							, "set_start"
							, "set_duration"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_duration"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_duration
							, "set_inpoint"
							, "set_max_duration"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_max_duration"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_max_duration
							, "set_duration"
							, "set_priority"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_priority"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_priority
							, "set_max_duration"
							, "ripple"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("ripple"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // ripple
							, "set_priority"
							, "ripple_end"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("ripple_end"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // ripple_end
							, "ripple"
							, "roll_start"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("roll_start"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // roll_start
							, "ripple_end"
							, "roll_end"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("roll_end"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // roll_end
							, "roll_start"
							, "trim"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("trim"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // trim
							, "roll_end"
							, "deep_copy"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("deep_copy"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // deep_copy
							, "trim"
							, "paste"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("paste"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // paste
							, "deep_copy"
							, "list_children_properties"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("list_children_properties"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // list_children_properties
							, "paste"
							, "lookup_child"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("lookup_child"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // lookup_child
							, "list_children_properties"
							, "get_track_types"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_track_types"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_track_types
							, "lookup_child"
							, "set_child_property"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_child_property"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_child_property
							, "get_track_types"
							, "get_layer_priority"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_layer_priority"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_layer_priority
							, "set_child_property"
							, "get_natural_framerate"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("get_natural_framerate"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // get_natural_framerate
							, "get_layer_priority"
							, "set_child_property_full"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("set_child_property_full"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // set_child_property_full
							, "get_natural_framerate"
							, "_ges_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_ges_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 14 // _ges_reserved
							, "set_child_property_full"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _class_abi;
			}
		}


		// End of the ABI representation.

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr ges_timeline_element_get_type();

		public static new GLib.GType GType { 
			get {
				IntPtr raw_ret = ges_timeline_element_get_type();
				GLib.GType ret = new GLib.GType(raw_ret);
				return ret;
			}
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_add_child_property(IntPtr raw, IntPtr pspec, IntPtr child);

		public bool AddChildProperty(IntPtr pspec, GLib.Object child) {
			bool raw_ret = ges_timeline_element_add_child_property(Handle, pspec, child == null ? IntPtr.Zero : child.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr ges_timeline_element_copy(IntPtr raw, bool deep);

		public GES.TimelineElement Copy(bool deep) {
			IntPtr raw_ret = ges_timeline_element_copy(Handle, deep);
			GES.TimelineElement ret = GLib.Object.GetObject(raw_ret) as GES.TimelineElement;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_edit(IntPtr raw, IntPtr layers, long new_layer_priority, int mode, int edge, ulong position);

		public bool Edit(GLib.List layers, long new_layer_priority, GES.EditMode mode, GES.Edge edge, ulong position) {
			bool raw_ret = ges_timeline_element_edit(Handle, layers == null ? IntPtr.Zero : layers.Handle, new_layer_priority, (int) mode, (int) edge, position);
			bool ret = raw_ret;
			return ret;
		}

		public bool Edit(long new_layer_priority, GES.EditMode mode, GES.Edge edge, ulong position) {
			return Edit (null, new_layer_priority, mode, edge, position);
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern unsafe bool ges_timeline_element_edit_full(IntPtr raw, long new_layer_priority, int mode, int edge, ulong position, out IntPtr error);

		public unsafe bool EditFull(long new_layer_priority, GES.EditMode mode, GES.Edge edge, ulong position) {
			IntPtr error = IntPtr.Zero;
			bool raw_ret = ges_timeline_element_edit_full(Handle, new_layer_priority, (int) mode, (int) edge, position, out error);
			bool ret = raw_ret;
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_get_child_property(IntPtr raw, IntPtr property_name, IntPtr value);

		public bool GetChildProperty(string property_name, out GLib.Value value) {
			IntPtr native_property_name = GLib.Marshaller.StringToPtrGStrdup (property_name);
			IntPtr native_value = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (GLib.Value)));
			bool raw_ret = ges_timeline_element_get_child_property(Handle, native_property_name, native_value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_property_name);
			value = (GLib.Value) Marshal.PtrToStructure (native_value, typeof (GLib.Value));
			Marshal.FreeHGlobal (native_value);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern void ges_timeline_element_get_child_property_by_pspec(IntPtr raw, IntPtr pspec, IntPtr value);

		public GLib.Value GetChildPropertyByPspec(IntPtr pspec) {
			GLib.Value value;
			IntPtr native_value = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (GLib.Value)));
			ges_timeline_element_get_child_property_by_pspec(Handle, pspec, native_value);
			value = (GLib.Value) Marshal.PtrToStructure (native_value, typeof (GLib.Value));
			Marshal.FreeHGlobal (native_value);
			return value;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern uint ges_timeline_element_get_layer_priority(IntPtr raw);

		public uint LayerPriority { 
			get {
				uint raw_ret = ges_timeline_element_get_layer_priority(Handle);
				uint ret = raw_ret;
				return ret;
			}
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_get_natural_framerate(IntPtr raw, out int framerate_n, out int framerate_d);

		public bool GetNaturalFramerate(out int framerate_n, out int framerate_d) {
			bool raw_ret = ges_timeline_element_get_natural_framerate(Handle, out framerate_n, out framerate_d);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr ges_timeline_element_get_toplevel_parent(IntPtr raw);

		public GES.TimelineElement ToplevelParent { 
			get {
				IntPtr raw_ret = ges_timeline_element_get_toplevel_parent(Handle);
				GES.TimelineElement ret = GLib.Object.GetObject(raw_ret, true) as GES.TimelineElement;
				return ret;
			}
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern int ges_timeline_element_get_track_types(IntPtr raw);

		public GES.TrackType TrackTypes { 
			get {
				int raw_ret = ges_timeline_element_get_track_types(Handle);
				GES.TrackType ret = (GES.TrackType) raw_ret;
				return ret;
			}
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_lookup_child(IntPtr raw, IntPtr prop_name, out IntPtr child, out IntPtr pspec);

		public bool LookupChild(string prop_name, out GLib.Object child, out IntPtr pspec) {
			IntPtr native_prop_name = GLib.Marshaller.StringToPtrGStrdup (prop_name);
			IntPtr native_child;
			bool raw_ret = ges_timeline_element_lookup_child(Handle, native_prop_name, out native_child, out pspec);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_prop_name);
			child = GLib.Object.GetObject (native_child);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr ges_timeline_element_paste(IntPtr raw, ulong paste_position);

		public GES.TimelineElement Paste(ulong paste_position) {
			IntPtr raw_ret = ges_timeline_element_paste(Handle, paste_position);
			GES.TimelineElement ret = GLib.Object.GetObject(raw_ret, true) as GES.TimelineElement;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_remove_child_property(IntPtr raw, IntPtr pspec);

		public bool RemoveChildProperty(IntPtr pspec) {
			bool raw_ret = ges_timeline_element_remove_child_property(Handle, pspec);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_ripple(IntPtr raw, ulong start);

		public bool Ripple(ulong start) {
			bool raw_ret = ges_timeline_element_ripple(Handle, start);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_ripple_end(IntPtr raw, ulong end);

		public bool RippleEnd(ulong end) {
			bool raw_ret = ges_timeline_element_ripple_end(Handle, end);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_roll_end(IntPtr raw, ulong end);

		public bool RollEnd(ulong end) {
			bool raw_ret = ges_timeline_element_roll_end(Handle, end);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_roll_start(IntPtr raw, ulong start);

		public bool RollStart(ulong start) {
			bool raw_ret = ges_timeline_element_roll_start(Handle, start);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_set_child_property(IntPtr raw, IntPtr property_name, IntPtr value);

		public bool SetChildProperty(string property_name, GLib.Value value) {
			IntPtr native_property_name = GLib.Marshaller.StringToPtrGStrdup (property_name);
			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			bool raw_ret = ges_timeline_element_set_child_property(Handle, native_property_name, native_value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_property_name);
			Marshal.FreeHGlobal (native_value);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern void ges_timeline_element_set_child_property_by_pspec(IntPtr raw, IntPtr pspec, IntPtr value);

		public void SetChildPropertyByPspec(IntPtr pspec, GLib.Value value) {
			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			ges_timeline_element_set_child_property_by_pspec(Handle, pspec, native_value);
			Marshal.FreeHGlobal (native_value);
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern unsafe bool ges_timeline_element_set_child_property_full(IntPtr raw, IntPtr property_name, IntPtr value, out IntPtr error);

		public unsafe bool SetChildPropertyFull(string property_name, GLib.Value value) {
			IntPtr native_property_name = GLib.Marshaller.StringToPtrGStrdup (property_name);
			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			IntPtr error = IntPtr.Zero;
			bool raw_ret = ges_timeline_element_set_child_property_full(Handle, native_property_name, native_value, out error);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_property_name);
			Marshal.FreeHGlobal (native_value);
			if (error != IntPtr.Zero) throw new GLib.GException (error);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_set_duration(IntPtr raw, ulong duration);

		public bool SetDuration(ulong duration) {
			bool raw_ret = ges_timeline_element_set_duration(Handle, duration);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_set_inpoint(IntPtr raw, ulong inpoint);

		public bool SetInpoint(ulong inpoint) {
			bool raw_ret = ges_timeline_element_set_inpoint(Handle, inpoint);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_set_max_duration(IntPtr raw, ulong maxduration);

		public bool SetMaxDuration(ulong maxduration) {
			bool raw_ret = ges_timeline_element_set_max_duration(Handle, maxduration);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_set_name(IntPtr raw, IntPtr name);

		public bool SetName(string name) {
			IntPtr native_name = GLib.Marshaller.StringToPtrGStrdup (name);
			bool raw_ret = ges_timeline_element_set_name(Handle, native_name);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_name);
			return ret;
		}

		public bool SetName() {
			return SetName (null);
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_set_parent(IntPtr raw, IntPtr parent);

		public bool SetParent(GES.TimelineElement parent) {
			bool raw_ret = ges_timeline_element_set_parent(Handle, parent == null ? IntPtr.Zero : parent.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_set_priority(IntPtr raw, uint priority);

		[Obsolete]
		public bool SetPriority(uint priority) {
			bool raw_ret = ges_timeline_element_set_priority(Handle, priority);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_set_start(IntPtr raw, ulong start);

		public bool SetStart(ulong start) {
			bool raw_ret = ges_timeline_element_set_start(Handle, start);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_set_timeline(IntPtr raw, IntPtr timeline);

		public bool SetTimeline(GES.Timeline timeline) {
			bool raw_ret = ges_timeline_element_set_timeline(Handle, timeline == null ? IntPtr.Zero : timeline.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_timeline_element_trim(IntPtr raw, ulong start);

		public bool Trim(ulong start) {
			bool raw_ret = ges_timeline_element_trim(Handle, start);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr ges_extractable_get_asset(IntPtr raw);

		public GES.Asset Asset { 
			get {
				IntPtr raw_ret = ges_extractable_get_asset(Handle);
				GES.Asset ret = GLib.Object.GetObject(raw_ret) as GES.Asset;
				return ret;
			}
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr ges_extractable_get_id(IntPtr raw);

		public string Id { 
			get {
				IntPtr raw_ret = ges_extractable_get_id(Handle);
				string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
				return ret;
			}
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_extractable_set_asset(IntPtr raw, IntPtr asset);

		public bool SetAsset(GES.Asset asset) {
			bool raw_ret = ges_extractable_set_asset(Handle, asset == null ? IntPtr.Zero : asset.Handle);
			bool ret = raw_ret;
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_add_metas_from_string(IntPtr raw, IntPtr str);

		public bool AddMetasFromString(string str) {
			IntPtr native_str = GLib.Marshaller.StringToPtrGStrdup (str);
			bool raw_ret = ges_meta_container_add_metas_from_string(Handle, native_str);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_str);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_check_meta_registered(IntPtr raw, IntPtr meta_item, out int flags, out IntPtr type);

		public bool CheckMetaRegistered(string meta_item, out GES.MetaFlag flags, out GLib.GType type) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			int native_flags;
			IntPtr native_type;
			bool raw_ret = ges_meta_container_check_meta_registered(Handle, native_meta_item, out native_flags, out native_type);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			flags = (GES.MetaFlag) native_flags;
			type = new GLib.GType(native_type);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern void ges_meta_container_foreach(IntPtr raw, GESSharp.MetaForeachFuncNative func, IntPtr user_data);

		public void Foreach(GES.MetaForeachFunc func) {
			GESSharp.MetaForeachFuncWrapper func_wrapper = new GESSharp.MetaForeachFuncWrapper (func);
			ges_meta_container_foreach(Handle, func_wrapper.NativeDelegate, IntPtr.Zero);
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_get_boolean(IntPtr raw, IntPtr meta_item, out bool dest);

		public bool GetBoolean(string meta_item, out bool dest) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_get_boolean(Handle, native_meta_item, out dest);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_get_date(IntPtr raw, IntPtr meta_item, out IntPtr dest);

		public bool GetDate(string meta_item, out GLib.Date dest) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			IntPtr native_dest;
			bool raw_ret = ges_meta_container_get_date(Handle, native_meta_item, out native_dest);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			dest = new GLib.Date(native_dest);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_get_date_time(IntPtr raw, IntPtr meta_item, out IntPtr dest);

		public bool GetDateTime(string meta_item, out Gst.DateTime dest) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			IntPtr native_dest;
			bool raw_ret = ges_meta_container_get_date_time(Handle, native_meta_item, out native_dest);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			dest = native_dest == IntPtr.Zero ? null : (Gst.DateTime) GLib.Opaque.GetOpaque (native_dest, typeof (Gst.DateTime), true);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_get_double(IntPtr raw, IntPtr meta_item, out double dest);

		public bool GetDouble(string meta_item, out double dest) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_get_double(Handle, native_meta_item, out dest);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_get_float(IntPtr raw, IntPtr meta_item, out float dest);

		public bool GetFloat(string meta_item, out float dest) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_get_float(Handle, native_meta_item, out dest);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_get_int(IntPtr raw, IntPtr meta_item, out int dest);

		public bool GetInt(string meta_item, out int dest) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_get_int(Handle, native_meta_item, out dest);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_get_int64(IntPtr raw, IntPtr meta_item, out long dest);

		public bool GetInt64(string meta_item, out long dest) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_get_int64(Handle, native_meta_item, out dest);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr ges_meta_container_get_marker_list(IntPtr raw, IntPtr key);

		public GES.MarkerList GetMarkerList(string key) {
			IntPtr native_key = GLib.Marshaller.StringToPtrGStrdup (key);
			IntPtr raw_ret = ges_meta_container_get_marker_list(Handle, native_key);
			GES.MarkerList ret = GLib.Object.GetObject(raw_ret, true) as GES.MarkerList;
			GLib.Marshaller.Free (native_key);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr ges_meta_container_get_meta(IntPtr raw, IntPtr key);

		public GLib.Value GetMeta(string key) {
			IntPtr native_key = GLib.Marshaller.StringToPtrGStrdup (key);
			IntPtr raw_ret = ges_meta_container_get_meta(Handle, native_key);
			GLib.Value ret = (GLib.Value) Marshal.PtrToStructure (raw_ret, typeof (GLib.Value));
			GLib.Marshaller.Free (native_key);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr ges_meta_container_get_string(IntPtr raw, IntPtr meta_item);

		public string GetString(string meta_item) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			IntPtr raw_ret = ges_meta_container_get_string(Handle, native_meta_item);
			string ret = GLib.Marshaller.Utf8PtrToString (raw_ret);
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_get_uint(IntPtr raw, IntPtr meta_item, out uint dest);

		public bool GetUint(string meta_item, out uint dest) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_get_uint(Handle, native_meta_item, out dest);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_get_uint64(IntPtr raw, IntPtr meta_item, out ulong dest);

		public bool GetUint64(string meta_item, out ulong dest) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_get_uint64(Handle, native_meta_item, out dest);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern IntPtr ges_meta_container_metas_to_string(IntPtr raw);

		public string MetasToString() {
			IntPtr raw_ret = ges_meta_container_metas_to_string(Handle);
			string ret = GLib.Marshaller.PtrToStringGFree(raw_ret);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta(IntPtr raw, int flags, IntPtr meta_item, IntPtr value);

		public bool RegisterMeta(GES.MetaFlag flags, string meta_item, GLib.Value value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			bool raw_ret = ges_meta_container_register_meta(Handle, (int) flags, native_meta_item, native_value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			Marshal.FreeHGlobal (native_value);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta_boolean(IntPtr raw, int flags, IntPtr meta_item, bool value);

		public bool RegisterMetaBoolean(GES.MetaFlag flags, string meta_item, bool value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_register_meta_boolean(Handle, (int) flags, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta_date(IntPtr raw, int flags, IntPtr meta_item, IntPtr value);

		public bool RegisterMetaDate(GES.MetaFlag flags, string meta_item, GLib.Date value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_register_meta_date(Handle, (int) flags, native_meta_item, value == null ? IntPtr.Zero : value.Handle);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta_date_time(IntPtr raw, int flags, IntPtr meta_item, IntPtr value);

		public bool RegisterMetaDateTime(GES.MetaFlag flags, string meta_item, Gst.DateTime value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_register_meta_date_time(Handle, (int) flags, native_meta_item, value == null ? IntPtr.Zero : value.Handle);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta_double(IntPtr raw, int flags, IntPtr meta_item, double value);

		public bool RegisterMetaDouble(GES.MetaFlag flags, string meta_item, double value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_register_meta_double(Handle, (int) flags, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta_float(IntPtr raw, int flags, IntPtr meta_item, float value);

		public bool RegisterMetaFloat(GES.MetaFlag flags, string meta_item, float value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_register_meta_float(Handle, (int) flags, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta_int(IntPtr raw, int flags, IntPtr meta_item, int value);

		public bool RegisterMetaInt(GES.MetaFlag flags, string meta_item, int value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_register_meta_int(Handle, (int) flags, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta_int64(IntPtr raw, int flags, IntPtr meta_item, long value);

		public bool RegisterMetaInt64(GES.MetaFlag flags, string meta_item, long value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_register_meta_int64(Handle, (int) flags, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta_string(IntPtr raw, int flags, IntPtr meta_item, IntPtr value);

		public bool RegisterMetaString(GES.MetaFlag flags, string meta_item, string value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
			bool raw_ret = ges_meta_container_register_meta_string(Handle, (int) flags, native_meta_item, native_value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			GLib.Marshaller.Free (native_value);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta_uint(IntPtr raw, int flags, IntPtr meta_item, uint value);

		public bool RegisterMetaUint(GES.MetaFlag flags, string meta_item, uint value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_register_meta_uint(Handle, (int) flags, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_meta_uint64(IntPtr raw, int flags, IntPtr meta_item, ulong value);

		public bool RegisterMetaUint64(GES.MetaFlag flags, string meta_item, ulong value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_register_meta_uint64(Handle, (int) flags, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_register_static_meta(IntPtr raw, int flags, IntPtr meta_item, IntPtr type);

		public bool RegisterStaticMeta(GES.MetaFlag flags, string meta_item, GLib.GType type) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_register_static_meta(Handle, (int) flags, native_meta_item, type.Val);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_boolean(IntPtr raw, IntPtr meta_item, bool value);

		public bool SetBoolean(string meta_item, bool value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_set_boolean(Handle, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_date(IntPtr raw, IntPtr meta_item, IntPtr value);

		public bool SetDate(string meta_item, GLib.Date value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_set_date(Handle, native_meta_item, value == null ? IntPtr.Zero : value.Handle);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_date_time(IntPtr raw, IntPtr meta_item, IntPtr value);

		public bool SetDateTime(string meta_item, Gst.DateTime value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_set_date_time(Handle, native_meta_item, value == null ? IntPtr.Zero : value.Handle);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_double(IntPtr raw, IntPtr meta_item, double value);

		public bool SetDouble(string meta_item, double value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_set_double(Handle, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_float(IntPtr raw, IntPtr meta_item, float value);

		public bool SetFloat(string meta_item, float value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_set_float(Handle, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_int(IntPtr raw, IntPtr meta_item, int value);

		public bool SetInt(string meta_item, int value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_set_int(Handle, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_int64(IntPtr raw, IntPtr meta_item, long value);

		public bool SetInt64(string meta_item, long value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_set_int64(Handle, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_marker_list(IntPtr raw, IntPtr meta_item, IntPtr list);

		public bool SetMarkerList(string meta_item, GES.MarkerList list) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_set_marker_list(Handle, native_meta_item, list == null ? IntPtr.Zero : list.Handle);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_meta(IntPtr raw, IntPtr meta_item, IntPtr value);

		public bool SetMeta(string meta_item, GLib.Value value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			IntPtr native_value = GLib.Marshaller.StructureToPtrAlloc (value);
			bool raw_ret = ges_meta_container_set_meta(Handle, native_meta_item, native_value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			Marshal.FreeHGlobal (native_value);
			return ret;
		}

		public bool SetMeta(string meta_item) {
			return SetMeta (meta_item, GLib.Value.Empty);
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_string(IntPtr raw, IntPtr meta_item, IntPtr value);

		public bool SetString(string meta_item, string value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			IntPtr native_value = GLib.Marshaller.StringToPtrGStrdup (value);
			bool raw_ret = ges_meta_container_set_string(Handle, native_meta_item, native_value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			GLib.Marshaller.Free (native_value);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_uint(IntPtr raw, IntPtr meta_item, uint value);

		public bool SetUint(string meta_item, uint value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_set_uint(Handle, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
		static extern bool ges_meta_container_set_uint64(IntPtr raw, IntPtr meta_item, ulong value);

		public bool SetUint64(string meta_item, ulong value) {
			IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
			bool raw_ret = ges_meta_container_set_uint64(Handle, native_meta_item, value);
			bool ret = raw_ret;
			GLib.Marshaller.Free (native_meta_item);
			return ret;
		}

		[GLib.Signal("notify-meta")]
		public event GES.NotifyMetaHandler NotifyMeta {
			add {
				this.AddSignalHandler ("notify-meta", value, typeof (GES.NotifyMetaArgs));
			}
			remove {
				this.RemoveSignalHandler ("notify-meta", value);
			}
		}

		static NotifyMetaNativeDelegate NotifyMeta_cb_delegate;
		static NotifyMetaNativeDelegate NotifyMetaVMCallback {
			get {
				if (NotifyMeta_cb_delegate == null)
					NotifyMeta_cb_delegate = new NotifyMetaNativeDelegate (NotifyMeta_cb);
				return NotifyMeta_cb_delegate;
			}
		}

		static void OverrideNotifyMeta (GLib.GType gtype)
		{
			OverrideNotifyMeta (gtype, NotifyMetaVMCallback);
		}

		static void OverrideNotifyMeta (GLib.GType gtype, NotifyMetaNativeDelegate callback)
		{
			OverrideVirtualMethod (gtype, "notify-meta", callback);
		}
		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
		delegate void NotifyMetaNativeDelegate (IntPtr inst, IntPtr key, IntPtr value);

		static void NotifyMeta_cb (IntPtr inst, IntPtr key, IntPtr value)
		{
			try {
				GES.TimelineElement __obj = GLib.Object.GetObject (inst, false) as GES.TimelineElement;
				__obj.OnNotifyMeta (GLib.Marshaller.Utf8PtrToString (key), (GLib.Value) Marshal.PtrToStructure (value, typeof (GLib.Value)));
			} catch (Exception e) {
				GLib.ExceptionManager.RaiseUnhandledException (e, false);
			}
		}

		[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideNotifyMeta")]
		protected virtual void OnNotifyMeta (string key, GLib.Value value)
		{
			InternalNotifyMeta (key, value);
		}

		private void InternalNotifyMeta (string key, GLib.Value value)
		{
			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 (key);
			inst_and_params.Append (vals [1]);
			vals [2] = new GLib.Value (value);
			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 TimelineElement ()
		{
			GtkSharp.GstEditingServices.ObjectManager.Initialize ();
		}

		// Internal representation of the wrapped structure ABI.
		static GLib.AbiStruct _abi_info = null;
		static public new GLib.AbiStruct abi_info {
			get {
				if (_abi_info == null)
					_abi_info = new GLib.AbiStruct (new List<GLib.AbiField>{ 
						new GLib.AbiField("parent"
							, GLib.Object.abi_info.Fields
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // parent
							, null
							, "asset"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("asset"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // asset
							, "parent"
							, "start"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("start"
							, -1
							, (uint) Marshal.SizeOf(typeof(ulong)) // start
							, "asset"
							, "inpoint"
							, (long) Marshal.OffsetOf(typeof(GESTimelineElement_startAlign), "start")
							, 0
							),
						new GLib.AbiField("inpoint"
							, -1
							, (uint) Marshal.SizeOf(typeof(ulong)) // inpoint
							, "start"
							, "duration"
							, (long) Marshal.OffsetOf(typeof(GESTimelineElement_inpointAlign), "inpoint")
							, 0
							),
						new GLib.AbiField("duration"
							, -1
							, (uint) Marshal.SizeOf(typeof(ulong)) // duration
							, "inpoint"
							, "maxduration"
							, (long) Marshal.OffsetOf(typeof(GESTimelineElement_durationAlign), "duration")
							, 0
							),
						new GLib.AbiField("maxduration"
							, -1
							, (uint) Marshal.SizeOf(typeof(ulong)) // maxduration
							, "duration"
							, "priority"
							, (long) Marshal.OffsetOf(typeof(GESTimelineElement_maxdurationAlign), "maxduration")
							, 0
							),
						new GLib.AbiField("priority"
							, -1
							, (uint) Marshal.SizeOf(typeof(uint)) // priority
							, "maxduration"
							, "timeline"
							, (long) Marshal.OffsetOf(typeof(GESTimelineElement_priorityAlign), "priority")
							, 0
							),
						new GLib.AbiField("timeline"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // timeline
							, "priority"
							, "name"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("name"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // name
							, "timeline"
							, "priv"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("priv"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) // priv
							, "name"
							, "_ges_reserved"
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
						new GLib.AbiField("_ges_reserved"
							, -1
							, (uint) Marshal.SizeOf(typeof(IntPtr)) * 20 // _ges_reserved
							, "priv"
							, null
							, (uint) Marshal.SizeOf(typeof(IntPtr))
							, 0
							),
					});

				return _abi_info;
			}
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GESTimelineElement_startAlign
		{
			sbyte f1;
			private ulong start;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GESTimelineElement_inpointAlign
		{
			sbyte f1;
			private ulong inpoint;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GESTimelineElement_durationAlign
		{
			sbyte f1;
			private ulong duration;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GESTimelineElement_maxdurationAlign
		{
			sbyte f1;
			private ulong maxduration;
		}

		[StructLayout(LayoutKind.Sequential)]
		public struct GESTimelineElement_priorityAlign
		{
			sbyte f1;
			private uint priority;
		}


		// End of the ABI representation.

#endregion
	}
}