GType

GType — GLib окружение идентификации типов и система управления

Краткое описание



#include <glib-object.h>


typedef             GType;
#define             G_TYPE_FUNDAMENTAL                  (type)
#define             G_TYPE_FUNDAMENTAL_MAX
#define             G_TYPE_MAKE_FUNDAMENTAL             (x)
#define             G_TYPE_IS_ABSTRACT                  (type)
#define             G_TYPE_IS_DERIVED                   (type)
#define             G_TYPE_IS_FUNDAMENTAL               (type)
#define             G_TYPE_IS_VALUE_TYPE                (type)
#define             G_TYPE_HAS_VALUE_TABLE              (type)
#define             G_TYPE_IS_CLASSED                   (type)
#define             G_TYPE_IS_INSTANTIATABLE            (type)
#define             G_TYPE_IS_DERIVABLE                 (type)
#define             G_TYPE_IS_DEEP_DERIVABLE            (type)
#define             G_TYPE_IS_INTERFACE                 (type)
                    GTypeInterface;
                    GTypeInstance;
                    GTypeClass;
                    GTypeInfo;
                    GTypeFundamentalInfo;
                    GInterfaceInfo;
                    GTypeValueTable;
#define             G_TYPE_FROM_INSTANCE                (instance)
#define             G_TYPE_FROM_CLASS                   (g_class)
#define             G_TYPE_FROM_INTERFACE               (g_iface)
#define             G_TYPE_INSTANCE_GET_CLASS           (instance, g_type, c_type)
#define             G_TYPE_INSTANCE_GET_INTERFACE       (instance, g_type, c_type)
#define             G_TYPE_INSTANCE_GET_PRIVATE         (instance, g_type, c_type)
#define             G_TYPE_CHECK_INSTANCE               (instance)
#define             G_TYPE_CHECK_INSTANCE_CAST          (instance, g_type, c_type)
#define             G_TYPE_CHECK_INSTANCE_TYPE          (instance, g_type)
#define             G_TYPE_CHECK_CLASS_CAST             (g_class, g_type, c_type)
#define             G_TYPE_CHECK_CLASS_TYPE             (g_class, g_type)
#define             G_TYPE_CHECK_VALUE                  (value)
#define             G_TYPE_CHECK_VALUE_TYPE             (value, g_type)
#define             G_TYPE_FLAG_RESERVED_ID_BIT
void                g_type_init                         (void);
enum                GTypeDebugFlags;
void                g_type_init_with_debug_flags        (GTypeDebugFlags debug_flags);
const gchar*        g_type_name                         (GType type);
GQuark              g_type_qname                        (GType type);
GType               g_type_from_name                    (const gchar *name);
GType               g_type_parent                       (GType type);
guint               g_type_depth                        (GType type);
GType               g_type_next_base                    (GType leaf_type,
                                                         GType root_type);
gboolean            g_type_is_a                         (GType type,
                                                         GType is_a_type);
gpointer            g_type_class_ref                    (GType type);
gpointer            g_type_class_peek                   (GType type);
gpointer            g_type_class_peek_static            (GType type);
void                g_type_class_unref                  (gpointer g_class);
gpointer            g_type_class_peek_parent            (gpointer g_class);
void                g_type_class_add_private            (gpointer g_class,
                                                         gsize private_size);
gpointer            g_type_interface_peek               (gpointer instance_class,
                                                         GType iface_type);
gpointer            g_type_interface_peek_parent        (gpointer g_iface);
gpointer            g_type_default_interface_ref        (GType g_type);
gpointer            g_type_default_interface_peek       (GType g_type);
void                g_type_default_interface_unref      (gpointer g_iface);
GType*              g_type_children                     (GType type,
                                                         guint *n_children);
GType*              g_type_interfaces                   (GType type,
                                                         guint *n_interfaces);
GType*              g_type_interface_prerequisites      (GType interface_type,
                                                         guint *n_prerequisites);
void                g_type_set_qdata                    (GType type,
                                                         GQuark quark,
                                                         gpointer data);
gpointer            g_type_get_qdata                    (GType type,
                                                         GQuark quark);
void                g_type_query                        (GType type,
                                                         GTypeQuery *query);
                    GTypeQuery;
void                (*GBaseInitFunc)                    (gpointer g_class);
void                (*GBaseFinalizeFunc)                (gpointer g_class);
void                (*GClassInitFunc)                   (gpointer g_class,
                                                         gpointer class_data);
void                (*GClassFinalizeFunc)               (gpointer g_class,
                                                         gpointer class_data);
void                (*GInstanceInitFunc)                (GTypeInstance *instance,
                                                         gpointer g_class);
void                (*GInterfaceInitFunc)               (gpointer g_iface,
                                                         gpointer iface_data);
void                (*GInterfaceFinalizeFunc)           (gpointer g_iface,
                                                         gpointer iface_data);
gboolean            (*GTypeClassCacheFunc)              (gpointer cache_data,
                                                         GTypeClass *g_class);
enum                GTypeFlags;
enum                GTypeFundamentalFlags;
GType               g_type_register_static              (GType parent_type,
                                                         const gchar *type_name,
                                                         const GTypeInfo *info,
                                                         GTypeFlags flags);
GType               g_type_register_static_simple       (GType parent_type,
                                                         const gchar *type_name,
                                                         guint class_size,
                                                         GClassInitFunc class_init,
                                                         guint instance_size,
                                                         GInstanceInitFunc instance_init,
                                                         GTypeFlags flags);
GType               g_type_register_dynamic             (GType parent_type,
                                                         const gchar *type_name,
                                                         GTypePlugin *plugin,
                                                         GTypeFlags flags);
GType               g_type_register_fundamental         (GType type_id,
                                                         const gchar *type_name,
                                                         const GTypeInfo *info,
                                                         const GTypeFundamentalInfo *finfo,
                                                         GTypeFlags flags);
void                g_type_add_interface_static         (GType instance_type,
                                                         GType interface_type,
                                                         const GInterfaceInfo *info);
void                g_type_add_interface_dynamic        (GType instance_type,
                                                         GType interface_type,
                                                         GTypePlugin *plugin);
void                g_type_interface_add_prerequisite   (GType interface_type,
                                                         GType prerequisite_type);
GTypePlugin*        g_type_get_plugin                   (GType type);
GTypePlugin*        g_type_interface_get_plugin         (GType instance_type,
                                                         GType interface_type);
GType               g_type_fundamental_next             (void);
GType               g_type_fundamental                  (GType type_id);
GTypeInstance*      g_type_create_instance              (GType type);
void                g_type_free_instance                (GTypeInstance *instance);
void                g_type_add_class_cache_func         (gpointer cache_data,
                                                         GTypeClassCacheFunc cache_func);
void                g_type_remove_class_cache_func      (gpointer cache_data,
                                                         GTypeClassCacheFunc cache_func);
void                g_type_class_unref_uncached         (gpointer g_class);
void                g_type_add_interface_check          (gpointer check_data,
                                                         GTypeInterfaceCheckFunc check_func);
void                g_type_remove_interface_check       (gpointer check_data,
                                                         GTypeInterfaceCheckFunc check_func);
void                (*GTypeInterfaceCheckFunc)          (gpointer check_data,
                                                         gpointer g_iface);
GTypeValueTable*    g_type_value_table_peek             (GType type);
#define             G_DEFINE_TYPE                       (TN, t_n, T_P)
#define             G_DEFINE_TYPE_WITH_CODE             (TN, t_n, T_P, _C_)
#define             G_DEFINE_ABSTRACT_TYPE              (TN, t_n, T_P)
#define             G_DEFINE_ABSTRACT_TYPE_WITH_CODE    (TN, t_n, T_P, _C_)
#define             G_IMPLEMENT_INTERFACE               (TYPE_IFACE, iface_init)
#define             G_DEFINE_TYPE_EXTENDED              (TN, t_n, T_P, _f_, _C_)


#define             G_TYPE_INVALID
#define             G_TYPE_NONE
#define             G_TYPE_INTERFACE
#define             G_TYPE_CHAR
#define             G_TYPE_UCHAR
#define             G_TYPE_BOOLEAN
#define             G_TYPE_INT
#define             G_TYPE_UINT
#define             G_TYPE_LONG
#define             G_TYPE_ULONG
#define             G_TYPE_INT64
#define             G_TYPE_UINT64
#define             G_TYPE_ENUM
#define             G_TYPE_FLAGS
#define             G_TYPE_FLOAT
#define             G_TYPE_DOUBLE
#define             G_TYPE_STRING
#define             G_TYPE_POINTER
#define             G_TYPE_BOXED
#define             G_TYPE_PARAM
#define             G_TYPE_OBJECT
#define             G_TYPE_GTYPE

#define             G_TYPE_RESERVED_GLIB_FIRST
#define             G_TYPE_RESERVED_GLIB_LAST
#define             G_TYPE_RESERVED_BSE_FIRST
#define             G_TYPE_RESERVED_BSE_LAST
#define             G_TYPE_RESERVED_USER_FIRST

Описание

GType API является основой системы GObject. Он обеспечивает средства для регистрации и управления всеми базовыми типами данных, определённых пользователем объектов и типами интерфейсов. Перед использованием любых функций GType или GObject, должна быть вызвана g_type_init() для инициализации системы типов.

