The GLib Object System, or GObject, is a free software library providing a portable object system and transparent cross-language interoperability. GObject is designed for use both directly in C programs to provide object-oriented C-based APIs and through bindings to other languages to provide transparent cross-language interoperability, e.g. PyGObject.
History
Depending only on GLib and libc, GObject is a cornerstone of GNOME and is used throughout GTK, Pango, ATK, and most higher-level GNOME libraries like GStreamer and applications. Prior to GTK+ 2.0, code similar to GObject was part of the GTK codebase. (The name “GObject” was not yet in use — the common baseclass was called GtkObject.)
At the release of GTK+ 2.0, the object system was extracted into a separate library due to its general utility. In the process, most non-GUI-specific parts of the GtkObject class were moved up into GObject, the new common baseclass. Having existed as a separate library since March 11, 2002 (the release date of GTK+ 2.0), the GObject library is now used by many non-GUI programs such as command-line and server applications.
Relation to GLib
Though GObject has its own separate set of documentation and is usually compiled into its own shared library file, the source code for GObject resides in the GLib source tree and is distributed along with GLib. For this reason, GObject uses the GLib version numbers and is typically packaged together with GLib (for example, Debian puts GObject in its libglib2.0 package family).
The type system
At the most basic level of the GObject framework lies a generic and dynamic type system called GType. The GType system holds a runtime description of all objects allowing glue code to facilitate multiple language bindings. The type system can handle any singly inherited class structure, in addition to non-classed types such as opaque pointers, strings, and variously sized integers and floating point numbers.
The type system knows how to copy, assign, and destroy values belonging to any of the registered types. This is trivial for types like integers, but many complex objects are reference-counted, while some are complex but not reference-counted. When the type system “copies” a reference-counted object, it will typically just increase its reference count, whereas when copying a complex, non-reference-counted object (such as a string), it will typically create an actual copy by allocating memory.
This basic functionality is used for implementing GValue, a type of generic container that can hold values of any type known by the type system. Such containers are particularly useful when interacting with dynamically typed language environments in which all native values reside in such type-tagged containers.
Fundamental types
Types that do not have any associated classes are called non-classed. These types, together with all types that correspond to some form of root class, are known as fundamental types: the types from which all other types are derived. These make up a relatively closed set, but although the average user is not expected to create their own fundamental types, the possibility does exist and has been exploited to create custom class hierarchies — i.e., class hierarchies not based on the GObject class.
As of GLib 2.9.2, the non-classed built-in fundamental types are: an empty type, corresponding to C's void (G_TYPE_NONE); types corresponding to C's signed and unsigned char, int, long, and 64-bit integers (G_TYPE_CHAR, G_TYPE_UCHAR, G_TYPE_INT, G_TYPE_UINT, G_TYPE_LONG, G_TYPE_ULONG, G_TYPE_INT64, and G_TYPE_UINT64); a boolean type (G_TYPE_BOOLEAN); an enumeration type and a “flags” type, both corresponding to C's enum type, but differing in that the latter is only used for bit fields (G_TYPE_ENUM and G_TYPE_FLAGS); types for single- and double-precision IEEE floats, corresponding to C's float and double (G_TYPE_FLOAT and G_TYPE_DOUBLE); a string type, corresponding to C's char * (G_TYPE_STRING); an opaque pointer type, corresponding to C's void * (G_TYPE_POINTER).
The classed built-in fundamental types are: a base class type for instances of GObject, the root of the standard class inheritance tree (G_TYPE_OBJECT) a base interface type, analogous to the base class type but representing the root of the standard interface inheritance tree (G_TYPE_INTERFACE) a type for boxed structures, which are used to wrap simple value objects or foreign objects in reference-counted “boxes” (G_TYPE_BOXED) a type for “parameter specification objects,” which are used in GObject to describe metadata for object properties (G_TYPE_PARAM).