TypeClass

class TypeClass(*args, **kwargs)

An opaque structure used as the base of all classes.

Methods

class TypeClass

add_private(private_size: int) → None

Registers a private structure for an instantiatable type.

When an object is allocated, the private structures for the type and all of its parent types are allocated sequentially in the same memory block as the public structures, and are zero-filled.

Note that the accumulated size of the private structures of a type and all its parent types cannot exceed 64 KiB.

This function should be called in the type’s class_init() function. The private structure can be retrieved using the TYPE_INSTANCE_GET_PRIVATE() macro.

The following example shows attaching a private structure MyObjectPrivate to an object MyObject defined in the standard GObject fashion in the type’s class_init() function.

Note the use of a structure member “priv” to avoid the overhead of repeatedly calling MY_OBJECT_GET_PRIVATE().

typedef struct _MyObject        MyObject;
typedef struct _MyObjectPrivate MyObjectPrivate;

struct _MyObject {
 GObject parent;

 MyObjectPrivate *priv;
};

struct _MyObjectPrivate {
  int some_field;
};

static void
my_object_class_init (MyObjectClass *klass)
{
  g_type_class_add_private (klass, sizeof (MyObjectPrivate));
}

static void
my_object_init (MyObject *my_object)
{
  my_object->priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object,
                                                 MY_TYPE_OBJECT,
                                                 MyObjectPrivate);
  // my_object->priv->some_field will be automatically initialised to 0
}

static int
my_object_get_some_field (MyObject *my_object)
{
  MyObjectPrivate *priv;

  g_return_val_if_fail (MY_IS_OBJECT (my_object), 0);

  priv = my_object->priv;

  return priv->some_field;
}

Added in version 2.4.

Deprecated since version 2.58: Use the ADD_PRIVATE() macro with the ``G_DEFINE_``* family of macros to add instance private data to a type

Parameters:

private_size – size of private structure

adjust_private_offset(g_class: None, private_size_or_offset: int) → None

Parameters:

• g_class

• private_size_or_offset

get_private(private_type: type) → None

Parameters:

private_type

peek(type: type) → TypeClass

This function is essentially the same as ref(), except that the classes reference count isn’t incremented. As a consequence, this function may return None if the class of the type passed in does not currently exist (hasn’t been referenced before).

Parameters:

type – type ID of a classed type

peek_parent() → TypeClass

This is a convenience function often needed in class initializers. It returns the class structure of the immediate parent type of the class passed in. Since derived classes hold a reference count on their parent classes as long as they are instantiated, the returned class will always exist.

This function is essentially equivalent to: g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class)))

peek_static(type: type) → TypeClass

A more efficient version of peek() which works only for static types.

Added in version 2.4.

Parameters:

type – type ID of a classed type

Fields

class TypeClass

g_type