Для создания типа и регистрационных целей, все типы относятся к одной из двух категорий: статические или динамические. Статические типы никогда не загружаются и не выгружаются во время выполнения, как это могут делать динамические типы. Статические типы создаются с помощью g_type_register_static() которая получает определённую информацию помещаемую в неё через структуру GTypeInfo. Динамические типы создаются с помощью g_type_register_dynamic() которая принимает вместо сструктуры GTypePlugin. Оставшаяся информация типа (GTypeInfo структура) находится во время выполнения через GTypePlugin и g_type_plugin_*() API. Эти регистрационные функции полезно вызывать только однажды из функции целью которой является возврат идентификатора типа для определённого класса. Как только тип (либо класс или интерфейс) зарегистрирован, он может быть инстанциирован, унаследован, или реализован в зависимости от того, что это за тип. Есть также третья регистрационная функция для регистрации базовых типов g_type_register_fundamental() которая требует и структуру GTypeInfo и структуру GTypeFundamentalInfo, но она редко используется, так как большинство базовых типов является предопределёнными и не определяются пользователем.

В заключительном слове об именах типов. Такой идентификатор должен быть по крайней мере длиной из трёх символов. Максимального предела длины не существует. Первый символ должен быть буквой (a-z или A-Z) или символом подчёркивания '_'. Последующие символы могут быть буквами, цифрами или одним из символов '-_+'.

Детали

GType

Числовое значение которое представляет уникальный идентификатор зарегистрированного типа.

G_TYPE_FUNDAMENTAL()

#define G_TYPE_FUNDAMENTAL(type)	(g_type_fundamental (type))

Возвращает базовый тип который наследует type. Базовые типы являются типами которые служат основой для производных типов, таким образом они являются корнями отдельных иерархий наследования.

type : GType значение.

G_TYPE_FUNDAMENTAL_MAX

#define	G_TYPE_FUNDAMENTAL_MAX		(255 << G_TYPE_FUNDAMENTAL_SHIFT)

Целочисленная константа представляющая количество идентификаторов, зарезервированных для типов обозначенных во время компиляции.

G_TYPE_MAKE_FUNDAMENTAL()

#define	G_TYPE_MAKE_FUNDAMENTAL(x)	((GType) ((x) << G_TYPE_FUNDAMENTAL_SHIFT))

Возвращает ID для базового типа с номером x. Используйте g_type_fundamental_next() вместо этого макроса для создания нового базового типа.

x : номер базового типа.

G_TYPE_IS_ABSTRACT()

#define G_TYPE_IS_ABSTRACT(type)                (g_type_test_flags ((type), G_TYPE_FLAG_ABSTRACT))

Возвращает TRUE если type является абстрактным. Абстрактный тип может не инициироваться и используется обычно как абстрактный основной класс для наследования классов.

type : значение GType.

G_TYPE_IS_DERIVED()

#define G_TYPE_IS_DERIVED(type)                 ((type) > G_TYPE_FUNDAMENTAL_MAX)

Возвращает TRUE если type унаследован из другого типа (возвращает TRUE для всех не базовых типов).

type : значение GType.

G_TYPE_IS_FUNDAMENTAL()

#define G_TYPE_IS_FUNDAMENTAL(type)             ((type) <= G_TYPE_FUNDAMENTAL_MAX)

Возвращает TRUE если type является базовым типом.

type : значение GType.

G_TYPE_IS_VALUE_TYPE()

#define G_TYPE_IS_VALUE_TYPE(type)              (g_type_check_is_value_type (type))

Возвращает TRUE если type является типовым значением и может использоваться с помощью g_value_init().

type : значение GType.

G_TYPE_HAS_VALUE_TABLE()

#define G_TYPE_HAS_VALUE_TABLE(type)            (g_type_value_table_peek (type) != NULL)

Возвращает TRUE если type имеет GTypeValueTable.

type : значение GType.

G_TYPE_IS_CLASSED()

#define G_TYPE_IS_CLASSED(type)                 (g_type_test_flags ((type), G_TYPE_FLAG_CLASSED))

Возвращает TRUE если type является классовым типом.

type : значение GType.

G_TYPE_IS_INSTANTIATABLE()

#define G_TYPE_IS_INSTANTIATABLE(type)          (g_type_test_flags ((type), G_TYPE_FLAG_INSTANTIATABLE))

Возвращает TRUE если type может быть инстанциирован. Инстанциация - это процесс создания экземпляра объекта данного типа.

type : значение GType.

G_TYPE_IS_DERIVABLE()

#define G_TYPE_IS_DERIVABLE(type)               (g_type_test_flags ((type), G_TYPE_FLAG_DERIVABLE))

Возвращает TRUE если type является наследником. Наследуемый тип может использоваться как основной класс плоской (одноуровневой) иерархии класса.

type : значение GType.

G_TYPE_IS_DEEP_DERIVABLE()

#define G_TYPE_IS_DEEP_DERIVABLE(type)          (g_type_test_flags ((type), G_TYPE_FLAG_DEEP_DERIVABLE))

Возвращает TRUE если type глубоко наследуемыйй тип. Глубоко наследуемыйй тип может использоваться как основной класс глубокой (многоуровневой) иерархии класса.

type : значение GType.

G_TYPE_IS_INTERFACE()

#define G_TYPE_IS_INTERFACE(type)               (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INTERFACE)

Возвращает TRUE если type является интерфейсным типом. Интерфейсные типы обеспечивают чистый API, реализация которого обеспечивается другим типом (который, как говорится в таких случаях, соответствует интерфейсу). GLib интерфейсы являются в некотором роде аналогами интерфейсов Java и C++ классов содержащие только чистые виртуальные функции, различие в том, что GType интерфейсы не наследуемый (но можно посмотреть альтернативу g_type_interface_add_prerequisite()).

type : значение GType.

GTypeInterface

typedef struct {
} GTypeInterface;

Непрозрачная структура используемая как основа всех интерфейсных типов.

GTypeInstance

typedef struct {
} GTypeInstance;

Непрозрачная структура используемая как основа всех инстанциируемых типов.

GTypeClass

typedef struct {
} GTypeClass;

Непрозрачная структура используемая как основа всех классов.

GTypeInfo

typedef struct {
  /* interface types, classed types, instantiated types */
  guint16                class_size;
  
  GBaseInitFunc          base_init;
  GBaseFinalizeFunc      base_finalize;
  
  /* interface types, classed types, instantiated types */
  GClassInitFunc         class_init;
  GClassFinalizeFunc     class_finalize;
  gconstpointer          class_data;
  
  /* instantiated types */
  guint16                instance_size;
  guint16                n_preallocs;
  GInstanceInitFunc      instance_init;
  
  /* value handling */
  const GTypeValueTable	*value_table;
} GTypeInfo;

Эта структура используется для обеспечения системы типов информацией запрашиваемой для инициализации и уничтожения (финализации) типового класса и его экземпляра. Инициализированная структура помещается в функцию g_type_register_static() (или копируется в структуру GTypeInfo обеспеченную функцией g_type_plugin_complete_type_info()). Система типов выполнит глубокую копию этой сструктуры, поэтому память не должна быть постоянной через вызов g_type_register_static().

guint16 `class_size`;	Размер сструктуры класса (требуется для интерфейсных, классифицированных и инстанцируемых типов).
GBaseInitFunc `base_init`;	Расположение основной инициализирующей функции (опционально).
GBaseFinalizeFunc `base_finalize`;	Расположение основной финализирующей функции (опционально).
GClassInitFunc `class_init`;	Расположение функции инициализации класса для классов и типов. Расположение по умолчанию vtable инициализирующей функции для интерфейсных типов. (опционально) Для заполнения виртуальной функции класса используется либо эта функция либо значение по умолчанию vtable, и выполняет специфичную для типа установку такую как регистрация сигналов и свойств объекта.
GClassFinalizeFunc `class_finalize`;	Расположение функции финализации класса для классов и типов. Расположение по умолчанию в vtable функции финализации интерфейсных типов. (опционально)
gconstpointer `class_data`;	Данные обеспечиваемые пользователем помещаемые в классовые функции инициализация/финализация.
guint16 `instance_size`;	Размер экземпляра (объекта) сструктуры (запрашиваемый только для инстанциирования).
guint16 `n_preallocs`;	До GLib 2.10, представлял количество предварительно распределённых (кэшированных) экземпляров для резервирования памяти (0 указывает на отсутствие кэша). Начиная с версии GLib 2.10, игнорируется, так как теперь экземпляры распределяются с помощью slice allocator.
GInstanceInitFunc `instance_init`;	Расположение функции инициализирующей экземпляр (опционально, только для инстанциируемых типов).
const GTypeValueTable *`value_table`;	Табличная функция GTypeValueTable для основной обработки GValues этого типа (обычно полезна только для базовых типов).

GTypeFundamentalInfo

typedef struct {
  GTypeFundamentalFlags  type_flags;
} GTypeFundamentalInfo;

Структура обеспечивающая информацией систему типов специально для управления базовыми типами.

GTypeFundamentalFlags type_flags; GTypeFundamentalFlags описывает характеристики базового типа

GInterfaceInfo

typedef struct {
  GInterfaceInitFunc     interface_init;
  GInterfaceFinalizeFunc interface_finalize;
  gpointer               interface_data;
} GInterfaceInfo;

Структура обеспечивает информацию для системы типов которая используется специально для управления интерфейсными типами.

GInterfaceInitFunc `interface_init`;	расположение функции инициализации интерфейса
GInterfaceFinalizeFunc `interface_finalize`;	расположение функции финализации интерфейса
gpointer `interface_data`;	пользовательские данные для функций инициализации/финализации интерфейса

GTypeValueTable

