gstreamer/ges/generated/GES_TimelineElement.cs
2018-01-29 16:25:26 -03:00

2113 lines
71 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);
[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
static extern void ges_timeline_element_set_duration(IntPtr raw, ulong duration);
[GLib.Property ("duration")]
public ulong Duration {
get {
ulong raw_ret = ges_timeline_element_get_duration(Handle);
ulong ret = raw_ret;
return ret;
}
set {
ges_timeline_element_set_duration(Handle, value);
}
}
[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);
[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
static extern void ges_timeline_element_set_max_duration(IntPtr raw, ulong maxduration);
[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 {
ges_timeline_element_set_max_duration(Handle, value);
}
}
[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);
[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
static extern void ges_timeline_element_set_priority(IntPtr raw, uint priority);
[Obsolete]
[GLib.Property ("priority")]
public uint Priority {
get {
uint raw_ret = ges_timeline_element_get_priority(Handle);
uint ret = raw_ret;
return ret;
}
set {
ges_timeline_element_set_priority(Handle, value);
}
}
[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);
[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
static extern void ges_timeline_element_set_start(IntPtr raw, ulong start);
[GLib.Property ("start")]
public ulong Start {
get {
ulong raw_ret = ges_timeline_element_get_start(Handle);
ulong ret = raw_ret;
return ret;
}
set {
ges_timeline_element_set_start(Handle, value);
}
}
[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);
[DllImport("ges-1.0", CallingConvention = CallingConvention.Cdecl)]
static extern void ges_timeline_element_set_inpoint(IntPtr raw, ulong inpoint);
public ulong Inpoint {
get {
ulong raw_ret = ges_timeline_element_get_inpoint(Handle);
ulong ret = raw_ret;
return ret;
}
set {
ges_timeline_element_set_inpoint(Handle, value);
}
}
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("deep-notify")]
public event GES.DeepNotifyHandler DeepNotify {
add {
this.AddSignalHandler ("deep-notify", value, typeof (GES.DeepNotifyArgs));
}
remove {
this.RemoveSignalHandler ("deep-notify", value);
}
}
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;
}
// 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"
, "_ges_reserved"
, (uint) Marshal.SizeOf(typeof(IntPtr))
, 0
),
new GLib.AbiField("_ges_reserved"
, -1
, (uint) Marshal.SizeOf(typeof(IntPtr)) * 18 // _ges_reserved
, "get_track_types"
, 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_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 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) 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 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_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, int flags, IntPtr type);
public bool CheckMetaRegistered(string meta_item, GES.MetaFlag flags, GLib.GType type) {
IntPtr native_meta_item = GLib.Marshaller.StringToPtrGStrdup (meta_item);
bool raw_ret = ges_meta_container_check_meta_registered(Handle, native_meta_item, (int) flags, type.Val);
bool ret = raw_ret;
GLib.Marshaller.Free (native_meta_item);
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_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;
}
public bool RegisterMetaDateTime(GES.MetaFlag flags, string meta_item) {
return RegisterMetaDateTime (flags, meta_item, null);
}
[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;
}
public bool RegisterMetaString(GES.MetaFlag flags, string meta_item) {
return RegisterMetaString (flags, meta_item, null);
}
[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_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_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 _object, IntPtr p0);
static void NotifyMeta_cb (IntPtr inst, IntPtr _object, IntPtr p0)
{
try {
GES.TimelineElement __obj = GLib.Object.GetObject (inst, false) as GES.TimelineElement;
__obj.OnNotifyMeta (GLib.Marshaller.Utf8PtrToString (_object), (GLib.Value) Marshal.PtrToStructure (p0, typeof (GLib.Value)));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException (e, false);
}
}
[GLib.DefaultSignalHandler(Type=typeof(GES.TimelineElement), ConnectionMethod="OverrideNotifyMeta")]
protected virtual void OnNotifyMeta (string _object, GLib.Value p0)
{
InternalNotifyMeta (_object, p0);
}
private void InternalNotifyMeta (string _object, GLib.Value p0)
{
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 (_object);
inst_and_params.Append (vals [1]);
vals [2] = new GLib.Value (p0);
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
}
}