|  |  |  | GObject Reference Manual |  | 
|---|
GType's Interfaces are very similar to Java's interfaces. To declare one of these you have to register a non-instantiable classed type which derives from GTypeInterface. The following piece of code declares such an interface.
#define MAMAN_IBAZ_TYPE                (maman_ibaz_get_type ())
#define MAMAN_IBAZ(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_IBAZ_TYPE, MamanIbaz))
#define MAMAN_IS_IBAZ(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_IBAZ_TYPE))
#define MAMAN_IBAZ_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), MAMAN_IBAZ_TYPE, MamanIbazInterface))
typedef struct _MamanIbaz MamanIbaz; /* dummy object */
typedef struct _MamanIbazInterface MamanIbazInterface;
struct _MamanIbazInterface {
  GTypeInterface parent;
  void (*do_action) (MamanIbaz *self);
};
GType maman_ibaz_get_type (void);
void maman_ibaz_do_action (MamanIbaz *self);
          The interface function, maman_ibaz_do_action is implemented
          in a pretty simple way:
void maman_ibaz_do_action (MamanIbaz *self)
{
  MAMAN_IBAZ_GET_INTERFACE (self)->do_action (self);
}
         maman_ibaz_get_type registers a type named MamanIBaz
         which inherits from G_TYPE_INTERFACE. All interfaces must be children of G_TYPE_INTERFACE in the 
         inheritance tree.
        
	  An interface is defined by only one structure which must contain as first member
	  a GTypeInterface structure. The interface structure is expected to
	  contain the function pointers of the interface methods. It is good style to 
	  define helper functions for each of the interface methods which simply call
	  the interface' method directly: maman_ibaz_do_action
	  is one of these.
	
	  Once an interface type is registered, you must register implementations for these
          interfaces. The function named maman_baz_get_type registers
          a new GType named MamanBaz which inherits from GObject and which
          implements the interface MamanIBaz.
static void maman_baz_do_action (MamanIbaz *self)
{
  g_print ("Baz implementation of IBaz interface Action.\n");
}
static void
baz_interface_init (gpointer         g_iface,
                    gpointer         iface_data)
{
  MamanIbazInterface *iface = (MamanIbazInterface *)g_iface;
  iface->do_action = maman_baz_do_action;
}
GType 
maman_baz_get_type (void)
{
  static GType type = 0;
  if (type == 0) {
    static const GTypeInfo info = {
      sizeof (MamanBazInterface),
      NULL,   /* base_init */
      NULL,   /* base_finalize */
      NULL,   /* class_init */
      NULL,   /* class_finalize */
      NULL,   /* class_data */
      sizeof (MamanBaz),
      0,      /* n_preallocs */
      NULL    /* instance_init */
    };
    static const GInterfaceInfo ibaz_info = {
      (GInterfaceInitFunc) baz_interface_init,    /* interface_init */
      NULL,               /* interface_finalize */
      NULL          /* interface_data */
    };
    type = g_type_register_static (G_TYPE_OBJECT,
                                   "MamanBazType",
                                   &info, 0);
    g_type_add_interface_static (type,
                                 MAMAN_IBAZ_TYPE,
                                 &ibaz_info);
  }
  return type;
}
	  g_type_add_interface_static records in the type system that
	  a given type implements also FooInterface 
	  (foo_interface_get_type returns the type of 
	  FooInterface).
		The GInterfaceInfo structure holds
	  information about the implementation of the interface:
struct _GInterfaceInfo
{
  GInterfaceInitFunc     interface_init;
  GInterfaceFinalizeFunc interface_finalize;
  gpointer               interface_data;
};
	    When an instantiable classed type which registered an interface implementation
	    is created for the first time, its class structure is initialized following the process
	    described in the section called “Instantiable classed types: objects”. Once the class structure is 
	      initialized,the function type_class_init_Wm (implemented in 
	      gtype.c) initializes the interface implementations associated with
	      that type by calling type_iface_vtable_init_Wm for each
	      interface.
	  
First a memory buffer is allocated to hold the interface structure. The parent's interface structure is then copied over to the new interface structure (the parent interface is already initialized at that point). If there is no parent interface, the interface structure is initialized with zeros. The g_type and the g_instance_type fields are then initialized: g_type is set to the type of the most-derived interface and g_instance_type is set to the type of the most derived type which implements this interface.
	    Finally, the interface' most-derived base_init function and then 
	    the implementation's interface_init
	    function are invoked. It is important to understand that if there are multiple 
	    implementations of an interface the base_init and 
	    interface_init functions will be
	    invoked once for each implementation initialized.
	  
It is thus common for base_init functions to hold a local static boolean variable which makes sure that the interface type is initialized only once even if there are multiple implementations of the interface:
static void
maman_ibaz_base_init (gpointer g_iface)
{
  static gboolean initialized = FALSE;
  if (!initialized) {
    /* create interface signals here. */
    initialized = TRUE;
  }
}
If you have found the stuff about interface hairy, you are right: it is hairy but there is not much I can do about it. What I can do is summarize what you need to know about interfaces:
The above process can be summarized as follows:
Table 2. Interface Initialization
| Invocation time | Function Invoked | Function's parameters | Remark | 
|---|---|---|---|
| First call to g_type_create_instancefor type
		    implementing interface | interface' base_init function | On interface' vtable | Register interface' signals here (use a local static boolean variable as described above to make sure not to register them twice.). | 
| First call to g_type_create_instancefor type
		    implementing interface | interface' interface_init function | On interface' vtable | Initialize interface' implementation. That is, initialize the interface method pointers in the interface structure to the function's implementation. | 
It is highly unlikely (ie: I do not know of anyone who actually used it) you will ever need other more fancy things such as the ones described in the following section (the section called “Interface Destruction”).
	    When the last instance of an instantiable type which registered an interface implementation
	    is destroyed, the interface's implementations associated to the type are destroyed by
	    type_iface_vtable_finalize_Wm (in gtype.c).
	  
	    type_iface_vtable_finalize_Wm invokes first the implementation's 
	    interface_finalize function and then the interface's most-derived
	    base_finalize function.
	  
	    Again, it is important to understand, as in 
	    the section called “Interface Initialization”,
	      that both interface_finalize and base_finalize
	      are invoked exactly once for the destruction of each implementation of an interface. Thus,
	      if you were to use one of these functions, you would need to use a static integer variable
	      which would hold the number of instances of implementations of an interface such that
	      the interface's class is destroyed only once (when the integer variable reaches zero).
	  
The above process can be summarized as follows:
Table 3. Interface Finalization
| Invocation time | Function Invoked | Function's parameters | 
|---|---|---|
| Last call to g_type_free_instancefor type
		    implementing interface | interface' interface_finalize function | On interface' vtable | 
| Last call to g_type_free_instancefor type
		    implementing interface | interface' base_finalize function | On interface' vtable | 
Now that you have read this section, you can forget about it. Please, forget it as soon as possible.