typedef struct {
  void     (*value_init)         (GValue       *value);
  void     (*value_free)         (GValue       *value);
  void     (*value_copy)         (const GValue *src_value,
				  GValue       *dest_value);
  /* varargs functionality (optional) */
  gpointer (*value_peek_pointer) (const GValue *value);
  gchar	    *collect_format;
  gchar*   (*collect_value)      (GValue       *value,
				  guint         n_collect_values,
				  GTypeCValue  *collect_values,
				  guint		collect_flags);
  gchar	    *lcopy_format;
  gchar*   (*lcopy_value)        (const GValue *value,
				  guint         n_collect_values,
				  GTypeCValue  *collect_values,
				  guint		collect_flags);
} GTypeValueTable;

GTypeValueTable обеспечивает функции требуемые реализацией GValue, которая служит контейнером для значений типа.

value_init () По умолчанию инициализирует содержимое values записывая значения непосредственно в массив value->data. Массив данных GValue помещённый в эту функцию будет заполнен нулями с помощью memset(), поэтому не нужно беспокоится об освобождении предыдущего содержимого. Например реализация строкового значения которое могло бы быть не NULL, может выглядеть так: { value->data[0].v_pointer = g_strdup (""); }

value_free () Освобождает любое предыдущее содержимое массива данных помещённого в value. Ресурсы распределённые для содержимого GValue после вызова этой функции освобождаются. На примере нашей строки выше: { /* освобождает строки только без определённого флага статического хранения */ if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)) g_free (value->data[0].v_pointer); }

value_copy () dest_value это GValue с разделом данных заполненным нулями, а src_value надлежащим образом установленная GValue того же или производного типа. Цель функции заключается в копировании содержимого src_value в dest_value, то есть даже после освобождения src_value, содержимое dest_value останется доступным. Типовой пример строки: { dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer); }

value_peek_pointer () Если значение содержимого заполнено указателем, таким как объекты или строки, возвращает этот указатель, таким образом вызывающая программа может посмотреть текущее содержимое. Расширение нашего примера строки выше: { return value->data[0].v_pointer; }

gchar *collect_format;

Формат строки описывающий как накапливается содержимое этого значения поразрядно. Каждый символ в формате представляет накапливаемый параметр и непосредственно символы указывают тип параметра. В настоящее время поддерживаются параметры:

	'i' - Целочисленные. помещаются как collect_values[].v_int.
	'l' - Longs. помещаются как collect_values[].v_long.
	'd' - Doubles. помещаются как collect_values[].v_double.
	'p' - Указатели. помещаются как collect_values[].v_pointer.

Должно быть отмечено, что для конструирования списка переменных параметров, ANSI C преобразует каждый тип меньше чем целочисленное в int, а floats в doubles. Поэтому для накапливания short int или char, нужно использовать 'i', а для накапливания floats 'd'.

collect_value () функция collect_value() отвечает за преобразование накопленных значений из списка переменных параметров в содержимое подходящее для хранения в GValue. Эта функция должна установить value подобно value_init(); например для строкового значения которое не допускает NULL указателей, она должна либо вернуть ошибку, либо выполнить неявное преобразование сохранив пустую строку. value помещённый в эту функцию является нулевым массивом данных, таким образом точно так же как для value_init() гарантирует отсутствие предыдущего содержимого которое нужно освобождать. n_collect_values точная длина строки collect_format, а collect_values массив объединений GTypeCValue с длиной n_collect_values, содержащий накопленные значения согласно collect_format. collect_flags - является параметром обеспечивающим подсказку для вызывающей программы. Он может содержать флаг G_VALUE_NOCOPY_CONTENTS указывающий, что накопленное значение содержимого можно рассматривать как "static" в течение жизненного цикла value. Поэтому дополнительная копия содержимого сохранённого в collect_values не требуется для назначения value. Наш пример строки выше, мы продолжим следующим: { if (!collect_values[0].v_pointer) value->data[0].v_pointer = g_strdup (""); else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) { value->data[0].v_pointer = collect_values[0].v_pointer; /* keep a flag for the value_free() implementation to not free this string */ value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS; } else value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer); return NULL; } Должно быть отмечено, что это вообще плохая идея следовать подсказке G_VALUE_NOCOPY_CONTENTS для подсчёта типовых ссылок. Из-за повторно используемого запроса и условия подсчёта ссылок с помощью кода GSignal, подсчёт ссылок должен всегда увеличиваться подсчёта ссылок содержимого хранящегося в массиве value->data. На мгновение отклонимся от нашего примера строки, и рассмотрим экземпляр реализации для collect_value() с "" { if (collect_values[0].v_pointer) { GObject *object = G_OBJECT (collect_values[0].v_pointer); /* never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types */ value->data[0].v_pointer = g_object_ref (object); return NULL; } else return g_strdup_printf ("Object passed as invalid NULL pointer"); } Подсчёт ссылок для допустимых объектов всегда увеличивается, независимо от collect_flags. Для недопустимых объектов, пример возвращает вновь распределённую строку без изменения value. После успешного выполнения, collect_value() должен вернуть NULL. Однако если произошла ошибка, collect_value() может выдать ошибку возвращая вновь распределённую не-NULL строку, дав подходящее описание произошедшей ошибки. Вызываемый код не пытается определить допустимость содержимого value при возвращении ошибки, value просто выбрасывается без дальнейшего освобождения. Так же, это хороший метод не распределять содержимое GValue, до возвращения ошибки, однако, collect_values() не обязана возвращать правильно установленное value для возврата ошибки, просто потому что любое не-NULL возвращение рассматривается как фатальное условие поэтому дальнейшее поведение программы не определено.

gchar *lcopy_format; Формат описывающий аргументы накопленные для lcopy_value, аналогичен collect_format. Обычно, строка lcopy_format состоит только из 'p' для обеспечения lcopy_value() указателями на сохраняемые расположения.

lcopy_value () Эта функция отвечает за сохранение содержимого value в параметрах помещаемых через список переменных параметров которые накоплены в collect_values согласно lcopy_format. n_collect_values равен длине строки lcopy_format, а collect_flags может содержать G_VALUE_NOCOPY_CONTENTS. В отличие от collect_value(), lcopy_value() обязан всегда должным образом поддерживать G_VALUE_NOCOPY_CONTENTS. Подобно collect_value() функция может прерываться преждевременно возвращая вновь распределённую строку описывающую произошедшую ошибку. Завершаем пример строки: { gchar **string_p = collect_values[0].v_pointer; if (!string_p) return g_strdup_printf ("string location passed as NULL"); if (collect_flags & G_VALUE_NOCOPY_CONTENTS) *string_p = value->data[0].v_pointer; else *string_p = g_strdup (value->data[0].v_pointer); } И демонстрационная версия lcopy_value() для подсчёта ссылок типов: { GObject **object_p = collect_values[0].v_pointer; if (!object_p) return g_strdup_printf ("object location passed as NULL"); if (!value->data[0].v_pointer) *object_p = NULL; else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) /* always honour */ *object_p = value->data[0].v_pointer; else *object_p = g_object_ref (value->data[0].v_pointer); return NULL; }

G_TYPE_FROM_INSTANCE()

#define G_TYPE_FROM_INSTANCE(instance)                          (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class))

Возвращает идентификатор типа из полученной сструктуры instance.

Этот макрос должен использоваться только при реализации типа.

instance : Расположение допустимой сструктуры GTypeInstance.

G_TYPE_FROM_CLASS()

#define G_TYPE_FROM_CLASS(g_class)                              (((GTypeClass*) (g_class))->g_type)

Возвращает идентификатор из полученной сструктуры class.

Этот макрос должен использоваться только при реализации типа.

g_class : Расположение допустимой сструктуры GTypeClass.

G_TYPE_FROM_INTERFACE()

#define G_TYPE_FROM_INTERFACE(g_iface)                          (((GTypeInterface*) (g_iface))->g_type)

Возвращает идентификатор из полученной сструктуры interface.

Этот макрос должен использоваться только при реализации типа.

g_iface : Расположение допустимой сструктуры GTypeInterface.

G_TYPE_INSTANCE_GET_CLASS()

#define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type)     (_G_TYPE_IGC ((instance), (g_type), c_type))

Возвращает структуру класса полученного instance, приводя к указанному типу предка экземпляра g_type.

Внимание

Помните что в течение вызова GInstanceInitFunc(), указатель класса изменяется, поэтому может не всегда возвращаться ожидаемый указатель.

Этот макрос должен использоваться только при реализации типа.

`instance` :	Расположение сструктуры GTypeInstance.
`g_type` :	Тип возвращаемого родительского класса.
`c_type` :	C тип соответствующий `g_type`.

G_TYPE_INSTANCE_GET_INTERFACE()

#define G_TYPE_INSTANCE_GET_INTERFACE(instance, g_type, c_type) (_G_TYPE_IGI ((instance), (g_type), c_type))

Возвращает структуру интерфейса для интерфейса g_type полученного instance.

Этот макрос должен использоваться только для реализации типа.

`instance` :	Расположение сструктуры GTypeInstance.
`g_type` :	Возвращаемые интерфейсный тип.
`c_type` :	C тип соответствующий `g_type`.

G_TYPE_INSTANCE_GET_PRIVATE()

#define G_TYPE_INSTANCE_GET_PRIVATE(instance, g_type, c_type)   ((c_type*) g_type_instance_get_private ((GTypeInstance*) (instance), (g_type)))

Выдаёт закрытую структуру для определённого типа. Закрытая структура должна быть зарегистрирована в функции class_init с помощью g_type_class_add_private().

Этот макрос должен использоваться только при реализации типа.

`instance` :	экземпляр типа наследующий `private_type`.
`g_type` :	идентификатор типа который определяется с помощью закрытых данных.
`c_type` :	C тип для закрытой сструктуры.

Начиная с версии 2.4

G_TYPE_CHECK_INSTANCE()

