gstreamer/ges/generated/GES/TimelineElement.cs
Thibault Saunier d0aba011b3 Update GES
2020-06-17 21:52:01 -04:00

2629 lines
91 KiB
C#

// 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_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_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_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
}
}