## Conventions

There are a number of conventions users are expected to follow when creating new types which are to be exported in a header file:

- Type names (including object names) must be at least three characters long and start with ‘a–z’, ‘A–Z’ or ‘_’.

- Use the `object_method` pattern for function names: to invoke the method named `save` on an instance of object type file, call `file_save`.

- Use prefixing to avoid namespace conflicts with other projects. If your library (or application) is named Viewer, prefix all your function names with viewer_. For example: `viewer_object_method`.

- Create a macro named `PREFIX_TYPE_OBJECT` which always returns the GType for the associated object type. For an object of type File in the Viewer namespace, use: `VIEWER_TYPE_FILE`. This macro is implemented using a function named `prefix_object_get_type`; for example, `viewer_file_get_type`.

- Use `G_DECLARE_FINAL_TYPE` or `G_DECLARE_DERIVABLE_TYPE` to define various other conventional macros for your object:

  - `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 building GLib). For example, we would create `VIEWER_FILE (obj)` to keep the previous example.

  - `PREFIX_OBJECT_CLASS (klass)`, which 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. An example is: `VIEWER_FILE_CLASS`.

  - `PREFIX_IS_OBJECT (obj)`, which returns a gboolean which indicates whether the input object instance pointer is non-NULL and of type OBJECT. For example, `VIEWER_IS_FILE`.

  - `PREFIX_IS_OBJECT_CLASS (klass)`, which returns a boolean if the input class pointer is a pointer to a class of type OBJECT. For example, `VIEWER_IS_FILE_CLASS`.

  - `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). For example, `VIEWER_FILE_GET_CLASS`.

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:

    1
    2

    #define VIEWER_TYPE_FILE viewer_file_get_type ()
    G_DECLARE_FINAL_TYPE (ViewerFile, viewer_file, VIEWER, FILE, GObject)

Unless your code has special requirements, you can use the `G_DEFINE_TYPE` macro to define a class:

    1

    G_DEFINE_TYPE (ViewerFile, viewer_file, G_TYPE_OBJECT)

Otherwise, the `viewer_file_get_type` function must be implemented manually:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

    GType viewer_file_get_type (void)
    {
      static GType type = 0;
      if (type == 0) {
        const GTypeInfo info = {
          /* You fill this structure. */
        };
        type = g_type_register_static (G_TYPE_OBJECT,
                                       "ViewerFile",
                                       &info, 0);
      }
      return type;
    }