#define G_TYPE_CHECK_INSTANCE(instance)				(_G_TYPE_CHI ((GTypeInstance*) (instance)))

Возвращает TRUE если instance является допустимой структурой GTypeInstance, иначе издаёт предупреждение и возвращает FALSE.

Этот макрос должен использоваться только при реализации типа.

instance : Расположение сструктуры GTypeInstance.

G_TYPE_CHECK_INSTANCE_CAST()

#define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type)    (_G_TYPE_CIC ((instance), (g_type), c_type))

Проверяет является ли instance экземпляром типа идентифицируемым g_type и издаёт предупреждение если это не так. Возвращает instance приведённый к указателю c_type.

Этот макрос должен использоваться только при реализации типа.

`instance` :	Расположение сструктуры GTypeInstance.
`g_type` :	возвращаемый тип.
`c_type` :	C тип соответствующий `g_type`.

G_TYPE_CHECK_INSTANCE_TYPE()

#define G_TYPE_CHECK_INSTANCE_TYPE(instance, g_type)            (_G_TYPE_CIT ((instance), (g_type)))

Возвращает TRUE если instance является экземпляром типа идентифицируемым g_type. Иначе издаёт предупреждение и возвращает FALSE.

Этот макрос должен использоваться только при реализации типа.

`instance` :	Расположение сструктуры GTypeInstance.
`g_type` :	Проверяемый тип

G_TYPE_CHECK_CLASS_CAST()

#define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type)        (_G_TYPE_CCC ((g_class), (g_type), c_type))

Проверяет является ли g_class классовой структурой типа идентифицируемого g_type и издаёт предупреждение если это не так. Возвращает g_class приведённый к указателю c_type.

Этот макрос должен использоваться только при реализации типа.

`g_class` :	Расположение сструктуры GTypeClass.
`g_type` :	Возвращаемый тип.
`c_type` :	C тип соответствующий `g_type`.

G_TYPE_CHECK_CLASS_TYPE()

#define G_TYPE_CHECK_CLASS_TYPE(g_class, g_type)                (_G_TYPE_CCT ((g_class), (g_type)))

Возвращает TRUE если g_class является классовой структурой типа идентифицируемого с помощью g_type. Иначе издаёт предупреждение и возвращает FALSE.

Этот макрос должен использоваться только при реализации типа.

`g_class` :	Расположение сструктуры GTypeClass.
`g_type` :	Проверяемый тип.

G_TYPE_CHECK_VALUE()

#define G_TYPE_CHECK_VALUE(value)				(_G_TYPE_CHV ((value)))

Возвращает TRUE если value инициализировано типовым значением.

Этот макрос должен использоваться только при реализации типа.

value : GValue

G_TYPE_CHECK_VALUE_TYPE()

#define G_TYPE_CHECK_VALUE_TYPE(value, g_type)			(_G_TYPE_CVH ((value), (g_type)))

Возвращает TRUE если value инициализировано значением типа g_type.

Этот макрос должен использоваться только при реализации типа.

`value` :	GValue
`g_type` :	Проверяемый тип.

G_TYPE_FLAG_RESERVED_ID_BIT

#define	G_TYPE_FLAG_RESERVED_ID_BIT	((GType) (1 << 0))

Бит в числе типа который должен быть нетронутым.

g_type_init ()

void g_type_init (void);

Перед любым использованием системы типов, вызывается g_type_init() для инициализации системы типов и сортировки других частей кода (таких как различные реализации базовых типов или системы сигналов).

Перечисление GTypeDebugFlags

typedef enum	/*< skip >*/
{
  G_TYPE_DEBUG_NONE	= 0,
  G_TYPE_DEBUG_OBJECTS	= 1 << 0,
  G_TYPE_DEBUG_SIGNALS	= 1 << 1,
  G_TYPE_DEBUG_MASK	= 0x03
} GTypeDebugFlags;

Перечисление значений GTypeDebugFlags может помещаться в g_type_init_with_debug_flags() для переключения отладочных сообщений в процессе выполнения. Помните что сообщения могут также переключаться с помощью установки переменной окружения GOBJECT_DEBUG в список разделённых между собой символом ':' "objects" и "signals".

`G_TYPE_DEBUG_NONE`	Не печатать сообщение.
`G_TYPE_DEBUG_OBJECTS`	Напечатать сообщение об подсчёте объекта.
`G_TYPE_DEBUG_SIGNALS`	Напечатать сообщение об эмиссии сигнала.
`G_TYPE_DEBUG_MASK`	Маска покрывающая все отладочные флаги.

g_type_init_with_debug_flags ()

void g_type_init_with_debug_flags (GTypeDebugFlags debug_flags);

Подобна g_type_init(), но дополнительно устанавливает отладочные флаги.

debug_flags : Поразрядная комбинация значений GTypeDebugFlags для отладки.

g_type_name ()

const gchar* g_type_name (GType type);

Возвращает уникальное имя которое назначено типу ID (это привилегированный метод определения был ли определённый тип зарегистрирован для помещённого ID).

`type` :	Тип для которого возвращается имя.
Возвращает :	Статичное имя типа или `NULL`.

g_type_qname ()

GQuark g_type_qname (GType type);

Возвращает соответствующий кварк названия типа ID.

`type` :	тип для которого возвращается кварк.
Возвращает :	Кварк имени типа или 0.

g_type_from_name ()

GType g_type_from_name (const gchar *name);

Находит типовой ID из полученного имени типа, возвращает 0 если нет зарегистрированного типа с данным именем (это привилегированный метод определения по имени был ли зарегистрирован тип).

`name` :	Имя типа для поиска.
Возвращает :	Соответствующий типу ID или 0.

g_type_parent ()

GType g_type_parent (GType type);

Возвращает прямого родителя типа переданного в типе. Если тип не имеет помещённого в него родителя, то есть это базовый тип, возвращается 0.

`type` :	Производный тип.
Возвращает :	Родительский тип.

g_type_depth ()

guint g_type_depth (GType type);

Возвращает длину родословной помещенной в тип. Это включает сам тип непосредственно, поэтому базовые типы имеют глубину 1.

`type` :	значение GType.
Возвращает :	Глубина родословной `type`.

g_type_next_base ()

GType               g_type_next_base                    (GType leaf_type,
                                                         GType root_type);

Получает leaf_type и root_type который содержится в его родителе, возвращает тип непосредственно родителя root_type. Другими словами, эта функция определяет тип который получен непосредственно из root_type, который является также базовым классом leaf_type. Учитывая корневой тип и тип ответвления, эта функция может использоваться для определения типов и порядка в котором тип ответвления появляется из корневого типа.

`leaf_type` :	Потомок `root_type` и возвращаемый тип.
`root_type` :	Непосредственный родитель возвращаемого типа.
Возвращает :	Непосредственный ребёнок `root_type` и родитель `leaf_type`.

g_type_is_a ()

gboolean            g_type_is_a                         (GType type,
                                                         GType is_a_type);

Если is_a_type является производным типом, проверяет является ли type потомком is_a_type. Если is_a_type является интерфейсом, проверяет соответствует ли он type.

`type` :	Тип для проверки родословной.
`is_a_type` :	Возможный родитель `type` или интерфейс соответствующий `type`.
Возвращает :	`TRUE` если `type` содержит `is_a_type`.

g_type_class_ref ()

gpointer g_type_class_ref (GType type);

Увеличивает количество ссылок классовой сструктуры принадлежащей type. Эта функция создаст запрашиваемый класс если он ещё не существует.

`type` :	Типовой ID классифицируемого типа.
Возвращает :	Структуру GTypeClass для полученного типового ID.

g_type_class_peek ()

gpointer g_type_class_peek (GType type);

Эта функция такая же как g_type_class_ref(), только количество ссылок уменьшается. Как следствие, эта функция может вернуть NULL если помещённый в неё классовый тип в данный момент не существует (не имеет ссылок).

`type` :	Типовой ID классифицируемого типа.
Возвращает :	Структура GTypeClass для полученного типового ID или `NULL` если класс в данный момент не существует.

g_type_class_peek_static ()

gpointer g_type_class_peek_static (GType type);

Более эффективная версия g_type_class_peek() которая работает только для статических типов.

`type` :	Типовой ID классифицируемого типа.
Возвращает :	Структура GTypeClass для полученного типового ID или `NULL` если класс не существует в данный момент или загружается динамически.

Начиная с версии 2.4

g_type_class_unref ()

void g_type_class_unref (gpointer g_class);

Уменьшает количество ссылок помещённой сструктуры класса. Как только последняя ссылка была освобождена, класс может финализироваться системой типов, поэтому дальнейшее разыменование указателя класса после g_type_class_unref() невозможно.

g_class : Структура GTypeClass для сброса ссылки.

g_type_class_peek_parent ()

gpointer g_type_class_peek_parent (gpointer g_class);

Эта удобная функция часто необходима при инициализации класса. Она возвращает структуру класса непосредственно родительского типа помещенного класса. Так как производные классы содержат количество ссылок их родительских классов пока они инстанциирубтся, возвращаемый класс будет всегда существовать. Эта функция очень похожа на:


g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class)));

`g_class` :	Структура GTypeClass для определения родительского класса.
Возвращает :	Родительский класс `g_class`.

g_type_class_add_private ()

void                g_type_class_add_private            (gpointer g_class,
                                                         gsize private_size);

Регистрирует закрытую структуру для инстанциируемого типа; когда объект распределён, закрытая структура типа и все родительские типы распределяются последовательно в тот же блок памяти что и общие сструктуры. Эта функция должна вызываться в типовой функции class_init(). Закрытая структура может быть найдена используя макрос G_TYPE_INSTANCE_GET_PRIVATE(). В следующем примере показано прикрепление закрытой сструктуры MyObjectPrivate к объекту MyObject определённому в стандартном стиле GObject.


