/* -*- mode: C; c-basic-offset: 4 -*- */
#include <glib.h>
#include <glib-object.h>

static guint foo_signal_id = 0;
static guint bar_signal_id = 0;


static GType test_i_get_type (void);
static GType test_a_get_type (void);
static GType test_b_get_type (void);
static GType test_c_get_type (void);

#define TEST_TYPE_I (test_i_get_type ())
#define TEST_I(object) (G_TYPE_CHECK_INSTANCE_CAST((object), TEST_TYPE_I, TestI))
#define TEST_I_CLASS(vtable) (G_TYPE_CHECK_CLASS_CAST((vtable), TEST_TYPE_I, TestIClass))
#define TEST_IS_I(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), TEST_TYPE_I))
#define TEST_IS_I_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE((vtable), TEST_TYPE_I))
#define TEST_I_GET_CLASS(object) (G_TYPE_INSTANCE_GET_INTERFACE((object), TEST_TYPE_I, TestIClass))

typedef struct _TestI TestI;
typedef struct _TestIClass TestIClass;

struct _TestIClass {
    GTypeInterface base_iface;
};

static void
test_i_foo (TestI *self)
{
    g_print("TestI::foo called.\n");
}


static void
test_i_base_init (gpointer g_class)
{
    static gboolean initialised = FALSE;

    if (!initialised) {
	foo_signal_id = g_signal_newv("foo",
				      TEST_TYPE_I,
				      G_SIGNAL_RUN_LAST,
				      g_cclosure_new(G_CALLBACK(test_i_foo),
						     NULL, NULL),
				      NULL, NULL,
				      g_cclosure_marshal_VOID__VOID,
				      G_TYPE_NONE, 0, NULL);
    }
    initialised = TRUE;
}

static GType
test_i_get_type (void)
{
    static GType type = 0;
  
    if (!type) {
	static const GTypeInfo type_info = {
	    sizeof (TestIClass),
	    (GBaseInitFunc) test_i_base_init, /* base_init */
	    NULL,             /* base_finalize */
	};
      
	type = g_type_register_static (G_TYPE_INTERFACE, "TestI",
				       &type_info, 0);
    }
  
    return type;
}



#define TEST_TYPE_A (test_a_get_type())
#define TEST_A(object) (G_TYPE_CHECK_INSTANCE_CAST((object), TEST_TYPE_A, TestA))
#define TEST_A_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_A, TestAClass))
#define TEST_IS_A(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), TEST_TYPE_A))
#define TEST_IS_A_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_A))
#define TEST_A_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TEST_TYPE_A, TestAClass))

typedef struct _TestA TestA;
typedef struct _TestAClass TestAClass;

struct _TestA {
    GObject parent;
};
struct _TestAClass {
    GObjectClass parent_class;

    void (* bar) (TestA *self);
};

static void
test_a_foo (TestI *self)
{
    GValue args[1] = { { 0, } };

    g_print("TestA::foo called.  Chaining up.\n");

    g_value_init (&args[0], TEST_TYPE_A);
    g_value_set_object (&args[0], self);

    g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
    g_signal_chain_from_overridden (args, NULL);

    g_value_unset (&args[0]);
}

static void
test_a_bar (TestA *self)
{
    g_print("TestA::bar called.\n");
}

static void
test_a_class_init (TestAClass *class)
{
    class->bar = test_a_bar;

    bar_signal_id = g_signal_new("bar",
				 TEST_TYPE_A,
				 G_SIGNAL_RUN_LAST,
				 G_STRUCT_OFFSET (TestAClass, bar),
				 NULL, NULL,
				 g_cclosure_marshal_VOID__VOID,
				 G_TYPE_NONE, 0);
}

static void
test_a_interface_init (TestIClass *iface)
{
    g_signal_override_class_closure (foo_signal_id,
				     TEST_TYPE_A,
				     g_cclosure_new (G_CALLBACK (test_a_foo),
						     NULL, NULL));
}

static GType
test_a_get_type (void)
{
    static GType type = 0;
  
    if (!type) {
	static const GTypeInfo type_info = {
            sizeof(TestAClass),
            (GBaseInitFunc) NULL,
            (GBaseFinalizeFunc) NULL,
            (GClassInitFunc) test_a_class_init,
            NULL, /* class_finalize */
            NULL, /* class_data */
            sizeof(TestAClass),
            0, /* n_preallocs */
            (GInstanceInitFunc) NULL,
	};
	static const GInterfaceInfo interface_info = {
	    (GInterfaceInitFunc) test_a_interface_init,
	    NULL,
	    NULL
	};

	type = g_type_register_static (G_TYPE_OBJECT, "TestA",
				       &type_info, 0);
	g_type_add_interface_static (type, TEST_TYPE_I, &interface_info);
    }
  
  return type;
}


#define TEST_TYPE_B (test_b_get_type())
#define TEST_B(object) (G_TYPE_CHECK_INSTANCE_CAST((object), TEST_TYPE_B, TestB))
#define TEST_B_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_B, TestBClass))
#define TEST_IS_B(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), TEST_TYPE_B))
#define TEST_IS_B_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_B))
#define TEST_B_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TEST_TYPE_B, TestBClass))

typedef struct _TestB TestB;
typedef struct _TestBClass TestBClass;

struct _TestB {
    TestA parent;
};
struct _TestBClass {
    TestAClass parent_class;
};

