context: // This file was generated by the Gtk# code generator.
  // Any changes made will be lost if regenerated.
  
  namespace GES {
  
  	using System;
  	using System.Collections;
  	using System.Collections.Generic;
  	using System.Runtime.InteropServices;
  
  #region Autogenerated code
  	public partial class Container : GES.TimelineElement {
  
  		protected Container (IntPtr raw) : base(raw) {}
  
  		protected Container() : base(IntPtr.Zero)
  		{
  			CreateNativeObject (new string [0], new GLib.Value [0]);
  		}
  
  		[GLib.Property ("height")]
  		public uint Height {
  			get {
  				GLib.Value val = GetProperty ("height");
  				uint ret = (uint) val;
  				val.Dispose ();
  				return ret;
  			}
  		}
  
  		public GLib.List Children {
  			get {
  				unsafe {
  					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("children"));
  					return new GLib.List((*raw_ptr));
  				}
  			}
  		}
  
  		public uint HeightField {
  			get {
  				unsafe {
  					uint* raw_ptr = (uint*)(((byte*)Handle) + abi_info.GetFieldOffset("height"));
  					return (*raw_ptr);
  				}
  			}
  		}
  
  		public GES.ChildrenControlMode ChildrenControlMode {
  			get {
  				unsafe {
  					int* raw_ptr = (int*)(((byte*)Handle) + abi_info.GetFieldOffset("children_control_mode"));
  					return (GES.ChildrenControlMode) (*raw_ptr);
  				}
  			}
  		}
  
  		public GES.TimelineElement InitiatedMove {
  			get {
  				unsafe {
  					IntPtr* raw_ptr = (IntPtr*)(((byte*)Handle) + abi_info.GetFieldOffset("initiated_move"));
  					return GLib.Object.GetObject((*raw_ptr)) as GES.TimelineElement;
  				}
  			}
  		}
  
  		[GLib.Signal("child-added")]
  		public event GES.ChildAddedHandler ChildAdded {
  			add {
  				this.AddSignalHandler ("child-added", value, typeof (GES.ChildAddedArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("child-added", value);
  			}
  		}
  
  		[GLib.Signal("child-removed")]
  		public event GES.ChildRemovedHandler ChildRemoved {
  			add {
  				this.AddSignalHandler ("child-removed", value, typeof (GES.ChildRemovedArgs));
  			}
  			remove {
  				this.RemoveSignalHandler ("child-removed", value);
  			}
  		}
  
  		static ChildAddedNativeDelegate ChildAdded_cb_delegate;
  		static ChildAddedNativeDelegate ChildAddedVMCallback {
  			get {
  				if (ChildAdded_cb_delegate == null)
  					ChildAdded_cb_delegate = new ChildAddedNativeDelegate (ChildAdded_cb);
  				return ChildAdded_cb_delegate;
  			}
  		}
  
  		static void OverrideChildAdded (GLib.GType gtype)
  		{
  			OverrideChildAdded (gtype, ChildAddedVMCallback);
  		}
  
  		static void OverrideChildAdded (GLib.GType gtype, ChildAddedNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("child_added"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void ChildAddedNativeDelegate (IntPtr inst, IntPtr element);
  
  		static void ChildAdded_cb (IntPtr inst, IntPtr element)
  		{
  			try {
  				Container __obj = GLib.Object.GetObject (inst, false) as Container;
  				__obj.OnChildAdded (GLib.Object.GetObject(element) as GES.TimelineElement);
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(GES.Container), ConnectionMethod="OverrideChildAdded")]
  		protected virtual void OnChildAdded (GES.TimelineElement element)
  		{
  			InternalChildAdded (element);
  		}
  
  		private void InternalChildAdded (GES.TimelineElement element)
  		{
  			ChildAddedNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("child_added"));
  				unmanaged = (ChildAddedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ChildAddedNativeDelegate));
  			}
  			if (unmanaged == null) return;
  
  			unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
  		}
  
  		static ChildRemovedNativeDelegate ChildRemoved_cb_delegate;
  		static ChildRemovedNativeDelegate ChildRemovedVMCallback {
  			get {
  				if (ChildRemoved_cb_delegate == null)
  					ChildRemoved_cb_delegate = new ChildRemovedNativeDelegate (ChildRemoved_cb);
  				return ChildRemoved_cb_delegate;
  			}
  		}
  
  		static void OverrideChildRemoved (GLib.GType gtype)
  		{
  			OverrideChildRemoved (gtype, ChildRemovedVMCallback);
  		}
  
  		static void OverrideChildRemoved (GLib.GType gtype, ChildRemovedNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("child_removed"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate void ChildRemovedNativeDelegate (IntPtr inst, IntPtr element);
  
  		static void ChildRemoved_cb (IntPtr inst, IntPtr element)
  		{
  			try {
  				Container __obj = GLib.Object.GetObject (inst, false) as Container;
  				__obj.OnChildRemoved (GLib.Object.GetObject(element) as GES.TimelineElement);
  			} catch (Exception e) {
  				GLib.ExceptionManager.RaiseUnhandledException (e, false);
  			}
  		}
  
  		[GLib.DefaultSignalHandler(Type=typeof(GES.Container), ConnectionMethod="OverrideChildRemoved")]
  		protected virtual void OnChildRemoved (GES.TimelineElement element)
  		{
  			InternalChildRemoved (element);
  		}
  
  		private void InternalChildRemoved (GES.TimelineElement element)
  		{
  			ChildRemovedNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("child_removed"));
  				unmanaged = (ChildRemovedNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(ChildRemovedNativeDelegate));
  			}
  			if (unmanaged == null) return;
  
  			unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
  		}
  
  		static AddChildNativeDelegate AddChild_cb_delegate;
  		static AddChildNativeDelegate AddChildVMCallback {
  			get {
  				if (AddChild_cb_delegate == null)
  					AddChild_cb_delegate = new AddChildNativeDelegate (AddChild_cb);
  				return AddChild_cb_delegate;
  			}
  		}
  
  		static void OverrideAddChild (GLib.GType gtype)
  		{
  			OverrideAddChild (gtype, AddChildVMCallback);
  		}
  
  		static void OverrideAddChild (GLib.GType gtype, AddChildNativeDelegate callback)
  		{
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) gtype.GetClassPtr()) + (long) class_abi.GetFieldOffset("add_child"));
  				*raw_ptr = Marshal.GetFunctionPointerForDelegate((Delegate) callback);
  			}
  		}
  
  		[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
  		delegate bool AddChildNativeDelegate (IntPtr inst, IntPtr element);
  
  		static bool AddChild_cb (IntPtr inst, IntPtr element)
  		{
  			try {
  				Container __obj = GLib.Object.GetObject (inst, false) as Container;
  				bool __result;
  				__result = __obj.OnAddChild (GLib.Object.GetObject(element) 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.Container), ConnectionMethod="OverrideAddChild")]
  		protected virtual bool OnAddChild (GES.TimelineElement element)
  		{
  			return InternalAddChild (element);
  		}
  
  		private bool InternalAddChild (GES.TimelineElement element)
  		{
  			AddChildNativeDelegate unmanaged = null;
  			unsafe {
  				IntPtr* raw_ptr = (IntPtr*)(((long) this.LookupGType().GetThresholdType().GetClassPtr()) + (long) class_abi.GetFieldOffset("add_child"));
  				unmanaged = (AddChildNativeDelegate) Marshal.GetDelegateForFunctionPointer(*raw_ptr, typeof(AddChildNativeDelegate));
  			}
  			if (unmanaged == null) return false;
  
  			bool __result = unmanaged (this.Handle, element == null ? IntPtr.Zero : element.Handle);
  			return __result;
  		}
  
  		static RemoveChildNativeDelegate RemoveChild_cb_delegate;
  		static RemoveChildNativeDelegate RemoveChildVMCallback {
  			get {
  				if (RemoveChild_cb_delegate == null)
  					RemoveChild_cb_delegate = new RemoveChildNativeDelegate (RemoveChild_cb);
  				return RemoveChild_cb_delegate;
  			}
  		}
  
  		static void OverrideRemoveChild (GLib.GType gtype)
  		{
  
gt: 			OverrideRemoveChild (gtype, RemoveChildVMCallback);