typedef struct _MyObjectPrivate MyObjectPrivate;

struct _MyObjectPrivate {
  int some_field;
};

#define MY_OBJECT_GET_PRIVATE(o)  \
   (G_TYPE_INSTANCE_GET_PRIVATE ((o), MY_TYPE_OBJECT, MyObjectPrivate))

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

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

  return priv->some_field;
}

`g_class` :	классовая структура для инстанциируемого типа
`private_size` :	размер закрытой сструктуры.

Начиная с версии 2.4

g_type_interface_peek ()

gpointer            g_type_interface_peek               (gpointer instance_class,
                                                         GType iface_type);

Возвращает структуру GTypeInterface интерфейса которому соответствует помещённый класс.

`instance_class` :	Структура GTypeClass.
`iface_type` :	ID интерфейса которому соответствует этот класс.
Возвращает :	Структуру GTypeInterface интерфейса iface_type если реализован с помощью `instance_class`, иначе `NULL`.

g_type_interface_peek_parent ()

gpointer g_type_interface_peek_parent (gpointer g_iface);

Возвращает структуру GTypeInterface соответствующего родительского типа типового экземпляра которому принадлежит g_iface. Это полезно когда наследуется реализация интерфейса из родительского типа и возможно отменяются некоторые методы.

`g_iface` :	Структура GTypeInterface.
Возвращает :	Соответствующую структуру GTypeInterface родительского типа типового экземпляра к которому принадлежит `g_iface`, или `NULL` если родительский тип не соответствует интерфейсу.

g_type_default_interface_ref ()

gpointer g_type_default_interface_ref (GType g_type);

Увеличивает количество ссылок для интерфейсного типа g_type, и возвращает значение по умолчанию интерфейс vtable для типа.

Если тип в текущий момент не используется, то значение по умолчанию vtable для типа будет создано и инициализировано вызовом инициализации основного типа и функций инициализации значения по умолчанию vtable для типа (@base_init и class_init члены GTypeInfo). Вызов g_type_default_interface_ref() полезен когда вам нужно убедиться что сигналы и свойства для интерфейса были установлены.

`g_type` :	интерфейсный тип
Возвращает :	значение по умолчанию vtable для интерфейса; вызовите `g_type_default_interface_unref()` после использования интерфейса.

Начиная с версии 2.4

g_type_default_interface_peek ()

gpointer g_type_default_interface_peek (GType g_type);

Если интерфейсный тип g_type в текущий момент используется, возвращает значение по умолчанию vtable интерфейса.

`g_type` :	интерфейсный тип
Возвращает :	значение по умолчанию vtable для интерфейса, или `NULL` если тип в текущий момент не используется.

Начиная с версии 2.4

g_type_default_interface_unref ()

void g_type_default_interface_unref (gpointer g_iface);

Уменьшает количество ссылок для типа соответствующего значению по умолчанию vtable интерфейса g_iface. Если тип динамический, то когда ни кто не использует интерфейс и все ссылки сброшены, будет вызвана функция финализации для значения по умолчанию vtable интерфейса (class_finalize член GTypeInfo).

g_iface : значение по умолчанию сструктуры vtable для интерфейса, которую возвращает g_type_default_interface_ref()

Начиная с версии 2.4

g_type_children ()

GType*              g_type_children                     (GType type,
                                                         guint *n_children);

Возвращает вновь распределенный и 0-завершённый массив типа ID, записывая в список дочерние типы type. Возвращаемое значение должно быть освобождено с помощью g_free() после использования.

`type` :	Родительский тип.
`n_children` :	Опционально guint указатель на содержащий количество дочерних типов.
Возвращает :	Вновь распределённый и 0-завершённый массив дочерних типов.

g_type_interfaces ()

GType*              g_type_interfaces                   (GType type,
                                                         guint *n_interfaces);

Возвращает вновь распределённый и 0-завершённый массив типа ID, записывая в список интерфейсные типы которым соответствует этот type. Возвращаемое значение должно быть освобождено с помощью g_free() после использования.

`type` :	Тип для списка интерфейсных типов.
`n_interfaces` :	Опционально guint указатель содержащий количество интерфейсных типов.
Возвращает :	Вновь распределённый и 0-завершённый массив интерфейсных типов.

g_type_interface_prerequisites ()

GType*              g_type_interface_prerequisites      (GType interface_type,
                                                         guint *n_prerequisites);

Возвращает предпосылки интерфейсного типа.

`interface_type` :	тип интерфейса
`n_prerequisites` :	расположение для возвращаемого количества предпосылок, или `NULL`
Возвращает :	вновь распределённый 0-завершённый массив GType содержащий предпосылки `interface_type`

Начиная с версии 2.2

g_type_set_qdata ()

void                g_type_set_qdata                    (GType type,
                                                         GQuark quark,
                                                         gpointer data);

Прикрепляет произвольные данные к типу.

`type` :	GType
`quark` :	GQuark для идентификации данных
`data` :	данные

g_type_get_qdata ()

gpointer            g_type_get_qdata                    (GType type,
                                                         GQuark quark);

Возвращает данные предварительно прикреплённые к type с помощью g_type_set_qdata().

`type` :	GType
`quark` :	GQuark для идентификации данных
Возвращает :	данные, или `NULL` если данные не найдены

g_type_query ()

void                g_type_query                        (GType type,
                                                         GTypeQuery *query);

Запрашивает у системы типов информацию об определённом типе. Эта функция заполняет определённую пользователем структуру типовой информацией. Если помещен неверный GType, type член GTypeQuery равен 0. Все члены заполненные в структуре GTypeQuery должны рассматриваться как константы и не должны изменяться.

`type` :	GType значение статичного, классифицированного типа.
`query` :	Обеспеченная пользователем структура которая заполняется константными значениями в случае успешного выполнения.

GTypeQuery

typedef struct {
  GType		type;
  const gchar  *type_name;
  guint		class_size;
  guint		instance_size;
} GTypeQuery;

Структура содержащая информацию для определённого типа. Она заполняется функцией g_type_query().

GType `type`;	GType значение типа.
const gchar * `type_name`;	имя типа.
guint `class_size`;	размер сструктуры класса.
guint `instance_size`;	размер сструктуры экземпляра.

GBaseInitFunc ()

void (*GBaseInitFunc) (gpointer g_class);

Это callback-функция используемая системой типов для основной инициализации классовых структур производных типов. Она вызывается как часть процесса инициализации всех производных классов и должна перераспределить или сбросить все динамические члены класса скопированные из родительского класса. Например, члены класса (такие как строки) которые не достаточно обработать простым копированием памяти родительского класса в производный класс, должны быть изменены. Смотрите GClassInitFunc() для обсуждения процесса инициализации классов.

g_class : Структура GTypeClass для инициализации.

GBaseFinalizeFunc ()

void (*GBaseFinalizeFunc) (gpointer g_class);

Это callback-функция используемая системой типов для финализации тех частей сструктуры класса производного типа которые были установлены из соответствующей функции GBaseInitFunc(). Финализация класса в основном работает в обратном порядке относительно процесса инициализации класса. Смотрите GClassInitFunc() для обсуждения процесса инициализации класса.

g_class : Структура GTypeClass для финализации.

GClassInitFunc ()

void                (*GClassInitFunc)                   (gpointer g_class,
                                                         gpointer class_data);

Это callback-функция используемая системой типов для инициализации класса определённого типа. Она должна инициализировать все статичные члены класса. Процесс инициализации класса включает:

	1 - Копирование основных членов из родительского класса в структуру класса наследника.
	2 - Инициализация нулём оставшихся членов не скопированных из родительского класса.
	3 - Запрос `GBaseInitFunc()` инициализируя весь родительский тип и классовый тип.
	4 - Запрос инициализатора класса `GClassInitFunc()`.

Так как производные классы частично инициализируются через копирование памяти родительского класса, основное правило в том, что GBaseInitFunc() и GBaseFinalizeFunc() должны заботится о необходимой переинициализации и высвобождении тех членов класса которые были введены типом определившим эти GBaseInitFunc()/GBaseFinalizeFunc(). GClassInitFunc() должна заботиться только об инициализации статичных членов класса, в то время как динамические члены класса (такие как распределённые строки или ресурсы подсчёта ссылок) лучше обрабатывать с помощью GBaseInitFunc() для данного типа, таким образом надлежащая инициализация динамических членов класса также выполняется для инициализации классов производных типов. Пример может помочь понять предназначение разных инициализаторов класса:


typedef struct {
  GObjectClass parent_class;
  gint         static_integer;
  gchar       *dynamic_string;
} TypeAClass;
static void
type_a_base_class_init (TypeAClass *class)
{
  class->dynamic_string = g_strdup ("some string");
}
static void
type_a_base_class_finalize (TypeAClass *class)
{
  g_free (class->dynamic_string);
}
static void
type_a_class_init (TypeAClass *class)
{
  class->static_integer = 42;
}

typedef struct {
  TypeAClass   parent_class;
  gfloat       static_float;
  GString     *dynamic_gstring;
} TypeBClass;
static void
type_b_base_class_init (TypeBClass *class)
{
  class->dynamic_gstring = g_string_new ("some other string");
}
static void
type_b_base_class_finalize (TypeBClass *class)
{
  g_string_free (class->dynamic_gstring);
}
static void
type_b_class_init (TypeBClass *class)
{
  class->static_float = 3.14159265358979323846;
}

