mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-24 21:10:27 +00:00
2d00f898fb
Making it cleaner and simpler to navigate and removing previous ugly and now useless hack where we were renaming files ourself to make meson happy.
2113 lines
71 KiB
C#
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
|
|
}
|
|
}
|