GtkSharp/gtk/Container.custom

// Container.custom - customizations to Gtk.Container
//
// Authors: Mike Kestner  <mkestner@ximian.com>
//
// Copyright (c) 2004 Novell, Inc.

[DllImport("libgtk-win32-2.0-0.dll")]
static extern IntPtr gtk_container_get_children (IntPtr raw);

public Widget[] Children {
	get {
		IntPtr list_ptr = gtk_container_get_children (Handle);
		if (list_ptr == IntPtr.Zero)
			return new Widget [0];

		GLib.List list = new GLib.List (list_ptr);
		Widget[] result = new Widget [list.Count];
		for (int i = 0; i < list.Count; i++)
			result [i] = list [i] as Widget;
		return result;
	}
}

[DllImport("libgtk-win32-2.0-0.dll")]
static extern bool gtk_container_get_focus_chain (IntPtr raw, out IntPtr list_ptr);

[DllImport("libgtk-win32-2.0-0.dll")]
static extern void gtk_container_set_focus_chain (IntPtr raw, IntPtr list_ptr);

public Widget[] FocusChain {
	get {
		IntPtr list_ptr;
		bool success = gtk_container_get_focus_chain (Handle, out list_ptr);
		if (!success)
			return new Widget [0];

		GLib.List list = new GLib.List (list_ptr);
		Widget[] result = new Widget [list.Count];
		for (int i = 0; i < list.Count; i++)
			result [i] = list [i] as Widget;
		return result;
	}
	set {
		GLib.List list = new GLib.List (IntPtr.Zero);
		foreach (Widget val in value)
			list.Append (val.Handle);
		gtk_container_set_focus_chain (Handle, list.Handle);
	}
		
}

[DllImport("gtksharpglue")]
static extern void gtksharp_container_base_forall (IntPtr handle, bool include_internals, IntPtr cb, IntPtr data);

[DllImport("gtksharpglue")]
static extern void gtksharp_container_override_forall (GLib.GType gtype, ForallDelegate cb);

[DllImport("gtksharpglue")]
static extern void gtksharp_container_invoke_gtk_callback (IntPtr cb, IntPtr handle, IntPtr data);

delegate void ForallDelegate (IntPtr container, bool include_internals, IntPtr cb, IntPtr data);

static ForallDelegate ForallCallback;

public struct CallbackInvoker {
	IntPtr cb;
	IntPtr data;

	internal CallbackInvoker (IntPtr cb, IntPtr data)
	{
		this.cb = cb;
		this.data = data;
	}

	internal IntPtr Data {
		get {
			return data;
		}
	}

	internal IntPtr Callback {
		get {
			return cb;
		}
	}

	public void Invoke (Widget w)
	{
		gtksharp_container_invoke_gtk_callback (cb, w.Handle, data);
	}
}

static void Forall_cb (IntPtr container, bool include_internals, IntPtr cb, IntPtr data)
{
	Container obj = GLib.Object.GetObject (container, false) as Container;
	CallbackInvoker invoker = new CallbackInvoker (cb, data);
	obj.ForAll (include_internals, invoker);
}

protected static void OverrideForall (GLib.GType gtype)
{
	if (ForallCallback == null)
		ForallCallback = new ForallDelegate (Forall_cb);
	gtksharp_container_override_forall (gtype, ForallCallback);
}

[GLib.DefaultSignalHandler (Type=typeof(Gtk.Container), ConnectionMethod="OverrideForall")]
protected virtual void ForAll (bool include_internals, CallbackInvoker invoker)
{
	gtksharp_container_base_forall (Handle, include_internals, invoker.Callback, invoker.Data);
}

[DllImport("gtksharpglue")]
static extern IntPtr gtksharp_container_base_child_type(IntPtr raw);

[DllImport("gtksharpglue")]
static extern void gtksharp_container_override_child_type (GLib.GType type, ChildTypeDelegate cb);

delegate IntPtr ChildTypeDelegate (IntPtr raw);

static ChildTypeDelegate ChildTypeCallback;

static IntPtr ChildType_cb (IntPtr raw)
{
	Container obj = GLib.Object.GetObject (raw, false) as Container;
	GLib.GType gtype = obj.ChildType ();
	return gtype.Val;
}

protected static void OverrideChildType (GLib.GType gtype)
{
	if (ChildTypeCallback == null)
		ChildTypeCallback = new ChildTypeDelegate (ChildType_cb);
	gtksharp_container_override_child_type (gtype, ChildTypeCallback);
}

[GLib.DefaultSignalHandler (Type=typeof(Gtk.Container), ConnectionMethod="OverrideChildType")]
public virtual GLib.GType ChildType() {
	IntPtr raw_ret = gtksharp_container_base_child_type(Handle);
	GLib.GType ret = new GLib.GType(raw_ret);
	return ret;
}