Инициализация TypeBClass сначала вызовет инициализацию TypeAClass (производные классы ссылаются на их родительские классы, смотрите g_type_class_ref()). Инициализация TypeAClass инициализирует нулями свои поля, зтем вызовет свою GBaseInitFunc() type_a_base_class_init() для распределения своих динамических членов (dynamic_string), и наконец вызовет свою GClassInitFunc() type_a_class_init() для инициализации статических членов (static_integer). Первым шагом в процессе инициализации TypeBClass является прямое копирование памяти содержащей TypeAClass в TypeBClass и инициализация нулями оставшихся полей в TypeBClass. Динамические члены TypeAClass внутри TypeBClass теперь необходимо переинициализировать выполнив вызов type_a_base_class_init() с параметром TypeBClass. После GBaseInitFunc() из TypeBClass, вызывается type_b_base_class_init() для распределения динамических членов TypeBClass (dynamic_gstring), и наконец GClassInitFunc() из TypeBClass, вызывается type_b_class_init() для завершения процесса инициализации со статическими членами (static_float). Соответствующее количество частей финализации для GBaseInitFunc() функций обеспечивают освобождение распределённых ресурсов во время финализации класса.

`g_class` :	Структура GTypeClass для инициализации.
`class_data` :	Член `class_data` поставляемый через структуру GTypeInfo.

GClassFinalizeFunc ()

void                (*GClassFinalizeFunc)               (gpointer g_class,
                                                         gpointer class_data);

Это callback-функция используемая системой типов для финализации класса. Она редко нужна, так как динамически распределяемые ресурсы классов должны обрабатываться с помощью GBaseInitFunc() и GBaseFinalizeFunc(). Кроме того, спецификация GClassFinalizeFunc() в структуре GTypeInfo статических типов недоступна, потому что классы статических типов никогда не финализируются (они искусственно поддерживаются когда количество их ссылок достигает нуля).

`g_class` :	Структура GTypeClass для финализации.
`class_data` :	Член `class_data` поставляемый через структуру GTypeInfo.

GInstanceInitFunc ()

void                (*GInstanceInitFunc)                (GTypeInstance *instance,
                                                         gpointer g_class);

Это callback-функция используемая системой типов для инициализации нового экземпляра типа. Эта функция инициализирует все члены экземпляра и распределяет все ресурсы запрашиваемые ими. Инициализация производного экземпляра включает вызов всех инициализаторов экземпляров его родительских типов, поэтому член класса экземпляра изменяется в течение его инициализации чтобы всегда указывать на класс к которому принадлежит тип введённый в текущий инициализатор.

`instance` :	Инициализируемый экземпляр.
`g_class` :	Класс создаваемого типового экземпляра.

GInterfaceInitFunc ()

void                (*GInterfaceInitFunc)               (gpointer g_iface,
                                                         gpointer iface_data);

Это callback-функция используемая системой типов для инициализации нового интерфейса. Эта функция должна инициализировать все внутренние данные и распределять любые ресурсы запрошенные интерфейсом.

`g_iface` :	Структура для инициализации интерфейса.
`iface_data` :	`class_data` поставляемый через структуру GTypeInfo.

GInterfaceFinalizeFunc ()

void                (*GInterfaceFinalizeFunc)           (gpointer g_iface,
                                                         gpointer iface_data);

Это callback-функция используемая системой типов для финализации интерфейса. Эта функция должна уничтожать любые внутренние данные и освобождать любые ресурсы распределённые соответствующей функцией GInterfaceInitFunc().

`g_iface` :	Интерфейсная структура для финализации.
`iface_data` :	`class_data` поставляемый через структуру GTypeInfo.

GTypeClassCacheFunc ()

gboolean            (*GTypeClassCacheFunc)              (gpointer cache_data,
                                                         GTypeClass *g_class);

Эта callback-функция вызывается когда количество ссылок класса сбрасывается к нулю. Она может использовать g_type_class_ref() чтобы предотвратить освобождение класса. Вы не должны вызывать g_type_class_unref() из функции GTypeClassCacheFunc чтобы не допустить бесконечную рекурсию, используйте вместо неё g_type_class_unref_uncached().

Функции должны проверять id класса является ли он фактически кэшируеммым классом данного типа, так как все классы проходят через туже цепочку GTypeClassCacheFunc.

`cache_data` :	данные помещаемые в вызов `g_type_add_class_cache_func()`
`g_class` :	Структура GTypeClass на которую нет ссылок
Возвращает :	`TRUE` для прекращения последующих вызовов GTypeClassCacheFunc, `FALSE` для продолжения.

enum GTypeFlags

typedef enum    /*< skip >*/
{
  G_TYPE_FLAG_ABSTRACT		= (1 << 4),
  G_TYPE_FLAG_VALUE_ABSTRACT	= (1 << 5)
} GTypeFlags;

Битовая маска для контроля характеристик типа.

`G_TYPE_FLAG_ABSTRACT`	Указывает абстрактный тип. Экземпляры не могут быть созданы для абстрактного типа.
`G_TYPE_FLAG_VALUE_ABSTRACT`	Указывает значение абстрактного типа, то есть тип который введён в таблицу значений, но не может использоваться для `g_value_init()`.

enum GTypeFundamentalFlags

typedef enum    /*< skip >*/
{
  G_TYPE_FLAG_CLASSED           = (1 << 0),
  G_TYPE_FLAG_INSTANTIATABLE    = (1 << 1),
  G_TYPE_FLAG_DERIVABLE         = (1 << 2),
  G_TYPE_FLAG_DEEP_DERIVABLE    = (1 << 3)
} GTypeFundamentalFlags;

Битовая маска используемая для контроля специфичных характеристик базового типа.

`G_TYPE_FLAG_CLASSED`	Указывает классифицированный тип.
`G_TYPE_FLAG_INSTANTIATABLE`	Указывает инстанциируемый тип (подразумевает классифицируемый).
`G_TYPE_FLAG_DERIVABLE`	Указывает простой наследуемыйй тип.
`G_TYPE_FLAG_DEEP_DERIVABLE`	Указывает глубину наследуемого типа (включая производный).

g_type_register_static ()

GType               g_type_register_static              (GType parent_type,
                                                         const gchar *type_name,
                                                         const GTypeInfo *info,
                                                         GTypeFlags flags);

Регистрирует type_name как имя нового статичного типа унаследовавшего parent_type. Система типов использует информацию содержащуюся в структуре GTypeInfo указанной параметром info для управления типом и его экземплярами (если не абстрактный). Значение flags определяет природу типа (например абстрактный или нет).

`parent_type` :	Предок производного типа.
`type_name` :	0-завершённая строка используемая как имя нового типа.
`info` :	Структура GTypeInfo для данного типа.
`flags` :	Побитная комбинация значений GTypeFlags.
Возвращает :	Новый идентификатор типа.

g_type_register_static_simple ()

GType               g_type_register_static_simple       (GType parent_type,
                                                         const gchar *type_name,
                                                         guint class_size,
                                                         GClassInitFunc class_init,
                                                         guint instance_size,
                                                         GInstanceInitFunc instance_init,
                                                         GTypeFlags flags);

Регистрирует type_name как имя нового статичного типа унаследовавшего parent_type. Значение flags определяет природу типа (например абстрактный или нет). Она заполняет GTypeInfo структуру и вызывает g_type_register_static().

`parent_type` :	Тип который является предком производного типа.
`type_name` :	0-завершённая строка используемая как имя нового типа.
`class_size` :	Размер сструктуры класса (смотрите GTypeInfo)
`class_init` :	Расположение функции инициализации класса (смотрите GTypeInfo)
`instance_size` :	Размер сструктуры экземпляра (смотрите GTypeInfo)
`instance_init` :	Расположение функции инициализации экземпляра (смотрите GTypeInfo)
`flags` :	Побитная комбинация значений GTypeFlags.
Возвращает :	Идентификатор нового типа.

Начиная с версии 2.12

g_type_register_dynamic ()

GType               g_type_register_dynamic             (GType parent_type,
                                                         const gchar *type_name,
                                                         GTypePlugin *plugin,
                                                         GTypeFlags flags);

Регистрирует type_name как имя нового динамического типа унаследовавшего parent_type. Система типов использует информацию содержащуюся в структуре GTypePlugin указанной параметром plugin для управления типом и его экземпляром (если не абстрактный). Значение flags определяет природу типа (например абстрактный или нет).

`parent_type` :	Предок данного типа.
`type_name` :	0-завершённая строка используемая как имя нового типа.
`plugin` :	Структура GTypePlugin в которой находится GTypeInfo.
`flags` :	Побитовая комбинация значений GTypeFlags.
Возвращает :	Идентификатор нового типа или G_TYPE_INVALID если регистрация не удалась.

g_type_register_fundamental ()

GType               g_type_register_fundamental         (GType type_id,
                                                         const gchar *type_name,
                                                         const GTypeInfo *info,
                                                         const GTypeFundamentalInfo *finfo,
                                                         GTypeFlags flags);

Регистрирует type_id как предопределённый идентификатор, а type_name как имя базового типа. Система типов использует информацию содержащуюся в структуре GTypeInfo указанной параметром info и в структуре GTypeFundamentalInfo указанной параметром finfo для управления экземпляром типа. Значение flags определяет дополнительные характеристики базового типа.

`type_id` :	Предопределённое значение GTypeFundamentals.
`type_name` :	0-завершённая строка используемая как имя нового типа.
`info` :	Структура GTypeInfo данного типа.
`finfo` :	Структура GTypeFundamentalInfo для данного типа.
`flags` :	Побитная комбинация значений GTypeFlags.
Возвращает :	Предопределённый идентификатор типа.