static void
test_b_foo (TestA *self)
{
    GValue args[1] = { { 0, } };

    g_print("TestB::foo called.  Chaining up.\n");

    g_value_init (&args[0], TEST_TYPE_A);
    g_value_set_object (&args[0], self);

    g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
    g_signal_chain_from_overridden (args, NULL);

    g_value_unset (&args[0]);
}

static void
test_b_bar (TestI *self)
{
    GValue args[1] = { { 0, } };

    g_print("TestB::bar called.  Chaining up.\n");

    g_value_init (&args[0], TEST_TYPE_A);
    g_value_set_object (&args[0], self);

    g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id);
    g_signal_chain_from_overridden (args, NULL);

    g_value_unset (&args[0]);
}

static void
test_b_class_init (TestBClass *class)
{
    g_signal_override_class_closure (foo_signal_id,
				     TEST_TYPE_B,
				     g_cclosure_new (G_CALLBACK (test_b_foo),
						     NULL, NULL));
    g_signal_override_class_closure (bar_signal_id,
				     TEST_TYPE_B,
				     g_cclosure_new (G_CALLBACK (test_b_bar),
						     NULL, NULL));
}

static GType
test_b_get_type (void)
{
    static GType type = 0;
  
    if (!type) {
	static const GTypeInfo type_info = {
            sizeof(TestBClass),
            (GBaseInitFunc) NULL,
            (GBaseFinalizeFunc) NULL,
            (GClassInitFunc) test_b_class_init,
            NULL, /* class_finalize */
            NULL, /* class_data */
            sizeof(TestBClass),
            0, /* n_preallocs */
            (GInstanceInitFunc) NULL,
	};

	type = g_type_register_static (TEST_TYPE_A, "TestB",
				       &type_info, 0);
    }
  
  return type;
}


#define TEST_TYPE_C (test_c_get_type())
#define TEST_C(object) (G_TYPE_CHECK_INSTANCE_CAST((object), TEST_TYPE_C, TestC))
#define TEST_C_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_C, TestCClass))
#define TEST_IS_C(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), TEST_TYPE_C))
#define TEST_IS_C_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_C))
#define TEST_C_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), TEST_TYPE_C, TestCClass))

typedef struct _TestC TestC;
typedef struct _TestCClass TestCClass;

struct _TestC {
    TestB parent;
};
struct _TestCClass {
    TestBClass parent_class;
};

static void
test_c_foo (TestA *self)
{
    GValue args[1] = { { 0, } };

    g_print("TestC::foo called.  Chaining up.\n");

    g_value_init (&args[0], TEST_TYPE_A);
    g_value_set_object (&args[0], self);

    g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
    g_signal_chain_from_overridden (args, NULL);

    g_value_unset (&args[0]);
}

static void
test_c_bar (TestI *self)
{
    GValue args[1] = { { 0, } };

    g_print("TestC::bar called.  Chaining up.\n");

    g_value_init (&args[0], TEST_TYPE_A);
    g_value_set_object (&args[0], self);

    g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id);
    g_signal_chain_from_overridden (args, NULL);

    g_value_unset (&args[0]);
}

static void
test_c_class_init (TestBClass *class)
{
    g_signal_override_class_closure (foo_signal_id,
				     TEST_TYPE_C,
				     g_cclosure_new (G_CALLBACK (test_c_foo),
						     NULL, NULL));
    g_signal_override_class_closure (bar_signal_id,
				     TEST_TYPE_C,
				     g_cclosure_new (G_CALLBACK (test_c_bar),
						     NULL, NULL));
}

static GType
test_c_get_type (void)
{
    static GType type = 0;
  
    if (!type) {
	static const GTypeInfo type_info = {
            sizeof(TestCClass),
            (GBaseInitFunc) NULL,
            (GBaseFinalizeFunc) NULL,
            (GClassInitFunc) test_c_class_init,
            NULL, /* class_finalize */
            NULL, /* class_data */
            sizeof(TestCClass),
            0, /* n_preallocs */
            (GInstanceInitFunc) NULL,
	};

	type = g_type_register_static (TEST_TYPE_B, "TestC",
				       &type_info, 0);
    }
  
  return type;
}


int
main (int argc, char **argv)
{
    GObject *self;

    g_type_init();

    self = g_object_new(TEST_TYPE_A, NULL);
    g_print("*** emiting foo on a TestA instance (expect chain A->I)\n");
    g_signal_emit(self, foo_signal_id, 0);
    g_print("*** emiting bar on a TestA instance\n");
    g_signal_emit(self, bar_signal_id, 0);
    g_object_unref(self);

    g_print("\n");

    self = g_object_new(TEST_TYPE_B, NULL);
    g_print("*** emiting foo on a TestB instance (expect chain B->A->I)\n");
    g_signal_emit(self, foo_signal_id, 0);
    g_print("*** emiting bar on a TestB instance (expect chain B->A)\n");
    g_signal_emit(self, bar_signal_id, 0);
    g_object_unref(self);

    g_print("\n");

    self = g_object_new(TEST_TYPE_C, NULL);
    g_print("*** emiting foo on a TestC instance (expect chain C->B->A->I)\n");
    g_signal_emit(self, foo_signal_id, 0);
    g_print("*** emiting bar on a TestC instance (expect chain C->B->A)\n");
    g_signal_emit(self, bar_signal_id, 0);
    g_object_unref(self);

    return 0;
}