|  |  |  | GObject Reference Manual |  | 
|---|
There are a number of conventions users are expected to follow when creating new types which are to be exported in a header file:
	      Use the object_method pattern for function names: to invoke
	      the method named foo on an instance of object type bar, call 
	      bar_foo.
	    
Use prefixing to avoid namespace conflicts with other projects.
	      If your library (or application) is named Maman, 
	      prefix all your function names with maman_.
	      For example: maman_object_method.
	    
Create a macro named PREFIX_OBJECT_TYPE which always 
	      returns the Gtype for the associated object type. For an object of type 
	      Bar in a libray prefixed by maman, 
	      use: MAMAN_BAR_TYPE.
	      It is common although not a convention to implement this macro using either a global 
	      static variable or a function named prefix_object_get_type.
	      We will follow the function pattern wherever possible in this document.
	    
Create a macro named PREFIX_OBJECT (obj) which 
	      returns a pointer of type PrefixObject. This macro is used to enforce
	      static type safety by doing explicit casts wherever needed. It also enforces
	      dynamic type safety by doing runtime checks. It is possible to disable the dynamic
              type checks in production builds (see 
              http://developer.gnome.org/doc/API/2.0/glib/glib-building.html).
              For example, we would create 
	      MAMAN_BAR (obj) to keep the previous example.
	    
If the type is classed, create a macro named 
	      PREFIX_OBJECT_CLASS (klass). This macro
		is strictly equivalent to the previous casting macro: it does static casting with
		dynamic type checking of class structures. It is expected to return a pointer
		to a class structure of type PrefixObjectClass. Again, an example is:
		MAMAN_BAR_CLASS.
Create a macro named PREFIX_IS_BAR (obj): this macro is expected
		to return a gboolean which indicates whether or not the input
		object instance pointer of type BAR.
If the type is classed, create a macro named
	      PREFIX_IS_OBJECT_CLASS (klass) which, as above, returns a boolean
	      if the input class pointer is a pointer to a class of type OBJECT.
	    
If the type is classed, create a macro named 
	      PREFIX_OBJECT_GET_CLASS (obj)
	    which returns the class pointer associated to an instance of a given type. This macro
	    is used for static and dynamic type safety purposes (just like the previous casting
	    macros).
	The implementation of these macros is pretty straightforward: a number of simple-to-use 
	macros are provided in gtype.h. For the example we used above, we would 
	write the following trivial code to declare the macros:
#define MAMAN_BAR_TYPE (maman_bar_get_type ()) #define MAMAN_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_BAR_TYPE, MamanBar)) #define MAMAN_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MAMAN_BAR_TYPE, MamanBarClass)) #define MAMAN_IS_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAMAN_BAR_TYPE)) #define MAMAN_IS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MAMAN_BAR_TYPE)) #define MAMAN_BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MAMAN_BAR_TYPE, MamanBarClass))
Stick to the naming klass as class is a registered c++ keyword.
	The following code shows how to implement the maman_bar_get_type
	function:
GType maman_bar_get_type (void)
{
  static GType type = 0;
  if (type == 0) {
    static const GTypeInfo info = {
      /* You fill this structure. */
    };
    type = g_type_register_static (G_TYPE_OBJECT,
                                   "MamanBarType",
                                   &info, 0);
  }
  return type;
}