g_type_add_interface_static ()

void                g_type_add_interface_static         (GType instance_type,
                                                         GType interface_type,
                                                         const GInterfaceInfo *info);

Добавляет статический interface_type к instantiable_type. Информация содержащаяся в структуре GTypeInterfaceInfo указанная параметром info используется для управления связью.

`instance_type` :	Значение GType инстанциируемого типа.
`interface_type` :	GType значение интерфейсного типа.
`info` :	Структура GInterfaceInfo для данной комбинации (`instance_type`, `interface_type`).

g_type_add_interface_dynamic ()

void                g_type_add_interface_dynamic        (GType instance_type,
                                                         GType interface_type,
                                                         GTypePlugin *plugin);

Добавляет динамический interface_type к instantiable_type. Информация содержащаяся в структуре GTypePlugin указанной параметром plugin используется для управления связью.

`instance_type` :	GType значение инстанциируемого типа.
`interface_type` :	GType значение интерфейсного типа.
`plugin` :	GTypePlugin структура находящаяся в GInterfaceInfo.

g_type_interface_add_prerequisite ()

void                g_type_interface_add_prerequisite   (GType interface_type,
                                                         GType prerequisite_type);

Добавляет prerequisite_type в список предпосылок interface_type. Это значит что любая реализация типа interface_type должна так же реализовать prerequisite_type. Предпосылки могут рассматриваться как альтернатива интерфейсного ответвления (которые не поддерживает GType). Интерфейс может иметь один инстанциируемый тип предпосылки.

`interface_type` :	GType значение интерфейсного типа.
`prerequisite_type` :	GType значение интерфейсного инстанциируемого типа.

g_type_get_plugin ()

GTypePlugin* g_type_get_plugin (GType type);

Возвращает структуру GTypePlugin для type или NULL если type не имеет структуру GTypePlugin.

`type` :	GType для поиска модуля (plugin).
Возвращает :	Соответствующий модуль если `type` является динамическим типом, иначе `NULL`.

g_type_interface_get_plugin ()

GTypePlugin*        g_type_interface_get_plugin         (GType instance_type,
                                                         GType interface_type);

Возвращает структуру GTypePlugin для динамического интерфейса interface_type который был добавлен к instance_type, или NULL если interface_type не добавлен к instance_type или если не имеет GTypePlugin структуру. Смотрите g_type_add_interface_dynamic().

`instance_type` :	GType значение инстанциируемого типа.
`interface_type` :	GType значение интерфейсного типа.
Возвращает :	GTypePlugin для динамического интерфейса `interface_type` принадлежащего `instance_type`.

g_type_fundamental_next ()

GType g_type_fundamental_next (void);

Возвращает следующий свободный идентификатор базового типа который можно использовать для регистрации нового базового типа с помощью g_type_register_fundamental(). Возвращаемый ID типа представляет наивысший регистрируемый идентификатор базового типа.

Возвращает :

Следующий за последним ID зарегистрированного базового типа, или 0 если система типов исчерпала идентификаторы базовых типов.

g_type_fundamental ()

GType g_type_fundamental (GType type_id);

Внутренняя функция, используется для извлечения части ID базового типа. вместо неё используйте G_TYPE_FUNDAMENTAL().

`type_id` :	допустимый ID типа
Возвращает :	ID базового типа

g_type_create_instance ()

GTypeInstance* g_type_create_instance (GType type);

Создаёт инициализированный экземпляр type если type является допустимым и может быть инстанциирован. Система типов выполняет только основное распределение и установку сструктуры для экземпляра: фактически экземпляр создаётся функциями поставляемыми реализацией базового типа. Поэтому использование g_type_create_instance() зарезервировано только для реализации базового типа. Например экземпляры иерархии GObject должны создаваться через g_object_new() и никогда не должны создаваться непосредственно через g_type_create_instance() которая не обрабатывает такие вещи как единственный ребёнок объекта или конструкцию объекта. Помните: Не используйте эту функцию, кроме как для реализации базового типа. Также языковые привязки не должны использовать эту функцию, а использовать вместо неё g_object_new().

`type` :	Инстанциируемый тип для создания экземпляра.
Возвращает :	Распределённый и инициализированный экземпляр, подвергается дальнейшей обработке реализацией базового типа.

g_type_free_instance ()

void g_type_free_instance (GTypeInstance *instance);

Освобождает экземпляр типа, возвращает его в пул экземпляров типа, если он есть.

Как g_type_create_instance(), эта функция зарезервирована для реализаций базовых типов.

instance : экземпляр типа.

g_type_add_class_cache_func ()

void                g_type_add_class_cache_func         (gpointer cache_data,
                                                         GTypeClassCacheFunc cache_func);

Добавляет GTypeClassCacheFunc которая будет вызвана перед сбросом количества ссылок класса в ноль. Это может использоваться для предотвращения преждевременного разрушения класса. Все установленные функции GTypeClassCacheFunc будут скованы пока одна из них не вернёт TRUE. Функции должны контролировать помещаемый id класс, должна ли она фактически кэшировать класс этого типа, так как все классы направляются через туже цепочку GTypeClassCacheFunc.

`cache_data` :	данные помещаемые в `cache_func`
`cache_func` :	GTypeClassCacheFunc

g_type_remove_class_cache_func ()

void                g_type_remove_class_cache_func      (gpointer cache_data,
                                                         GTypeClassCacheFunc cache_func);

Удаляет предварительно установленную GTypeClassCacheFunc. Кэш содержащийся в cache_func должен быть пустым когда вызывается g_type_remove_class_cache_func() чтобы избежать утечек.

`cache_data` :	данные полученные при добавлении `cache_func`
`cache_func` :	GTypeClassCacheFunc

g_type_class_unref_uncached ()

void g_type_class_unref_uncached (gpointer g_class);

Вариант g_type_class_unref() для использования в GTypeClassCacheFunc реализации. Она отменяет ссылку на класс без контроля цепочки GTypeClassCacheFunc, избегая рекурсии которая моглабы иначе произойти.

g_class : Структура GTypeClass для отмены ссылок.

g_type_add_interface_check ()

void                g_type_add_interface_check          (gpointer check_data,
                                                         GTypeInterfaceCheckFunc check_func);

Добавляет функцию вызываемую после инициализации vtable интерфейса для любого класса (то есть после вызова interface_init члена GInterfaceInfo).

Эта функция полезна когда вам нужно контролировать логическое выражение зависящее от интерфейсного класса. Например, реализация GObject использует это средство для контроля реализации объектом всех свойств которые определены его интерфейсом.

`check_data` :	данные помещаемые в `check_func`
`check_func` :	функция вызываемая после каждой инициализации интерфейса.

Начиная с версии 2.4

g_type_remove_interface_check ()

void                g_type_remove_interface_check       (gpointer check_data,
                                                         GTypeInterfaceCheckFunc check_func);

Удаляет интерфейсную функцию контроля добавленную с помощью g_type_add_interface_check().

`check_data` :	данные callback-функции помещаемые в `g_type_add_interface_check()`
`check_func` :	callback-функция помещаемая в `g_type_add_interface_check()`

Начиная с версии 2.4

GTypeInterfaceCheckFunc ()

void                (*GTypeInterfaceCheckFunc)          (gpointer check_data,
                                                         gpointer g_iface);

Эта callback-функция вызывается после инициализации vtable интерфейса. Смотрите g_type_add_interface_check().

`check_data` :	данные помещаемые в `g_type_add_interface_check()`.
`g_iface` :	инициализируемый интерфейс

Начиная с версии 2.4

g_type_value_table_peek ()

GTypeValueTable* g_type_value_table_peek (GType type);

Возвращает расположение GTypeValueTable связанной с type. Помните что эта функция должна использоваться только из исходного кода который реализует или знает внутреннюю реализацию type.

`type` :	GType значение.
Возвращает :	Расположение GTypeValueTable связанной с `type` или `NULL` если нет GTypeValueTable связанной с `type`.

G_DEFINE_TYPE()

#define G_DEFINE_TYPE(TN, t_n, T_P)			    G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, 0, {})

Удобный макрос для реализации типа, который декларирует функцию инициализации класса, функцию инициализации экземпляра (смотрите GTypeInfo для информации об этом) и статическую переменную с именем t_n_parent_class указывающую на родительский класс. Кроме того, он определяет функцию *_get_type(). Смотрите G_DEFINE_TYPE_EXTENDED() для примера.

`TN` :	Имя нового типа, в верхнем регистре.
`t_n` :	Имя нового типа, в нижнем регистре, со словами разделёнными символом '_'.
`T_P` :	GType родительского типа.

Начиная с версии 2.4

G_DEFINE_TYPE_WITH_CODE()

#define G_DEFINE_TYPE_WITH_CODE(TN, t_n, T_P, _C_)	    _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, 0) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()

Удобный макрос для реализации типа. Похож на G_DEFINE_TYPE(), но позволяет вставить произвольный код в функцию *_get_type(), например реализовать интерфейс через G_IMPLEMENT_INTERFACE(). Смотрите G_DEFINE_TYPE_EXTENDED() для примера.

`TN` :	имя нового типа в верхнем регистре (in Camel case).
`t_n` :	имя нового типа в нижнем регистре, со словами разделёнными знаком '_'.
`T_P` :	GType родительского типа.
`_C_` :	Произвольный код который вставляется в функцию *`_get_type()`.

Начиная с версии 2.4

G_DEFINE_ABSTRACT_TYPE()

#define G_DEFINE_ABSTRACT_TYPE(TN, t_n, T_P)		    G_DEFINE_TYPE_EXTENDED (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT, {})

Удобный макрос для реализации типа. Похож на G_DEFINE_TYPE(), но определяет абстрактный тип. Смотрите G_DEFINE_TYPE_EXTENDED() для примера.

`TN` :	имя нового типа в верхнем регистре (in Camel case).
`t_n` :	имя нового типа в нижнем регистре, со словами разделёнными знаком '_'.
`T_P` :	GType родительского типа.

Начиная с версии 2.4

G_DEFINE_ABSTRACT_TYPE_WITH_CODE()

#define G_DEFINE_ABSTRACT_TYPE_WITH_CODE(TN, t_n, T_P, _C_) _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, G_TYPE_FLAG_ABSTRACT) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()

Удобный макрос для реализации типа. Похож на G_DEFINE_TYPE_WITH_CODE(), определяет абстрактный тип и позволяет вставить произвольный код в функцию *_get_type(), например реализовать интерфейс через G_IMPLEMENT_INTERFACE(). Смотрите G_DEFINE_TYPE_EXTENDED() для примера.

`TN` :	имя нового типа, в верхнем регистре (in Camel case).
`t_n` :	имя нового типа в нижнем регистре, со словами разделёнными символом '_'.
`T_P` :	GType родительского типа.
`_C_` :	Произвольный код вставляемый в функцию @`type_name_get_type()`.

Начиная с версии 2.4

G_IMPLEMENT_INTERFACE()

#define G_IMPLEMENT_INTERFACE(TYPE_IFACE, iface_init)

Удобный макрос для простого добавления интерфейса в _C_ раздел G_DEFINE_TYPE_WITH_CODE() или G_DEFINE_ABSTRACT_TYPE_WITH_CODE(). Смотрите G_DEFINE_TYPE_EXTENDED() для примера.

Помните что этот макрос может использоваться только вместе с G_DEFINE_TYPE_* макросами, так как он зависит от переменных имён из этих макросов.

`TYPE_IFACE` :	GType добавляемого интерфейса
`iface_init` :	Функция инициализации интерфейса

Начиная с версии 2.4

G_DEFINE_TYPE_EXTENDED()

#define G_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_)	    _G_DEFINE_TYPE_EXTENDED_BEGIN (TN, t_n, T_P, _f_) {_C_;} _G_DEFINE_TYPE_EXTENDED_END()

Основной макрос для удобной реализации типа, на котором основан G_DEFINE_TYPE(), и так далее.


G_DEFINE_TYPE_EXTENDED (GtkGadget, 
                        gtk_gadget, 
                        GTK_TYPE_WIDGET,
                        0, 
                        G_IMPLEMENT_INTERFACE (TYPE_GIZMO, 
                                               gtk_gadget_gizmo_init));

разворачивается до


static void     gtk_gadget_init       (GtkGadget      *self);
static void     gtk_gadget_class_init (GtkGadgetClass *klass);
static gpointer gtk_gadget_parent_class = NULL;
static void     gtk_gadget_class_intern_init (gpointer klass)
{
  gtk_gadget_parent_class = g_type_class_peek_parent (klass);
  gtk_gadget_class_init ((GtkGadgetClass*) klass);
}

GType
gtk_gadget_get_type (void)
{
  static GType g_define_type_id = 0; 
  if (G_UNLIKELY (g_define_type_id == 0)) 
    { 
      static const GTypeInfo g_define_type_info = { 
        sizeof (GtkGadgetClass), 
        (GBaseInitFunc) NULL, 
        (GBaseFinalizeFunc) NULL, 
        (GClassInitFunc) gtk_gadget_class_intern_init, 
        (GClassFinalizeFunc) NULL, 
        NULL,   /* class_data */ 
        sizeof (GtkGadget), 
        0,      /* n_preallocs */ 
        (GInstanceInitFunc) gtk_gadget_init, 
      }; 
      g_define_type_id = g_type_register_static (GTK_TYPE_WIDGET, "GtkGadget", &g_define_type_info, 0); 
      {
        static const GInterfaceInfo g_implement_interface_info = {
          (GInterfaceInitFunc) gtk_gadget_gizmo_init
        };
        g_type_add_interface_static (g_define_type_id, TYPE_GIZMO, &g_implement_interface_info);
      } 
    } 
  return g_define_type_id; 
}

Единственные части определяемые вручную это сструктуры интерфейса и класса и определение функций инициализации экземпляра и класса.

`TN` :
`t_n` :
`T_P` :
`_f_` :
`_C_` :

Начиная с версии 2.4

G_TYPE_INVALID

#define G_TYPE_INVALID			G_TYPE_MAKE_FUNDAMENTAL (0)

Недопустимый GType используется как ошибочное значение которое возвращают некоторые функции возвращающие GType.

G_TYPE_NONE

#define G_TYPE_NONE			G_TYPE_MAKE_FUNDAMENTAL (1)

Базовый тип который используется как замена для возвращаемого типа C void.

G_TYPE_INTERFACE

#define G_TYPE_INTERFACE		G_TYPE_MAKE_FUNDAMENTAL (2)

Базовый тип из который наследуют все интерфейсы.

G_TYPE_CHAR

#define G_TYPE_CHAR			G_TYPE_MAKE_FUNDAMENTAL (3)

Базовый тип соответствующий gchar. Тип подписываемый с помощью G_TYPE_CHAR беззаговорочно 8-битное целочисленное со знаком. Это может быть или не может быть тем же C типом "gchar".

G_TYPE_UCHAR

#define G_TYPE_UCHAR			G_TYPE_MAKE_FUNDAMENTAL (4)

Базовый тип соответствующий guchar.

G_TYPE_BOOLEAN

#define G_TYPE_BOOLEAN			G_TYPE_MAKE_FUNDAMENTAL (5)

Базовый тип соответствующий gboolean.

G_TYPE_INT

#define G_TYPE_INT			G_TYPE_MAKE_FUNDAMENTAL (6)

Базовый тип соответствующий gint.

G_TYPE_UINT

#define G_TYPE_UINT			G_TYPE_MAKE_FUNDAMENTAL (7)

Базовый тип соответствующий guint.

G_TYPE_LONG

#define G_TYPE_LONG			G_TYPE_MAKE_FUNDAMENTAL (8)

Базовый тип соответствующий glong.

G_TYPE_ULONG

#define G_TYPE_ULONG			G_TYPE_MAKE_FUNDAMENTAL (9)

Базовый тип соответствующий gulong.

G_TYPE_INT64

#define G_TYPE_INT64			G_TYPE_MAKE_FUNDAMENTAL (10)

Базовый тип соответствующий gint64.

G_TYPE_UINT64

#define G_TYPE_UINT64			G_TYPE_MAKE_FUNDAMENTAL (11)

Базовый тип соответствующий guint64.

G_TYPE_ENUM

#define G_TYPE_ENUM			G_TYPE_MAKE_FUNDAMENTAL (12)

Базовый тип который наследуют все перечислимые типы.

G_TYPE_FLAGS

#define G_TYPE_FLAGS			G_TYPE_MAKE_FUNDAMENTAL (13)

Базовый тип который наследуют все флаговые типы.

G_TYPE_FLOAT

#define G_TYPE_FLOAT			G_TYPE_MAKE_FUNDAMENTAL (14)

Базовый тип соответствующий gfloat.

G_TYPE_DOUBLE

#define G_TYPE_DOUBLE			G_TYPE_MAKE_FUNDAMENTAL (15)

Базовый тип соответствующий gdouble.

G_TYPE_STRING

#define G_TYPE_STRING			G_TYPE_MAKE_FUNDAMENTAL (16)

Базовый тип соответствующий nul-завершённой C строке.

G_TYPE_POINTER

#define G_TYPE_POINTER			G_TYPE_MAKE_FUNDAMENTAL (17)

Базовый тип соответствующий gpointer.

G_TYPE_BOXED

#define G_TYPE_BOXED			G_TYPE_MAKE_FUNDAMENTAL (18)

Базовый тип который наследуют все boxed типы.

G_TYPE_PARAM

#define G_TYPE_PARAM			G_TYPE_MAKE_FUNDAMENTAL (19)

Базовый тип который наследуют все GParamSpec типы.

G_TYPE_OBJECT

#define G_TYPE_OBJECT			G_TYPE_MAKE_FUNDAMENTAL (20)

Базовый тип для GObject.

G_TYPE_GTYPE

#define	G_TYPE_GTYPE			 (g_gtype_get_type())

Тип для GType.

G_TYPE_RESERVED_GLIB_FIRST

#define G_TYPE_RESERVED_GLIB_FIRST	(21)

Первый номер базового типа для создания идентификатора базового типа с помощью G_TYPE_MAKE_FUNDAMENTAL() зарезервированный для GLib.

G_TYPE_RESERVED_GLIB_LAST

#define G_TYPE_RESERVED_GLIB_LAST	(31)

Последний номер базового типа зарезервированный для GLib.

G_TYPE_RESERVED_BSE_FIRST

#define G_TYPE_RESERVED_BSE_FIRST	(32)

Первый номер базового типа для создания идентификатора базового типа с помощью G_TYPE_MAKE_FUNDAMENTAL() зарезервированный для BSE.

G_TYPE_RESERVED_BSE_LAST

#define G_TYPE_RESERVED_BSE_LAST	(48)

Последний номер базового типа зарезервированный для BSE.

G_TYPE_RESERVED_USER_FIRST

#define G_TYPE_RESERVED_USER_FIRST	(49)

Первый доступный номер базового типа для создания нового идентификатора базового типа с помощью G_TYPE_MAKE_FUNDAMENTAL().

			Справочное описание GObject
Top \| Описание