{.deadCodeElim: on.}
when defined(windows):
const
gliblib = "libglib-2.0-0.dll"
gmodulelib = "libgmodule-2.0-0.dll"
gobjectlib = "libgobject-2.0-0.dll"
else:
const
gliblib = "libglib-2.0.so"
gmodulelib = "libgmodule-2.0.so"
gobjectlib = "libgobject-2.0.so"
# gthreadlib = "libgthread-2.0.so"
type
PGTypePlugin* = pointer
PGParamSpecPool* = pointer
PPchar* = ptr cstring
PPPchar* = ptr PPchar
PPPgchar* = ptr PPgchar
PPgchar* = ptr cstring
gchar* = char
gshort* = cshort
glong* = clong
gint* = cint
gboolean* = bool
guchar* = char
gushort* = int16
gulong* = int
guint* = cint
gfloat* = cfloat
gdouble* = cdouble
gpointer* = pointer
Pgshort* = ptr gshort
Pglong* = ptr glong
Pgint* = ptr gint
PPgint* = ptr Pgint
Pgboolean* = ptr gboolean
Pguchar* = ptr guchar
PPguchar* = ptr Pguchar
Pgushort* = ptr gushort
Pgulong* = ptr gulong
Pguint* = ptr guint
Pgfloat* = ptr gfloat
Pgdouble* = ptr gdouble
pgpointer* = ptr gpointer
gconstpointer* = pointer
PGCompareFunc* = ptr TGCompareFunc
TGCompareFunc* = proc (a, b: gconstpointer): gint{.cdecl.}
PGCompareDataFunc* = ptr TGCompareDataFunc
TGCompareDataFunc* = proc (a, b: gconstpointer, user_data: gpointer): gint{.
cdecl.}
PGEqualFunc* = ptr TGEqualFunc
TGEqualFunc* = proc (a, b: gconstpointer): gboolean{.cdecl.}
PGDestroyNotify* = ptr TGDestroyNotify
TGDestroyNotify* = proc (data: gpointer){.cdecl.}
PGFunc* = ptr TGFunc
TGFunc* = proc (data, userdata: gpointer, key: gconstpointer){.cdecl.}
PGHashFunc* = ptr TGHashFunc
TGHashFunc* = proc (key: gconstpointer): guint{.cdecl.}
PGHFunc* = ptr TGHFunc
TGHFunc* = proc (key, value, user_data: gpointer){.cdecl.}
PGFreeFunc* = proc (data: gpointer){.cdecl.}
PGTimeVal* = ptr TGTimeVal
TGTimeVal*{.final.} = object
tv_sec*: glong
tv_usec*: glong
guint64* = int64
gint8* = int8
guint8* = int8
gint16* = int16
guint16* = int16
gint32* = int32
guint32* = int32
gint64* = int64
gssize* = int32
gsize* = int32
Pgint8* = ptr gint8
Pguint8* = ptr guint8
Pgint16* = ptr gint16
Pguint16* = ptr guint16
Pgint32* = ptr gint32
Pguint32* = ptr guint32
Pgint64* = ptr gint64
Pguint64* = ptr guint64
pgssize* = ptr gssize
pgsize* = ptr gsize
TGQuark* = guint32
PGQuark* = ptr TGQuark
PGTypeCValue* = ptr TGTypeCValue
TGTypeCValue*{.final.} = object
v_double*: gdouble
GType* = gulong
PGType* = ptr GType
PGTypeClass* = ptr TGTypeClass
TGTypeClass*{.final.} = object
g_type*: GType
PGTypeInstance* = ptr TGTypeInstance
TGTypeInstance*{.final.} = object
g_class*: PGTypeClass
PGTypeInterface* = ptr TGTypeInterface
TGTypeInterface*{.pure.} = object
g_type*: GType
g_instance_type*: GType
PGTypeQuery* = ptr TGTypeQuery
TGTypeQuery*{.final.} = object
theType*: GType
type_name*: cstring
class_size*: guint
instance_size*: guint
PGValue* = ptr TGValue
TGValue*{.final.} = object
g_type*: GType
data*: array[0..1, gdouble]
PGData* = pointer
PPGData* = ptr PGData
PGSList* = ptr TGSList
PPGSList* = ptr PGSList
TGSList*{.final.} = object
data*: gpointer
next*: PGSList
PGList* = ptr TGList
TGList*{.final.} = object
data*: gpointer
next*: PGList
prev*: PGList
TGParamFlags* = int32
PGParamFlags* = ptr TGParamFlags
PGParamSpec* = ptr TGParamSpec
PPGParamSpec* = ptr PGParamSpec
TGParamSpec*{.final.} = object
g_type_instance*: TGTypeInstance
name*: cstring
flags*: TGParamFlags
value_type*: GType
owner_type*: GType
nick*: cstring
blurb*: cstring
qdata*: PGData
ref_count*: guint
param_id*: guint
PGParamSpecClass* = ptr TGParamSpecClass
TGParamSpecClass*{.final.} = object
g_type_class*: TGTypeClass
value_type*: GType
finalize*: proc (pspec: PGParamSpec){.cdecl.}
value_set_default*: proc (pspec: PGParamSpec, value: PGValue){.cdecl.}
value_validate*: proc (pspec: PGParamSpec, value: PGValue): gboolean{.cdecl.}
values_cmp*: proc (pspec: PGParamSpec, value1: PGValue, value2: PGValue): gint{.
cdecl.}
dummy*: array[0..3, gpointer]
PGParameter* = ptr TGParameter
TGParameter*{.final.} = object
name*: cstring
value*: TGValue
TGBoxedCopyFunc* = proc (boxed: gpointer): gpointer{.cdecl.}
TGBoxedFreeFunc* = proc (boxed: gpointer){.cdecl.}
PGsource = pointer # I don't know and don't care
const
G_TYPE_FUNDAMENTAL_SHIFT* = 2
G_TYPE_FUNDAMENTAL_MAX* = 255 shl G_TYPE_FUNDAMENTAL_SHIFT
G_TYPE_INVALID* = GType(0 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_NONE* = GType(1 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_INTERFACE* = GType(2 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_CHAR* = GType(3 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_UCHAR* = GType(4 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_BOOLEAN* = GType(5 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_INT* = GType(6 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_UINT* = GType(7 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_LONG* = GType(8 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_ULONG* = GType(9 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_INT64* = GType(10 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_UINT64* = GType(11 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_ENUM* = GType(12 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_FLAGS* = GType(13 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_FLOAT* = GType(14 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_DOUBLE* = GType(15 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_STRING* = GType(16 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_POINTER* = GType(17 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_BOXED* = GType(18 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_PARAM* = GType(19 shl G_TYPE_FUNDAMENTAL_SHIFT)
G_TYPE_OBJECT* = GType(20 shl G_TYPE_FUNDAMENTAL_SHIFT)
proc G_TYPE_MAKE_FUNDAMENTAL*(x: int): GType
const
G_TYPE_RESERVED_GLIB_FIRST* = 21
G_TYPE_RESERVED_GLIB_LAST* = 31
G_TYPE_RESERVED_BSE_FIRST* = 32
G_TYPE_RESERVED_BSE_LAST* = 48
G_TYPE_RESERVED_USER_FIRST* = 49
proc G_TYPE_IS_FUNDAMENTAL*(theType: GType): bool
proc G_TYPE_IS_DERIVED*(theType: GType): bool
proc G_TYPE_IS_INTERFACE*(theType: GType): bool
proc G_TYPE_IS_CLASSED*(theType: GType): gboolean
proc G_TYPE_IS_INSTANTIATABLE*(theType: GType): bool
proc G_TYPE_IS_DERIVABLE*(theType: GType): bool
proc G_TYPE_IS_DEEP_DERIVABLE*(theType: GType): bool
proc G_TYPE_IS_ABSTRACT*(theType: GType): bool
proc G_TYPE_IS_VALUE_ABSTRACT*(theType: GType): bool
proc G_TYPE_IS_VALUE_TYPE*(theType: GType): bool
proc G_TYPE_HAS_VALUE_TABLE*(theType: GType): bool
proc G_TYPE_CHECK_INSTANCE*(instance: Pointer): gboolean
proc G_TYPE_CHECK_INSTANCE_CAST*(instance: Pointer, g_type: GType): PGTypeInstance
proc G_TYPE_CHECK_INSTANCE_TYPE*(instance: Pointer, g_type: GType): bool
proc G_TYPE_INSTANCE_GET_CLASS*(instance: Pointer, g_type: GType): PGTypeClass
proc G_TYPE_INSTANCE_GET_INTERFACE*(instance: Pointer, g_type: GType): Pointer
proc G_TYPE_CHECK_CLASS_CAST*(g_class: pointer, g_type: GType): Pointer
proc G_TYPE_CHECK_CLASS_TYPE*(g_class: pointer, g_type: GType): bool
proc G_TYPE_CHECK_VALUE*(value: Pointer): bool
proc G_TYPE_CHECK_VALUE_TYPE*(value: pointer, g_type: GType): bool
proc G_TYPE_FROM_INSTANCE*(instance: Pointer): GType
proc G_TYPE_FROM_CLASS*(g_class: Pointer): GType
proc G_TYPE_FROM_INTERFACE*(g_iface: Pointer): GType
type
TGTypeDebugFlags* = int32
PGTypeDebugFlags* = ptr TGTypeDebugFlags
const
G_TYPE_DEBUG_NONE* = 0
G_TYPE_DEBUG_OBJECTS* = 1 shl 0
G_TYPE_DEBUG_SIGNALS* = 1 shl 1
G_TYPE_DEBUG_MASK* = 0x00000003
proc g_type_init*(){.cdecl, dynlib: gobjectlib, importc: "g_type_init".}
proc g_type_init_with_debug_flags*(debug_flags: TGTypeDebugFlags){.cdecl,
dynlib: gobjectlib, importc: "g_type_init_with_debug_flags".}
proc g_type_name*(theType: GType): cstring{.cdecl, dynlib: gobjectlib,
importc: "g_type_name".}
proc g_type_qname*(theType: GType): TGQuark{.cdecl, dynlib: gobjectlib,
importc: "g_type_qname".}
proc g_type_from_name*(name: cstring): GType{.cdecl, dynlib: gobjectlib,
importc: "g_type_from_name".}
proc g_type_parent*(theType: GType): GType{.cdecl, dynlib: gobjectlib,
importc: "g_type_parent".}
proc g_type_depth*(theType: GType): guint{.cdecl, dynlib: gobjectlib,
importc: "g_type_depth".}
proc g_type_next_base*(leaf_type: GType, root_type: GType): GType{.cdecl,
dynlib: gobjectlib, importc: "g_type_next_base".}
proc g_type_is_a*(theType: GType, is_a_type: GType): gboolean{.cdecl,
dynlib: gobjectlib, importc: "g_type_is_a".}
proc g_type_class_ref*(theType: GType): gpointer{.cdecl, dynlib: gobjectlib,
importc: "g_type_class_ref".}
proc g_type_class_peek*(theType: GType): gpointer{.cdecl, dynlib: gobjectlib,
importc: "g_type_class_peek".}
proc g_type_class_unref*(g_class: gpointer){.cdecl, dynlib: gobjectlib,
importc: "g_type_class_unref".}
proc g_type_class_peek_parent*(g_class: gpointer): gpointer{.cdecl,
dynlib: gobjectlib, importc: "g_type_class_peek_parent".}
proc g_type_interface_peek*(instance_class: gpointer, iface_type: GType): gpointer{.
cdecl, dynlib: gobjectlib, importc: "g_type_interface_peek".}
proc g_type_interface_peek_parent*(g_iface: gpointer): gpointer{.cdecl,
dynlib: gobjectlib, importc: "g_type_interface_peek_parent".}
proc g_type_children*(theType: GType, n_children: Pguint): PGType{.cdecl,
dynlib: gobjectlib, importc: "g_type_children".}
proc g_type_interfaces*(theType: GType, n_interfaces: Pguint): PGType{.cdecl,
dynlib: gobjectlib, importc: "g_type_interfaces".}
proc g_type_set_qdata*(theType: GType, quark: TGQuark, data: gpointer){.cdecl,
dynlib: gobjectlib, importc: "g_type_set_qdata".}
proc g_type_get_qdata*(theType: GType, quark: TGQuark): gpointer{.cdecl,
dynlib: gobjectlib, importc: "g_type_get_qdata".}
proc g_type_query*(theType: GType, query: PGTypeQuery){.cdecl,
dynlib: gobjectlib, importc: "g_type_query".}
type
TGBaseInitFunc* = proc (g_class: gpointer){.cdecl.}
TGBaseFinalizeFunc* = proc (g_class: gpointer){.cdecl.}
TGClassInitFunc* = proc (g_class: gpointer, class_data: gpointer){.cdecl.}
TGClassFinalizeFunc* = proc (g_class: gpointer, class_data: gpointer){.cdecl.}
TGInstanceInitFunc* = proc (instance: PGTypeInstance, g_class: gpointer){.
cdecl.}
TGInterfaceInitFunc* = proc (g_iface: gpointer, iface_data: gpointer){.cdecl.}
TGInterfaceFinalizeFunc* = proc (g_iface: gpointer, iface_data: gpointer){.
cdecl.}
TGTypeClassCacheFunc* = proc (cache_data: gpointer, g_class: PGTypeClass): gboolean{.
cdecl.}
TGTypeFundamentalFlags* = int32
PGTypeFundamentalFlags* = ptr TGTypeFundamentalFlags
const
G_TYPE_FLAG_CLASSED* = 1 shl 0
G_TYPE_FLAG_INSTANTIATABLE* = 1 shl 1
G_TYPE_FLAG_DERIVABLE* = 1 shl 2
G_TYPE_FLAG_DEEP_DERIVABLE* = 1 shl 3
type
TGTypeFlags* = int32
PGTypeFlags* = ptr TGTypeFlags
const
G_TYPE_FLAG_ABSTRACT* = 1 shl 4
G_TYPE_FLAG_VALUE_ABSTRACT* = 1 shl 5
type
PGTypeValueTable* = ptr TGTypeValueTable
TGTypeValueTable*{.final.} = object
value_init*: proc (value: PGValue){.cdecl.}
value_free*: proc (value: PGValue){.cdecl.}
value_copy*: proc (src_value: PGValue, dest_value: PGValue){.cdecl.}
value_peek_pointer*: proc (value: PGValue): gpointer{.cdecl.}
collect_format*: cstring
collect_value*: proc (value: PGValue, n_collect_values: guint,
collect_values: PGTypeCValue, collect_flags: guint): cstring{.
cdecl.}
lcopy_format*: cstring
lcopy_value*: proc (value: PGValue, n_collect_values: guint,
collect_values: PGTypeCValue, collect_flags: guint): cstring{.
cdecl.}
PGTypeInfo* = ptr TGTypeInfo
TGTypeInfo*{.final.} = object
class_size*: guint16
base_init*: TGBaseInitFunc
base_finalize*: TGBaseFinalizeFunc
class_init*: TGClassInitFunc
class_finalize*: TGClassFinalizeFunc
class_data*: gconstpointer
instance_size*: guint16
n_preallocs*: guint16
instance_init*: TGInstanceInitFunc
value_table*: PGTypeValueTable
PGTypeFundamentalInfo* = ptr TGTypeFundamentalInfo
TGTypeFundamentalInfo*{.final.} = object
type_flags*: TGTypeFundamentalFlags
PGInterfaceInfo* = ptr TGInterfaceInfo
TGInterfaceInfo*{.final.} = object
interface_init*: TGInterfaceInitFunc
interface_finalize*: TGInterfaceFinalizeFunc
interface_data*: gpointer
proc g_type_register_static*(parent_type: GType, type_name: cstring,
info: PGTypeInfo, flags: TGTypeFlags): GType{.
cdecl, dynlib: gobjectlib, importc: "g_type_register_static".}
proc g_type_register_dynamic*(parent_type: GType, type_name: cstring,
plugin: PGTypePlugin, flags: TGTypeFlags): GType{.
cdecl, dynlib: gobjectlib, importc: "g_type_register_dynamic".}
proc g_type_register_fundamental*(type_id: GType, type_name: cstring,
info: PGTypeInfo,
finfo: PGTypeFundamentalInfo,
flags: TGTypeFlags): GType{.cdecl,
dynlib: gobjectlib, importc: "g_type_register_fundamental".}
proc g_type_add_interface_static*(instance_type: GType, interface_type: GType,
info: PGInterfaceInfo){.cdecl,
dynlib: gobjectlib, importc: "g_type_add_interface_static".}
proc g_type_add_interface_dynamic*(instance_type: GType, interface_type: GType,
plugin: PGTypePlugin){.cdecl,
dynlib: gobjectlib, importc: "g_type_add_interface_dynamic".}
proc g_type_interface_add_prerequisite*(interface_type: GType,
prerequisite_type: GType){.cdecl,
dynlib: gobjectlib, importc: "g_type_interface_add_prerequisite".}
proc g_type_get_plugin*(theType: GType): PGTypePlugin{.cdecl,
dynlib: gobjectlib, importc: "g_type_get_plugin".}
proc g_type_interface_get_plugin*(instance_type: GType,
implementation_type: GType): PGTypePlugin{.
cdecl, dynlib: gobjectlib, importc: "g_type_interface_get_plugin".}
proc g_type_fundamental_next*(): GType{.cdecl, dynlib: gobjectlib,
importc: "g_type_fundamental_next".}
proc g_type_fundamental*(type_id: GType): GType{.cdecl, dynlib: gobjectlib,
importc: "g_type_fundamental".}
proc g_type_create_instance*(theType: GType): PGTypeInstance{.cdecl,
dynlib: gobjectlib, importc: "g_type_create_instance".}
proc g_type_free_instance*(instance: PGTypeInstance){.cdecl, dynlib: gobjectlib,
importc: "g_type_free_instance".}
proc g_type_add_class_cache_func*(cache_data: gpointer,
cache_func: TGTypeClassCacheFunc){.cdecl,
dynlib: gobjectlib, importc: "g_type_add_class_cache_func".}
proc g_type_remove_class_cache_func*(cache_data: gpointer,
cache_func: TGTypeClassCacheFunc){.cdecl,
dynlib: gobjectlib, importc: "g_type_remove_class_cache_func".}
proc g_type_class_unref_uncached*(g_class: gpointer){.cdecl, dynlib: gobjectlib,
importc: "g_type_class_unref_uncached".}
proc g_type_value_table_peek*(theType: GType): PGTypeValueTable{.cdecl,
dynlib: gobjectlib, importc: "g_type_value_table_peek".}
proc private_g_type_check_instance*(instance: PGTypeInstance): gboolean{.cdecl,
dynlib: gobjectlib, importc: "g_type_check_instance".}
proc private_g_type_check_instance_cast*(instance: PGTypeInstance,
iface_type: GType): PGTypeInstance{.cdecl, dynlib: gobjectlib,
importc: "g_type_check_instance_cast".}
proc private_g_type_check_instance_is_a*(instance: PGTypeInstance,
iface_type: GType): gboolean{.cdecl, dynlib: gobjectlib,
importc: "g_type_check_instance_is_a".}
proc private_g_type_check_class_cast*(g_class: PGTypeClass, is_a_type: GType): PGTypeClass{.
cdecl, dynlib: gobjectlib, importc: "g_type_check_class_cast".}
proc private_g_type_check_class_is_a*(g_class: PGTypeClass, is_a_type: GType): gboolean{.
cdecl, dynlib: gobjectlib, importc: "g_type_check_class_is_a".}
proc private_g_type_check_is_value_type*(theType: GType): gboolean{.cdecl,
dynlib: gobjectlib, importc: "g_type_check_is_value_type".}
proc private_g_type_check_value*(value: PGValue): gboolean{.cdecl,
dynlib: gobjectlib, importc: "g_type_check_value".}
proc private_g_type_check_value_holds*(value: PGValue, theType: GType): gboolean{.
cdecl, dynlib: gobjectlib, importc: "g_type_check_value_holds".}
proc private_g_type_test_flags*(theType: GType, flags: guint): gboolean{.cdecl,
dynlib: gobjectlib, importc: "g_type_test_flags".}
proc g_type_name_from_instance*(instance: PGTypeInstance): cstring{.cdecl,
dynlib: gobjectlib, importc: "g_type_name_from_instance".}
proc g_type_name_from_class*(g_class: PGTypeClass): cstring{.cdecl,
dynlib: gobjectlib, importc: "g_type_name_from_class".}
const
G_TYPE_FLAG_RESERVED_ID_BIT* = GType(1 shl 0)
proc G_TYPE_IS_VALUE*(theType: GType): bool
proc G_IS_VALUE*(value: pointer): bool
proc G_VALUE_TYPE*(value: Pointer): GType
proc G_VALUE_TYPE_NAME*(value: Pointer): cstring
proc G_VALUE_HOLDS*(value: pointer, g_type: GType): bool
type
TGValueTransform* = proc (src_value: PGValue, dest_value: PGValue){.cdecl.}
proc g_value_init*(value: PGValue, g_type: GType): PGValue{.cdecl,
dynlib: gobjectlib, importc: "g_value_init".}
proc g_value_copy*(src_value: PGValue, dest_value: PGValue){.cdecl,
dynlib: gobjectlib, importc: "g_value_copy".}
proc g_value_reset*(value: PGValue): PGValue{.cdecl, dynlib: gobjectlib,
importc: "g_value_reset".}
proc g_value_unset*(value: PGValue){.cdecl, dynlib: gobjectlib,
importc: "g_value_unset".}
proc g_value_set_instance*(value: PGValue, instance: gpointer){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_instance".}
proc g_value_fits_pointer*(value: PGValue): gboolean{.cdecl, dynlib: gobjectlib,
importc: "g_value_fits_pointer".}
proc g_value_peek_pointer*(value: PGValue): gpointer{.cdecl, dynlib: gobjectlib,
importc: "g_value_peek_pointer".}
proc g_value_type_compatible*(src_type: GType, dest_type: GType): gboolean{.
cdecl, dynlib: gobjectlib, importc: "g_value_type_compatible".}
proc g_value_type_transformable*(src_type: GType, dest_type: GType): gboolean{.
cdecl, dynlib: gobjectlib, importc: "g_value_type_transformable".}
proc g_value_transform*(src_value: PGValue, dest_value: PGValue): gboolean{.
cdecl, dynlib: gobjectlib, importc: "g_value_transform".}
proc g_value_register_transform_func*(src_type: GType, dest_type: GType,
transform_func: TGValueTransform){.cdecl,
dynlib: gobjectlib, importc: "g_value_register_transform_func".}
const
G_VALUE_NOCOPY_CONTENTS* = 1 shl 27
type
PGValueArray* = ptr TGValueArray
TGValueArray*{.final.} = object
n_values*: guint
values*: PGValue
n_prealloced*: guint
proc g_value_array_get_nth*(value_array: PGValueArray, index: guint): PGValue{.
cdecl, dynlib: gobjectlib, importc: "g_value_array_get_nth".}
proc g_value_array_new*(n_prealloced: guint): PGValueArray{.cdecl,
dynlib: gobjectlib, importc: "g_value_array_new".}
proc g_value_array_free*(value_array: PGValueArray){.cdecl, dynlib: gobjectlib,
importc: "g_value_array_free".}
proc g_value_array_copy*(value_array: PGValueArray): PGValueArray{.cdecl,
dynlib: gobjectlib, importc: "g_value_array_copy".}
proc g_value_array_prepend*(value_array: PGValueArray, value: PGValue): PGValueArray{.
cdecl, dynlib: gobjectlib, importc: "g_value_array_prepend".}
proc g_value_array_append*(value_array: PGValueArray, value: PGValue): PGValueArray{.
cdecl, dynlib: gobjectlib, importc: "g_value_array_append".}
proc g_value_array_insert*(value_array: PGValueArray, index: guint,
value: PGValue): PGValueArray{.cdecl,
dynlib: gobjectlib, importc: "g_value_array_insert".}
proc g_value_array_remove*(value_array: PGValueArray, index: guint): PGValueArray{.
cdecl, dynlib: gobjectlib, importc: "g_value_array_remove".}
proc g_value_array_sort*(value_array: PGValueArray, compare_func: TGCompareFunc): PGValueArray{.
cdecl, dynlib: gobjectlib, importc: "g_value_array_sort".}
proc g_value_array_sort_with_data*(value_array: PGValueArray,
compare_func: TGCompareDataFunc,
user_data: gpointer): PGValueArray{.cdecl,
dynlib: gobjectlib, importc: "g_value_array_sort_with_data".}
const
G_VALUE_COLLECT_INT* = 'i'
G_VALUE_COLLECT_LONG* = 'l'
G_VALUE_COLLECT_INT64* = 'q'
G_VALUE_COLLECT_DOUBLE* = 'd'
G_VALUE_COLLECT_POINTER* = 'p'
G_VALUE_COLLECT_FORMAT_MAX_LENGTH* = 8
proc G_VALUE_HOLDS_CHAR*(value: PGValue): bool
proc G_VALUE_HOLDS_UCHAR*(value: PGValue): bool
proc G_VALUE_HOLDS_BOOLEAN*(value: PGValue): bool
proc G_VALUE_HOLDS_INT*(value: PGValue): bool
proc G_VALUE_HOLDS_UINT*(value: PGValue): bool
proc G_VALUE_HOLDS_LONG*(value: PGValue): bool
proc G_VALUE_HOLDS_ULONG*(value: PGValue): bool
proc G_VALUE_HOLDS_INT64*(value: PGValue): bool
proc G_VALUE_HOLDS_UINT64*(value: PGValue): bool
proc G_VALUE_HOLDS_FLOAT*(value: PGValue): bool
proc G_VALUE_HOLDS_DOUBLE*(value: PGValue): bool
proc G_VALUE_HOLDS_STRING*(value: PGValue): bool
proc G_VALUE_HOLDS_POINTER*(value: PGValue): bool
proc g_value_set_char*(value: PGValue, v_char: gchar){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_char".}
proc g_value_get_char*(value: PGValue): gchar{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_char".}
proc g_value_set_uchar*(value: PGValue, v_uchar: guchar){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_uchar".}
proc g_value_get_uchar*(value: PGValue): guchar{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_uchar".}
proc g_value_set_boolean*(value: PGValue, v_boolean: gboolean){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_boolean".}
proc g_value_get_boolean*(value: PGValue): gboolean{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_boolean".}
proc g_value_set_int*(value: PGValue, v_int: gint){.cdecl, dynlib: gobjectlib,
importc: "g_value_set_int".}
proc g_value_get_int*(value: PGValue): gint{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_int".}
proc g_value_set_uint*(value: PGValue, v_uint: guint){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_uint".}
proc g_value_get_uint*(value: PGValue): guint{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_uint".}
proc g_value_set_long*(value: PGValue, v_long: glong){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_long".}
proc g_value_get_long*(value: PGValue): glong{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_long".}
proc g_value_set_ulong*(value: PGValue, v_ulong: gulong){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_ulong".}
proc g_value_get_ulong*(value: PGValue): gulong{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_ulong".}
proc g_value_set_int64*(value: PGValue, v_int64: gint64){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_int64".}
proc g_value_get_int64*(value: PGValue): gint64{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_int64".}
proc g_value_set_uint64*(value: PGValue, v_uint64: guint64){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_uint64".}
proc g_value_get_uint64*(value: PGValue): guint64{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_uint64".}
proc g_value_set_float*(value: PGValue, v_float: gfloat){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_float".}
proc g_value_get_float*(value: PGValue): gfloat{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_float".}
proc g_value_set_double*(value: PGValue, v_double: gdouble){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_double".}
proc g_value_get_double*(value: PGValue): gdouble{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_double".}
proc g_value_set_string*(value: PGValue, v_string: cstring){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_string".}
proc g_value_set_static_string*(value: PGValue, v_string: cstring){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_static_string".}
proc g_value_get_string*(value: PGValue): cstring{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_string".}
proc g_value_dup_string*(value: PGValue): cstring{.cdecl, dynlib: gobjectlib,
importc: "g_value_dup_string".}
proc g_value_set_pointer*(value: PGValue, v_pointer: gpointer){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_pointer".}
proc g_value_get_pointer*(value: PGValue): gpointer{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_pointer".}
proc g_pointer_type_register_static*(name: cstring): GType{.cdecl,
dynlib: gobjectlib, importc: "g_pointer_type_register_static".}
proc g_strdup_value_contents*(value: PGValue): cstring{.cdecl,
dynlib: gobjectlib, importc: "g_strdup_value_contents".}
proc g_value_set_string_take_ownership*(value: PGValue, v_string: cstring){.
cdecl, dynlib: gobjectlib, importc: "g_value_set_string_take_ownership".}
type
Tgchararray* = gchar
Pgchararray* = ptr Tgchararray
proc G_TYPE_IS_PARAM*(theType: GType): bool
proc G_PARAM_SPEC*(pspec: Pointer): PGParamSpec
proc G_IS_PARAM_SPEC*(pspec: Pointer): bool
proc G_PARAM_SPEC_CLASS*(pclass: Pointer): PGParamSpecClass
proc G_IS_PARAM_SPEC_CLASS*(pclass: Pointer): bool
proc G_PARAM_SPEC_GET_CLASS*(pspec: Pointer): PGParamSpecClass
proc G_PARAM_SPEC_TYPE*(pspec: Pointer): GType
proc G_PARAM_SPEC_TYPE_NAME*(pspec: Pointer): cstring
proc G_PARAM_SPEC_VALUE_TYPE*(pspec: Pointer): GType
proc G_VALUE_HOLDS_PARAM*(value: Pointer): bool
const
G_PARAM_READABLE* = 1 shl 0
G_PARAM_WRITABLE* = 1 shl 1
G_PARAM_CONSTRUCT* = 1 shl 2
G_PARAM_CONSTRUCT_ONLY* = 1 shl 3
G_PARAM_LAX_VALIDATION* = 1 shl 4
G_PARAM_PRIVATE* = 1 shl 5
G_PARAM_READWRITE* = G_PARAM_READABLE or G_PARAM_WRITABLE
G_PARAM_MASK* = 0x000000FF
G_PARAM_USER_SHIFT* = 8
proc g_param_spec_ref*(pspec: PGParamSpec): PGParamSpec{.cdecl, dynlib: gliblib,
importc: "g_param_spec_ref".}
proc g_param_spec_unref*(pspec: PGParamSpec){.cdecl, dynlib: gliblib,
importc: "g_param_spec_unref".}
proc g_param_spec_sink*(pspec: PGParamSpec){.cdecl, dynlib: gliblib,
importc: "g_param_spec_sink".}
proc g_param_spec_get_qdata*(pspec: PGParamSpec, quark: TGQuark): gpointer{.
cdecl, dynlib: gliblib, importc: "g_param_spec_get_qdata".}
proc g_param_spec_set_qdata*(pspec: PGParamSpec, quark: TGQuark, data: gpointer){.
cdecl, dynlib: gliblib, importc: "g_param_spec_set_qdata".}
proc g_param_spec_set_qdata_full*(pspec: PGParamSpec, quark: TGQuark,
data: gpointer, destroy: TGDestroyNotify){.
cdecl, dynlib: gliblib, importc: "g_param_spec_set_qdata_full".}
proc g_param_spec_steal_qdata*(pspec: PGParamSpec, quark: TGQuark): gpointer{.
cdecl, dynlib: gliblib, importc: "g_param_spec_steal_qdata".}
proc g_param_value_set_default*(pspec: PGParamSpec, value: PGValue){.cdecl,
dynlib: gliblib, importc: "g_param_value_set_default".}
proc g_param_value_defaults*(pspec: PGParamSpec, value: PGValue): gboolean{.
cdecl, dynlib: gliblib, importc: "g_param_value_defaults".}
proc g_param_value_validate*(pspec: PGParamSpec, value: PGValue): gboolean{.
cdecl, dynlib: gliblib, importc: "g_param_value_validate".}
proc g_param_value_convert*(pspec: PGParamSpec, src_value: PGValue,
dest_value: PGValue, strict_validation: gboolean): gboolean{.
cdecl, dynlib: gliblib, importc: "g_param_value_convert".}
proc g_param_values_cmp*(pspec: PGParamSpec, value1: PGValue, value2: PGValue): gint{.
cdecl, dynlib: gliblib, importc: "g_param_values_cmp".}
proc g_param_spec_get_name*(pspec: PGParamSpec): cstring{.cdecl,
dynlib: gliblib, importc: "g_param_spec_get_name".}
proc g_param_spec_get_nick*(pspec: PGParamSpec): cstring{.cdecl,
dynlib: gliblib, importc: "g_param_spec_get_nick".}
proc g_param_spec_get_blurb*(pspec: PGParamSpec): cstring{.cdecl,
dynlib: gliblib, importc: "g_param_spec_get_blurb".}
proc g_value_set_param*(value: PGValue, param: PGParamSpec){.cdecl,
dynlib: gliblib, importc: "g_value_set_param".}
proc g_value_get_param*(value: PGValue): PGParamSpec{.cdecl, dynlib: gliblib,
importc: "g_value_get_param".}
proc g_value_dup_param*(value: PGValue): PGParamSpec{.cdecl, dynlib: gliblib,
importc: "g_value_dup_param".}
proc g_value_set_param_take_ownership*(value: PGValue, param: PGParamSpec){.
cdecl, dynlib: gliblib, importc: "g_value_set_param_take_ownership".}
type
PGParamSpecTypeInfo* = ptr TGParamSpecTypeInfo
TGParamSpecTypeInfo*{.final.} = object
instance_size*: guint16
n_preallocs*: guint16
instance_init*: proc (pspec: PGParamSpec){.cdecl.}
value_type*: GType
finalize*: proc (pspec: PGParamSpec){.cdecl.}
value_set_default*: proc (pspec: PGParamSpec, value: PGValue){.cdecl.}
value_validate*: proc (pspec: PGParamSpec, value: PGValue): gboolean{.cdecl.}
values_cmp*: proc (pspec: PGParamSpec, value1: PGValue, value2: PGValue): gint{.
cdecl.}
proc g_param_type_register_static*(name: cstring,
pspec_info: PGParamSpecTypeInfo): GType{.
cdecl, dynlib: gliblib, importc: "g_param_type_register_static".}
proc g_param_type_register_static_constant*(name: cstring,
pspec_info: PGParamSpecTypeInfo, opt_type: GType): GType{.cdecl,
dynlib: gliblib, importc: "`g_param_type_register_static_constant`".}
proc g_param_spec_internal*(param_type: GType, name: cstring, nick: cstring,
blurb: cstring, flags: TGParamFlags): gpointer{.
cdecl, dynlib: gliblib, importc: "g_param_spec_internal".}
proc g_param_spec_pool_new*(type_prefixing: gboolean): PGParamSpecPool{.cdecl,
dynlib: gliblib, importc: "g_param_spec_pool_new".}
proc g_param_spec_pool_insert*(pool: PGParamSpecPool, pspec: PGParamSpec,
owner_type: GType){.cdecl, dynlib: gliblib,
importc: "g_param_spec_pool_insert".}
proc g_param_spec_pool_remove*(pool: PGParamSpecPool, pspec: PGParamSpec){.
cdecl, dynlib: gliblib, importc: "g_param_spec_pool_remove".}
proc g_param_spec_pool_lookup*(pool: PGParamSpecPool, param_name: cstring,
owner_type: GType, walk_ancestors: gboolean): PGParamSpec{.
cdecl, dynlib: gliblib, importc: "g_param_spec_pool_lookup".}
proc g_param_spec_pool_list_owned*(pool: PGParamSpecPool, owner_type: GType): PGList{.
cdecl, dynlib: gliblib, importc: "g_param_spec_pool_list_owned".}
proc g_param_spec_pool_list*(pool: PGParamSpecPool, owner_type: GType,
n_pspecs_p: Pguint): PPGParamSpec{.cdecl,
dynlib: gliblib, importc: "g_param_spec_pool_list".}
type
PGClosure* = ptr TGClosure
PGClosureNotifyData* = ptr TGClosureNotifyData
TGClosureNotify* = proc (data: gpointer, closure: PGClosure){.cdecl.}
TGClosure*{.final.} = object
flag0*: int32
marshal*: proc (closure: PGClosure, return_value: PGValue,
n_param_values: guint, param_values: PGValue,
invocation_hint, marshal_data: gpointer){.cdecl.}
data*: gpointer
notifiers*: PGClosureNotifyData
TGCallBackProcedure* = proc (){.cdecl.}
TGCallback* = proc (){.cdecl.}
TGClosureMarshal* = proc (closure: PGClosure, return_value: PGValue,
n_param_values: guint, param_values: PGValue,
invocation_hint: gpointer, marshal_data: gpointer){.
cdecl.}
TGClosureNotifyData*{.final.} = object
data*: gpointer
notify*: TGClosureNotify
proc G_CLOSURE_NEEDS_MARSHAL*(closure: Pointer): bool
proc G_CLOSURE_N_NOTIFIERS*(cl: PGClosure): int32
proc G_CCLOSURE_SWAP_DATA*(cclosure: PGClosure): int32
proc G_CALLBACK*(f: pointer): TGCallback
const
bm_TGClosure_ref_count* = 0x00007FFF'i32
bp_TGClosure_ref_count* = 0'i32
bm_TGClosure_meta_marshal* = 0x00008000'i32
bp_TGClosure_meta_marshal* = 15'i32
bm_TGClosure_n_guards* = 0x00010000'i32
bp_TGClosure_n_guards* = 16'i32
bm_TGClosure_n_fnotifiers* = 0x00060000'i32
bp_TGClosure_n_fnotifiers* = 17'i32
bm_TGClosure_n_inotifiers* = 0x07F80000'i32
bp_TGClosure_n_inotifiers* = 19'i32
bm_TGClosure_in_inotify* = 0x08000000'i32
bp_TGClosure_in_inotify* = 27'i32
bm_TGClosure_floating* = 0x10000000'i32
bp_TGClosure_floating* = 28'i32
bm_TGClosure_derivative_flag* = 0x20000000'i32
bp_TGClosure_derivative_flag* = 29'i32
bm_TGClosure_in_marshal* = 0x40000000'i32
bp_TGClosure_in_marshal* = 30'i32
bm_TGClosure_is_invalid* = 0x80000000'i32
bp_TGClosure_is_invalid* = 31'i32
proc ref_count*(a: var TGClosure): guint
proc set_ref_count*(a: var TGClosure, ref_count: guint)
proc meta_marshal*(a: PGClosure): guint
proc set_meta_marshal*(a: var TGClosure, meta_marshal: guint)
proc n_guards*(a: PGClosure): guint
proc set_n_guards*(a: var TGClosure, n_guards: guint)
proc n_fnotifiers*(a: PGClosure): guint
proc set_n_fnotifiers*(a: var TGClosure, n_fnotifiers: guint)
proc n_inotifiers*(a: PGClosure): guint
proc in_inotify*(a: var TGClosure): guint
proc set_in_inotify*(a: var TGClosure, in_inotify: guint)
proc floating*(a: var TGClosure): guint
proc set_floating*(a: var TGClosure, floating: guint)
proc derivative_flag*(a: PGClosure): guint
proc set_derivative_flag*(a: var TGClosure, derivative_flag: guint)
proc in_marshal*(a: var TGClosure): guint
proc set_in_marshal*(a: var TGClosure, in_marshal: guint)
proc is_invalid*(a: var TGClosure): guint
proc set_is_invalid*(a: var TGClosure, is_invalid: guint)
type
PGCClosure* = ptr TGCClosure
TGCClosure*{.final.} = object
closure*: TGClosure
callback*: gpointer
proc g_cclosure_new*(callback_func: TGCallback, user_data: gpointer,
destroy_data: TGClosureNotify): PGClosure{.cdecl,
dynlib: gliblib, importc: "g_cclosure_new".}
proc g_cclosure_new_swap*(callback_func: TGCallback, user_data: gpointer,
destroy_data: TGClosureNotify): PGClosure{.cdecl,
dynlib: gliblib, importc: "g_cclosure_new_swap".}
proc g_signal_type_cclosure_new*(itype: GType, struct_offset: guint): PGClosure{.
cdecl, dynlib: gliblib, importc: "g_signal_type_cclosure_new".}
proc g_closure_ref*(closure: PGClosure): PGClosure{.cdecl, dynlib: gliblib,
importc: "g_closure_ref".}
proc g_closure_sink*(closure: PGClosure){.cdecl, dynlib: gliblib,
importc: "g_closure_sink".}
proc g_closure_unref*(closure: PGClosure){.cdecl, dynlib: gliblib,
importc: "g_closure_unref".}
proc g_closure_new_simple*(sizeof_closure: guint, data: gpointer): PGClosure{.
cdecl, dynlib: gliblib, importc: "g_closure_new_simple".}
proc g_closure_add_finalize_notifier*(closure: PGClosure, notify_data: gpointer,
notify_func: TGClosureNotify){.cdecl,
dynlib: gliblib, importc: "g_closure_add_finalize_notifier".}
proc g_closure_remove_finalize_notifier*(closure: PGClosure,
notify_data: gpointer, notify_func: TGClosureNotify){.cdecl,
dynlib: gliblib, importc: "g_closure_remove_finalize_notifier".}
proc g_closure_add_invalidate_notifier*(closure: PGClosure,
notify_data: gpointer,
notify_func: TGClosureNotify){.cdecl,
dynlib: gliblib, importc: "g_closure_add_invalidate_notifier".}
proc g_closure_remove_invalidate_notifier*(closure: PGClosure,
notify_data: gpointer, notify_func: TGClosureNotify){.cdecl,
dynlib: gliblib, importc: "g_closure_remove_invalidate_notifier".}
proc g_closure_add_marshal_guards*(closure: PGClosure,
pre_marshal_data: gpointer,
pre_marshal_notify: TGClosureNotify,
post_marshal_data: gpointer,
post_marshal_notify: TGClosureNotify){.cdecl,
dynlib: gliblib, importc: "g_closure_add_marshal_guards".}
proc g_closure_set_marshal*(closure: PGClosure, marshal: TGClosureMarshal){.
cdecl, dynlib: gliblib, importc: "g_closure_set_marshal".}
proc g_closure_set_meta_marshal*(closure: PGClosure, marshal_data: gpointer,
meta_marshal: TGClosureMarshal){.cdecl,
dynlib: gliblib, importc: "g_closure_set_meta_marshal".}
proc g_closure_invalidate*(closure: PGClosure){.cdecl, dynlib: gliblib,
importc: "g_closure_invalidate".}
proc g_closure_invoke*(closure: PGClosure, return_value: PGValue,
n_param_values: guint, param_values: PGValue,
invocation_hint: gpointer){.cdecl, dynlib: gliblib,
importc: "g_closure_invoke".}
type
PGSignalInvocationHint* = ptr TGSignalInvocationHint
PGSignalCMarshaller* = ptr TGSignalCMarshaller
TGSignalCMarshaller* = TGClosureMarshal
TGSignalEmissionHook* = proc (ihint: PGSignalInvocationHint,
n_param_values: guint, param_values: PGValue,
data: gpointer): gboolean{.cdecl.}
TGSignalAccumulator* = proc (ihint: PGSignalInvocationHint,
return_accu: PGValue, handler_return: PGValue,
data: gpointer): gboolean{.cdecl.}
PGSignalFlags* = ptr TGSignalFlags
TGSignalFlags* = int32
TGSignalInvocationHint*{.final.} = object
signal_id*: guint
detail*: TGQuark
run_type*: TGSignalFlags
PGSignalQuery* = ptr TGSignalQuery
TGSignalQuery*{.final.} = object
signal_id*: guint
signal_name*: cstring
itype*: GType
signal_flags*: TGSignalFlags
return_type*: GType
n_params*: guint
param_types*: PGType
const
G_SIGNAL_RUN_FIRST* = 1 shl 0
G_SIGNAL_RUN_LAST* = 1 shl 1
G_SIGNAL_RUN_CLEANUP* = 1 shl 2
G_SIGNAL_NO_RECURSE* = 1 shl 3
G_SIGNAL_DETAILED* = 1 shl 4
G_SIGNAL_ACTION* = 1 shl 5
G_SIGNAL_NO_HOOKS* = 1 shl 6
G_SIGNAL_FLAGS_MASK* = 0x0000007F
type
PGConnectFlags* = ptr TGConnectFlags
TGConnectFlags* = int32
const
G_CONNECT_AFTER* = 1 shl 0
G_CONNECT_SWAPPED* = 1 shl 1
type
PGSignalMatchType* = ptr TGSignalMatchType
TGSignalMatchType* = int32
const
G_SIGNAL_MATCH_ID* = 1 shl 0
G_SIGNAL_MATCH_DETAIL* = 1 shl 1
G_SIGNAL_MATCH_CLOSURE* = 1 shl 2
G_SIGNAL_MATCH_FUNC* = 1 shl 3
G_SIGNAL_MATCH_DATA* = 1 shl 4
G_SIGNAL_MATCH_UNBLOCKED* = 1 shl 5
G_SIGNAL_MATCH_MASK* = 0x0000003F
G_SIGNAL_TYPE_STATIC_SCOPE* = G_TYPE_FLAG_RESERVED_ID_BIT
proc g_signal_newv*(signal_name: cstring, itype: GType,
signal_flags: TGSignalFlags, class_closure: PGClosure,
accumulator: TGSignalAccumulator, accu_data: gpointer,
c_marshaller: TGSignalCMarshaller, return_type: GType,
n_params: guint, param_types: PGType): guint{.cdecl,
dynlib: gobjectlib, importc: "g_signal_newv".}
proc g_signal_emitv*(instance_and_params: PGValue, signal_id: guint,
detail: TGQuark, return_value: PGValue){.cdecl,
dynlib: gobjectlib, importc: "g_signal_emitv".}
proc g_signal_lookup*(name: cstring, itype: GType): guint{.cdecl,
dynlib: gobjectlib, importc: "g_signal_lookup".}
proc g_signal_name*(signal_id: guint): cstring{.cdecl, dynlib: gobjectlib,
importc: "g_signal_name".}
proc g_signal_query*(signal_id: guint, query: PGSignalQuery){.cdecl,
dynlib: gobjectlib, importc: "g_signal_query".}
proc g_signal_list_ids*(itype: GType, n_ids: Pguint): Pguint{.cdecl,
dynlib: gobjectlib, importc: "g_signal_list_ids".}
proc g_signal_parse_name*(detailed_signal: cstring, itype: GType,
signal_id_p: Pguint, detail_p: PGQuark,
force_detail_quark: gboolean): gboolean{.cdecl,
dynlib: gobjectlib, importc: "g_signal_parse_name".}
proc g_signal_get_invocation_hint*(instance: gpointer): PGSignalInvocationHint{.
cdecl, dynlib: gobjectlib, importc: "g_signal_get_invocation_hint".}
proc g_signal_stop_emission*(instance: gpointer, signal_id: guint,
detail: TGQuark){.cdecl, dynlib: gobjectlib,
importc: "g_signal_stop_emission".}
proc g_signal_stop_emission_by_name*(instance: gpointer,
detailed_signal: cstring){.cdecl,
dynlib: gobjectlib, importc: "g_signal_stop_emission_by_name".}
proc g_signal_add_emission_hook*(signal_id: guint, quark: TGQuark,
hook_func: TGSignalEmissionHook,
hook_data: gpointer,
data_destroy: TGDestroyNotify): gulong{.cdecl,
dynlib: gobjectlib, importc: "g_signal_add_emission_hook".}
proc g_signal_remove_emission_hook*(signal_id: guint, hook_id: gulong){.cdecl,
dynlib: gobjectlib, importc: "g_signal_remove_emission_hook".}
proc g_signal_has_handler_pending*(instance: gpointer, signal_id: guint,
detail: TGQuark, may_be_blocked: gboolean): gboolean{.
cdecl, dynlib: gobjectlib, importc: "g_signal_has_handler_pending".}
proc g_signal_connect_closure_by_id*(instance: gpointer, signal_id: guint,
detail: TGQuark, closure: PGClosure,
after: gboolean): gulong{.cdecl,
dynlib: gobjectlib, importc: "g_signal_connect_closure_by_id".}
proc g_signal_connect_closure*(instance: gpointer, detailed_signal: cstring,
closure: PGClosure, after: gboolean): gulong{.
cdecl, dynlib: gobjectlib, importc: "g_signal_connect_closure".}
proc g_signal_connect_data*(instance: gpointer, detailed_signal: cstring,
c_handler: TGCallback, data: gpointer,
destroy_data: TGClosureNotify,
connect_flags: TGConnectFlags): gulong{.cdecl,
dynlib: gobjectlib, importc: "g_signal_connect_data".}
proc g_signal_handler_block*(instance: gpointer, handler_id: gulong){.cdecl,
dynlib: gobjectlib, importc: "g_signal_handler_block".}
proc g_signal_handler_unblock*(instance: gpointer, handler_id: gulong){.cdecl,
dynlib: gobjectlib, importc: "g_signal_handler_unblock".}
proc g_signal_handler_disconnect*(instance: gpointer, handler_id: gulong){.
cdecl, dynlib: gobjectlib, importc: "g_signal_handler_disconnect".}
proc g_signal_handler_is_connected*(instance: gpointer, handler_id: gulong): gboolean{.
cdecl, dynlib: gobjectlib, importc: "g_signal_handler_is_connected".}
proc g_signal_handler_find*(instance: gpointer, mask: TGSignalMatchType,
signal_id: guint, detail: TGQuark,
closure: PGClosure, func: gpointer, data: gpointer): gulong{.
cdecl, dynlib: gobjectlib, importc: "g_signal_handler_find".}
proc g_signal_handlers_block_matched*(instance: gpointer,
mask: TGSignalMatchType, signal_id: guint,
detail: TGQuark, closure: PGClosure,
func: gpointer, data: gpointer): guint{.
cdecl, dynlib: gobjectlib, importc: "g_signal_handlers_block_matched".}
proc g_signal_handlers_unblock_matched*(instance: gpointer,
mask: TGSignalMatchType,
signal_id: guint, detail: TGQuark,
closure: PGClosure, func: gpointer,
data: gpointer): guint{.cdecl,
dynlib: gobjectlib, importc: "g_signal_handlers_unblock_matched".}
proc g_signal_handlers_disconnect_matched*(instance: gpointer,
mask: TGSignalMatchType, signal_id: guint, detail: TGQuark,
closure: PGClosure, func: gpointer, data: gpointer): guint{.cdecl,
dynlib: gobjectlib, importc: "g_signal_handlers_disconnect_matched".}
proc g_signal_override_class_closure*(signal_id: guint, instance_type: GType,
class_closure: PGClosure){.cdecl,
dynlib: gobjectlib, importc: "g_signal_override_class_closure".}
proc g_signal_chain_from_overridden*(instance_and_params: PGValue,
return_value: PGValue){.cdecl,
dynlib: gobjectlib, importc: "g_signal_chain_from_overridden".}
proc g_signal_connect*(instance: gpointer, detailed_signal: cstring,
c_handler: TGCallback, data: gpointer): gulong
proc g_signal_connect_after*(instance: gpointer, detailed_signal: cstring,
c_handler: TGCallback, data: gpointer): gulong
proc g_signal_connect_swapped*(instance: gpointer, detailed_signal: cstring,
c_handler: TGCallback, data: gpointer): gulong
proc g_signal_handlers_disconnect_by_func*(instance: gpointer,
func, data: gpointer): guint
proc g_signal_handlers_block_by_func*(instance: gpointer, func, data: gpointer)
proc g_signal_handlers_unblock_by_func*(instance: gpointer, func, data: gpointer)
proc g_signal_handlers_destroy*(instance: gpointer){.cdecl, dynlib: gobjectlib,
importc: "g_signal_handlers_destroy".}
proc g_signals_destroy*(itype: GType){.cdecl, dynlib: gobjectlib,
importc: "`g_signals_destroy`".}
type
TGTypePluginUse* = proc (plugin: PGTypePlugin){.cdecl.}
TGTypePluginUnuse* = proc (plugin: PGTypePlugin){.cdecl.}
TGTypePluginCompleteTypeInfo* = proc (plugin: PGTypePlugin, g_type: GType,
info: PGTypeInfo,
value_table: PGTypeValueTable){.cdecl.}
TGTypePluginCompleteInterfaceInfo* = proc (plugin: PGTypePlugin,
instance_type: GType, interface_type: GType, info: PGInterfaceInfo){.cdecl.}
PGTypePluginClass* = ptr TGTypePluginClass
TGTypePluginClass*{.final.} = object
base_iface*: TGTypeInterface
use_plugin*: TGTypePluginUse
unuse_plugin*: TGTypePluginUnuse
complete_type_info*: TGTypePluginCompleteTypeInfo
complete_interface_info*: TGTypePluginCompleteInterfaceInfo
proc G_TYPE_TYPE_PLUGIN*(): GType
proc G_TYPE_PLUGIN*(inst: Pointer): PGTypePlugin
proc G_TYPE_PLUGIN_CLASS*(vtable: Pointer): PGTypePluginClass
proc G_IS_TYPE_PLUGIN*(inst: Pointer): bool
proc G_IS_TYPE_PLUGIN_CLASS*(vtable: Pointer): bool
proc G_TYPE_PLUGIN_GET_CLASS*(inst: Pointer): PGTypePluginClass
proc g_type_plugin_get_type*(): GType{.cdecl, dynlib: gliblib,
importc: "g_type_plugin_get_type".}
proc g_type_plugin_use*(plugin: PGTypePlugin){.cdecl, dynlib: gliblib,
importc: "g_type_plugin_use".}
proc g_type_plugin_unuse*(plugin: PGTypePlugin){.cdecl, dynlib: gliblib,
importc: "g_type_plugin_unuse".}
proc g_type_plugin_complete_type_info*(plugin: PGTypePlugin, g_type: GType,
info: PGTypeInfo,
value_table: PGTypeValueTable){.cdecl,
dynlib: gliblib, importc: "g_type_plugin_complete_type_info".}
proc g_type_plugin_complete_interface_info*(plugin: PGTypePlugin,
instance_type: GType, interface_type: GType, info: PGInterfaceInfo){.cdecl,
dynlib: gliblib, importc: "g_type_plugin_complete_interface_info".}
type
PGObject* = ptr TGObject
TGObject*{.pure.} = object
g_type_instance*: TGTypeInstance
ref_count*: guint
qdata*: PGData
TGObjectGetPropertyFunc* = proc (anObject: PGObject, property_id: guint,
value: PGValue, pspec: PGParamSpec){.cdecl.}
TGObjectSetPropertyFunc* = proc (anObject: PGObject, property_id: guint,
value: PGValue, pspec: PGParamSpec){.cdecl.}
TGObjectFinalizeFunc* = proc (anObject: PGObject){.cdecl.}
TGWeakNotify* = proc (data: gpointer, where_the_object_was: PGObject){.cdecl.}
PGObjectConstructParam* = ptr TGObjectConstructParam
PGObjectClass* = ptr TGObjectClass
TGObjectClass*{.pure.} = object
g_type_class*: TGTypeClass
construct_properties*: PGSList
constructor*: proc (theType: GType, n_construct_properties: guint,
construct_properties: PGObjectConstructParam): PGObject{.
cdecl.}
set_property*: proc (anObject: PGObject, property_id: guint, value: PGValue,
pspec: PGParamSpec){.cdecl.}
get_property*: proc (anObject: PGObject, property_id: guint, value: PGValue,
pspec: PGParamSpec){.cdecl.}
dispose*: proc (anObject: PGObject){.cdecl.}
finalize*: proc (anObject: PGObject){.cdecl.}
dispatch_properties_changed*: proc (anObject: PGObject, n_pspecs: guint,
pspecs: PPGParamSpec){.cdecl.}
notify*: proc (anObject: PGObject, pspec: PGParamSpec){.cdecl.}
pdummy*: array[0..7, gpointer]
TGObjectConstructParam*{.final.} = object
pspec*: PGParamSpec
value*: PGValue
proc G_TYPE_IS_OBJECT*(theType: GType): bool
proc G_OBJECT*(anObject: pointer): PGObject
proc G_OBJECT_CLASS*(class: Pointer): PGObjectClass
proc G_IS_OBJECT*(anObject: pointer): bool
proc G_IS_OBJECT_CLASS*(class: Pointer): bool
proc G_OBJECT_GET_CLASS*(anObject: pointer): PGObjectClass
proc G_OBJECT_TYPE*(anObject: pointer): GType
proc G_OBJECT_TYPE_NAME*(anObject: pointer): cstring
proc G_OBJECT_CLASS_TYPE*(class: Pointer): GType
proc G_OBJECT_CLASS_NAME*(class: Pointer): cstring
proc G_VALUE_HOLDS_OBJECT*(value: Pointer): bool
proc g_object_class_install_property*(oclass: PGObjectClass, property_id: guint,
pspec: PGParamSpec){.cdecl,
dynlib: gobjectlib, importc: "g_object_class_install_property".}
proc g_object_class_find_property*(oclass: PGObjectClass, property_name: cstring): PGParamSpec{.
cdecl, dynlib: gobjectlib, importc: "g_object_class_find_property".}
proc g_object_class_list_properties*(oclass: PGObjectClass, n_properties: Pguint): PPGParamSpec{.
cdecl, dynlib: gobjectlib, importc: "g_object_class_list_properties".}
proc g_object_set_property*(anObject: PGObject, property_name: cstring,
value: PGValue){.cdecl, dynlib: gobjectlib,
importc: "g_object_set_property".}
proc g_object_get_property*(anObject: PGObject, property_name: cstring,
value: PGValue){.cdecl, dynlib: gobjectlib,
importc: "g_object_get_property".}
proc g_object_freeze_notify*(anObject: PGObject){.cdecl, dynlib: gobjectlib,
importc: "g_object_freeze_notify".}
proc g_object_notify*(anObject: PGObject, property_name: cstring){.cdecl,
dynlib: gobjectlib, importc: "g_object_notify".}
proc g_object_thaw_notify*(anObject: PGObject){.cdecl, dynlib: gobjectlib,
importc: "g_object_thaw_notify".}
proc g_object_ref*(anObject: gpointer): gpointer{.cdecl, dynlib: gobjectlib,
importc: "g_object_ref".}
proc g_object_unref*(anObject: gpointer){.cdecl, dynlib: gobjectlib,
importc: "g_object_unref".}
proc g_object_weak_ref*(anObject: PGObject, notify: TGWeakNotify, data: gpointer){.
cdecl, dynlib: gobjectlib, importc: "g_object_weak_ref".}
proc g_object_weak_unref*(anObject: PGObject, notify: TGWeakNotify,
data: gpointer){.cdecl, dynlib: gobjectlib,
importc: "g_object_weak_unref".}
proc g_object_add_weak_pointer*(anObject: PGObject,
weak_pointer_location: Pgpointer){.cdecl,
dynlib: gobjectlib, importc: "g_object_add_weak_pointer".}
proc g_object_remove_weak_pointer*(anObject: PGObject,
weak_pointer_location: Pgpointer){.cdecl,
dynlib: gobjectlib, importc: "g_object_remove_weak_pointer".}
proc g_object_get_qdata*(anObject: PGObject, quark: TGQuark): gpointer{.cdecl,
dynlib: gobjectlib, importc: "g_object_get_qdata".}
proc g_object_set_qdata*(anObject: PGObject, quark: TGQuark, data: gpointer){.
cdecl, dynlib: gobjectlib, importc: "g_object_set_qdata".}
proc g_object_set_qdata_full*(anObject: PGObject, quark: TGQuark,
data: gpointer, destroy: TGDestroyNotify){.cdecl,
dynlib: gobjectlib, importc: "g_object_set_qdata_full".}
proc g_object_steal_qdata*(anObject: PGObject, quark: TGQuark): gpointer{.cdecl,
dynlib: gobjectlib, importc: "g_object_steal_qdata".}
proc g_object_get_data*(anObject: PGObject, key: cstring): gpointer{.cdecl,
dynlib: gobjectlib, importc: "g_object_get_data".}
proc g_object_set_data*(anObject: PGObject, key: cstring, data: gpointer){.
cdecl, dynlib: gobjectlib, importc: "g_object_set_data".}
proc g_object_set_data_full*(anObject: PGObject, key: cstring, data: gpointer,
destroy: TGDestroyNotify){.cdecl,
dynlib: gobjectlib, importc: "g_object_set_data_full".}
proc g_object_steal_data*(anObject: PGObject, key: cstring): gpointer{.cdecl,
dynlib: gobjectlib, importc: "g_object_steal_data".}
proc g_object_watch_closure*(anObject: PGObject, closure: PGClosure){.cdecl,
dynlib: gobjectlib, importc: "g_object_watch_closure".}
proc g_cclosure_new_object*(callback_func: TGCallback, anObject: PGObject): PGClosure{.
cdecl, dynlib: gobjectlib, importc: "g_cclosure_new_object".}
proc g_cclosure_new_object_swap*(callback_func: TGCallback, anObject: PGObject): PGClosure{.
cdecl, dynlib: gobjectlib, importc: "g_cclosure_new_object_swap".}
proc g_closure_new_object*(sizeof_closure: guint, anObject: PGObject): PGClosure{.
cdecl, dynlib: gobjectlib, importc: "g_closure_new_object".}
proc g_value_set_object*(value: PGValue, v_object: gpointer){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_object".}
proc g_value_get_object*(value: PGValue): gpointer{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_object".}
proc g_value_dup_object*(value: PGValue): PGObject{.cdecl, dynlib: gobjectlib,
importc: "g_value_dup_object".}
proc g_signal_connect_object*(instance: gpointer, detailed_signal: cstring,
c_handler: TGCallback, gobject: gpointer,
connect_flags: TGConnectFlags): gulong{.cdecl,
dynlib: gobjectlib, importc: "g_signal_connect_object".}
proc g_object_run_dispose*(anObject: PGObject){.cdecl, dynlib: gobjectlib,
importc: "g_object_run_dispose".}
proc g_value_set_object_take_ownership*(value: PGValue, v_object: gpointer){.
cdecl, dynlib: gobjectlib, importc: "g_value_set_object_take_ownership".}
proc G_OBJECT_WARN_INVALID_PSPEC*(anObject: gpointer, pname: cstring,
property_id: gint, pspec: gpointer)
proc G_OBJECT_WARN_INVALID_PROPERTY_ID*(anObject: gpointer, property_id: gint,
pspec: gpointer)
type
G_FLAGS_TYPE* = GType
const
G_E* = 2.71828
G_LN2* = 0.693147
G_LN10* = 2.30259
G_PI* = 3.14159
G_PI_2* = 1.57080
G_PI_4* = 0.785398
G_SQRT2* = 1.41421
G_LITTLE_ENDIAN* = 1234
G_BIG_ENDIAN* = 4321
G_PDP_ENDIAN* = 3412
proc GUINT16_SWAP_LE_BE_CONSTANT*(val: guint16): guint16
proc GUINT32_SWAP_LE_BE_CONSTANT*(val: guint32): guint32
type
PGEnumClass* = ptr TGEnumClass
PGEnumValue* = ptr TGEnumValue
TGEnumClass*{.final.} = object
g_type_class*: TGTypeClass
minimum*: gint
maximum*: gint
n_values*: guint
values*: PGEnumValue
TGEnumValue*{.final.} = object
value*: gint
value_name*: cstring
value_nick*: cstring
PGFlagsClass* = ptr TGFlagsClass
PGFlagsValue* = ptr TGFlagsValue
TGFlagsClass*{.final.} = object
g_type_class*: TGTypeClass
mask*: guint
n_values*: guint
values*: PGFlagsValue
TGFlagsValue*{.final.} = object
value*: guint
value_name*: cstring
value_nick*: cstring
proc G_TYPE_IS_ENUM*(theType: GType): gboolean
proc G_ENUM_CLASS*(class: pointer): PGEnumClass
proc G_IS_ENUM_CLASS*(class: pointer): gboolean
proc G_ENUM_CLASS_TYPE*(class: pointer): GType
proc G_ENUM_CLASS_TYPE_NAME*(class: pointer): cstring
proc G_TYPE_IS_FLAGS*(theType: GType): gboolean
proc G_FLAGS_CLASS*(class: pointer): PGFlagsClass
proc G_IS_FLAGS_CLASS*(class: pointer): gboolean
proc G_FLAGS_CLASS_TYPE*(class: pointer): GType
proc G_FLAGS_CLASS_TYPE_NAME*(class: pointer): cstring
proc G_VALUE_HOLDS_ENUM*(value: pointer): gboolean
proc G_VALUE_HOLDS_FLAGS*(value: pointer): gboolean
proc g_enum_get_value*(enum_class: PGEnumClass, value: gint): PGEnumValue{.
cdecl, dynlib: gliblib, importc: "g_enum_get_value".}
proc g_enum_get_value_by_name*(enum_class: PGEnumClass, name: cstring): PGEnumValue{.
cdecl, dynlib: gliblib, importc: "g_enum_get_value_by_name".}
proc g_enum_get_value_by_nick*(enum_class: PGEnumClass, nick: cstring): PGEnumValue{.
cdecl, dynlib: gliblib, importc: "g_enum_get_value_by_nick".}
proc g_flags_get_first_value*(flags_class: PGFlagsClass, value: guint): PGFlagsValue{.
cdecl, dynlib: gliblib, importc: "g_flags_get_first_value".}
proc g_flags_get_value_by_name*(flags_class: PGFlagsClass, name: cstring): PGFlagsValue{.
cdecl, dynlib: gliblib, importc: "g_flags_get_value_by_name".}
proc g_flags_get_value_by_nick*(flags_class: PGFlagsClass, nick: cstring): PGFlagsValue{.
cdecl, dynlib: gliblib, importc: "g_flags_get_value_by_nick".}
proc g_value_set_enum*(value: PGValue, v_enum: gint){.cdecl, dynlib: gliblib,
importc: "g_value_set_enum".}
proc g_value_get_enum*(value: PGValue): gint{.cdecl, dynlib: gliblib,
importc: "g_value_get_enum".}
proc g_value_set_flags*(value: PGValue, v_flags: guint){.cdecl, dynlib: gliblib,
importc: "g_value_set_flags".}
proc g_value_get_flags*(value: PGValue): guint{.cdecl, dynlib: gliblib,
importc: "g_value_get_flags".}
proc g_enum_register_static*(name: cstring, const_static_values: PGEnumValue): GType{.
cdecl, dynlib: gliblib, importc: "g_enum_register_static".}
proc g_flags_register_static*(name: cstring, const_static_values: PGFlagsValue): GType{.
cdecl, dynlib: gliblib, importc: "g_flags_register_static".}
proc g_enum_complete_type_info*(g_enum_type: GType, info: PGTypeInfo,
const_values: PGEnumValue){.cdecl,
dynlib: gliblib, importc: "g_enum_complete_type_info".}
proc g_flags_complete_type_info*(g_flags_type: GType, info: PGTypeInfo,
const_values: PGFlagsValue){.cdecl,
dynlib: gliblib, importc: "g_flags_complete_type_info".}
const
G_MINFLOAT* = 0.00000
G_MAXFLOAT* = 1.70000e+308
G_MINDOUBLE* = G_MINFLOAT
G_MAXDOUBLE* = G_MAXFLOAT
G_MAXSHORT* = 32767
G_MINSHORT* = - G_MAXSHORT - 1
G_MAXUSHORT* = 2 * G_MAXSHORT + 1
G_MAXINT* = 2147483647
G_MININT* = - G_MAXINT - 1
G_MAXUINT* = - 1
G_MINLONG* = G_MININT
G_MAXLONG* = G_MAXINT
G_MAXULONG* = G_MAXUINT
G_MAXINT64* = high(int64)
G_MININT64* = low(int64)
const
G_GINT16_FORMAT* = "hi"
G_GUINT16_FORMAT* = "hu"
G_GINT32_FORMAT* = 'i'
G_GUINT32_FORMAT* = 'u'
G_HAVE_GINT64* = 1
G_GINT64_FORMAT* = "I64i"
G_GUINT64_FORMAT* = "I64u"
GLIB_SIZEOF_VOID_P* = SizeOf(Pointer)
GLIB_SIZEOF_LONG* = SizeOf(int32)
GLIB_SIZEOF_SIZE_T* = SizeOf(int32)
type
PGSystemThread* = ptr TGSystemThread
TGSystemThread*{.final.} = object
data*: array[0..3, char]
dummy_double*: float64
dummy_pointer*: pointer
dummy_long*: int32
const
GLIB_SYSDEF_POLLIN* = 1
GLIB_SYSDEF_POLLOUT* = 4
GLIB_SYSDEF_POLLPRI* = 2
GLIB_SYSDEF_POLLERR* = 8
GLIB_SYSDEF_POLLHUP* = 16
GLIB_SYSDEF_POLLNVAL* = 32
proc GUINT_TO_POINTER*(i: guint): pointer
type
PGAsciiType* = ptr TGAsciiType
TGAsciiType* = int32
const
G_ASCII_ALNUM* = 1 shl 0
G_ASCII_ALPHA* = 1 shl 1
G_ASCII_CNTRL* = 1 shl 2
G_ASCII_DIGIT* = 1 shl 3
G_ASCII_GRAPH* = 1 shl 4
G_ASCII_LOWER* = 1 shl 5
G_ASCII_PRINT* = 1 shl 6
G_ASCII_PUNCT* = 1 shl 7
G_ASCII_SPACE* = 1 shl 8
G_ASCII_UPPER* = 1 shl 9
G_ASCII_XDIGIT* = 1 shl 10
proc g_ascii_tolower*(c: gchar): gchar{.cdecl, dynlib: gliblib,
importc: "g_ascii_tolower".}
proc g_ascii_toupper*(c: gchar): gchar{.cdecl, dynlib: gliblib,
importc: "g_ascii_toupper".}
proc g_ascii_digit_value*(c: gchar): gint{.cdecl, dynlib: gliblib,
importc: "g_ascii_digit_value".}
proc g_ascii_xdigit_value*(c: gchar): gint{.cdecl, dynlib: gliblib,
importc: "g_ascii_xdigit_value".}
const
G_STR_DELIMITERS* = "``-|> <."
proc g_strdelimit*(str: cstring, delimiters: cstring, new_delimiter: gchar): cstring{.
cdecl, dynlib: gliblib, importc: "g_strdelimit".}
proc g_strcanon*(str: cstring, valid_chars: cstring, substitutor: gchar): cstring{.
cdecl, dynlib: gliblib, importc: "g_strcanon".}
proc g_strerror*(errnum: gint): cstring{.cdecl, dynlib: gliblib,
importc: "g_strerror".}
proc g_strsignal*(signum: gint): cstring{.cdecl, dynlib: gliblib,
importc: "g_strsignal".}
proc g_strreverse*(str: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_strreverse".}
proc g_strlcpy*(dest: cstring, src: cstring, dest_size: gsize): gsize{.cdecl,
dynlib: gliblib, importc: "g_strlcpy".}
proc g_strlcat*(dest: cstring, src: cstring, dest_size: gsize): gsize{.cdecl,
dynlib: gliblib, importc: "g_strlcat".}
proc g_strstr_len*(haystack: cstring, haystack_len: gssize, needle: cstring): cstring{.
cdecl, dynlib: gliblib, importc: "g_strstr_len".}
proc g_strrstr*(haystack: cstring, needle: cstring): cstring{.cdecl,
dynlib: gliblib, importc: "g_strrstr".}
proc g_strrstr_len*(haystack: cstring, haystack_len: gssize, needle: cstring): cstring{.
cdecl, dynlib: gliblib, importc: "g_strrstr_len".}
proc g_str_has_suffix*(str: cstring, suffix: cstring): gboolean{.cdecl,
dynlib: gliblib, importc: "g_str_has_suffix".}
proc g_str_has_prefix*(str: cstring, prefix: cstring): gboolean{.cdecl,
dynlib: gliblib, importc: "g_str_has_prefix".}
proc g_strtod*(nptr: cstring, endptr: PPgchar): gdouble{.cdecl, dynlib: gliblib,
importc: "g_strtod".}
proc g_ascii_strtod*(nptr: cstring, endptr: PPgchar): gdouble{.cdecl,
dynlib: gliblib, importc: "g_ascii_strtod".}
const
G_ASCII_DTOSTR_BUF_SIZE* = 29 + 10
proc g_ascii_dtostr*(buffer: cstring, buf_len: gint, d: gdouble): cstring{.
cdecl, dynlib: gliblib, importc: "g_ascii_dtostr".}
proc g_ascii_formatd*(buffer: cstring, buf_len: gint, format: cstring,
d: gdouble): cstring{.cdecl, dynlib: gliblib,
importc: "g_ascii_formatd".}
proc g_strchug*(str: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_strchug".}
proc g_strchomp*(str: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_strchomp".}
proc g_ascii_strcasecmp*(s1: cstring, s2: cstring): gint{.cdecl,
dynlib: gliblib, importc: "g_ascii_strcasecmp".}
proc g_ascii_strncasecmp*(s1: cstring, s2: cstring, n: gsize): gint{.cdecl,
dynlib: gliblib, importc: "g_ascii_strncasecmp".}
proc g_ascii_strdown*(str: cstring, len: gssize): cstring{.cdecl,
dynlib: gliblib, importc: "g_ascii_strdown".}
proc g_ascii_strup*(str: cstring, len: gssize): cstring{.cdecl, dynlib: gliblib,
importc: "g_ascii_strup".}
proc g_strdup*(str: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_strdup".}
proc g_strndup*(str: cstring, n: gsize): cstring{.cdecl, dynlib: gliblib,
importc: "g_strndup".}
proc g_strnfill*(length: gsize, fill_char: gchar): cstring{.cdecl,
dynlib: gliblib, importc: "g_strnfill".}
proc g_strcompress*(source: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_strcompress".}
proc g_strescape*(source: cstring, exceptions: cstring): cstring{.cdecl,
dynlib: gliblib, importc: "g_strescape".}
proc g_memdup*(mem: gconstpointer, byte_size: guint): gpointer{.cdecl,
dynlib: gliblib, importc: "g_memdup".}
proc g_strsplit*(str: cstring, delimiter: cstring, max_tokens: gint): PPgchar{.
cdecl, dynlib: gliblib, importc: "g_strsplit".}
proc g_strjoinv*(separator: cstring, str_array: PPgchar): cstring{.cdecl,
dynlib: gliblib, importc: "g_strjoinv".}
proc g_strfreev*(str_array: PPgchar){.cdecl, dynlib: gliblib,
importc: "g_strfreev".}
proc g_strdupv*(str_array: PPgchar): PPgchar{.cdecl, dynlib: gliblib,
importc: "g_strdupv".}
proc g_stpcpy*(dest: cstring, src: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_stpcpy".}
proc g_get_user_name*(): cstring{.cdecl, dynlib: gliblib,
importc: "g_get_user_name".}
proc g_get_real_name*(): cstring{.cdecl, dynlib: gliblib,
importc: "g_get_real_name".}
proc g_get_home_dir*(): cstring{.cdecl, dynlib: gliblib,
importc: "g_get_home_dir".}
proc g_get_tmp_dir*(): cstring{.cdecl, dynlib: gliblib, importc: "g_get_tmp_dir".}
proc g_get_prgname*(): cstring{.cdecl, dynlib: gliblib, importc: "g_get_prgname".}
proc g_set_prgname*(prgname: cstring){.cdecl, dynlib: gliblib,
importc: "g_set_prgname".}
type
PGDebugKey* = ptr TGDebugKey
TGDebugKey*{.final.} = object
key*: cstring
value*: guint
proc g_parse_debug_string*(str: cstring, keys: PGDebugKey, nkeys: guint): guint{.
cdecl, dynlib: gliblib, importc: "g_parse_debug_string".}
proc g_path_is_absolute*(file_name: cstring): gboolean{.cdecl, dynlib: gliblib,
importc: "g_path_is_absolute".}
proc g_path_skip_root*(file_name: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_path_skip_root".}
proc g_basename*(file_name: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_basename".}
proc g_dirname*(file_name: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_path_get_dirname".}
proc g_get_current_dir*(): cstring{.cdecl, dynlib: gliblib,
importc: "g_get_current_dir".}
proc g_path_get_basename*(file_name: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_path_get_basename".}
proc g_path_get_dirname*(file_name: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_path_get_dirname".}
proc g_nullify_pointer*(nullify_location: Pgpointer){.cdecl, dynlib: gliblib,
importc: "g_nullify_pointer".}
proc g_getenv*(variable: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_getenv".}
type
TGVoidFunc* = proc (){.cdecl.}
proc g_atexit*(func: TGVoidFunc){.cdecl, dynlib: gliblib, importc: "g_atexit".}
proc g_find_program_in_path*(program: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_find_program_in_path".}
proc g_bit_nth_lsf*(mask: gulong, nth_bit: gint): gint{.cdecl, dynlib: gliblib,
importc: "g_bit_nth_lsf".}
proc g_bit_nth_msf*(mask: gulong, nth_bit: gint): gint{.cdecl, dynlib: gliblib,
importc: "g_bit_nth_msf".}
proc g_bit_storage*(number: gulong): guint{.cdecl, dynlib: gliblib,
importc: "g_bit_storage".}
type
PPGTrashStack* = ptr PGTrashStack
PGTrashStack* = ptr TGTrashStack
TGTrashStack*{.final.} = object
next*: PGTrashStack
proc g_trash_stack_push*(stack_p: PPGTrashStack, data_p: gpointer){.cdecl,
dynlib: gliblib, importc: "g_trash_stack_push".}
proc g_trash_stack_pop*(stack_p: PPGTrashStack): gpointer{.cdecl,
dynlib: gliblib, importc: "g_trash_stack_pop".}
proc g_trash_stack_peek*(stack_p: PPGTrashStack): gpointer{.cdecl,
dynlib: gliblib, importc: "g_trash_stack_peek".}
proc g_trash_stack_height*(stack_p: PPGTrashStack): guint{.cdecl,
dynlib: gliblib, importc: "g_trash_stack_height".}
type
PGHashTable* = pointer
TGHRFunc* = proc (key, value, user_data: gpointer): gboolean{.cdecl.}
proc g_hash_table_new*(hash_func: TGHashFunc, key_equal_func: TGEqualFunc): PGHashTable{.
cdecl, dynlib: gliblib, importc: "g_hash_table_new".}
proc g_hash_table_new_full*(hash_func: TGHashFunc, key_equal_func: TGEqualFunc,
key_destroy_func: TGDestroyNotify,
value_destroy_func: TGDestroyNotify): PGHashTable{.
cdecl, dynlib: gliblib, importc: "g_hash_table_new_full".}
proc g_hash_table_destroy*(hash_table: PGHashTable){.cdecl, dynlib: gliblib,
importc: "g_hash_table_destroy".}
proc g_hash_table_insert*(hash_table: PGHashTable, key: gpointer,
value: gpointer){.cdecl, dynlib: gliblib,
importc: "g_hash_table_insert".}
proc g_hash_table_replace*(hash_table: PGHashTable, key: gpointer,
value: gpointer){.cdecl, dynlib: gliblib,
importc: "g_hash_table_replace".}
proc g_hash_table_remove*(hash_table: PGHashTable, key: gconstpointer): gboolean{.
cdecl, dynlib: gliblib, importc: "g_hash_table_remove".}
proc g_hash_table_steal*(hash_table: PGHashTable, key: gconstpointer): gboolean{.
cdecl, dynlib: gliblib, importc: "g_hash_table_steal".}
proc g_hash_table_lookup*(hash_table: PGHashTable, key: gconstpointer): gpointer{.
cdecl, dynlib: gliblib, importc: "g_hash_table_lookup".}
proc g_hash_table_lookup_extended*(hash_table: PGHashTable,
lookup_key: gconstpointer,
orig_key: Pgpointer, value: Pgpointer): gboolean{.
cdecl, dynlib: gliblib, importc: "g_hash_table_lookup_extended".}
proc g_hash_table_foreach*(hash_table: PGHashTable, func: TGHFunc,
user_data: gpointer){.cdecl, dynlib: gliblib,
importc: "g_hash_table_foreach".}
proc g_hash_table_foreach_remove*(hash_table: PGHashTable, func: TGHRFunc,
user_data: gpointer): guint{.cdecl,
dynlib: gliblib, importc: "g_hash_table_foreach_remove".}
proc g_hash_table_foreach_steal*(hash_table: PGHashTable, func: TGHRFunc,
user_data: gpointer): guint{.cdecl,
dynlib: gliblib, importc: "g_hash_table_foreach_steal".}
proc g_hash_table_size*(hash_table: PGHashTable): guint{.cdecl, dynlib: gliblib,
importc: "g_hash_table_size".}
proc g_str_equal*(v: gconstpointer, v2: gconstpointer): gboolean{.cdecl,
dynlib: gliblib, importc: "g_str_equal".}
proc g_str_hash*(v: gconstpointer): guint{.cdecl, dynlib: gliblib,
importc: "g_str_hash".}
proc g_int_equal*(v: gconstpointer, v2: gconstpointer): gboolean{.cdecl,
dynlib: gliblib, importc: "g_int_equal".}
proc g_int_hash*(v: gconstpointer): guint{.cdecl, dynlib: gliblib,
importc: "g_int_hash".}
proc g_direct_hash*(v: gconstpointer): guint{.cdecl, dynlib: gliblib,
importc: "g_direct_hash".}
proc g_direct_equal*(v: gconstpointer, v2: gconstpointer): gboolean{.cdecl,
dynlib: gliblib, importc: "g_direct_equal".}
proc g_quark_try_string*(str: cstring): TGQuark{.cdecl, dynlib: gliblib,
importc: "g_quark_try_string".}
proc g_quark_from_static_string*(str: cstring): TGQuark{.cdecl, dynlib: gliblib,
importc: "g_quark_from_static_string".}
proc g_quark_from_string*(str: cstring): TGQuark{.cdecl, dynlib: gliblib,
importc: "g_quark_from_string".}
proc g_quark_to_string*(quark: TGQuark): cstring{.cdecl, dynlib: gliblib,
importc: "g_quark_to_string".}
const
G_MEM_ALIGN* = GLIB_SIZEOF_VOID_P
type
PGMemVTable* = ptr TGMemVTable
TGMemVTable*{.final.} = object
malloc*: proc (n_bytes: gsize): gpointer{.cdecl.}
realloc*: proc (mem: gpointer, n_bytes: gsize): gpointer{.cdecl.}
free*: proc (mem: gpointer){.cdecl.}
calloc*: proc (n_blocks: gsize, n_block_bytes: gsize): gpointer{.cdecl.}
try_malloc*: proc (n_bytes: gsize): gpointer{.cdecl.}
try_realloc*: proc (mem: gpointer, n_bytes: gsize): gpointer{.cdecl.}
PGMemChunk* = pointer
PGAllocator* = pointer
proc g_malloc*(n_bytes: gulong): gpointer{.cdecl, dynlib: gliblib,
importc: "g_malloc".}
proc g_malloc0*(n_bytes: gulong): gpointer{.cdecl, dynlib: gliblib,
importc: "g_malloc0".}
proc g_realloc*(mem: gpointer, n_bytes: gulong): gpointer{.cdecl,
dynlib: gliblib, importc: "g_realloc".}
proc g_free*(mem: gpointer){.cdecl, dynlib: gliblib, importc: "g_free".}
proc g_try_malloc*(n_bytes: gulong): gpointer{.cdecl, dynlib: gliblib,
importc: "g_try_malloc".}
proc g_try_realloc*(mem: gpointer, n_bytes: gulong): gpointer{.cdecl,
dynlib: gliblib, importc: "g_try_realloc".}
#proc g_new*(bytes_per_struct, n_structs: gsize): gpointer
#proc g_new0*(bytes_per_struct, n_structs: gsize): gpointer
#proc g_renew*(struct_size: gsize, OldMem: gpointer, n_structs: gsize): gpointer
proc g_mem_set_vtable*(vtable: PGMemVTable){.cdecl, dynlib: gliblib,
importc: "g_mem_set_vtable".}
proc g_mem_is_system_malloc*(): gboolean{.cdecl, dynlib: gliblib,
importc: "g_mem_is_system_malloc".}
proc g_mem_profile*(){.cdecl, dynlib: gliblib, importc: "g_mem_profile".}
proc g_chunk_new*(chunk: Pointer): Pointer
proc g_chunk_new0*(chunk: Pointer): Pointer
proc g_chunk_free*(mem_chunk: PGMemChunk, mem: gpointer)
const
G_ALLOC_ONLY* = 1
G_ALLOC_AND_FREE* = 2
proc g_mem_chunk_new*(name: cstring, atom_size: gint, area_size: gulong,
theType: gint): PGMemChunk{.cdecl, dynlib: gliblib,
importc: "g_mem_chunk_new".}
proc g_mem_chunk_destroy*(mem_chunk: PGMemChunk){.cdecl, dynlib: gliblib,
importc: "g_mem_chunk_destroy".}
proc g_mem_chunk_alloc*(mem_chunk: PGMemChunk): gpointer{.cdecl,
dynlib: gliblib, importc: "g_mem_chunk_alloc".}
proc g_mem_chunk_alloc0*(mem_chunk: PGMemChunk): gpointer{.cdecl,
dynlib: gliblib, importc: "g_mem_chunk_alloc0".}
proc g_mem_chunk_free*(mem_chunk: PGMemChunk, mem: gpointer){.cdecl,
dynlib: gliblib, importc: "g_mem_chunk_free".}
proc g_mem_chunk_clean*(mem_chunk: PGMemChunk){.cdecl, dynlib: gliblib,
importc: "g_mem_chunk_clean".}
proc g_mem_chunk_reset*(mem_chunk: PGMemChunk){.cdecl, dynlib: gliblib,
importc: "g_mem_chunk_reset".}
proc g_mem_chunk_print*(mem_chunk: PGMemChunk){.cdecl, dynlib: gliblib,
importc: "g_mem_chunk_print".}
proc g_mem_chunk_info*(){.cdecl, dynlib: gliblib, importc: "g_mem_chunk_info".}
proc g_blow_chunks*(){.cdecl, dynlib: gliblib, importc: "g_blow_chunks".}
proc g_allocator_new*(name: cstring, n_preallocs: guint): PGAllocator{.cdecl,
dynlib: gliblib, importc: "g_allocator_new".}
proc g_allocator_free*(allocator: PGAllocator){.cdecl, dynlib: gliblib,
importc: "g_allocator_free".}
const
G_ALLOCATOR_LIST* = 1
G_ALLOCATOR_SLIST* = 2
G_ALLOCATOR_NODE* = 3
proc g_slist_push_allocator*(allocator: PGAllocator){.cdecl, dynlib: gliblib,
importc: "g_slist_push_allocator".}
proc g_slist_pop_allocator*(){.cdecl, dynlib: gliblib,
importc: "g_slist_pop_allocator".}
proc g_slist_alloc*(): PGSList{.cdecl, dynlib: gliblib, importc: "g_slist_alloc".}
proc g_slist_free*(list: PGSList){.cdecl, dynlib: gliblib,
importc: "g_slist_free".}
proc g_slist_free_1*(list: PGSList){.cdecl, dynlib: gliblib,
importc: "g_slist_free_1".}
proc g_slist_append*(list: PGSList, data: gpointer): PGSList{.cdecl,
dynlib: gliblib, importc: "g_slist_append".}
proc g_slist_prepend*(list: PGSList, data: gpointer): PGSList{.cdecl,
dynlib: gliblib, importc: "g_slist_prepend".}
proc g_slist_insert*(list: PGSList, data: gpointer, position: gint): PGSList{.
cdecl, dynlib: gliblib, importc: "g_slist_insert".}
proc g_slist_insert_sorted*(list: PGSList, data: gpointer, func: TGCompareFunc): PGSList{.
cdecl, dynlib: gliblib, importc: "g_slist_insert_sorted".}
proc g_slist_insert_before*(slist: PGSList, sibling: PGSList, data: gpointer): PGSList{.
cdecl, dynlib: gliblib, importc: "g_slist_insert_before".}
proc g_slist_concat*(list1: PGSList, list2: PGSList): PGSList{.cdecl,
dynlib: gliblib, importc: "g_slist_concat".}
proc g_slist_remove*(list: PGSList, data: gconstpointer): PGSList{.cdecl,
dynlib: gliblib, importc: "g_slist_remove".}
proc g_slist_remove_all*(list: PGSList, data: gconstpointer): PGSList{.cdecl,
dynlib: gliblib, importc: "g_slist_remove_all".}
proc g_slist_remove_link*(list: PGSList, link: PGSList): PGSList{.cdecl,
dynlib: gliblib, importc: "g_slist_remove_link".}
proc g_slist_delete_link*(list: PGSList, link: PGSList): PGSList{.cdecl,
dynlib: gliblib, importc: "g_slist_delete_link".}
proc g_slist_reverse*(list: PGSList): PGSList{.cdecl, dynlib: gliblib,
importc: "g_slist_reverse".}
proc g_slist_copy*(list: PGSList): PGSList{.cdecl, dynlib: gliblib,
importc: "g_slist_copy".}
proc g_slist_nth*(list: PGSList, n: guint): PGSList{.cdecl, dynlib: gliblib,
importc: "g_slist_nth".}
proc g_slist_find*(list: PGSList, data: gconstpointer): PGSList{.cdecl,
dynlib: gliblib, importc: "g_slist_find".}
proc g_slist_find_custom*(list: PGSList, data: gconstpointer,
func: TGCompareFunc): PGSList{.cdecl, dynlib: gliblib,
importc: "g_slist_find_custom".}
proc g_slist_position*(list: PGSList, llink: PGSList): gint{.cdecl,
dynlib: gliblib, importc: "g_slist_position".}
proc g_slist_index*(list: PGSList, data: gconstpointer): gint{.cdecl,
dynlib: gliblib, importc: "g_slist_index".}
proc g_slist_last*(list: PGSList): PGSList{.cdecl, dynlib: gliblib,
importc: "g_slist_last".}
proc g_slist_length*(list: PGSList): guint{.cdecl, dynlib: gliblib,
importc: "g_slist_length".}
proc g_slist_foreach*(list: PGSList, func: TGFunc, user_data: gpointer){.cdecl,
dynlib: gliblib, importc: "g_slist_foreach".}
proc g_slist_sort*(list: PGSList, compare_func: TGCompareFunc): PGSList{.cdecl,
dynlib: gliblib, importc: "g_slist_sort".}
proc g_slist_sort_with_data*(list: PGSList, compare_func: TGCompareDataFunc,
user_data: gpointer): PGSList{.cdecl,
dynlib: gliblib, importc: "g_slist_sort_with_data".}
proc g_slist_nth_data*(list: PGSList, n: guint): gpointer{.cdecl,
dynlib: gliblib, importc: "g_slist_nth_data".}
proc g_slist_next*(slist: PGSList): PGSList
proc g_list_push_allocator*(allocator: PGAllocator){.cdecl, dynlib: gliblib,
importc: "g_list_push_allocator".}
proc g_list_pop_allocator*(){.cdecl, dynlib: gliblib,
importc: "g_list_pop_allocator".}
proc g_list_alloc*(): PGList{.cdecl, dynlib: gliblib, importc: "g_list_alloc".}
proc g_list_free*(list: PGList){.cdecl, dynlib: gliblib, importc: "g_list_free".}
proc g_list_free_1*(list: PGList){.cdecl, dynlib: gliblib,
importc: "g_list_free_1".}
proc g_list_append*(list: PGList, data: gpointer): PGList{.cdecl,
dynlib: gliblib, importc: "g_list_append".}
proc g_list_prepend*(list: PGList, data: gpointer): PGList{.cdecl,
dynlib: gliblib, importc: "g_list_prepend".}
proc g_list_insert*(list: PGList, data: gpointer, position: gint): PGList{.
cdecl, dynlib: gliblib, importc: "g_list_insert".}
proc g_list_insert_sorted*(list: PGList, data: gpointer, func: TGCompareFunc): PGList{.
cdecl, dynlib: gliblib, importc: "g_list_insert_sorted".}
proc g_list_insert_before*(list: PGList, sibling: PGList, data: gpointer): PGList{.
cdecl, dynlib: gliblib, importc: "g_list_insert_before".}
proc g_list_concat*(list1: PGList, list2: PGList): PGList{.cdecl,
dynlib: gliblib, importc: "g_list_concat".}
proc g_list_remove*(list: PGList, data: gconstpointer): PGList{.cdecl,
dynlib: gliblib, importc: "g_list_remove".}
proc g_list_remove_all*(list: PGList, data: gconstpointer): PGList{.cdecl,
dynlib: gliblib, importc: "g_list_remove_all".}
proc g_list_remove_link*(list: PGList, llink: PGList): PGList{.cdecl,
dynlib: gliblib, importc: "g_list_remove_link".}
proc g_list_delete_link*(list: PGList, link: PGList): PGList{.cdecl,
dynlib: gliblib, importc: "g_list_delete_link".}
proc g_list_reverse*(list: PGList): PGList{.cdecl, dynlib: gliblib,
importc: "g_list_reverse".}
proc g_list_copy*(list: PGList): PGList{.cdecl, dynlib: gliblib,
importc: "g_list_copy".}
proc g_list_nth*(list: PGList, n: guint): PGList{.cdecl, dynlib: gliblib,
importc: "g_list_nth".}
proc g_list_nth_prev*(list: PGList, n: guint): PGList{.cdecl, dynlib: gliblib,
importc: "g_list_nth_prev".}
proc g_list_find*(list: PGList, data: gconstpointer): PGList{.cdecl,
dynlib: gliblib, importc: "g_list_find".}
proc g_list_find_custom*(list: PGList, data: gconstpointer, func: TGCompareFunc): PGList{.
cdecl, dynlib: gliblib, importc: "g_list_find_custom".}
proc g_list_position*(list: PGList, llink: PGList): gint{.cdecl,
dynlib: gliblib, importc: "g_list_position".}
proc g_list_index*(list: PGList, data: gconstpointer): gint{.cdecl,
dynlib: gliblib, importc: "g_list_index".}
proc g_list_last*(list: PGList): PGList{.cdecl, dynlib: gliblib,
importc: "g_list_last".}
proc g_list_first*(list: PGList): PGList{.cdecl, dynlib: gliblib,
importc: "g_list_first".}
proc g_list_length*(list: PGList): guint{.cdecl, dynlib: gliblib,
importc: "g_list_length".}
proc g_list_foreach*(list: PGList, func: TGFunc, user_data: gpointer){.cdecl,
dynlib: gliblib, importc: "g_list_foreach".}
proc g_list_sort*(list: PGList, compare_func: TGCompareFunc): PGList{.cdecl,
dynlib: gliblib, importc: "g_list_sort".}
proc g_list_sort_with_data*(list: PGList, compare_func: TGCompareDataFunc,
user_data: gpointer): PGList{.cdecl,
dynlib: gliblib, importc: "g_list_sort_with_data".}
proc g_list_nth_data*(list: PGList, n: guint): gpointer{.cdecl, dynlib: gliblib,
importc: "g_list_nth_data".}
proc g_list_previous*(list: PGList): PGList
proc g_list_next*(list: PGList): PGList
type
PGCache* = pointer
TGCacheNewFunc* = proc (key: gpointer): gpointer{.cdecl.}
TGCacheDupFunc* = proc (value: gpointer): gpointer{.cdecl.}
TGCacheDestroyFunc* = proc (value: gpointer){.cdecl.}
proc g_cache_new*(value_new_func: TGCacheNewFunc,
value_destroy_func: TGCacheDestroyFunc,
key_dup_func: TGCacheDupFunc,
key_destroy_func: TGCacheDestroyFunc,
hash_key_func: TGHashFunc, hash_value_func: TGHashFunc,
key_equal_func: TGEqualFunc): PGCache{.cdecl, dynlib: gliblib,
importc: "g_cache_new".}
proc g_cache_destroy*(cache: PGCache){.cdecl, dynlib: gliblib,
importc: "g_cache_destroy".}
proc g_cache_insert*(cache: PGCache, key: gpointer): gpointer{.cdecl,
dynlib: gliblib, importc: "g_cache_insert".}
proc g_cache_remove*(cache: PGCache, value: gconstpointer){.cdecl,
dynlib: gliblib, importc: "g_cache_remove".}
proc g_cache_key_foreach*(cache: PGCache, func: TGHFunc, user_data: gpointer){.
cdecl, dynlib: gliblib, importc: "g_cache_key_foreach".}
proc g_cache_value_foreach*(cache: PGCache, func: TGHFunc, user_data: gpointer){.
cdecl, dynlib: gliblib, importc: "g_cache_value_foreach".}
type
PGCompletionFunc* = ptr TGCompletionFunc
TGCompletionFunc* = gchar
TGCompletionStrncmpFunc* = proc (s1: cstring, s2: cstring, n: gsize): gint{.
cdecl.}
PGCompletion* = ptr TGCompletion
TGCompletion*{.final.} = object
items*: PGList
func*: TGCompletionFunc
prefix*: cstring
cache*: PGList
strncmp_func*: TGCompletionStrncmpFunc
proc g_completion_new*(func: TGCompletionFunc): PGCompletion{.cdecl,
dynlib: gliblib, importc: "g_completion_new".}
proc g_completion_add_items*(cmp: PGCompletion, items: PGList){.cdecl,
dynlib: gliblib, importc: "g_completion_add_items".}
proc g_completion_remove_items*(cmp: PGCompletion, items: PGList){.cdecl,
dynlib: gliblib, importc: "g_completion_remove_items".}
proc g_completion_clear_items*(cmp: PGCompletion){.cdecl, dynlib: gliblib,
importc: "g_completion_clear_items".}
proc g_completion_complete*(cmp: PGCompletion, prefix: cstring,
new_prefix: PPgchar): PGList{.cdecl,
dynlib: gliblib, importc: "g_completion_complete".}
proc g_completion_set_compare*(cmp: PGCompletion,
strncmp_func: TGCompletionStrncmpFunc){.cdecl,
dynlib: gliblib, importc: "g_completion_set_compare".}
proc g_completion_free*(cmp: PGCompletion){.cdecl, dynlib: gliblib,
importc: "g_completion_free".}
type
PGConvertError* = ptr TGConvertError
TGConvertError* = enum
G_CONVERT_ERROR_NO_CONVERSION, G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
G_CONVERT_ERROR_FAILED, G_CONVERT_ERROR_PARTIAL_INPUT,
G_CONVERT_ERROR_BAD_URI, G_CONVERT_ERROR_NOT_ABSOLUTE_PATH
proc G_CONVERT_ERROR*(): TGQuark
proc g_convert_error_quark*(): TGQuark{.cdecl, dynlib: gliblib,
importc: "g_convert_error_quark".}
type
PGIConv* = ptr TGIConv
TGIConv* = pointer
proc g_iconv_open*(to_codeset: cstring, from_codeset: cstring): TGIConv{.cdecl,
dynlib: gliblib, importc: "g_iconv_open".}
proc g_iconv*(`converter`: TGIConv, inbuf: PPgchar, inbytes_left: Pgsize,
outbuf: PPgchar, outbytes_left: Pgsize): gsize{.cdecl,
dynlib: gliblib, importc: "g_iconv".}
proc g_iconv_close*(`converter`: TGIConv): gint{.cdecl, dynlib: gliblib,
importc: "g_iconv_close".}
proc g_convert*(str: cstring, len: gssize, to_codeset: cstring,
from_codeset: cstring, bytes_read: Pgsize,
bytes_written: Pgsize, error: pointer): cstring{.cdecl,
dynlib: gliblib, importc: "g_convert".}
proc g_convert_with_iconv*(str: cstring, len: gssize, `converter`: TGIConv,
bytes_read: Pgsize, bytes_written: Pgsize,
error: pointer): cstring{.cdecl, dynlib: gliblib,
importc: "g_convert_with_iconv".}
proc g_convert_with_fallback*(str: cstring, len: gssize, to_codeset: cstring,
from_codeset: cstring, fallback: cstring,
bytes_read: Pgsize, bytes_written: Pgsize,
error: pointer): cstring{.cdecl, dynlib: gliblib,
importc: "g_convert_with_fallback".}
proc g_locale_to_utf8*(opsysstring: cstring, len: gssize, bytes_read: Pgsize,
bytes_written: Pgsize, error: pointer): cstring{.cdecl,
dynlib: gliblib, importc: "g_locale_to_utf8".}
proc g_locale_from_utf8*(utf8string: cstring, len: gssize, bytes_read: Pgsize,
bytes_written: Pgsize, error: pointer): cstring{.cdecl,
dynlib: gliblib, importc: "g_locale_from_utf8".}
proc g_filename_to_utf8*(opsysstring: cstring, len: gssize, bytes_read: Pgsize,
bytes_written: Pgsize, error: pointer): cstring{.cdecl,
dynlib: gliblib, importc: "g_filename_to_utf8".}
proc g_filename_from_utf8*(utf8string: cstring, len: gssize, bytes_read: Pgsize,
bytes_written: Pgsize, error: pointer): cstring{.
cdecl, dynlib: gliblib, importc: "g_filename_from_utf8".}
proc g_filename_from_uri*(uri: cstring, hostname: PPchar, error: pointer): cstring{.
cdecl, dynlib: gliblib, importc: "g_filename_from_uri".}
proc g_filename_to_uri*(filename: cstring, hostname: cstring, error: pointer): cstring{.
cdecl, dynlib: gliblib, importc: "g_filename_to_uri".}
type
TGDataForeachFunc* = proc (key_id: TGQuark, data: gpointer,
user_data: gpointer){.cdecl.}
proc g_datalist_init*(datalist: PPGData){.cdecl, dynlib: gliblib,
importc: "g_datalist_init".}
proc g_datalist_clear*(datalist: PPGData){.cdecl, dynlib: gliblib,
importc: "g_datalist_clear".}
proc g_datalist_id_get_data*(datalist: PPGData, key_id: TGQuark): gpointer{.
cdecl, dynlib: gliblib, importc: "g_datalist_id_get_data".}
proc g_datalist_id_set_data_full*(datalist: PPGData, key_id: TGQuark,
data: gpointer, destroy_func: TGDestroyNotify){.
cdecl, dynlib: gliblib, importc: "g_datalist_id_set_data_full".}
proc g_datalist_id_remove_no_notify*(datalist: PPGData, key_id: TGQuark): gpointer{.
cdecl, dynlib: gliblib, importc: "g_datalist_id_remove_no_notify".}
proc g_datalist_foreach*(datalist: PPGData, func: TGDataForeachFunc,
user_data: gpointer){.cdecl, dynlib: gliblib,
importc: "g_datalist_foreach".}
proc g_datalist_id_set_data*(datalist: PPGData, key_id: TGQuark, data: gpointer)
proc g_datalist_id_remove_data*(datalist: PPGData, key_id: TGQuark)
proc g_datalist_get_data*(datalist: PPGData, key_str: cstring): PPGData
proc g_datalist_set_data_full*(datalist: PPGData, key_str: cstring,
data: gpointer, destroy_func: TGDestroyNotify)
proc g_datalist_set_data*(datalist: PPGData, key_str: cstring, data: gpointer)
proc g_datalist_remove_no_notify*(datalist: PPGData, key_str: cstring)
proc g_datalist_remove_data*(datalist: PPGData, key_str: cstring)
proc g_dataset_id_get_data*(dataset_location: gconstpointer, key_id: TGQuark): gpointer{.
cdecl, dynlib: gliblib, importc: "g_dataset_id_get_data".}
proc g_dataset_id_set_data_full*(dataset_location: gconstpointer,
key_id: TGQuark, data: gpointer,
destroy_func: TGDestroyNotify){.cdecl,
dynlib: gliblib, importc: "g_dataset_id_set_data_full".}
proc g_dataset_id_remove_no_notify*(dataset_location: gconstpointer,
key_id: TGQuark): gpointer{.cdecl,
dynlib: gliblib, importc: "g_dataset_id_remove_no_notify".}
proc g_dataset_foreach*(dataset_location: gconstpointer,
func: TGDataForeachFunc, user_data: gpointer){.cdecl,
dynlib: gliblib, importc: "g_dataset_foreach".}
proc g_dataset_id_set_data*(location: gconstpointer, key_id: TGQuark,
data: gpointer)
proc g_dataset_id_remove_data*(location: gconstpointer, key_id: TGQuark)
proc g_dataset_get_data*(location: gconstpointer, key_str: cstring): gpointer
proc g_dataset_set_data_full*(location: gconstpointer, key_str: cstring,
data: gpointer, destroy_func: TGDestroyNotify)
proc g_dataset_remove_no_notify*(location: gconstpointer, key_str: cstring)
proc g_dataset_set_data*(location: gconstpointer, key_str: cstring,
data: gpointer)
proc g_dataset_remove_data*(location: gconstpointer, key_str: cstring)
type
PGTime* = ptr TGTime
TGTime* = gint32
PGDateYear* = ptr TGDateYear
TGDateYear* = guint16
PGDateDay* = ptr TGDateDay
TGDateDay* = guint8
Ptm* = ptr Ttm
Ttm*{.final.} = object
tm_sec*: gint
tm_min*: gint
tm_hour*: gint
tm_mday*: gint
tm_mon*: gint
tm_year*: gint
tm_wday*: gint
tm_yday*: gint
tm_isdst*: gint
tm_gmtoff*: glong
tm_zone*: cstring
type
PGDateDMY* = ptr TGDateDMY
TGDateDMY* = int
const
G_DATE_DAY* = 0
G_DATE_MONTH* = 1
G_DATE_YEAR* = 2
type
PGDateWeekday* = ptr TGDateWeekday
TGDateWeekday* = int
const
G_DATE_BAD_WEEKDAY* = 0
G_DATE_MONDAY* = 1
G_DATE_TUESDAY* = 2
G_DATE_WEDNESDAY* = 3
G_DATE_THURSDAY* = 4
G_DATE_FRIDAY* = 5
G_DATE_SATURDAY* = 6
G_DATE_SUNDAY* = 7
type
PGDateMonth* = ptr TGDateMonth
TGDateMonth* = int
const
G_DATE_BAD_MONTH* = 0
G_DATE_JANUARY* = 1
G_DATE_FEBRUARY* = 2
G_DATE_MARCH* = 3
G_DATE_APRIL* = 4
G_DATE_MAY* = 5
G_DATE_JUNE* = 6
G_DATE_JULY* = 7
G_DATE_AUGUST* = 8
G_DATE_SEPTEMBER* = 9
G_DATE_OCTOBER* = 10
G_DATE_NOVEMBER* = 11
G_DATE_DECEMBER* = 12
const
G_DATE_BAD_JULIAN* = 0
G_DATE_BAD_DAY* = 0
G_DATE_BAD_YEAR* = 0
type
PGDate* = ptr TGDate
TGDate*{.final.} = object
flag0*: int32
flag1*: int32
proc g_date_new*(): PGDate{.cdecl, dynlib: gliblib, importc: "g_date_new".}
proc g_date_new_dmy*(day: TGDateDay, month: TGDateMonth, year: TGDateYear): PGDate{.
cdecl, dynlib: gliblib, importc: "g_date_new_dmy".}
proc g_date_new_julian*(julian_day: guint32): PGDate{.cdecl, dynlib: gliblib,
importc: "g_date_new_julian".}
proc g_date_free*(date: PGDate){.cdecl, dynlib: gliblib, importc: "g_date_free".}
proc g_date_valid*(date: PGDate): gboolean{.cdecl, dynlib: gliblib,
importc: "g_date_valid".}
proc g_date_valid_month*(month: TGDateMonth): gboolean{.cdecl, dynlib: gliblib,
importc: "g_date_valid_month".}
proc g_date_valid_year*(year: TGDateYear): gboolean{.cdecl, dynlib: gliblib,
importc: "g_date_valid_year".}
proc g_date_valid_weekday*(weekday: TGDateWeekday): gboolean{.cdecl,
dynlib: gliblib, importc: "g_date_valid_weekday".}
proc g_date_valid_julian*(julian_date: guint32): gboolean{.cdecl,
dynlib: gliblib, importc: "g_date_valid_julian".}
proc g_date_get_weekday*(date: PGDate): TGDateWeekday{.cdecl, dynlib: gliblib,
importc: "g_date_get_weekday".}
proc g_date_get_month*(date: PGDate): TGDateMonth{.cdecl, dynlib: gliblib,
importc: "g_date_get_month".}
proc g_date_get_year*(date: PGDate): TGDateYear{.cdecl, dynlib: gliblib,
importc: "g_date_get_year".}
proc g_date_get_day*(date: PGDate): TGDateDay{.cdecl, dynlib: gliblib,
importc: "g_date_get_day".}
proc g_date_get_julian*(date: PGDate): guint32{.cdecl, dynlib: gliblib,
importc: "g_date_get_julian".}
proc g_date_get_day_of_year*(date: PGDate): guint{.cdecl, dynlib: gliblib,
importc: "g_date_get_day_of_year".}
proc g_date_get_monday_week_of_year*(date: PGDate): guint{.cdecl,
dynlib: gliblib, importc: "g_date_get_monday_week_of_year".}
proc g_date_get_sunday_week_of_year*(date: PGDate): guint{.cdecl,
dynlib: gliblib, importc: "g_date_get_sunday_week_of_year".}
proc g_date_clear*(date: PGDate, n_dates: guint){.cdecl, dynlib: gliblib,
importc: "g_date_clear".}
proc g_date_set_parse*(date: PGDate, str: cstring){.cdecl, dynlib: gliblib,
importc: "g_date_set_parse".}
proc g_date_set_time*(date: PGDate, time: TGTime){.cdecl, dynlib: gliblib,
importc: "g_date_set_time".}
proc g_date_set_month*(date: PGDate, month: TGDateMonth){.cdecl,
dynlib: gliblib, importc: "g_date_set_month".}
proc g_date_set_day*(date: PGDate, day: TGDateDay){.cdecl, dynlib: gliblib,
importc: "g_date_set_day".}
proc g_date_set_year*(date: PGDate, year: TGDateYear){.cdecl, dynlib: gliblib,
importc: "g_date_set_year".}
proc g_date_set_dmy*(date: PGDate, day: TGDateDay, month: TGDateMonth,
y: TGDateYear){.cdecl, dynlib: gliblib,
importc: "g_date_set_dmy".}
proc g_date_set_julian*(date: PGDate, julian_date: guint32){.cdecl,
dynlib: gliblib, importc: "g_date_set_julian".}
proc g_date_is_first_of_month*(date: PGDate): gboolean{.cdecl, dynlib: gliblib,
importc: "g_date_is_first_of_month".}
proc g_date_is_last_of_month*(date: PGDate): gboolean{.cdecl, dynlib: gliblib,
importc: "g_date_is_last_of_month".}
proc g_date_add_days*(date: PGDate, n_days: guint){.cdecl, dynlib: gliblib,
importc: "g_date_add_days".}
proc g_date_subtract_days*(date: PGDate, n_days: guint){.cdecl, dynlib: gliblib,
importc: "g_date_subtract_days".}
proc g_date_add_months*(date: PGDate, n_months: guint){.cdecl, dynlib: gliblib,
importc: "g_date_add_months".}
proc g_date_subtract_months*(date: PGDate, n_months: guint){.cdecl,
dynlib: gliblib, importc: "g_date_subtract_months".}
proc g_date_add_years*(date: PGDate, n_years: guint){.cdecl, dynlib: gliblib,
importc: "g_date_add_years".}
proc g_date_subtract_years*(date: PGDate, n_years: guint){.cdecl,
dynlib: gliblib, importc: "g_date_subtract_years".}
proc g_date_is_leap_year*(year: TGDateYear): gboolean{.cdecl, dynlib: gliblib,
importc: "g_date_is_leap_year".}
proc g_date_get_days_in_month*(month: TGDateMonth, year: TGDateYear): guint8{.
cdecl, dynlib: gliblib, importc: "g_date_get_days_in_month".}
proc g_date_get_monday_weeks_in_year*(year: TGDateYear): guint8{.cdecl,
dynlib: gliblib, importc: "g_date_get_monday_weeks_in_year".}
proc g_date_get_sunday_weeks_in_year*(year: TGDateYear): guint8{.cdecl,
dynlib: gliblib, importc: "g_date_get_sunday_weeks_in_year".}
proc g_date_days_between*(date1: PGDate, date2: PGDate): gint{.cdecl,
dynlib: gliblib, importc: "g_date_days_between".}
proc g_date_compare*(lhs: PGDate, rhs: PGDate): gint{.cdecl, dynlib: gliblib,
importc: "g_date_compare".}
proc g_date_to_struct_tm*(date: PGDate, tm: Ptm){.cdecl, dynlib: gliblib,
importc: "g_date_to_struct_tm".}
proc g_date_clamp*(date: PGDate, min_date: PGDate, max_date: PGDate){.cdecl,
dynlib: gliblib, importc: "g_date_clamp".}
proc g_date_order*(date1: PGDate, date2: PGDate){.cdecl, dynlib: gliblib,
importc: "g_date_order".}
proc g_date_strftime*(s: cstring, slen: gsize, format: cstring, date: PGDate): gsize{.
cdecl, dynlib: gliblib, importc: "g_date_strftime".}
type
PGDir* = pointer
proc g_dir_open*(path: cstring, flags: guint, error: pointer): PGDir{.cdecl,
dynlib: gliblib, importc: "g_dir_open".}
proc g_dir_read_name*(dir: PGDir): cstring{.cdecl, dynlib: gliblib,
importc: "g_dir_read_name".}
proc g_dir_rewind*(dir: PGDir){.cdecl, dynlib: gliblib, importc: "g_dir_rewind".}
proc g_dir_close*(dir: PGDir){.cdecl, dynlib: gliblib, importc: "g_dir_close".}
type
PGFileError* = ptr TGFileError
TGFileError* = gint
type
PGFileTest* = ptr TGFileTest
TGFileTest* = int
const
G_FILE_TEST_IS_REGULAR* = 1 shl 0
G_FILE_TEST_IS_SYMLINK* = 1 shl 1
G_FILE_TEST_IS_DIR* = 1 shl 2
G_FILE_TEST_IS_EXECUTABLE* = 1 shl 3
G_FILE_TEST_EXISTS* = 1 shl 4
const
G_FILE_ERROR_EXIST* = 0
G_FILE_ERROR_ISDIR* = 1
G_FILE_ERROR_ACCES* = 2
G_FILE_ERROR_NAMETOOLONG* = 3
G_FILE_ERROR_NOENT* = 4
G_FILE_ERROR_NOTDIR* = 5
G_FILE_ERROR_NXIO* = 6
G_FILE_ERROR_NODEV* = 7
G_FILE_ERROR_ROFS* = 8
G_FILE_ERROR_TXTBSY* = 9
G_FILE_ERROR_FAULT* = 10
G_FILE_ERROR_LOOP* = 11
G_FILE_ERROR_NOSPC* = 12
G_FILE_ERROR_NOMEM* = 13
G_FILE_ERROR_MFILE* = 14
G_FILE_ERROR_NFILE* = 15
G_FILE_ERROR_BADF* = 16
G_FILE_ERROR_INVAL* = 17
G_FILE_ERROR_PIPE* = 18
G_FILE_ERROR_AGAIN* = 19
G_FILE_ERROR_INTR* = 20
G_FILE_ERROR_IO* = 21
G_FILE_ERROR_PERM* = 22
G_FILE_ERROR_FAILED* = 23
proc G_FILE_ERROR*(): TGQuark
proc g_file_error_quark*(): TGQuark{.cdecl, dynlib: gliblib,
importc: "g_file_error_quark".}
proc g_file_error_from_errno*(err_no: gint): TGFileError{.cdecl,
dynlib: gliblib, importc: "g_file_error_from_errno".}
proc g_file_test*(filename: cstring, test: TGFileTest): gboolean{.cdecl,
dynlib: gliblib, importc: "g_file_test".}
proc g_file_get_contents*(filename: cstring, contents: PPgchar, length: Pgsize,
error: pointer): gboolean{.cdecl, dynlib: gliblib,
importc: "g_file_get_contents".}
proc g_mkstemp*(tmpl: cstring): int32{.cdecl, dynlib: gliblib,
importc: "g_mkstemp".}
proc g_file_open_tmp*(tmpl: cstring, name_used: PPchar, error: pointer): int32{.
cdecl, dynlib: gliblib, importc: "g_file_open_tmp".}
type
PGHook* = ptr TGHook
TGHook*{.final.} = object
data*: gpointer
next*: PGHook
prev*: PGHook
ref_count*: guint
hook_id*: gulong
flags*: guint
func*: gpointer
destroy*: TGDestroyNotify
PGHookList* = ptr TGHookList
TGHookCompareFunc* = proc (new_hook: PGHook, sibling: PGHook): gint{.cdecl.}
TGHookFindFunc* = proc (hook: PGHook, data: gpointer): gboolean{.cdecl.}
TGHookMarshaller* = proc (hook: PGHook, marshal_data: gpointer){.cdecl.}
TGHookCheckMarshaller* = proc (hook: PGHook, marshal_data: gpointer): gboolean{.
cdecl.}
TGHookFunc* = proc (data: gpointer){.cdecl.}
TGHookCheckFunc* = proc (data: gpointer): gboolean{.cdecl.}
TGHookFinalizeFunc* = proc (hook_list: PGHookList, hook: PGHook){.cdecl.}
TGHookList*{.final.} = object
seq_id*: gulong
flag0*: int32
hooks*: PGHook
hook_memchunk*: PGMemChunk
finalize_hook*: TGHookFinalizeFunc
dummy*: array[0..1, gpointer]
type
PGHookFlagMask* = ptr TGHookFlagMask
TGHookFlagMask* = int
const
G_HOOK_FLAG_ACTIVE* = 1'i32 shl 0'i32
G_HOOK_FLAG_IN_CALL* = 1'i32 shl 1'i32
G_HOOK_FLAG_MASK* = 0x0000000F'i32
const
G_HOOK_FLAG_USER_SHIFT* = 4'i32
bm_TGHookList_hook_size* = 0x0000FFFF'i32
bp_TGHookList_hook_size* = 0'i32
bm_TGHookList_is_setup* = 0x00010000'i32
bp_TGHookList_is_setup* = 16'i32
proc TGHookList_hook_size*(a: var TGHookList): guint
proc TGHookList_set_hook_size*(a: var TGHookList, `hook_size`: guint)
proc TGHookList_is_setup*(a: var TGHookList): guint
proc TGHookList_set_is_setup*(a: var TGHookList, `is_setup`: guint)
proc G_HOOK*(hook: pointer): PGHook
proc G_HOOK_FLAGS*(hook: PGHook): guint
proc G_HOOK_ACTIVE*(hook: PGHook): bool
proc G_HOOK_IN_CALL*(hook: PGHook): bool
proc G_HOOK_IS_VALID*(hook: PGHook): bool
proc G_HOOK_IS_UNLINKED*(hook: PGHook): bool
proc g_hook_list_init*(hook_list: PGHookList, hook_size: guint){.cdecl,
dynlib: gliblib, importc: "g_hook_list_init".}
proc g_hook_list_clear*(hook_list: PGHookList){.cdecl, dynlib: gliblib,
importc: "g_hook_list_clear".}
proc g_hook_alloc*(hook_list: PGHookList): PGHook{.cdecl, dynlib: gliblib,
importc: "g_hook_alloc".}
proc g_hook_free*(hook_list: PGHookList, hook: PGHook){.cdecl, dynlib: gliblib,
importc: "g_hook_free".}
proc g_hook_ref*(hook_list: PGHookList, hook: PGHook){.cdecl, dynlib: gliblib,
importc: "g_hook_ref".}
proc g_hook_unref*(hook_list: PGHookList, hook: PGHook){.cdecl, dynlib: gliblib,
importc: "g_hook_unref".}
proc g_hook_destroy*(hook_list: PGHookList, hook_id: gulong): gboolean{.cdecl,
dynlib: gliblib, importc: "g_hook_destroy".}
proc g_hook_destroy_link*(hook_list: PGHookList, hook: PGHook){.cdecl,
dynlib: gliblib, importc: "g_hook_destroy_link".}
proc g_hook_prepend*(hook_list: PGHookList, hook: PGHook){.cdecl,
dynlib: gliblib, importc: "g_hook_prepend".}
proc g_hook_insert_before*(hook_list: PGHookList, sibling: PGHook, hook: PGHook){.
cdecl, dynlib: gliblib, importc: "g_hook_insert_before".}
proc g_hook_insert_sorted*(hook_list: PGHookList, hook: PGHook,
func: TGHookCompareFunc){.cdecl, dynlib: gliblib,
importc: "g_hook_insert_sorted".}
proc g_hook_get*(hook_list: PGHookList, hook_id: gulong): PGHook{.cdecl,
dynlib: gliblib, importc: "g_hook_get".}
proc g_hook_find*(hook_list: PGHookList, need_valids: gboolean,
func: TGHookFindFunc, data: gpointer): PGHook{.cdecl,
dynlib: gliblib, importc: "g_hook_find".}
proc g_hook_find_data*(hook_list: PGHookList, need_valids: gboolean,
data: gpointer): PGHook{.cdecl, dynlib: gliblib,
importc: "g_hook_find_data".}
proc g_hook_find_func*(hook_list: PGHookList, need_valids: gboolean,
func: gpointer): PGHook{.cdecl, dynlib: gliblib,
importc: "g_hook_find_func".}
proc g_hook_find_func_data*(hook_list: PGHookList, need_valids: gboolean,
func: gpointer, data: gpointer): PGHook{.cdecl,
dynlib: gliblib, importc: "g_hook_find_func_data".}
proc g_hook_first_valid*(hook_list: PGHookList, may_be_in_call: gboolean): PGHook{.
cdecl, dynlib: gliblib, importc: "g_hook_first_valid".}
proc g_hook_next_valid*(hook_list: PGHookList, hook: PGHook,
may_be_in_call: gboolean): PGHook{.cdecl,
dynlib: gliblib, importc: "g_hook_next_valid".}
proc g_hook_compare_ids*(new_hook: PGHook, sibling: PGHook): gint{.cdecl,
dynlib: gliblib, importc: "g_hook_compare_ids".}
proc g_hook_append*(hook_list: PGHookList, hook: PGHook)
proc g_hook_list_invoke_check*(hook_list: PGHookList, may_recurse: gboolean){.
cdecl, dynlib: gliblib, importc: "g_hook_list_invoke_check".}
proc g_hook_list_marshal*(hook_list: PGHookList, may_recurse: gboolean,
marshaller: TGHookMarshaller, marshal_data: gpointer){.
cdecl, dynlib: gliblib, importc: "g_hook_list_marshal".}
proc g_hook_list_marshal_check*(hook_list: PGHookList, may_recurse: gboolean,
marshaller: TGHookCheckMarshaller,
marshal_data: gpointer){.cdecl, dynlib: gliblib,
importc: "g_hook_list_marshal_check".}
type
PGThreadPool* = ptr TGThreadPool
TGThreadPool*{.final.} = object
func*: TGFunc
user_data*: gpointer
exclusive*: gboolean
proc g_thread_pool_new*(func: TGFunc, user_data: gpointer, max_threads: gint,
exclusive: gboolean, error: pointer): PGThreadPool{.
cdecl, dynlib: gliblib, importc: "g_thread_pool_new".}
proc g_thread_pool_push*(pool: PGThreadPool, data: gpointer, error: pointer){.
cdecl, dynlib: gliblib, importc: "g_thread_pool_push".}
proc g_thread_pool_set_max_threads*(pool: PGThreadPool, max_threads: gint,
error: pointer){.cdecl, dynlib: gliblib,
importc: "g_thread_pool_set_max_threads".}
proc g_thread_pool_get_max_threads*(pool: PGThreadPool): gint{.cdecl,
dynlib: gliblib, importc: "g_thread_pool_get_max_threads".}
proc g_thread_pool_get_num_threads*(pool: PGThreadPool): guint{.cdecl,
dynlib: gliblib, importc: "g_thread_pool_get_num_threads".}
proc g_thread_pool_unprocessed*(pool: PGThreadPool): guint{.cdecl,
dynlib: gliblib, importc: "g_thread_pool_unprocessed".}
proc g_thread_pool_free*(pool: PGThreadPool, immediate: gboolean, wait: gboolean){.
cdecl, dynlib: gliblib, importc: "g_thread_pool_free".}
proc g_thread_pool_set_max_unused_threads*(max_threads: gint){.cdecl,
dynlib: gliblib, importc: "g_thread_pool_set_max_unused_threads".}
proc g_thread_pool_get_max_unused_threads*(): gint{.cdecl, dynlib: gliblib,
importc: "g_thread_pool_get_max_unused_threads".}
proc g_thread_pool_get_num_unused_threads*(): guint{.cdecl, dynlib: gliblib,
importc: "g_thread_pool_get_num_unused_threads".}
proc g_thread_pool_stop_unused_threads*(){.cdecl, dynlib: gliblib,
importc: "g_thread_pool_stop_unused_threads".}
type
PGTimer* = pointer
const
G_USEC_PER_SEC* = 1000000
proc g_timer_new*(): PGTimer{.cdecl, dynlib: gliblib, importc: "g_timer_new".}
proc g_timer_destroy*(timer: PGTimer){.cdecl, dynlib: gliblib,
importc: "g_timer_destroy".}
proc g_timer_start*(timer: PGTimer){.cdecl, dynlib: gliblib,
importc: "g_timer_start".}
proc g_timer_stop*(timer: PGTimer){.cdecl, dynlib: gliblib,
importc: "g_timer_stop".}
proc g_timer_reset*(timer: PGTimer){.cdecl, dynlib: gliblib,
importc: "g_timer_reset".}
proc g_timer_elapsed*(timer: PGTimer, microseconds: Pgulong): gdouble{.cdecl,
dynlib: gliblib, importc: "g_timer_elapsed".}
proc g_usleep*(microseconds: gulong){.cdecl, dynlib: gliblib,
importc: "g_usleep".}
proc g_time_val_add*(time: PGTimeVal, microseconds: glong){.cdecl,
dynlib: gliblib, importc: "g_time_val_add".}
type
Pgunichar* = ptr gunichar
gunichar* = guint32
Pgunichar2* = ptr gunichar2
gunichar2* = guint16
PGUnicodeType* = ptr TGUnicodeType
TGUnicodeType* = enum
G_UNICODE_CONTROL, G_UNICODE_FORMAT, G_UNICODE_UNASSIGNED,
G_UNICODE_PRIVATE_USE, G_UNICODE_SURROGATE, G_UNICODE_LOWERCASE_LETTER,
G_UNICODE_MODIFIER_LETTER, G_UNICODE_OTHER_LETTER,
G_UNICODE_TITLECASE_LETTER, G_UNICODE_UPPERCASE_LETTER,
G_UNICODE_COMBINING_MARK, G_UNICODE_ENCLOSING_MARK,
G_UNICODE_NON_SPACING_MARK, G_UNICODE_DECIMAL_NUMBER,
G_UNICODE_LETTER_NUMBER, G_UNICODE_OTHER_NUMBER,
G_UNICODE_CONNECT_PUNCTUATION, G_UNICODE_DASH_PUNCTUATION,
G_UNICODE_CLOSE_PUNCTUATION, G_UNICODE_FINAL_PUNCTUATION,
G_UNICODE_INITIAL_PUNCTUATION, G_UNICODE_OTHER_PUNCTUATION,
G_UNICODE_OPEN_PUNCTUATION, G_UNICODE_CURRENCY_SYMBOL,
G_UNICODE_MODIFIER_SYMBOL, G_UNICODE_MATH_SYMBOL, G_UNICODE_OTHER_SYMBOL,
G_UNICODE_LINE_SEPARATOR, G_UNICODE_PARAGRAPH_SEPARATOR,
G_UNICODE_SPACE_SEPARATOR
PGUnicodeBreakType* = ptr TGUnicodeBreakType
TGUnicodeBreakType* = enum
G_UNICODE_BREAK_MANDATORY, G_UNICODE_BREAK_CARRIAGE_RETURN,
G_UNICODE_BREAK_LINE_FEED, G_UNICODE_BREAK_COMBINING_MARK,
G_UNICODE_BREAK_SURROGATE, G_UNICODE_BREAK_ZERO_WIDTH_SPACE,
G_UNICODE_BREAK_INSEPARABLE, G_UNICODE_BREAK_NON_BREAKING_GLUE,
G_UNICODE_BREAK_CONTINGENT, G_UNICODE_BREAK_SPACE, G_UNICODE_BREAK_AFTER,
G_UNICODE_BREAK_BEFORE, G_UNICODE_BREAK_BEFORE_AND_AFTER,
G_UNICODE_BREAK_HYPHEN, G_UNICODE_BREAK_NON_STARTER,
G_UNICODE_BREAK_OPEN_PUNCTUATION, G_UNICODE_BREAK_CLOSE_PUNCTUATION,
G_UNICODE_BREAK_QUOTATION, G_UNICODE_BREAK_EXCLAMATION,
G_UNICODE_BREAK_IDEOGRAPHIC, G_UNICODE_BREAK_NUMERIC,
G_UNICODE_BREAK_INFIX_SEPARATOR, G_UNICODE_BREAK_SYMBOL,
G_UNICODE_BREAK_ALPHABETIC, G_UNICODE_BREAK_PREFIX, G_UNICODE_BREAK_POSTFIX,
G_UNICODE_BREAK_COMPLEX_CONTEXT, G_UNICODE_BREAK_AMBIGUOUS,
G_UNICODE_BREAK_UNKNOWN
proc g_get_charset*(charset: PPchar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_get_charset".}
proc g_unichar_isalnum*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_isalnum".}
proc g_unichar_isalpha*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_isalpha".}
proc g_unichar_iscntrl*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_iscntrl".}
proc g_unichar_isdigit*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_isdigit".}
proc g_unichar_isgraph*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_isgraph".}
proc g_unichar_islower*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_islower".}
proc g_unichar_isprint*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_isprint".}
proc g_unichar_ispunct*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_ispunct".}
proc g_unichar_isspace*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_isspace".}
proc g_unichar_isupper*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_isupper".}
proc g_unichar_isxdigit*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_isxdigit".}
proc g_unichar_istitle*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_istitle".}
proc g_unichar_isdefined*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_isdefined".}
proc g_unichar_iswide*(c: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_iswide".}
proc g_unichar_toupper*(c: gunichar): gunichar{.cdecl, dynlib: gliblib,
importc: "g_unichar_toupper".}
proc g_unichar_tolower*(c: gunichar): gunichar{.cdecl, dynlib: gliblib,
importc: "g_unichar_tolower".}
proc g_unichar_totitle*(c: gunichar): gunichar{.cdecl, dynlib: gliblib,
importc: "g_unichar_totitle".}
proc g_unichar_digit_value*(c: gunichar): gint{.cdecl, dynlib: gliblib,
importc: "g_unichar_digit_value".}
proc g_unichar_xdigit_value*(c: gunichar): gint{.cdecl, dynlib: gliblib,
importc: "g_unichar_xdigit_value".}
proc g_unichar_type*(c: gunichar): TGUnicodeType{.cdecl, dynlib: gliblib,
importc: "g_unichar_type".}
proc g_unichar_break_type*(c: gunichar): TGUnicodeBreakType{.cdecl,
dynlib: gliblib, importc: "g_unichar_break_type".}
proc g_unicode_canonical_ordering*(str: Pgunichar, len: gsize){.cdecl,
dynlib: gliblib, importc: "g_unicode_canonical_ordering".}
proc g_unicode_canonical_decomposition*(ch: gunichar, result_len: Pgsize): Pgunichar{.
cdecl, dynlib: gliblib, importc: "g_unicode_canonical_decomposition".}
proc g_utf8_next_char*(p: pguchar): pguchar
proc g_utf8_get_char*(p: cstring): gunichar{.cdecl, dynlib: gliblib,
importc: "g_utf8_get_char".}
proc g_utf8_get_char_validated*(p: cstring, max_len: gssize): gunichar{.cdecl,
dynlib: gliblib, importc: "g_utf8_get_char_validated".}
proc g_utf8_offset_to_pointer*(str: cstring, offset: glong): cstring{.cdecl,
dynlib: gliblib, importc: "g_utf8_offset_to_pointer".}
proc g_utf8_pointer_to_offset*(str: cstring, pos: cstring): glong{.cdecl,
dynlib: gliblib, importc: "g_utf8_pointer_to_offset".}
proc g_utf8_prev_char*(p: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_utf8_prev_char".}
proc g_utf8_find_next_char*(p: cstring, `end`: cstring): cstring{.cdecl,
dynlib: gliblib, importc: "g_utf8_find_next_char".}
proc g_utf8_find_prev_char*(str: cstring, p: cstring): cstring{.cdecl,
dynlib: gliblib, importc: "g_utf8_find_prev_char".}
proc g_utf8_strlen*(p: cstring, max: gssize): glong{.cdecl, dynlib: gliblib,
importc: "g_utf8_strlen".}
proc g_utf8_strncpy*(dest: cstring, src: cstring, n: gsize): cstring{.cdecl,
dynlib: gliblib, importc: "g_utf8_strncpy".}
proc g_utf8_strchr*(p: cstring, len: gssize, c: gunichar): cstring{.cdecl,
dynlib: gliblib, importc: "g_utf8_strchr".}
proc g_utf8_strrchr*(p: cstring, len: gssize, c: gunichar): cstring{.cdecl,
dynlib: gliblib, importc: "g_utf8_strrchr".}
proc g_utf8_to_utf16*(str: cstring, len: glong, items_read: Pglong,
items_written: Pglong, error: pointer): Pgunichar2{.cdecl,
dynlib: gliblib, importc: "g_utf8_to_utf16".}
proc g_utf8_to_ucs4*(str: cstring, len: glong, items_read: Pglong,
items_written: Pglong, error: pointer): Pgunichar{.cdecl,
dynlib: gliblib, importc: "g_utf8_to_ucs4".}
proc g_utf8_to_ucs4_fast*(str: cstring, len: glong, items_written: Pglong): Pgunichar{.
cdecl, dynlib: gliblib, importc: "g_utf8_to_ucs4_fast".}
proc g_utf16_to_ucs4*(str: Pgunichar2, len: glong, items_read: Pglong,
items_written: Pglong, error: pointer): Pgunichar{.cdecl,
dynlib: gliblib, importc: "g_utf16_to_ucs4".}
proc g_utf16_to_utf8*(str: Pgunichar2, len: glong, items_read: Pglong,
items_written: Pglong, error: pointer): cstring{.cdecl,
dynlib: gliblib, importc: "g_utf16_to_utf8".}
proc g_ucs4_to_utf16*(str: Pgunichar, len: glong, items_read: Pglong,
items_written: Pglong, error: pointer): Pgunichar2{.cdecl,
dynlib: gliblib, importc: "g_ucs4_to_utf16".}
proc g_ucs4_to_utf8*(str: Pgunichar, len: glong, items_read: Pglong,
items_written: Pglong, error: pointer): cstring{.cdecl,
dynlib: gliblib, importc: "g_ucs4_to_utf8".}
proc g_unichar_to_utf8*(c: gunichar, outbuf: cstring): gint{.cdecl,
dynlib: gliblib, importc: "g_unichar_to_utf8".}
proc g_utf8_validate*(str: cstring, max_len: gssize, `end`: PPgchar): gboolean{.
cdecl, dynlib: gliblib, importc: "g_utf8_validate".}
proc g_unichar_validate*(ch: gunichar): gboolean{.cdecl, dynlib: gliblib,
importc: "g_unichar_validate".}
proc g_utf8_strup*(str: cstring, len: gssize): cstring{.cdecl, dynlib: gliblib,
importc: "g_utf8_strup".}
proc g_utf8_strdown*(str: cstring, len: gssize): cstring{.cdecl,
dynlib: gliblib, importc: "g_utf8_strdown".}
proc g_utf8_casefold*(str: cstring, len: gssize): cstring{.cdecl,
dynlib: gliblib, importc: "g_utf8_casefold".}
type
PGNormalizeMode* = ptr TGNormalizeMode
TGNormalizeMode* = gint
const
G_NORMALIZE_DEFAULT* = 0
G_NORMALIZE_NFD* = G_NORMALIZE_DEFAULT
G_NORMALIZE_DEFAULT_COMPOSE* = 1
G_NORMALIZE_NFC* = G_NORMALIZE_DEFAULT_COMPOSE
G_NORMALIZE_ALL* = 2
G_NORMALIZE_NFKD* = G_NORMALIZE_ALL
G_NORMALIZE_ALL_COMPOSE* = 3
G_NORMALIZE_NFKC* = G_NORMALIZE_ALL_COMPOSE
proc g_utf8_normalize*(str: cstring, len: gssize, mode: TGNormalizeMode): cstring{.
cdecl, dynlib: gliblib, importc: "g_utf8_normalize".}
proc g_utf8_collate*(str1: cstring, str2: cstring): gint{.cdecl,
dynlib: gliblib, importc: "g_utf8_collate".}
proc g_utf8_collate_key*(str: cstring, len: gssize): cstring{.cdecl,
dynlib: gliblib, importc: "g_utf8_collate_key".}
type
PGString* = ptr TGString
TGString*{.final.} = object
str*: cstring
len*: gsize
allocated_len*: gsize
PGStringChunk* = pointer
proc g_string_chunk_new*(size: gsize): PGStringChunk{.cdecl, dynlib: gliblib,
importc: "g_string_chunk_new".}
proc g_string_chunk_free*(chunk: PGStringChunk){.cdecl, dynlib: gliblib,
importc: "g_string_chunk_free".}
proc g_string_chunk_insert*(chunk: PGStringChunk, str: cstring): cstring{.cdecl,
dynlib: gliblib, importc: "g_string_chunk_insert".}
proc g_string_chunk_insert_const*(chunk: PGStringChunk, str: cstring): cstring{.
cdecl, dynlib: gliblib, importc: "g_string_chunk_insert_const".}
proc g_string_new*(init: cstring): PGString{.cdecl, dynlib: gliblib,
importc: "g_string_new".}
proc g_string_new_len*(init: cstring, len: gssize): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_new_len".}
proc g_string_sized_new*(dfl_size: gsize): PGString{.cdecl, dynlib: gliblib,
importc: "g_string_sized_new".}
proc g_string_free*(str: PGString, free_segment: gboolean): cstring{.cdecl,
dynlib: gliblib, importc: "g_string_free".}
proc g_string_equal*(v: PGString, v2: PGString): gboolean{.cdecl,
dynlib: gliblib, importc: "g_string_equal".}
proc g_string_hash*(str: PGString): guint{.cdecl, dynlib: gliblib,
importc: "g_string_hash".}
proc g_string_assign*(str: PGString, rval: cstring): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_assign".}
proc g_string_truncate*(str: PGString, len: gsize): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_truncate".}
proc g_string_set_size*(str: PGString, len: gsize): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_set_size".}
proc g_string_insert_len*(str: PGString, pos: gssize, val: cstring, len: gssize): PGString{.
cdecl, dynlib: gliblib, importc: "g_string_insert_len".}
proc g_string_append*(str: PGString, val: cstring): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_append".}
proc g_string_append_len*(str: PGString, val: cstring, len: gssize): PGString{.
cdecl, dynlib: gliblib, importc: "g_string_append_len".}
proc g_string_append_c*(str: PGString, c: gchar): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_append_c".}
proc g_string_append_unichar*(str: PGString, wc: gunichar): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_append_unichar".}
proc g_string_prepend*(str: PGString, val: cstring): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_prepend".}
proc g_string_prepend_c*(str: PGString, c: gchar): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_prepend_c".}
proc g_string_prepend_unichar*(str: PGString, wc: gunichar): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_prepend_unichar".}
proc g_string_prepend_len*(str: PGString, val: cstring, len: gssize): PGString{.
cdecl, dynlib: gliblib, importc: "g_string_prepend_len".}
proc g_string_insert*(str: PGString, pos: gssize, val: cstring): PGString{.
cdecl, dynlib: gliblib, importc: "g_string_insert".}
proc g_string_insert_c*(str: PGString, pos: gssize, c: gchar): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_insert_c".}
proc g_string_insert_unichar*(str: PGString, pos: gssize, wc: gunichar): PGString{.
cdecl, dynlib: gliblib, importc: "g_string_insert_unichar".}
proc g_string_erase*(str: PGString, pos: gssize, len: gssize): PGString{.cdecl,
dynlib: gliblib, importc: "g_string_erase".}
proc g_string_ascii_down*(str: PGString): PGString{.cdecl, dynlib: gliblib,
importc: "g_string_ascii_down".}
proc g_string_ascii_up*(str: PGString): PGString{.cdecl, dynlib: gliblib,
importc: "g_string_ascii_up".}
proc g_string_down*(str: PGString): PGString{.cdecl, dynlib: gliblib,
importc: "g_string_down".}
proc g_string_up*(str: PGString): PGString{.cdecl, dynlib: gliblib,
importc: "g_string_up".}
type
PGIOError* = ptr TGIOError
TGIOError* = enum
G_IO_ERROR_NONE, G_IO_ERROR_AGAIN, G_IO_ERROR_INVAL, G_IO_ERROR_UNKNOWN
proc G_IO_CHANNEL_ERROR*(): TGQuark
type
PGIOChannelError* = ptr TGIOChannelError
TGIOChannelError* = enum
G_IO_CHANNEL_ERROR_FBIG, G_IO_CHANNEL_ERROR_INVAL, G_IO_CHANNEL_ERROR_IO,
G_IO_CHANNEL_ERROR_ISDIR, G_IO_CHANNEL_ERROR_NOSPC, G_IO_CHANNEL_ERROR_NXIO,
G_IO_CHANNEL_ERROR_OVERFLOW, G_IO_CHANNEL_ERROR_PIPE,
G_IO_CHANNEL_ERROR_FAILED
PGIOStatus* = ptr TGIOStatus
TGIOStatus* = enum
G_IO_STATUS_ERROR, G_IO_STATUS_NORMAL, G_IO_STATUS_EOF, G_IO_STATUS_AGAIN
PGSeekType* = ptr TGSeekType
TGSeekType* = enum
G_SEEK_CUR, G_SEEK_SET, G_SEEK_END
PGIOCondition* = ptr TGIOCondition
TGIOCondition* = gint
const
G_IO_IN* = GLIB_SYSDEF_POLLIN
G_IO_OUT* = GLIB_SYSDEF_POLLOUT
G_IO_PRI* = GLIB_SYSDEF_POLLPRI
G_IO_ERR* = GLIB_SYSDEF_POLLERR
G_IO_HUP* = GLIB_SYSDEF_POLLHUP
G_IO_NVAL* = GLIB_SYSDEF_POLLNVAL
type
PGIOFlags* = ptr TGIOFlags
TGIOFlags* = gint
const
G_IO_FLAG_APPEND* = 1 shl 0
G_IO_FLAG_NONBLOCK* = 1 shl 1
G_IO_FLAG_IS_READABLE* = 1 shl 2
G_IO_FLAG_IS_WRITEABLE* = 1 shl 3
G_IO_FLAG_IS_SEEKABLE* = 1 shl 4
G_IO_FLAG_MASK* = (1 shl 5) - 1
G_IO_FLAG_GET_MASK* = G_IO_FLAG_MASK
G_IO_FLAG_SET_MASK* = G_IO_FLAG_APPEND or G_IO_FLAG_NONBLOCK
type
PGIOChannel* = ptr TGIOChannel
TGIOFunc* = proc (source: PGIOChannel, condition: TGIOCondition,
data: gpointer): gboolean{.cdecl.}
PGIOFuncs* = ptr TGIOFuncs
TGIOFuncs*{.final.} = object
io_read*: proc (channel: PGIOChannel, buf: cstring, count: gsize,
bytes_read: Pgsize, err: pointer): TGIOStatus{.cdecl.}
io_write*: proc (channel: PGIOChannel, buf: cstring, count: gsize,
bytes_written: Pgsize, err: pointer): TGIOStatus{.cdecl.}
io_seek*: proc (channel: PGIOChannel, offset: gint64, theType: TGSeekType,
err: pointer): TGIOStatus{.cdecl.}
io_close*: proc (channel: PGIOChannel, err: pointer): TGIOStatus{.cdecl.}
io_create_watch*: proc (channel: PGIOChannel, condition: TGIOCondition): PGSource{.
cdecl.}
io_free*: proc (channel: PGIOChannel){.cdecl.}
io_set_flags*: proc (channel: PGIOChannel, flags: TGIOFlags, err: pointer): TGIOStatus{.
cdecl.}
io_get_flags*: proc (channel: PGIOChannel): TGIOFlags{.cdecl.}
TGIOChannel*{.final.} = object
ref_count*: guint
funcs*: PGIOFuncs
encoding*: cstring
read_cd*: TGIConv
write_cd*: TGIConv
line_term*: cstring
line_term_len*: guint
buf_size*: gsize
read_buf*: PGString
encoded_read_buf*: PGString
write_buf*: PGString
partial_write_buf*: array[0..5, gchar]
flag0*: guint16
reserved1*: gpointer
reserved2*: gpointer
const
bm_TGIOChannel_use_buffer* = 0x0001'i16
bp_TGIOChannel_use_buffer* = 0'i16
bm_TGIOChannel_do_encode* = 0x0002'i16
bp_TGIOChannel_do_encode* = 1'i16
bm_TGIOChannel_close_on_unref* = 0x0004'i16
bp_TGIOChannel_close_on_unref* = 2'i16
bm_TGIOChannel_is_readable* = 0x0008'i16
bp_TGIOChannel_is_readable* = 3'i16
bm_TGIOChannel_is_writeable* = 0x0010'i16
bp_TGIOChannel_is_writeable* = 4'i16
bm_TGIOChannel_is_seekable* = 0x0020'i16
bp_TGIOChannel_is_seekable* = 5'i16
proc TGIOChannel_use_buffer*(a: var TGIOChannel): guint
proc TGIOChannel_set_use_buffer*(a: var TGIOChannel, `use_buffer`: guint)
proc TGIOChannel_do_encode*(a: var TGIOChannel): guint
proc TGIOChannel_set_do_encode*(a: var TGIOChannel, `do_encode`: guint)
proc TGIOChannel_close_on_unref*(a: var TGIOChannel): guint
proc TGIOChannel_set_close_on_unref*(a: var TGIOChannel, `close_on_unref`: guint)
proc TGIOChannel_is_readable*(a: var TGIOChannel): guint
proc TGIOChannel_set_is_readable*(a: var TGIOChannel, `is_readable`: guint)
proc TGIOChannel_is_writeable*(a: var TGIOChannel): guint
proc TGIOChannel_set_is_writeable*(a: var TGIOChannel, `is_writeable`: guint)
proc TGIOChannel_is_seekable*(a: var TGIOChannel): guint
proc TGIOChannel_set_is_seekable*(a: var TGIOChannel, `is_seekable`: guint)
proc g_io_channel_init*(channel: PGIOChannel){.cdecl, dynlib: gliblib,
importc: "g_io_channel_init".}
proc g_io_channel_ref*(channel: PGIOChannel){.cdecl, dynlib: gliblib,
importc: "g_io_channel_ref".}
proc g_io_channel_unref*(channel: PGIOChannel){.cdecl, dynlib: gliblib,
importc: "g_io_channel_unref".}
proc g_io_channel_read*(channel: PGIOChannel, buf: cstring, count: gsize,
bytes_read: Pgsize): TGIOError{.cdecl, dynlib: gliblib,
importc: "g_io_channel_read".}
proc g_io_channel_write*(channel: PGIOChannel, buf: cstring, count: gsize,
bytes_written: Pgsize): TGIOError{.cdecl,
dynlib: gliblib, importc: "g_io_channel_write".}
proc g_io_channel_seek*(channel: PGIOChannel, offset: gint64,
theType: TGSeekType): TGIOError{.cdecl, dynlib: gliblib,
importc: "g_io_channel_seek".}
proc g_io_channel_close*(channel: PGIOChannel){.cdecl, dynlib: gliblib,
importc: "g_io_channel_close".}
proc g_io_channel_shutdown*(channel: PGIOChannel, flush: gboolean, err: pointer): TGIOStatus{.
cdecl, dynlib: gliblib, importc: "g_io_channel_shutdown".}
proc g_io_add_watch_full*(channel: PGIOChannel, priority: gint,
condition: TGIOCondition, func: TGIOFunc,
user_data: gpointer, notify: TGDestroyNotify): guint{.
cdecl, dynlib: gliblib, importc: "g_io_add_watch_full".}
proc g_io_create_watch*(channel: PGIOChannel, condition: TGIOCondition): PGSource{.
cdecl, dynlib: gliblib, importc: "g_io_create_watch".}
proc g_io_add_watch*(channel: PGIOChannel, condition: TGIOCondition,
func: TGIOFunc, user_data: gpointer): guint{.cdecl,
dynlib: gliblib, importc: "g_io_add_watch".}
proc g_io_channel_set_buffer_size*(channel: PGIOChannel, size: gsize){.cdecl,
dynlib: gliblib, importc: "g_io_channel_set_buffer_size".}
proc g_io_channel_get_buffer_size*(channel: PGIOChannel): gsize{.cdecl,
dynlib: gliblib, importc: "g_io_channel_get_buffer_size".}
proc g_io_channel_get_buffer_condition*(channel: PGIOChannel): TGIOCondition{.
cdecl, dynlib: gliblib, importc: "g_io_channel_get_buffer_condition".}
proc g_io_channel_set_flags*(channel: PGIOChannel, flags: TGIOFlags,
error: pointer): TGIOStatus{.cdecl,
dynlib: gliblib, importc: "g_io_channel_set_flags".}
proc g_io_channel_get_flags*(channel: PGIOChannel): TGIOFlags{.cdecl,
dynlib: gliblib, importc: "g_io_channel_get_flags".}
proc g_io_channel_set_line_term*(channel: PGIOChannel, line_term: cstring,
length: gint){.cdecl, dynlib: gliblib,
importc: "g_io_channel_set_line_term".}
proc g_io_channel_get_line_term*(channel: PGIOChannel, length: Pgint): cstring{.
cdecl, dynlib: gliblib, importc: "g_io_channel_get_line_term".}
proc g_io_channel_set_buffered*(channel: PGIOChannel, buffered: gboolean){.
cdecl, dynlib: gliblib, importc: "g_io_channel_set_buffered".}
proc g_io_channel_get_buffered*(channel: PGIOChannel): gboolean{.cdecl,
dynlib: gliblib, importc: "g_io_channel_get_buffered".}
proc g_io_channel_set_encoding*(channel: PGIOChannel, encoding: cstring,
error: pointer): TGIOStatus{.cdecl,
dynlib: gliblib, importc: "g_io_channel_set_encoding".}
proc g_io_channel_get_encoding*(channel: PGIOChannel): cstring{.cdecl,
dynlib: gliblib, importc: "g_io_channel_get_encoding".}
proc g_io_channel_set_close_on_unref*(channel: PGIOChannel, do_close: gboolean){.
cdecl, dynlib: gliblib, importc: "g_io_channel_set_close_on_unref".}
proc g_io_channel_get_close_on_unref*(channel: PGIOChannel): gboolean{.cdecl,
dynlib: gliblib, importc: "g_io_channel_get_close_on_unref".}
proc g_io_channel_flush*(channel: PGIOChannel, error: pointer): TGIOStatus{.
cdecl, dynlib: gliblib, importc: "g_io_channel_flush".}
proc g_io_channel_read_line*(channel: PGIOChannel, str_return: PPgchar,
length: Pgsize, terminator_pos: Pgsize,
error: pointer): TGIOStatus{.cdecl,
dynlib: gliblib, importc: "g_io_channel_read_line".}
proc g_io_channel_read_line_string*(channel: PGIOChannel, buffer: PGString,
terminator_pos: Pgsize, error: pointer): TGIOStatus{.
cdecl, dynlib: gliblib, importc: "g_io_channel_read_line_string".}
proc g_io_channel_read_to_end*(channel: PGIOChannel, str_return: PPgchar,
length: Pgsize, error: pointer): TGIOStatus{.
cdecl, dynlib: gliblib, importc: "g_io_channel_read_to_end".}
proc g_io_channel_read_chars*(channel: PGIOChannel, buf: cstring, count: gsize,
bytes_read: Pgsize, error: pointer): TGIOStatus{.
cdecl, dynlib: gliblib, importc: "g_io_channel_read_chars".}
proc g_io_channel_read_unichar*(channel: PGIOChannel, thechar: Pgunichar,
error: pointer): TGIOStatus{.cdecl,
dynlib: gliblib, importc: "g_io_channel_read_unichar".}
proc g_io_channel_write_chars*(channel: PGIOChannel, buf: cstring,
count: gssize, bytes_written: Pgsize,
error: pointer): TGIOStatus{.cdecl,
dynlib: gliblib, importc: "g_io_channel_write_chars".}
proc g_io_channel_write_unichar*(channel: PGIOChannel, thechar: gunichar,
error: pointer): TGIOStatus{.cdecl,
dynlib: gliblib, importc: "g_io_channel_write_unichar".}
proc g_io_channel_seek_position*(channel: PGIOChannel, offset: gint64,
theType: TGSeekType, error: pointer): TGIOStatus{.
cdecl, dynlib: gliblib, importc: "g_io_channel_seek_position".}
proc g_io_channel_new_file*(filename: cstring, mode: cstring, error: pointer): PGIOChannel{.
cdecl, dynlib: gliblib, importc: "g_io_channel_new_file".}
proc g_io_channel_error_quark*(): TGQuark{.cdecl, dynlib: gliblib,
importc: "g_io_channel_error_quark".}
proc g_io_channel_error_from_errno*(en: gint): TGIOChannelError{.cdecl,
dynlib: gliblib, importc: "g_io_channel_error_from_errno".}
proc g_io_channel_unix_new*(fd: int32): PGIOChannel{.cdecl, dynlib: gliblib,
importc: "g_io_channel_unix_new".}
proc g_io_channel_unix_get_fd*(channel: PGIOChannel): gint{.cdecl,
dynlib: gliblib, importc: "g_io_channel_unix_get_fd".}
const
G_LOG_LEVEL_USER_SHIFT* = 8
type
PGLogLevelFlags* = ptr TGLogLevelFlags
TGLogLevelFlags* = int32
const
G_LOG_FLAG_RECURSION* = 1 shl 0
G_LOG_FLAG_FATAL* = 1 shl 1
G_LOG_LEVEL_ERROR* = 1 shl 2
G_LOG_LEVEL_CRITICAL* = 1 shl 3
G_LOG_LEVEL_WARNING* = 1 shl 4
G_LOG_LEVEL_MESSAGE* = 1 shl 5
G_LOG_LEVEL_INFO* = 1 shl 6
G_LOG_LEVEL_DEBUG* = 1 shl 7
G_LOG_LEVEL_MASK* = not 3
const
G_LOG_FATAL_MASK* = 5
type
TGLogFunc* = proc (log_domain: cstring, log_level: TGLogLevelFlags,
TheMessage: cstring, user_data: gpointer){.cdecl.}
proc g_log_set_handler*(log_domain: cstring, log_levels: TGLogLevelFlags,
log_func: TGLogFunc, user_data: gpointer): guint{.cdecl,
dynlib: gliblib, importc: "g_log_set_handler".}
proc g_log_remove_handler*(log_domain: cstring, handler_id: guint){.cdecl,
dynlib: gliblib, importc: "g_log_remove_handler".}
proc g_log_default_handler*(log_domain: cstring, log_level: TGLogLevelFlags,
TheMessage: cstring, unused_data: gpointer){.cdecl,
dynlib: gliblib, importc: "g_log_default_handler".}
proc g_log_set_fatal_mask*(log_domain: cstring, fatal_mask: TGLogLevelFlags): TGLogLevelFlags{.
cdecl, dynlib: gliblib, importc: "g_log_set_fatal_mask".}
proc g_log_set_always_fatal*(fatal_mask: TGLogLevelFlags): TGLogLevelFlags{.
cdecl, dynlib: gliblib, importc: "g_log_set_always_fatal".}
proc `g_log_fallback_handler`*(log_domain: cstring, log_level: TGLogLevelFlags,
message: cstring, unused_data: gpointer){.cdecl,
dynlib: gliblib, importc: "g_log_fallback_handler".}
const
G_LOG_DOMAIN* = nil
when false:
proc g_error*(format: cstring){.varargs.}
proc g_message*(format: cstring){.varargs.}
proc g_critical*(format: cstring){.varargs.}
proc g_warning*(format: cstring){.varargs.}
type
TGPrintFunc* = proc (str: cstring)
proc g_set_print_handler*(func: TGPrintFunc): TGPrintFunc{.cdecl,
dynlib: gliblib, importc: "g_set_print_handler".}
proc g_set_printerr_handler*(func: TGPrintFunc): TGPrintFunc{.cdecl,
dynlib: gliblib, importc: "g_set_printerr_handler".}
type
PGMarkupError* = ptr TGMarkupError
TGMarkupError* = enum
G_MARKUP_ERROR_BAD_UTF8, G_MARKUP_ERROR_EMPTY, G_MARKUP_ERROR_PARSE,
G_MARKUP_ERROR_UNKNOWN_ELEMENT, G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
G_MARKUP_ERROR_INVALID_CONTENT
proc G_MARKUP_ERROR*(): TGQuark
proc g_markup_error_quark*(): TGQuark{.cdecl, dynlib: gliblib,
importc: "g_markup_error_quark".}
type
PGMarkupParseFlags* = ptr TGMarkupParseFlags
TGMarkupParseFlags* = int
const
G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG* = 1 shl 0
type
PGMarkupParseContext* = ptr TGMarkupParseContext
TGMarkupParseContext* = pointer
PGMarkupParser* = ptr TGMarkupParser
TGMarkupParser*{.final.} = object
start_element*: proc (context: PGMarkupParseContext, element_name: cstring,
attribute_names: PPgchar, attribute_values: PPgchar,
user_data: gpointer, error: pointer){.cdecl.}
end_element*: proc (context: PGMarkupParseContext, element_name: cstring,
user_data: gpointer, error: pointer){.cdecl.}
text*: proc (context: PGMarkupParseContext, text: cstring, text_len: gsize,
user_data: gpointer, error: pointer){.cdecl.}
passthrough*: proc (context: PGMarkupParseContext,
passthrough_text: cstring, text_len: gsize,
user_data: gpointer, error: pointer){.cdecl.}
error*: proc (context: PGMarkupParseContext, error: pointer,
user_data: gpointer){.cdecl.}
proc g_markup_parse_context_new*(parser: PGMarkupParser,
flags: TGMarkupParseFlags, user_data: gpointer,
user_data_dnotify: TGDestroyNotify): PGMarkupParseContext{.
cdecl, dynlib: gliblib, importc: "g_markup_parse_context_new".}
proc g_markup_parse_context_free*(context: PGMarkupParseContext){.cdecl,
dynlib: gliblib, importc: "g_markup_parse_context_free".}
proc g_markup_parse_context_parse*(context: PGMarkupParseContext, text: cstring,
text_len: gssize, error: pointer): gboolean{.
cdecl, dynlib: gliblib, importc: "g_markup_parse_context_parse".}
proc g_markup_parse_context_end_parse*(context: PGMarkupParseContext,
error: pointer): gboolean{.cdecl,
dynlib: gliblib, importc: "g_markup_parse_context_end_parse".}
proc g_markup_parse_context_get_position*(context: PGMarkupParseContext,
line_number: Pgint, char_number: Pgint){.cdecl, dynlib: gliblib,
importc: "g_markup_parse_context_get_position".}
proc g_markup_escape_text*(text: cstring, length: gssize): cstring{.cdecl,
dynlib: gliblib, importc: "g_markup_escape_text".}
type
PGNode* = ptr TGNode
TGNode*{.final.} = object
data*: gpointer
next*: PGNode
prev*: PGNode
parent*: PGNode
children*: PGNode
PGTraverseFlags* = ptr TGTraverseFlags
TGTraverseFlags* = gint
const
G_TRAVERSE_LEAFS* = 1 shl 0
G_TRAVERSE_NON_LEAFS* = 1 shl 1
G_TRAVERSE_ALL* = G_TRAVERSE_LEAFS or G_TRAVERSE_NON_LEAFS
G_TRAVERSE_MASK* = 0x00000003
type
PGTraverseType* = ptr TGTraverseType
TGTraverseType* = enum
G_IN_ORDER, G_PRE_ORDER, G_POST_ORDER, G_LEVEL_ORDER
TGNodeTraverseFunc* = proc (node: PGNode, data: gpointer): gboolean{.cdecl.}
TGNodeForeachFunc* = proc (node: PGNode, data: gpointer){.cdecl.}
proc G_NODE_IS_ROOT*(node: PGNode): bool
proc G_NODE_IS_LEAF*(node: PGNode): bool
proc g_node_push_allocator*(allocator: PGAllocator){.cdecl, dynlib: gliblib,
importc: "g_node_push_allocator".}
proc g_node_pop_allocator*(){.cdecl, dynlib: gliblib,
importc: "g_node_pop_allocator".}
proc g_node_new*(data: gpointer): PGNode{.cdecl, dynlib: gliblib,
importc: "g_node_new".}
proc g_node_destroy*(root: PGNode){.cdecl, dynlib: gliblib,
importc: "g_node_destroy".}
proc g_node_unlink*(node: PGNode){.cdecl, dynlib: gliblib,
importc: "g_node_unlink".}
proc g_node_copy*(node: PGNode): PGNode{.cdecl, dynlib: gliblib,
importc: "g_node_copy".}
proc g_node_insert*(parent: PGNode, position: gint, node: PGNode): PGNode{.
cdecl, dynlib: gliblib, importc: "g_node_insert".}
proc g_node_insert_before*(parent: PGNode, sibling: PGNode, node: PGNode): PGNode{.
cdecl, dynlib: gliblib, importc: "g_node_insert_before".}
proc g_node_insert_after*(parent: PGNode, sibling: PGNode, node: PGNode): PGNode{.
cdecl, dynlib: gliblib, importc: "g_node_insert_after".}
proc g_node_prepend*(parent: PGNode, node: PGNode): PGNode{.cdecl,
dynlib: gliblib, importc: "g_node_prepend".}
proc g_node_n_nodes*(root: PGNode, flags: TGTraverseFlags): guint{.cdecl,
dynlib: gliblib, importc: "g_node_n_nodes".}
proc g_node_get_root*(node: PGNode): PGNode{.cdecl, dynlib: gliblib,
importc: "g_node_get_root".}
proc g_node_is_ancestor*(node: PGNode, descendant: PGNode): gboolean{.cdecl,
dynlib: gliblib, importc: "g_node_is_ancestor".}
proc g_node_depth*(node: PGNode): guint{.cdecl, dynlib: gliblib,
importc: "g_node_depth".}
proc g_node_find*(root: PGNode, order: TGTraverseType, flags: TGTraverseFlags,
data: gpointer): PGNode{.cdecl, dynlib: gliblib,
importc: "g_node_find".}
proc g_node_append*(parent: PGNode, node: PGNode): PGNode
proc g_node_insert_data*(parent: PGNode, position: gint, data: gpointer): PGNode
proc g_node_insert_data_before*(parent: PGNode, sibling: PGNode, data: gpointer): PGNode
proc g_node_prepend_data*(parent: PGNode, data: gpointer): PGNode
proc g_node_append_data*(parent: PGNode, data: gpointer): PGNode
proc g_node_traverse*(root: PGNode, order: TGTraverseType,
flags: TGTraverseFlags, max_depth: gint,
func: TGNodeTraverseFunc, data: gpointer): guint{.cdecl,
dynlib: gliblib, importc: "g_node_traverse".}
proc g_node_max_height*(root: PGNode): guint{.cdecl, dynlib: gliblib,
importc: "g_node_max_height".}
proc g_node_children_foreach*(node: PGNode, flags: TGTraverseFlags,
func: TGNodeForeachFunc, data: gpointer){.cdecl,
dynlib: gliblib, importc: "g_node_children_foreach".}
proc g_node_reverse_children*(node: PGNode){.cdecl, dynlib: gliblib,
importc: "g_node_reverse_children".}
proc g_node_n_children*(node: PGNode): guint{.cdecl, dynlib: gliblib,
importc: "g_node_n_children".}
proc g_node_nth_child*(node: PGNode, n: guint): PGNode{.cdecl, dynlib: gliblib,
importc: "g_node_nth_child".}
proc g_node_last_child*(node: PGNode): PGNode{.cdecl, dynlib: gliblib,
importc: "g_node_last_child".}
proc g_node_find_child*(node: PGNode, flags: TGTraverseFlags, data: gpointer): PGNode{.
cdecl, dynlib: gliblib, importc: "g_node_find_child".}
proc g_node_child_position*(node: PGNode, child: PGNode): gint{.cdecl,
dynlib: gliblib, importc: "g_node_child_position".}
proc g_node_child_index*(node: PGNode, data: gpointer): gint{.cdecl,
dynlib: gliblib, importc: "g_node_child_index".}
proc g_node_first_sibling*(node: PGNode): PGNode{.cdecl, dynlib: gliblib,
importc: "g_node_first_sibling".}
proc g_node_last_sibling*(node: PGNode): PGNode{.cdecl, dynlib: gliblib,
importc: "g_node_last_sibling".}
proc g_node_prev_sibling*(node: PGNode): PGNode
proc g_node_next_sibling*(node: PGNode): PGNode
proc g_node_first_child*(node: PGNode): PGNode
type
PGTree* = pointer
TGTraverseFunc* = proc (key: gpointer, value: gpointer, data: gpointer): gboolean{.
cdecl.}
proc g_tree_new*(key_compare_func: TGCompareFunc): PGTree{.cdecl,
dynlib: gliblib, importc: "g_tree_new".}
proc g_tree_new_with_data*(key_compare_func: TGCompareDataFunc,
key_compare_data: gpointer): PGTree{.cdecl,
dynlib: gliblib, importc: "g_tree_new_with_data".}
proc g_tree_new_full*(key_compare_func: TGCompareDataFunc,
key_compare_data: gpointer,
key_destroy_func: TGDestroyNotify,
value_destroy_func: TGDestroyNotify): PGTree{.cdecl,
dynlib: gliblib, importc: "g_tree_new_full".}
proc g_tree_destroy*(tree: PGTree){.cdecl, dynlib: gliblib,
importc: "g_tree_destroy".}
proc g_tree_insert*(tree: PGTree, key: gpointer, value: gpointer){.cdecl,
dynlib: gliblib, importc: "g_tree_insert".}
proc g_tree_replace*(tree: PGTree, key: gpointer, value: gpointer){.cdecl,
dynlib: gliblib, importc: "g_tree_replace".}
proc g_tree_remove*(tree: PGTree, key: gconstpointer){.cdecl, dynlib: gliblib,
importc: "g_tree_remove".}
proc g_tree_steal*(tree: PGTree, key: gconstpointer){.cdecl, dynlib: gliblib,
importc: "g_tree_steal".}
proc g_tree_lookup*(tree: PGTree, key: gconstpointer): gpointer{.cdecl,
dynlib: gliblib, importc: "g_tree_lookup".}
proc g_tree_lookup_extended*(tree: PGTree, lookup_key: gconstpointer,
orig_key: Pgpointer, value: Pgpointer): gboolean{.
cdecl, dynlib: gliblib, importc: "g_tree_lookup_extended".}
proc g_tree_foreach*(tree: PGTree, func: TGTraverseFunc, user_data: gpointer){.
cdecl, dynlib: gliblib, importc: "g_tree_foreach".}
proc g_tree_search*(tree: PGTree, search_func: TGCompareFunc,
user_data: gconstpointer): gpointer{.cdecl, dynlib: gliblib,
importc: "g_tree_search".}
proc g_tree_height*(tree: PGTree): gint{.cdecl, dynlib: gliblib,
importc: "g_tree_height".}
proc g_tree_nnodes*(tree: PGTree): gint{.cdecl, dynlib: gliblib,
importc: "g_tree_nnodes".}
type
PGPatternSpec* = pointer
proc g_pattern_spec_new*(pattern: cstring): PGPatternSpec{.cdecl,
dynlib: gliblib, importc: "g_pattern_spec_new".}
proc g_pattern_spec_free*(pspec: PGPatternSpec){.cdecl, dynlib: gliblib,
importc: "g_pattern_spec_free".}
proc g_pattern_spec_equal*(pspec1: PGPatternSpec, pspec2: PGPatternSpec): gboolean{.
cdecl, dynlib: gliblib, importc: "g_pattern_spec_equal".}
proc g_pattern_match*(pspec: PGPatternSpec, string_length: guint, str: cstring,
string_reversed: cstring): gboolean{.cdecl,
dynlib: gliblib, importc: "g_pattern_match".}
proc g_pattern_match_string*(pspec: PGPatternSpec, str: cstring): gboolean{.
cdecl, dynlib: gliblib, importc: "g_pattern_match_string".}
proc g_pattern_match_simple*(pattern: cstring, str: cstring): gboolean{.cdecl,
dynlib: gliblib, importc: "g_pattern_match_simple".}
proc g_spaced_primes_closest*(num: guint): guint{.cdecl, dynlib: gliblib,
importc: "g_spaced_primes_closest".}
proc g_qsort_with_data*(pbase: gconstpointer, total_elems: gint, size: gsize,
compare_func: TGCompareDataFunc, user_data: gpointer){.
cdecl, dynlib: gliblib, importc: "g_qsort_with_data".}
type
PGQueue* = ptr TGQueue
TGQueue*{.final.} = object
head*: PGList
tail*: PGList
length*: guint
proc g_queue_new*(): PGQueue{.cdecl, dynlib: gliblib, importc: "g_queue_new".}
proc g_queue_free*(queue: PGQueue){.cdecl, dynlib: gliblib,
importc: "g_queue_free".}
proc g_queue_push_head*(queue: PGQueue, data: gpointer){.cdecl, dynlib: gliblib,
importc: "g_queue_push_head".}
proc g_queue_push_tail*(queue: PGQueue, data: gpointer){.cdecl, dynlib: gliblib,
importc: "g_queue_push_tail".}
proc g_queue_pop_head*(queue: PGQueue): gpointer{.cdecl, dynlib: gliblib,
importc: "g_queue_pop_head".}
proc g_queue_pop_tail*(queue: PGQueue): gpointer{.cdecl, dynlib: gliblib,
importc: "g_queue_pop_tail".}
proc g_queue_is_empty*(queue: PGQueue): gboolean{.cdecl, dynlib: gliblib,
importc: "g_queue_is_empty".}
proc g_queue_peek_head*(queue: PGQueue): gpointer{.cdecl, dynlib: gliblib,
importc: "g_queue_peek_head".}
proc g_queue_peek_tail*(queue: PGQueue): gpointer{.cdecl, dynlib: gliblib,
importc: "g_queue_peek_tail".}
proc g_queue_push_head_link*(queue: PGQueue, link: PGList){.cdecl,
dynlib: gliblib, importc: "g_queue_push_head_link".}
proc g_queue_push_tail_link*(queue: PGQueue, link: PGList){.cdecl,
dynlib: gliblib, importc: "g_queue_push_tail_link".}
proc g_queue_pop_head_link*(queue: PGQueue): PGList{.cdecl, dynlib: gliblib,
importc: "g_queue_pop_head_link".}
proc g_queue_pop_tail_link*(queue: PGQueue): PGList{.cdecl, dynlib: gliblib,
importc: "g_queue_pop_tail_link".}
type
PGRand* = pointer
proc g_rand_new_with_seed*(seed: guint32): PGRand{.cdecl, dynlib: gliblib,
importc: "g_rand_new_with_seed".}
proc g_rand_new*(): PGRand{.cdecl, dynlib: gliblib, importc: "g_rand_new".}
proc g_rand_free*(rand: PGRand){.cdecl, dynlib: gliblib, importc: "g_rand_free".}
proc g_rand_set_seed*(rand: PGRand, seed: guint32){.cdecl, dynlib: gliblib,
importc: "g_rand_set_seed".}
proc g_rand_boolean*(rand: PGRand): gboolean
proc g_rand_int*(rand: PGRand): guint32{.cdecl, dynlib: gliblib,
importc: "g_rand_int".}
proc g_rand_int_range*(rand: PGRand, `begin`: gint32, `end`: gint32): gint32{.
cdecl, dynlib: gliblib, importc: "g_rand_int_range".}
proc g_rand_double*(rand: PGRand): gdouble{.cdecl, dynlib: gliblib,
importc: "g_rand_double".}
proc g_rand_double_range*(rand: PGRand, `begin`: gdouble, `end`: gdouble): gdouble{.
cdecl, dynlib: gliblib, importc: "g_rand_double_range".}
proc g_random_set_seed*(seed: guint32){.cdecl, dynlib: gliblib,
importc: "g_random_set_seed".}
proc g_random_boolean*(): gboolean
proc g_random_int*(): guint32{.cdecl, dynlib: gliblib, importc: "g_random_int".}
proc g_random_int_range*(`begin`: gint32, `end`: gint32): gint32{.cdecl,
dynlib: gliblib, importc: "g_random_int_range".}
proc g_random_double*(): gdouble{.cdecl, dynlib: gliblib,
importc: "g_random_double".}
proc g_random_double_range*(`begin`: gdouble, `end`: gdouble): gdouble{.cdecl,
dynlib: gliblib, importc: "g_random_double_range".}
type
PGTuples* = ptr TGTuples
TGTuples*{.final.} = object
len*: guint
PGRelation* = pointer
proc g_relation_new*(fields: gint): PGRelation{.cdecl, dynlib: gliblib,
importc: "g_relation_new".}
proc g_relation_destroy*(relation: PGRelation){.cdecl, dynlib: gliblib,
importc: "g_relation_destroy".}
proc g_relation_index*(relation: PGRelation, field: gint, hash_func: TGHashFunc,
key_equal_func: TGEqualFunc){.cdecl, dynlib: gliblib,
importc: "g_relation_index".}
proc g_relation_delete*(relation: PGRelation, key: gconstpointer, field: gint): gint{.
cdecl, dynlib: gliblib, importc: "g_relation_delete".}
proc g_relation_select*(relation: PGRelation, key: gconstpointer, field: gint): PGTuples{.
cdecl, dynlib: gliblib, importc: "g_relation_select".}
proc g_relation_count*(relation: PGRelation, key: gconstpointer, field: gint): gint{.
cdecl, dynlib: gliblib, importc: "g_relation_count".}
proc g_relation_print*(relation: PGRelation){.cdecl, dynlib: gliblib,
importc: "g_relation_print".}
proc g_tuples_destroy*(tuples: PGTuples){.cdecl, dynlib: gliblib,
importc: "g_tuples_destroy".}
proc g_tuples_index*(tuples: PGTuples, index: gint, field: gint): gpointer{.
cdecl, dynlib: gliblib, importc: "g_tuples_index".}
type
PGTokenType* = ptr TGTokenType
TGTokenType* = gint
const
G_TOKEN_LEFT_PAREN* = 40
G_TOKEN_RIGHT_PAREN* = 41
G_TOKEN_LEFT_CURLY* = 123
G_TOKEN_RIGHT_CURLY* = 125
G_TOKEN_LEFT_BRACE* = 91
G_TOKEN_RIGHT_BRACE* = 93
G_TOKEN_EQUAL_SIGN* = 61
G_TOKEN_COMMA* = 44
G_TOKEN_NONE* = 256
G_TOKEN_ERROR* = 257
G_TOKEN_CHAR* = 258
G_TOKEN_OCTAL* = 260
G_TOKEN_INT* = 261
G_TOKEN_HEX* = 262
G_TOKEN_FLOAT* = 263
G_TOKEN_STRING* = 264
G_TOKEN_SYMBOL* = 265
G_TOKEN_IDENTIFIER* = 266
G_TOKEN_IDENTIFIER_NULL* = 267
G_TOKEN_COMMENT_SINGLE* = 268
G_TOKEN_COMMENT_MULTI* = 269
G_TOKEN_LAST* = 270
type
PGScanner* = ptr TGScanner
PGScannerConfig* = ptr TGScannerConfig
PGTokenValue* = ptr TGTokenValue
TGTokenValue*{.final.} = object
v_float*: gdouble
TGScannerMsgFunc* = proc (scanner: PGScanner, message: cstring,
error: gboolean){.cdecl.}
TGScanner*{.final.} = object
user_data*: gpointer
max_parse_errors*: guint
parse_errors*: guint
input_name*: cstring
qdata*: PGData
config*: PGScannerConfig
token*: TGTokenType
value*: TGTokenValue
line*: guint
position*: guint
next_token*: TGTokenType
next_value*: TGTokenValue
next_line*: guint
next_position*: guint
symbol_table*: PGHashTable
input_fd*: gint
text*: cstring
text_end*: cstring
buffer*: cstring
scope_id*: guint
msg_handler*: TGScannerMsgFunc
TGScannerConfig*{.final.} = object
cset_skip_characters*: cstring
cset_identifier_first*: cstring
cset_identifier_nth*: cstring
cpair_comment_single*: cstring
flag0*: int32
padding_dummy*: guint
const
G_CSET_A_2_Z_UCASE* = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
G_CSET_a_2_z_lcase* = "abcdefghijklmnopqrstuvwxyz"
G_CSET_DIGITS* = "0123456789"
const
bm_TGScannerConfig_case_sensitive* = 0x00000001'i32
bp_TGScannerConfig_case_sensitive* = 0'i32
bm_TGScannerConfig_skip_comment_multi* = 0x00000002'i32
bp_TGScannerConfig_skip_comment_multi* = 1'i32
bm_TGScannerConfig_skip_comment_single* = 0x00000004'i32
bp_TGScannerConfig_skip_comment_single* = 2'i32
bm_TGScannerConfig_scan_comment_multi* = 0x00000008'i32
bp_TGScannerConfig_scan_comment_multi* = 3'i32
bm_TGScannerConfig_scan_identifier* = 0x00000010'i32
bp_TGScannerConfig_scan_identifier* = 4'i32
bm_TGScannerConfig_scan_identifier_1char* = 0x00000020'i32
bp_TGScannerConfig_scan_identifier_1char* = 5'i32
bm_TGScannerConfig_scan_identifier_NULL* = 0x00000040'i32
bp_TGScannerConfig_scan_identifier_NULL* = 6'i32
bm_TGScannerConfig_scan_symbols* = 0x00000080'i32
bp_TGScannerConfig_scan_symbols* = 7'i32
bm_TGScannerConfig_scan_binary* = 0x00000100'i32
bp_TGScannerConfig_scan_binary* = 8'i32
bm_TGScannerConfig_scan_octal* = 0x00000200'i32
bp_TGScannerConfig_scan_octal* = 9'i32
bm_TGScannerConfig_scan_float* = 0x00000400'i32
bp_TGScannerConfig_scan_float* = 10'i32
bm_TGScannerConfig_scan_hex* = 0x00000800'i32
bp_TGScannerConfig_scan_hex* = 11'i32
bm_TGScannerConfig_scan_hex_dollar* = 0x00001000'i32
bp_TGScannerConfig_scan_hex_dollar* = 12'i32
bm_TGScannerConfig_scan_string_sq* = 0x00002000'i32
bp_TGScannerConfig_scan_string_sq* = 13'i32
bm_TGScannerConfig_scan_string_dq* = 0x00004000'i32
bp_TGScannerConfig_scan_string_dq* = 14'i32
bm_TGScannerConfig_numbers_2_int* = 0x00008000'i32
bp_TGScannerConfig_numbers_2_int* = 15'i32
bm_TGScannerConfig_int_2_float* = 0x00010000'i32
bp_TGScannerConfig_int_2_float* = 16'i32
bm_TGScannerConfig_identifier_2_string* = 0x00020000'i32
bp_TGScannerConfig_identifier_2_string* = 17'i32
bm_TGScannerConfig_char_2_token* = 0x00040000'i32
bp_TGScannerConfig_char_2_token* = 18'i32
bm_TGScannerConfig_symbol_2_token* = 0x00080000'i32
bp_TGScannerConfig_symbol_2_token* = 19'i32
bm_TGScannerConfig_scope_0_fallback* = 0x00100000'i32
bp_TGScannerConfig_scope_0_fallback* = 20'i32
proc TGScannerConfig_case_sensitive*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_case_sensitive*(a: var TGScannerConfig,
`case_sensitive`: guint)
proc TGScannerConfig_skip_comment_multi*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_skip_comment_multi*(a: var TGScannerConfig,
`skip_comment_multi`: guint)
proc TGScannerConfig_skip_comment_single*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_skip_comment_single*(a: var TGScannerConfig,
`skip_comment_single`: guint)
proc TGScannerConfig_scan_comment_multi*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_comment_multi*(a: var TGScannerConfig,
`scan_comment_multi`: guint)
proc TGScannerConfig_scan_identifier*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_identifier*(a: var TGScannerConfig,
`scan_identifier`: guint)
proc TGScannerConfig_scan_identifier_1char*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_identifier_1char*(a: var TGScannerConfig,
`scan_identifier_1char`: guint)
proc TGScannerConfig_scan_identifier_NULL*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_identifier_NULL*(a: var TGScannerConfig,
`scan_identifier_NULL`: guint)
proc TGScannerConfig_scan_symbols*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_symbols*(a: var TGScannerConfig,
`scan_symbols`: guint)
proc TGScannerConfig_scan_binary*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_binary*(a: var TGScannerConfig,
`scan_binary`: guint)
proc TGScannerConfig_scan_octal*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_octal*(a: var TGScannerConfig, `scan_octal`: guint)
proc TGScannerConfig_scan_float*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_float*(a: var TGScannerConfig, `scan_float`: guint)
proc TGScannerConfig_scan_hex*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_hex*(a: var TGScannerConfig, `scan_hex`: guint)
proc TGScannerConfig_scan_hex_dollar*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_hex_dollar*(a: var TGScannerConfig,
`scan_hex_dollar`: guint)
proc TGScannerConfig_scan_string_sq*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_string_sq*(a: var TGScannerConfig,
`scan_string_sq`: guint)
proc TGScannerConfig_scan_string_dq*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scan_string_dq*(a: var TGScannerConfig,
`scan_string_dq`: guint)
proc TGScannerConfig_numbers_2_int*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_numbers_2_int*(a: var TGScannerConfig,
`numbers_2_int`: guint)
proc TGScannerConfig_int_2_float*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_int_2_float*(a: var TGScannerConfig,
`int_2_float`: guint)
proc TGScannerConfig_identifier_2_string*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_identifier_2_string*(a: var TGScannerConfig,
`identifier_2_string`: guint)
proc TGScannerConfig_char_2_token*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_char_2_token*(a: var TGScannerConfig,
`char_2_token`: guint)
proc TGScannerConfig_symbol_2_token*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_symbol_2_token*(a: var TGScannerConfig,
`symbol_2_token`: guint)
proc TGScannerConfig_scope_0_fallback*(a: var TGScannerConfig): guint
proc TGScannerConfig_set_scope_0_fallback*(a: var TGScannerConfig,
`scope_0_fallback`: guint)
proc g_scanner_new*(config_templ: PGScannerConfig): PGScanner{.cdecl,
dynlib: gliblib, importc: "g_scanner_new".}
proc g_scanner_destroy*(scanner: PGScanner){.cdecl, dynlib: gliblib,
importc: "g_scanner_destroy".}
proc g_scanner_input_file*(scanner: PGScanner, input_fd: gint){.cdecl,
dynlib: gliblib, importc: "g_scanner_input_file".}
proc g_scanner_sync_file_offset*(scanner: PGScanner){.cdecl, dynlib: gliblib,
importc: "g_scanner_sync_file_offset".}
proc g_scanner_input_text*(scanner: PGScanner, text: cstring, text_len: guint){.
cdecl, dynlib: gliblib, importc: "g_scanner_input_text".}
proc g_scanner_get_next_token*(scanner: PGScanner): TGTokenType{.cdecl,
dynlib: gliblib, importc: "g_scanner_get_next_token".}
proc g_scanner_peek_next_token*(scanner: PGScanner): TGTokenType{.cdecl,
dynlib: gliblib, importc: "g_scanner_peek_next_token".}
proc g_scanner_cur_token*(scanner: PGScanner): TGTokenType{.cdecl,
dynlib: gliblib, importc: "g_scanner_cur_token".}
proc g_scanner_cur_value*(scanner: PGScanner): TGTokenValue{.cdecl,
dynlib: gliblib, importc: "g_scanner_cur_value".}
proc g_scanner_cur_line*(scanner: PGScanner): guint{.cdecl, dynlib: gliblib,
importc: "g_scanner_cur_line".}
proc g_scanner_cur_position*(scanner: PGScanner): guint{.cdecl, dynlib: gliblib,
importc: "g_scanner_cur_position".}
proc g_scanner_eof*(scanner: PGScanner): gboolean{.cdecl, dynlib: gliblib,
importc: "g_scanner_eof".}
proc g_scanner_set_scope*(scanner: PGScanner, scope_id: guint): guint{.cdecl,
dynlib: gliblib, importc: "g_scanner_set_scope".}
proc g_scanner_scope_add_symbol*(scanner: PGScanner, scope_id: guint,
symbol: cstring, value: gpointer){.cdecl,
dynlib: gliblib, importc: "g_scanner_scope_add_symbol".}
proc g_scanner_scope_remove_symbol*(scanner: PGScanner, scope_id: guint,
symbol: cstring){.cdecl, dynlib: gliblib,
importc: "g_scanner_scope_remove_symbol".}
proc g_scanner_scope_lookup_symbol*(scanner: PGScanner, scope_id: guint,
symbol: cstring): gpointer{.cdecl,
dynlib: gliblib, importc: "g_scanner_scope_lookup_symbol".}
proc g_scanner_scope_foreach_symbol*(scanner: PGScanner, scope_id: guint,
func: TGHFunc, user_data: gpointer){.cdecl,
dynlib: gliblib, importc: "g_scanner_scope_foreach_symbol".}
proc g_scanner_lookup_symbol*(scanner: PGScanner, symbol: cstring): gpointer{.
cdecl, dynlib: gliblib, importc: "g_scanner_lookup_symbol".}
proc g_scanner_unexp_token*(scanner: PGScanner, expected_token: TGTokenType,
identifier_spec: cstring, symbol_spec: cstring,
symbol_name: cstring, `message`: cstring,
is_error: gint){.cdecl, dynlib: gliblib,
importc: "g_scanner_unexp_token".}
proc G_SHELL_ERROR*(): TGQuark
type
PGShellError* = ptr TGShellError
TGShellError* = enum
G_SHELL_ERROR_BAD_QUOTING, G_SHELL_ERROR_EMPTY_STRING, G_SHELL_ERROR_FAILED
proc g_shell_error_quark*(): TGQuark{.cdecl, dynlib: gliblib,
importc: "g_shell_error_quark".}
proc g_shell_quote*(unquoted_string: cstring): cstring{.cdecl, dynlib: gliblib,
importc: "g_shell_quote".}
proc g_shell_unquote*(quoted_string: cstring, error: pointer): cstring{.cdecl,
dynlib: gliblib, importc: "g_shell_unquote".}
proc g_shell_parse_argv*(command_line: cstring, argcp: Pgint, argvp: PPPgchar,
error: pointer): gboolean{.cdecl, dynlib: gliblib,
importc: "g_shell_parse_argv".}
proc G_SPAWN_ERROR*(): TGQuark
type
PGSpawnError* = ptr TGSpawnError
TGSpawnError* = enum
G_SPAWN_ERROR_FORK, G_SPAWN_ERROR_READ, G_SPAWN_ERROR_CHDIR,
G_SPAWN_ERROR_ACCES, G_SPAWN_ERROR_PERM, G_SPAWN_ERROR_2BIG,
G_SPAWN_ERROR_NOEXEC, G_SPAWN_ERROR_NAMETOOLONG, G_SPAWN_ERROR_NOENT,
G_SPAWN_ERROR_NOMEM, G_SPAWN_ERROR_NOTDIR, G_SPAWN_ERROR_LOOP,
G_SPAWN_ERROR_TXTBUSY, G_SPAWN_ERROR_IO, G_SPAWN_ERROR_NFILE,
G_SPAWN_ERROR_MFILE, G_SPAWN_ERROR_INVAL, G_SPAWN_ERROR_ISDIR,
G_SPAWN_ERROR_LIBBAD, G_SPAWN_ERROR_FAILED
TGSpawnChildSetupFunc* = proc (user_data: gpointer){.cdecl.}
PGSpawnFlags* = ptr TGSpawnFlags
TGSpawnFlags* = int
const
G_SPAWN_LEAVE_DESCRIPTORS_OPEN* = 1 shl 0
G_SPAWN_DO_NOT_REAP_CHILD* = 1 shl 1
G_SPAWN_SEARCH_PATH* = 1 shl 2
G_SPAWN_STDOUT_TO_DEV_NULL* = 1 shl 3
G_SPAWN_STDERR_TO_DEV_NULL* = 1 shl 4
G_SPAWN_CHILD_INHERITS_STDIN* = 1 shl 5
G_SPAWN_FILE_AND_ARGV_ZERO* = 1 shl 6
proc g_spawn_error_quark*(): TGQuark{.cdecl, dynlib: gliblib,
importc: "g_spawn_error_quark".}
proc g_spawn_async*(working_directory: cstring, argv: PPgchar, envp: PPgchar,
flags: TGSpawnFlags, child_setup: TGSpawnChildSetupFunc,
user_data: gpointer, child_pid: Pgint, error: pointer): gboolean{.
cdecl, dynlib: gliblib, importc: "g_spawn_async".}
proc g_spawn_async_with_pipes*(working_directory: cstring, argv: PPgchar,
envp: PPgchar, flags: TGSpawnFlags,
child_setup: TGSpawnChildSetupFunc,
user_data: gpointer, child_pid: Pgint,
standard_input: Pgint, standard_output: Pgint,
standard_error: Pgint, error: pointer): gboolean{.
cdecl, dynlib: gliblib, importc: "g_spawn_async_with_pipes".}
proc g_spawn_sync*(working_directory: cstring, argv: PPgchar, envp: PPgchar,
flags: TGSpawnFlags, child_setup: TGSpawnChildSetupFunc,
user_data: gpointer, standard_output: PPgchar,
standard_error: PPgchar, exit_status: Pgint, error: pointer): gboolean{.
cdecl, dynlib: gliblib, importc: "g_spawn_sync".}
proc g_spawn_command_line_sync*(command_line: cstring, standard_output: PPgchar,
standard_error: PPgchar, exit_status: Pgint,
error: pointer): gboolean{.cdecl,
dynlib: gliblib, importc: "g_spawn_command_line_sync".}
proc g_spawn_command_line_async*(command_line: cstring, error: pointer): gboolean{.
cdecl, dynlib: gliblib, importc: "g_spawn_command_line_async".}
proc G_TYPE_IS_BOXED*(theType: GType): gboolean
proc G_VALUE_HOLDS_BOXED*(value: PGValue): gboolean
proc G_TYPE_CLOSURE*(): GType
proc G_TYPE_VALUE*(): GType
proc G_TYPE_VALUE_ARRAY*(): GType
proc G_TYPE_GSTRING*(): GType
proc g_boxed_copy*(boxed_type: GType, src_boxed: gconstpointer): gpointer{.
cdecl, dynlib: gobjectlib, importc: "g_boxed_copy".}
proc g_boxed_free*(boxed_type: GType, boxed: gpointer){.cdecl,
dynlib: gobjectlib, importc: "g_boxed_free".}
proc g_value_set_boxed*(value: PGValue, v_boxed: gconstpointer){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_boxed".}
proc g_value_set_static_boxed*(value: PGValue, v_boxed: gconstpointer){.cdecl,
dynlib: gobjectlib, importc: "g_value_set_static_boxed".}
proc g_value_get_boxed*(value: PGValue): gpointer{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_boxed".}
proc g_value_dup_boxed*(value: PGValue): gpointer{.cdecl, dynlib: gobjectlib,
importc: "g_value_dup_boxed".}
proc g_boxed_type_register_static*(name: cstring, boxed_copy: TGBoxedCopyFunc,
boxed_free: TGBoxedFreeFunc): GType{.cdecl,
dynlib: gobjectlib, importc: "g_boxed_type_register_static".}
proc g_value_set_boxed_take_ownership*(value: PGValue, v_boxed: gconstpointer){.
cdecl, dynlib: gobjectlib, importc: "g_value_set_boxed_take_ownership".}
proc g_closure_get_type*(): GType{.cdecl, dynlib: gobjectlib,
importc: "g_closure_get_type".}
proc g_value_get_type*(): GType{.cdecl, dynlib: gobjectlib,
importc: "g_value_get_type".}
proc g_value_array_get_type*(): GType{.cdecl, dynlib: gobjectlib,
importc: "g_value_array_get_type".}
proc g_gstring_get_type*(): GType{.cdecl, dynlib: gobjectlib,
importc: "g_gstring_get_type".}
type
PGModule* = pointer
TGModuleFlags* = int32
TGModuleCheckInit* = proc (module: PGModule): cstring{.cdecl.}
TGModuleUnload* = proc (module: PGModule){.cdecl.}
const
G_MODULE_BIND_LAZY* = 1 shl 0
G_MODULE_BIND_MASK* = 1
proc g_module_supported*(): gboolean{.cdecl, dynlib: gmodulelib,
importc: "g_module_supported".}
proc g_module_open*(file_name: cstring, flags: TGModuleFlags): PGModule{.cdecl,
dynlib: gmodulelib, importc: "g_module_open".}
proc g_module_close*(module: PGModule): gboolean{.cdecl, dynlib: gmodulelib,
importc: "g_module_close".}
proc g_module_make_resident*(module: PGModule){.cdecl, dynlib: gmodulelib,
importc: "g_module_make_resident".}
proc g_module_error*(): cstring{.cdecl, dynlib: gmodulelib,
importc: "g_module_error".}
proc g_module_symbol*(module: PGModule, symbol_name: cstring, symbol: Pgpointer): gboolean{.
cdecl, dynlib: gmodulelib, importc: "g_module_symbol".}
proc g_module_name*(module: PGModule): cstring{.cdecl, dynlib: gmodulelib,
importc: "g_module_name".}
proc g_module_build_path*(directory: cstring, module_name: cstring): cstring{.
cdecl, dynlib: gmodulelib, importc: "g_module_build_path".}
proc g_cclosure_marshal_VOID_VOID*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__VOID".}
proc g_cclosure_marshal_VOID_BOOLEAN*(closure: PGClosure,
return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__BOOLEAN".}
proc g_cclosure_marshal_VOID_CHAR*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__CHAR".}
proc g_cclosure_marshal_VOID_UCHAR*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UCHAR".}
proc g_cclosure_marshal_VOID_INT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt, param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__INT".}
proc g_cclosure_marshal_VOID_UINT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UINT".}
proc g_cclosure_marshal_VOID_LONG*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__LONG".}
proc g_cclosure_marshal_VOID_ULONG*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__ULONG".}
proc g_cclosure_marshal_VOID_ENUM*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__ENUM".}
proc g_cclosure_marshal_VOID_FLAGS*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__FLAGS".}
proc g_cclosure_marshal_VOID_FLOAT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__FLOAT".}
proc g_cclosure_marshal_VOID_DOUBLE*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__DOUBLE".}
proc g_cclosure_marshal_VOID_STRING*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__STRING".}
proc g_cclosure_marshal_VOID_PARAM*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__PARAM".}
proc g_cclosure_marshal_VOID_BOXED*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__BOXED".}
proc g_cclosure_marshal_VOID_POINTER*(closure: PGClosure,
return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__POINTER".}
proc g_cclosure_marshal_VOID_OBJECT*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__OBJECT".}
proc g_cclosure_marshal_STRING_OBJECT_POINTER*(closure: PGClosure,
return_value: PGValue, n_param_values: GUInt, param_values: PGValue,
invocation_hint: GPointer, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_STRING__OBJECT_POINTER".}
proc g_cclosure_marshal_VOID_UINT_POINTER*(closure: PGClosure,
return_value: PGValue, n_param_values: GUInt, param_values: PGValue,
invocation_hint: GPointer, marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_VOID__UINT_POINTER".}
proc g_cclosure_marshal_BOOLEAN_FLAGS*(closure: PGClosure,
return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gobjectlib, importc: "g_cclosure_marshal_BOOLEAN__FLAGS".}
proc g_cclosure_marshal_BOOL_FLAGS*(closure: PGClosure, return_value: PGValue,
n_param_values: GUInt,
param_values: PGValue,
invocation_hint: GPointer,
marshal_data: GPointer){.cdecl,
dynlib: gliblib, importc: "g_cclosure_marshal_BOOLEAN__FLAGS".}
proc GUINT16_SWAP_LE_BE_CONSTANT*(val: guint16): guint16 =
Result = ((val and 0x00FF'i16) shl 8'i16) or
((val and 0xFF00'i16) shr 8'i16)
proc GUINT32_SWAP_LE_BE_CONSTANT*(val: guint32): guint32 =
Result = ((val and 0x000000FF'i32) shl 24'i32) or
((val and 0x0000FF00'i32) shl 8'i32) or
((val and 0x00FF0000'i32) shr 8'i32) or
((val and 0xFF000000'i32) shr 24'i32)
proc GUINT_TO_POINTER*(i: guint): pointer =
Result = cast[Pointer](TAddress(i))
when false:
type
PGArray* = pointer
proc g_array_append_val*(a: PGArray, v: gpointer): PGArray =
result = g_array_append_vals(a, addr(v), 1)
proc g_array_prepend_val*(a: PGArray, v: gpointer): PGArray =
result = g_array_prepend_vals(a, addr(v), 1)
proc g_array_insert_val*(a: PGArray, i: guint, v: gpointer): PGArray =
result = g_array_insert_vals(a, i, addr(v), 1)
proc g_ptr_array_index*(parray: PGPtrArray, index: guint): gpointer =
result = cast[PGPointer](cast[int](parray ^. pdata) +
index * SizeOf(GPointer))^
proc G_THREAD_ERROR*(): TGQuark =
result = g_thread_error_quark()
proc g_mutex_lock*(mutex: PGMutex) =
if g_threads_got_initialized:
g_thread_functions_for_glib_use.mutex_lock(mutex)
proc g_mutex_trylock*(mutex: PGMutex): gboolean =
if g_threads_got_initialized:
result = g_thread_functions_for_glib_use.mutex_trylock(mutex)
else:
result = true
proc g_mutex_unlock*(mutex: PGMutex) =
if g_threads_got_initialized:
g_thread_functions_for_glib_use.mutex_unlock(mutex)
proc g_mutex_free*(mutex: PGMutex) =
if g_threads_got_initialized:
g_thread_functions_for_glib_use.mutex_free(mutex)
proc g_cond_wait*(cond: PGCond, mutex: PGMutex) =
if g_threads_got_initialized:
g_thread_functions_for_glib_use.cond_wait(cond, mutex)
proc g_cond_timed_wait*(cond: PGCond, mutex: PGMutex, end_time: PGTimeVal): gboolean =
if g_threads_got_initialized:
result = g_thread_functions_for_glib_use.cond_timed_wait(cond, mutex,
end_time)
else:
result = true
proc g_thread_supported*(): gboolean =
result = g_threads_got_initialized
proc g_mutex_new*(): PGMutex =
result = g_thread_functions_for_glib_use.mutex_new()
proc g_cond_new*(): PGCond =
result = g_thread_functions_for_glib_use.cond_new()
proc g_cond_signal*(cond: PGCond) =
if g_threads_got_initialized:
g_thread_functions_for_glib_use.cond_signal(cond)
proc g_cond_broadcast*(cond: PGCond) =
if g_threads_got_initialized:
g_thread_functions_for_glib_use.cond_broadcast(cond)
proc g_cond_free*(cond: PGCond) =
if g_threads_got_initialized:
g_thread_functions_for_glib_use.cond_free(cond)
proc g_private_new*(dest: TGDestroyNotify): PGPrivate =
result = g_thread_functions_for_glib_use.private_new(dest)
proc g_private_get*(private_key: PGPrivate): gpointer =
if g_threads_got_initialized:
result = g_thread_functions_for_glib_use.private_get(private_key)
else:
result = private_key
proc g_private_set*(private_key: var PGPrivate, data: gpointer) =
if g_threads_got_initialized:
nil
else:
private_key = data
proc g_thread_yield*() =
if g_threads_got_initialized:
g_thread_functions_for_glib_use.thread_yield
proc g_thread_create*(func: TGThreadFunc, data: gpointer, joinable: gboolean,
error: pointer): PGThread =
result = g_thread_create_full(func, data, 0, joinable, false,
G_THREAD_PRIORITY_NORMAL, error)
proc g_static_mutex_get_mutex*(mutex: PPGMutex): PGMutex =
result = g_static_mutex_get_mutex_impl(mutex)
proc g_static_mutex_lock*(mutex: PGStaticMutex) =
g_mutex_lock(g_static_mutex_get_mutex_impl(PPGMutex(mutex)))
proc g_static_mutex_trylock*(mutex: PGStaticMutex): gboolean =
result = g_mutex_trylock(g_static_mutex_get_mutex(PPGMutex(mutex)))
proc g_static_mutex_unlock*(mutex: PGStaticMutex) =
g_mutex_unlock(g_static_mutex_get_mutex_impl(PPGMutex(mutex)))
proc g_main_new*(is_running: gboolean): PGMainLoop =
result = g_main_loop_new(nil, is_running)
proc g_main_iteration*(may_block: gboolean): gboolean =
result = g_main_context_iteration(nil, may_block)
proc g_main_pending*(): gboolean =
result = g_main_context_pending(nil)
proc g_main_set_poll_func*(func: TGPollFunc) =
g_main_context_set_poll_func(nil, func)
proc g_slist_next*(slist: PGSList): PGSList =
if slist != nil:
result = slist.next
else:
result = nil
proc g_new*(bytes_per_struct, n_structs: int): gpointer =
result = g_malloc(n_structs * bytes_per_struct)
proc g_new0*(bytes_per_struct, n_structs: int): gpointer =
result = g_malloc0(n_structs * bytes_per_struct)
proc g_renew*(struct_size: int, OldMem: gpointer, n_structs: int): gpointer =
result = g_realloc(OldMem, struct_size * n_structs)
proc g_chunk_new*(chunk: Pointer): Pointer =
result = g_mem_chunk_alloc(chunk)
proc g_chunk_new0*(chunk: Pointer): Pointer =
result = g_mem_chunk_alloc0(chunk)
proc g_chunk_free*(mem_chunk: PGMemChunk, mem: gpointer) =
g_mem_chunk_free(mem_chunk, mem)
proc g_list_previous*(list: PGList): PGList =
if list != nil:
result = list.prev
else:
result = nil
proc g_list_next*(list: PGList): PGList =
if list != nil:
result = list.next
else:
result = nil
proc G_CONVERT_ERROR*(): TGQuark =
result = g_convert_error_quark()
proc g_datalist_id_set_data*(datalist: PPGData, key_id: TGQuark, data: gpointer) =
g_datalist_id_set_data_full(datalist, key_id, data, TGDestroyNotify(nil))
proc g_datalist_id_remove_data*(datalist: PPGData, key_id: TGQuark) =
g_datalist_id_set_data(datalist, key_id, nil)
proc g_datalist_get_data*(datalist: PPGData, key_str: cstring): PPGData =
result = cast[PPGData](g_datalist_id_get_data(datalist,
g_quark_try_string(key_str)))
proc g_datalist_set_data_full*(datalist: PPGData, key_str: cstring,
data: gpointer, destroy_func: TGDestroyNotify) =
g_datalist_id_set_data_full(datalist, g_quark_from_string(key_str), data,
destroy_func)
proc g_datalist_set_data*(datalist: PPGData, key_str: cstring, data: gpointer) =
g_datalist_set_data_full(datalist, key_str, data, nil)
proc g_datalist_remove_no_notify*(datalist: PPGData, key_str: cstring) =
discard g_datalist_id_remove_no_notify(datalist, g_quark_try_string(key_str))
proc g_datalist_remove_data*(datalist: PPGData, key_str: cstring) =
g_datalist_id_set_data(datalist, g_quark_try_string(key_str), nil)
proc g_dataset_id_set_data*(location: gconstpointer, key_id: TGQuark,
data: gpointer) =
g_dataset_id_set_data_full(location, key_id, data, nil)
proc g_dataset_id_remove_data*(location: gconstpointer, key_id: TGQuark) =
g_dataset_id_set_data(location, key_id, nil)
proc g_dataset_get_data*(location: gconstpointer, key_str: cstring): gpointer =
result = g_dataset_id_get_data(location, g_quark_try_string(key_str))
proc g_dataset_set_data_full*(location: gconstpointer, key_str: cstring,
data: gpointer, destroy_func: TGDestroyNotify) =
g_dataset_id_set_data_full(location, g_quark_from_string(key_str), data,
destroy_func)
proc g_dataset_remove_no_notify*(location: gconstpointer, key_str: cstring) =
discard g_dataset_id_remove_no_notify(location, g_quark_try_string(key_str))
proc g_dataset_set_data*(location: gconstpointer, key_str: cstring,
data: gpointer) =
g_dataset_set_data_full(location, key_str, data, nil)
proc g_dataset_remove_data*(location: gconstpointer, key_str: cstring) =
g_dataset_id_set_data(location, g_quark_try_string(key_str), nil)
proc G_FILE_ERROR*(): TGQuark =
result = g_file_error_quark()
proc TGHookList_hook_size*(a: var TGHookList): guint =
result = (a.flag0 and bm_TGHookList_hook_size) shr bp_TGHookList_hook_size
proc TGHookList_set_hook_size*(a: var TGHookList, `hook_size`: guint) =
a.flag0 = a.flag0 or
((`hook_size` shl bp_TGHookList_hook_size) and bm_TGHookList_hook_size)
proc TGHookList_is_setup*(a: var TGHookList): guint =
result = (a.flag0 and bm_TGHookList_is_setup) shr bp_TGHookList_is_setup
proc TGHookList_set_is_setup*(a: var TGHookList, `is_setup`: guint) =
a.flag0 = a.flag0 or
((`is_setup` shl bp_TGHookList_is_setup) and bm_TGHookList_is_setup)
proc G_HOOK*(hook: pointer): PGHook =
result = cast[PGHook](hook)
proc G_HOOK_FLAGS*(hook: PGHook): guint =
result = hook.flags
proc G_HOOK_ACTIVE*(hook: PGHook): bool =
result = (hook.flags and G_HOOK_FLAG_ACTIVE) != 0'i32
proc G_HOOK_IN_CALL*(hook: PGHook): bool =
result = (hook.flags and G_HOOK_FLAG_IN_CALL) != 0'i32
proc G_HOOK_IS_VALID*(hook: PGHook): bool =
result = (hook.hook_id != 0) and G_HOOK_ACTIVE(hook)
proc G_HOOK_IS_UNLINKED*(hook: PGHook): bool =
result = (hook.next == nil) and (hook.prev == nil) and (hook.hook_id == 0) and
(hook.ref_count == 0'i32)
proc g_hook_append*(hook_list: PGHookList, hook: PGHook) =
g_hook_insert_before(hook_list, nil, hook)
proc G_IO_CHANNEL_ERROR*(): TGQuark =
result = g_io_channel_error_quark()
proc TGIOChannel_use_buffer*(a: var TGIOChannel): guint =
result = (a.flag0 and bm_TGIOChannel_use_buffer) shr
bp_TGIOChannel_use_buffer
proc TGIOChannel_set_use_buffer*(a: var TGIOChannel, `use_buffer`: guint) =
a.flag0 = a.flag0 or
(int16(`use_buffer` shl bp_TGIOChannel_use_buffer) and
bm_TGIOChannel_use_buffer)
proc TGIOChannel_do_encode*(a: var TGIOChannel): guint =
result = (a.flag0 and bm_TGIOChannel_do_encode) shr
bp_TGIOChannel_do_encode
proc TGIOChannel_set_do_encode*(a: var TGIOChannel, `do_encode`: guint) =
a.flag0 = a.flag0 or
(int16(`do_encode` shl bp_TGIOChannel_do_encode) and
bm_TGIOChannel_do_encode)
proc TGIOChannel_close_on_unref*(a: var TGIOChannel): guint =
result = (a.flag0 and bm_TGIOChannel_close_on_unref) shr
bp_TGIOChannel_close_on_unref
proc TGIOChannel_set_close_on_unref*(a: var TGIOChannel, `close_on_unref`: guint) =
a.flag0 = a.flag0 or
(int16(`close_on_unref` shl bp_TGIOChannel_close_on_unref) and
bm_TGIOChannel_close_on_unref)
proc TGIOChannel_is_readable*(a: var TGIOChannel): guint =
result = (a.flag0 and bm_TGIOChannel_is_readable) shr
bp_TGIOChannel_is_readable
proc TGIOChannel_set_is_readable*(a: var TGIOChannel, `is_readable`: guint) =
a.flag0 = a.flag0 or
(int16(`is_readable` shl bp_TGIOChannel_is_readable) and
bm_TGIOChannel_is_readable)
proc TGIOChannel_is_writeable*(a: var TGIOChannel): guint =
result = (a.flag0 and bm_TGIOChannel_is_writeable) shr
bp_TGIOChannel_is_writeable
proc TGIOChannel_set_is_writeable*(a: var TGIOChannel, `is_writeable`: guint) =
a.flag0 = a.flag0 or
(int16(`is_writeable` shl bp_TGIOChannel_is_writeable) and
bm_TGIOChannel_is_writeable)
proc TGIOChannel_is_seekable*(a: var TGIOChannel): guint =
result = (a.flag0 and bm_TGIOChannel_is_seekable) shr
bp_TGIOChannel_is_seekable
proc TGIOChannel_set_is_seekable*(a: var TGIOChannel, `is_seekable`: guint) =
a.flag0 = a.flag0 or
(int16(`is_seekable` shl bp_TGIOChannel_is_seekable) and
bm_TGIOChannel_is_seekable)
proc g_utf8_next_char*(p: pguchar): pguchar =
result = cast[pguchar](cast[TAddress](p) + 1) # p + ord((g_utf8_skip + p^ )^ )
when false:
proc GLIB_CHECK_VERSION*(major, minor, micro: guint): bool =
result = ((GLIB_MAJOR_VERSION > major) or
((GLIB_MAJOR_VERSION == major) and (GLIB_MINOR_VERSION > minor)) or
((GLIB_MAJOR_VERSION == major) and (GLIB_MINOR_VERSION == minor) and
(GLIB_MICRO_VERSION >= micro)))
proc g_error*(format: cstring) =
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format)
proc g_message*(format: cstring) =
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, format)
proc g_critical*(format: cstring) =
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, format)
proc g_warning*(format: cstring) =
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, format)
proc G_MARKUP_ERROR*(): TGQuark =
result = g_markup_error_quark()
proc G_NODE_IS_ROOT*(node: PGNode): bool =
result = (node.parent == nil) and (node.next == nil) and (node.prev == nil)
proc G_NODE_IS_LEAF*(node: PGNode): bool =
result = node.children == nil
proc g_node_append*(parent: PGNode, node: PGNode): PGNode =
result = g_node_insert_before(parent, nil, node)
proc g_node_insert_data*(parent: PGNode, position: gint, data: gpointer): PGNode =
result = g_node_insert(parent, position, g_node_new(data))
proc g_node_insert_data_before*(parent: PGNode, sibling: PGNode, data: gpointer): PGNode =
result = g_node_insert_before(parent, sibling, g_node_new(data))
proc g_node_prepend_data*(parent: PGNode, data: gpointer): PGNode =
result = g_node_prepend(parent, g_node_new(data))
proc g_node_append_data*(parent: PGNode, data: gpointer): PGNode =
result = g_node_insert_before(parent, nil, g_node_new(data))
proc g_node_prev_sibling*(node: PGNode): PGNode =
if node != nil:
result = node.prev
else:
result = nil
proc g_node_next_sibling*(node: PGNode): PGNode =
if node != nil:
result = node.next
else:
result = nil
proc g_node_first_child*(node: PGNode): PGNode =
if node != nil:
result = node.children
else:
result = nil
proc g_rand_boolean*(rand: PGRand): gboolean =
result = (int(g_rand_int(rand)) and (1 shl 15)) != 0
proc g_random_boolean*(): gboolean =
result = (int(g_random_int()) and (1 shl 15)) != 0
proc TGScannerConfig_case_sensitive*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_case_sensitive) shr
bp_TGScannerConfig_case_sensitive
proc TGScannerConfig_set_case_sensitive*(a: var TGScannerConfig,
`case_sensitive`: guint) =
a.flag0 = a.flag0 or
((`case_sensitive` shl bp_TGScannerConfig_case_sensitive) and
bm_TGScannerConfig_case_sensitive)
proc TGScannerConfig_skip_comment_multi*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_skip_comment_multi) shr
bp_TGScannerConfig_skip_comment_multi
proc TGScannerConfig_set_skip_comment_multi*(a: var TGScannerConfig,
`skip_comment_multi`: guint) =
a.flag0 = a.flag0 or
((`skip_comment_multi` shl bp_TGScannerConfig_skip_comment_multi) and
bm_TGScannerConfig_skip_comment_multi)
proc TGScannerConfig_skip_comment_single*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_skip_comment_single) shr
bp_TGScannerConfig_skip_comment_single
proc TGScannerConfig_set_skip_comment_single*(a: var TGScannerConfig,
`skip_comment_single`: guint) =
a.flag0 = a.flag0 or
((`skip_comment_single` shl bp_TGScannerConfig_skip_comment_single) and
bm_TGScannerConfig_skip_comment_single)
proc TGScannerConfig_scan_comment_multi*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_comment_multi) shr
bp_TGScannerConfig_scan_comment_multi
proc TGScannerConfig_set_scan_comment_multi*(a: var TGScannerConfig,
`scan_comment_multi`: guint) =
a.flag0 = a.flag0 or
((`scan_comment_multi` shl bp_TGScannerConfig_scan_comment_multi) and
bm_TGScannerConfig_scan_comment_multi)
proc TGScannerConfig_scan_identifier*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_identifier) shr
bp_TGScannerConfig_scan_identifier
proc TGScannerConfig_set_scan_identifier*(a: var TGScannerConfig,
`scan_identifier`: guint) =
a.flag0 = a.flag0 or
((`scan_identifier` shl bp_TGScannerConfig_scan_identifier) and
bm_TGScannerConfig_scan_identifier)
proc TGScannerConfig_scan_identifier_1char*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_identifier_1char) shr
bp_TGScannerConfig_scan_identifier_1char
proc TGScannerConfig_set_scan_identifier_1char*(a: var TGScannerConfig,
`scan_identifier_1char`: guint) =
a.flag0 = a.flag0 or
((`scan_identifier_1char` shl bp_TGScannerConfig_scan_identifier_1char) and
bm_TGScannerConfig_scan_identifier_1char)
proc TGScannerConfig_scan_identifier_NULL*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_identifier_NULL) shr
bp_TGScannerConfig_scan_identifier_NULL
proc TGScannerConfig_set_scan_identifier_NULL*(a: var TGScannerConfig,
`scan_identifier_NULL`: guint) =
a.flag0 = a.flag0 or
((`scan_identifier_NULL` shl bp_TGScannerConfig_scan_identifier_NULL) and
bm_TGScannerConfig_scan_identifier_NULL)
proc TGScannerConfig_scan_symbols*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_symbols) shr
bp_TGScannerConfig_scan_symbols
proc TGScannerConfig_set_scan_symbols*(a: var TGScannerConfig,
`scan_symbols`: guint) =
a.flag0 = a.flag0 or
((`scan_symbols` shl bp_TGScannerConfig_scan_symbols) and
bm_TGScannerConfig_scan_symbols)
proc TGScannerConfig_scan_binary*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_binary) shr
bp_TGScannerConfig_scan_binary
proc TGScannerConfig_set_scan_binary*(a: var TGScannerConfig,
`scan_binary`: guint) =
a.flag0 = a.flag0 or
((`scan_binary` shl bp_TGScannerConfig_scan_binary) and
bm_TGScannerConfig_scan_binary)
proc TGScannerConfig_scan_octal*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_octal) shr
bp_TGScannerConfig_scan_octal
proc TGScannerConfig_set_scan_octal*(a: var TGScannerConfig, `scan_octal`: guint) =
a.flag0 = a.flag0 or
((`scan_octal` shl bp_TGScannerConfig_scan_octal) and
bm_TGScannerConfig_scan_octal)
proc TGScannerConfig_scan_float*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_float) shr
bp_TGScannerConfig_scan_float
proc TGScannerConfig_set_scan_float*(a: var TGScannerConfig, `scan_float`: guint) =
a.flag0 = a.flag0 or
((`scan_float` shl bp_TGScannerConfig_scan_float) and
bm_TGScannerConfig_scan_float)
proc TGScannerConfig_scan_hex*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_hex) shr
bp_TGScannerConfig_scan_hex
proc TGScannerConfig_set_scan_hex*(a: var TGScannerConfig, `scan_hex`: guint) =
a.flag0 = a.flag0 or
((`scan_hex` shl bp_TGScannerConfig_scan_hex) and
bm_TGScannerConfig_scan_hex)
proc TGScannerConfig_scan_hex_dollar*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_hex_dollar) shr
bp_TGScannerConfig_scan_hex_dollar
proc TGScannerConfig_set_scan_hex_dollar*(a: var TGScannerConfig,
`scan_hex_dollar`: guint) =
a.flag0 = a.flag0 or
((`scan_hex_dollar` shl bp_TGScannerConfig_scan_hex_dollar) and
bm_TGScannerConfig_scan_hex_dollar)
proc TGScannerConfig_scan_string_sq*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_string_sq) shr
bp_TGScannerConfig_scan_string_sq
proc TGScannerConfig_set_scan_string_sq*(a: var TGScannerConfig,
`scan_string_sq`: guint) =
a.flag0 = a.flag0 or
((`scan_string_sq` shl bp_TGScannerConfig_scan_string_sq) and
bm_TGScannerConfig_scan_string_sq)
proc TGScannerConfig_scan_string_dq*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scan_string_dq) shr
bp_TGScannerConfig_scan_string_dq
proc TGScannerConfig_set_scan_string_dq*(a: var TGScannerConfig,
`scan_string_dq`: guint) =
a.flag0 = a.flag0 or
((`scan_string_dq` shl bp_TGScannerConfig_scan_string_dq) and
bm_TGScannerConfig_scan_string_dq)
proc TGScannerConfig_numbers_2_int*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_numbers_2_int) shr
bp_TGScannerConfig_numbers_2_int
proc TGScannerConfig_set_numbers_2_int*(a: var TGScannerConfig,
`numbers_2_int`: guint) =
a.flag0 = a.flag0 or
((`numbers_2_int` shl bp_TGScannerConfig_numbers_2_int) and
bm_TGScannerConfig_numbers_2_int)
proc TGScannerConfig_int_2_float*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_int_2_float) shr
bp_TGScannerConfig_int_2_float
proc TGScannerConfig_set_int_2_float*(a: var TGScannerConfig,
`int_2_float`: guint) =
a.flag0 = a.flag0 or
((`int_2_float` shl bp_TGScannerConfig_int_2_float) and
bm_TGScannerConfig_int_2_float)
proc TGScannerConfig_identifier_2_string*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_identifier_2_string) shr
bp_TGScannerConfig_identifier_2_string
proc TGScannerConfig_set_identifier_2_string*(a: var TGScannerConfig,
`identifier_2_string`: guint) =
a.flag0 = a.flag0 or
((`identifier_2_string` shl bp_TGScannerConfig_identifier_2_string) and
bm_TGScannerConfig_identifier_2_string)
proc TGScannerConfig_char_2_token*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_char_2_token) shr
bp_TGScannerConfig_char_2_token
proc TGScannerConfig_set_char_2_token*(a: var TGScannerConfig,
`char_2_token`: guint) =
a.flag0 = a.flag0 or
((`char_2_token` shl bp_TGScannerConfig_char_2_token) and
bm_TGScannerConfig_char_2_token)
proc TGScannerConfig_symbol_2_token*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_symbol_2_token) shr
bp_TGScannerConfig_symbol_2_token
proc TGScannerConfig_set_symbol_2_token*(a: var TGScannerConfig,
`symbol_2_token`: guint) =
a.flag0 = a.flag0 or
((`symbol_2_token` shl bp_TGScannerConfig_symbol_2_token) and
bm_TGScannerConfig_symbol_2_token)
proc TGScannerConfig_scope_0_fallback*(a: var TGScannerConfig): guint =
result = (a.flag0 and bm_TGScannerConfig_scope_0_fallback) shr
bp_TGScannerConfig_scope_0_fallback
proc TGScannerConfig_set_scope_0_fallback*(a: var TGScannerConfig,
`scope_0_fallback`: guint) =
a.flag0 = a.flag0 or
((`scope_0_fallback` shl bp_TGScannerConfig_scope_0_fallback) and
bm_TGScannerConfig_scope_0_fallback)
proc g_scanner_freeze_symbol_table*(scanner: PGScanner) =
if Scanner == nil: nil
proc g_scanner_thaw_symbol_table*(scanner: PGScanner) =
if Scanner == nil: nil
proc G_SHELL_ERROR*(): TGQuark =
result = g_shell_error_quark()
proc G_SPAWN_ERROR*(): TGQuark =
result = g_spawn_error_quark()
when false:
proc g_ascii_isalnum*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_ALNUM) != 0
proc g_ascii_isalpha*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_ALPHA) != 0
proc g_ascii_iscntrl*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_CNTRL) != 0
proc g_ascii_isdigit*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_DIGIT) != 0
proc g_ascii_isgraph*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_GRAPH) != 0
proc g_ascii_islower*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_LOWER) != 0
proc g_ascii_isprint*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_PRINT) != 0
proc g_ascii_ispunct*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_PUNCT) != 0
proc g_ascii_isspace*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_SPACE) != 0
proc g_ascii_isupper*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_UPPER) != 0
proc g_ascii_isxdigit*(c: gchar): bool =
result = ((g_ascii_table[guchar(c)]) and G_ASCII_XDIGIT) != 0
proc g_strstrip*(str: cstring): cstring =
result = g_strchomp(g_strchug(str))
proc G_TYPE_MAKE_FUNDAMENTAL*(x: int): GType =
result = GType(x shl G_TYPE_FUNDAMENTAL_SHIFT)
proc G_TYPE_IS_FUNDAMENTAL*(theType: GType): bool =
result = theType <= G_TYPE_FUNDAMENTAL_MAX
proc G_TYPE_IS_DERIVED*(theType: GType): bool =
result = theType > G_TYPE_FUNDAMENTAL_MAX
proc G_TYPE_IS_INTERFACE*(theType: GType): bool =
result = (G_TYPE_FUNDAMENTAL(theType)) == G_TYPE_INTERFACE
proc G_TYPE_IS_CLASSED*(theType: GType): gboolean =
result = private_g_type_test_flags(theType, G_TYPE_FLAG_CLASSED)
proc G_TYPE_IS_INSTANTIATABLE*(theType: GType): bool =
result = private_g_type_test_flags(theType, G_TYPE_FLAG_INSTANTIATABLE)
proc G_TYPE_IS_DERIVABLE*(theType: GType): bool =
result = private_g_type_test_flags(theType, G_TYPE_FLAG_DERIVABLE)
proc G_TYPE_IS_DEEP_DERIVABLE*(theType: GType): bool =
result = private_g_type_test_flags(theType, G_TYPE_FLAG_DEEP_DERIVABLE)
proc G_TYPE_IS_ABSTRACT*(theType: GType): bool =
result = private_g_type_test_flags(theType, G_TYPE_FLAG_ABSTRACT)
proc G_TYPE_IS_VALUE_ABSTRACT*(theType: GType): bool =
result = private_g_type_test_flags(theType, G_TYPE_FLAG_VALUE_ABSTRACT)
proc G_TYPE_IS_VALUE_TYPE*(theType: GType): bool =
result = private_g_type_check_is_value_type(theType)
proc G_TYPE_HAS_VALUE_TABLE*(theType: GType): bool =
result = (g_type_value_table_peek(theType)) != nil
proc G_TYPE_CHECK_INSTANCE*(instance: Pointer): gboolean =
result = private_g_type_check_instance(cast[PGTypeInstance](instance))
proc G_TYPE_CHECK_INSTANCE_CAST*(instance: Pointer, g_type: GType): PGTypeInstance =
result = cast[PGTypeInstance](private_g_type_check_instance_cast(
cast[PGTypeInstance](instance), g_type))
proc G_TYPE_CHECK_INSTANCE_TYPE*(instance: Pointer, g_type: GType): bool =
result = private_g_type_check_instance_is_a(cast[PGTypeInstance](instance),
g_type)
proc G_TYPE_INSTANCE_GET_CLASS*(instance: Pointer, g_type: GType): PGTypeClass =
result = cast[PGTypeInstance](Instance).g_class
result = private_g_type_check_class_cast(result, g_type)
proc G_TYPE_INSTANCE_GET_INTERFACE*(instance: Pointer, g_type: GType): Pointer =
result = g_type_interface_peek((cast[PGTypeInstance](instance)).g_class,
g_type)
proc G_TYPE_CHECK_CLASS_CAST*(g_class: pointer, g_type: GType): Pointer =
result = private_g_type_check_class_cast(cast[PGTypeClass](g_class), g_type)
proc G_TYPE_CHECK_CLASS_TYPE*(g_class: pointer, g_type: GType): bool =
result = private_g_type_check_class_is_a(cast[PGTypeClass](g_class), g_type)
proc G_TYPE_CHECK_VALUE*(value: Pointer): bool =
result = private_g_type_check_value(cast[PGValue](Value))
proc G_TYPE_CHECK_VALUE_TYPE*(value: pointer, g_type: GType): bool =
result = private_g_type_check_value_holds(cast[PGValue](value), g_type)
proc G_TYPE_FROM_INSTANCE*(instance: Pointer): GType =
result = G_TYPE_FROM_CLASS((cast[PGTypeInstance](instance)).g_class)
proc G_TYPE_FROM_CLASS*(g_class: Pointer): GType =
result = (cast[PGTypeClass](g_class)).g_type
proc G_TYPE_FROM_INTERFACE*(g_iface: Pointer): GType =
result = (cast[PGTypeInterface](g_iface)).g_type
proc G_TYPE_IS_VALUE*(theType: GType): bool =
result = private_g_type_check_is_value_type(theType)
proc G_IS_VALUE*(value: Pointer): bool =
result = G_TYPE_CHECK_VALUE(value)
proc G_VALUE_TYPE*(value: Pointer): GType =
result = (cast[PGValue](value)).g_type
proc G_VALUE_TYPE_NAME*(value: Pointer): cstring =
result = g_type_name(G_VALUE_TYPE(value))
proc G_VALUE_HOLDS*(value: pointer, g_type: GType): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, g_type)
proc G_TYPE_IS_PARAM*(theType: GType): bool =
result = (G_TYPE_FUNDAMENTAL(theType)) == G_TYPE_PARAM
proc G_PARAM_SPEC*(pspec: Pointer): PGParamSpec =
result = cast[PGParamSpec](G_TYPE_CHECK_INSTANCE_CAST(pspec, G_TYPE_PARAM))
proc G_IS_PARAM_SPEC*(pspec: Pointer): bool =
result = G_TYPE_CHECK_INSTANCE_TYPE(pspec, G_TYPE_PARAM)
proc G_PARAM_SPEC_CLASS*(pclass: Pointer): PGParamSpecClass =
result = cast[PGParamSpecClass](G_TYPE_CHECK_CLASS_CAST(pclass, G_TYPE_PARAM))
proc G_IS_PARAM_SPEC_CLASS*(pclass: Pointer): bool =
result = G_TYPE_CHECK_CLASS_TYPE(pclass, G_TYPE_PARAM)
proc G_PARAM_SPEC_GET_CLASS*(pspec: Pointer): PGParamSpecClass =
result = cast[PGParamSpecClass](G_TYPE_INSTANCE_GET_CLASS(pspec, G_TYPE_PARAM))
proc G_PARAM_SPEC_TYPE*(pspec: Pointer): GType =
result = G_TYPE_FROM_INSTANCE(pspec)
proc G_PARAM_SPEC_TYPE_NAME*(pspec: Pointer): cstring =
result = g_type_name(G_PARAM_SPEC_TYPE(pspec))
proc G_PARAM_SPEC_VALUE_TYPE*(pspec: Pointer): GType =
result = (G_PARAM_SPEC(pspec)).value_type
proc G_VALUE_HOLDS_PARAM*(value: Pointer): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_PARAM)
proc G_CLOSURE_NEEDS_MARSHAL*(closure: Pointer): bool =
result = cast[PGClosure](closure).marshal == nil
proc G_CLOSURE_N_NOTIFIERS*(cl: PGClosure): int32 =
result = ((meta_marshal(cl) + ((n_guards(cl)) shl 1'i32)) +
(n_fnotifiers(cl))) + (n_inotifiers(cl))
proc G_CCLOSURE_SWAP_DATA*(cclosure: PGClosure): int32 =
result = derivative_flag(cclosure)
proc G_CALLBACK*(f: pointer): TGCallback =
result = cast[TGCallback](f)
proc ref_count*(a: var TGClosure): guint =
result = (a.flag0 and bm_TGClosure_ref_count) shr bp_TGClosure_ref_count
proc set_ref_count*(a: var TGClosure, `ref_count`: guint) =
a.flag0 = a.flag0 or
((`ref_count` shl bp_TGClosure_ref_count) and bm_TGClosure_ref_count)
proc meta_marshal*(a: PGClosure): guint =
result = (a.flag0 and bm_TGClosure_meta_marshal) shr
bp_TGClosure_meta_marshal
proc set_meta_marshal*(a: var TGClosure, `meta_marshal`: guint) =
a.flag0 = a.flag0 or
((`meta_marshal` shl bp_TGClosure_meta_marshal) and
bm_TGClosure_meta_marshal)
proc n_guards*(a: PGClosure): guint =
result = (a.flag0 and bm_TGClosure_n_guards) shr bp_TGClosure_n_guards
proc set_n_guards*(a: var TGClosure, `n_guards`: guint) =
a.flag0 = a.flag0 or
((`n_guards` shl bp_TGClosure_n_guards) and bm_TGClosure_n_guards)
proc n_fnotifiers*(a: PGClosure): guint =
result = (a.flag0 and bm_TGClosure_n_fnotifiers) shr
bp_TGClosure_n_fnotifiers
proc set_n_fnotifiers*(a: var TGClosure, `n_fnotifiers`: guint) =
a.flag0 = a.flag0 or
((`n_fnotifiers` shl bp_TGClosure_n_fnotifiers) and
bm_TGClosure_n_fnotifiers)
proc n_inotifiers*(a: PGClosure): guint =
result = (a.flag0 and bm_TGClosure_n_inotifiers) shr
bp_TGClosure_n_inotifiers
proc set_n_inotifiers*(a: var TGClosure, `n_inotifiers`: guint) =
a.flag0 = a.flag0 or
((`n_inotifiers` shl bp_TGClosure_n_inotifiers) and
bm_TGClosure_n_inotifiers)
proc in_inotify*(a: var TGClosure): guint =
result = (a.flag0 and bm_TGClosure_in_inotify) shr bp_TGClosure_in_inotify
proc set_in_inotify*(a: var TGClosure, `in_inotify`: guint) =
a.flag0 = a.flag0 or
((`in_inotify` shl bp_TGClosure_in_inotify) and bm_TGClosure_in_inotify)
proc floating*(a: var TGClosure): guint =
result = (a.flag0 and bm_TGClosure_floating) shr bp_TGClosure_floating
proc set_floating*(a: var TGClosure, `floating`: guint) =
a.flag0 = a.flag0 or
((`floating` shl bp_TGClosure_floating) and bm_TGClosure_floating)
proc derivative_flag*(a: PGClosure): guint =
result = (a.flag0 and bm_TGClosure_derivative_flag) shr
bp_TGClosure_derivative_flag
proc set_derivative_flag*(a: var TGClosure, `derivative_flag`: guint) =
a.flag0 = a.flag0 or
((`derivative_flag` shl bp_TGClosure_derivative_flag) and
bm_TGClosure_derivative_flag)
proc in_marshal*(a: var TGClosure): guint =
result = (a.flag0 and bm_TGClosure_in_marshal) shr bp_TGClosure_in_marshal
proc set_in_marshal*(a: var TGClosure, in_marshal: guint) =
a.flag0 = a.flag0 or
((in_marshal shl bp_TGClosure_in_marshal) and bm_TGClosure_in_marshal)
proc is_invalid*(a: var TGClosure): guint =
result = (a.flag0 and bm_TGClosure_is_invalid) shr bp_TGClosure_is_invalid
proc set_is_invalid*(a: var TGClosure, is_invalid: guint) =
a.flag0 = a.flag0 or
((is_invalid shl bp_TGClosure_is_invalid) and bm_TGClosure_is_invalid)
proc g_signal_connect*(instance: gpointer, detailed_signal: cstring,
c_handler: TGCallback, data: gpointer): gulong =
result = g_signal_connect_data(instance, detailed_signal, c_handler, data,
nil, TGConnectFlags(0))
proc g_signal_connect_after*(instance: gpointer, detailed_signal: cstring,
c_handler: TGCallback, data: gpointer): gulong =
result = g_signal_connect_data(instance, detailed_signal, c_handler, data,
nil, G_CONNECT_AFTER)
proc g_signal_connect_swapped*(instance: gpointer, detailed_signal: cstring,
c_handler: TGCallback, data: gpointer): gulong =
result = g_signal_connect_data(instance, detailed_signal, c_handler, data,
nil, G_CONNECT_SWAPPED)
proc g_signal_handlers_disconnect_by_func*(instance: gpointer,
func, data: gpointer): guint =
result = g_signal_handlers_disconnect_matched(instance,
TGSignalMatchType(G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0, 0, nil,
func, data)
proc g_signal_handlers_block_by_func*(instance: gpointer, func, data: gpointer) =
discard g_signal_handlers_block_matched(instance,
TGSignalMatchType(G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0, 0, nil,
func, data)
proc g_signal_handlers_unblock_by_func*(instance: gpointer, func, data: gpointer) =
discard g_signal_handlers_unblock_matched(instance,
TGSignalMatchType(G_SIGNAL_MATCH_FUNC or G_SIGNAL_MATCH_DATA), 0, 0, nil,
func, data)
proc G_TYPE_IS_OBJECT*(theType: GType): bool =
result = (G_TYPE_FUNDAMENTAL(theType)) == G_TYPE_OBJECT
proc G_OBJECT*(anObject: pointer): PGObject =
result = cast[PGObject](G_TYPE_CHECK_INSTANCE_CAST(anObject, G_TYPE_OBJECT))
proc G_OBJECT_CLASS*(class: Pointer): PGObjectClass =
result = cast[PGObjectClass](G_TYPE_CHECK_CLASS_CAST(class, G_TYPE_OBJECT))
proc G_IS_OBJECT*(anObject: pointer): bool =
result = G_TYPE_CHECK_INSTANCE_TYPE(anObject, G_TYPE_OBJECT)
proc G_IS_OBJECT_CLASS*(class: Pointer): bool =
result = G_TYPE_CHECK_CLASS_TYPE(class, G_TYPE_OBJECT)
proc G_OBJECT_GET_CLASS*(anObject: pointer): PGObjectClass =
result = cast[PGObjectClass](G_TYPE_INSTANCE_GET_CLASS(anObject, G_TYPE_OBJECT))
proc G_OBJECT_TYPE*(anObject: pointer): GType =
result = G_TYPE_FROM_INSTANCE(anObject)
proc G_OBJECT_TYPE_NAME*(anObject: pointer): cstring =
result = g_type_name(G_OBJECT_TYPE(anObject))
proc G_OBJECT_CLASS_TYPE*(class: Pointer): GType =
result = G_TYPE_FROM_CLASS(class)
proc G_OBJECT_CLASS_NAME*(class: Pointer): cstring =
result = g_type_name(G_OBJECT_CLASS_TYPE(class))
proc G_VALUE_HOLDS_OBJECT*(value: Pointer): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_OBJECT)
proc G_OBJECT_WARN_INVALID_PROPERTY_ID*(anObject: gpointer, property_id: gint,
pspec: gpointer) =
G_OBJECT_WARN_INVALID_PSPEC(anObject, "property", property_id, pspec)
proc G_OBJECT_WARN_INVALID_PSPEC*(anObject: gpointer, pname: cstring,
property_id: gint, pspec: gpointer) =
var
theObject: PGObject
pspec2: PGParamSpec
property_id: guint
theObject = cast[PGObject](anObject)
pspec2 = cast[PGParamSpec](pspec)
property_id = (property_id)
write(stdout, "invalid thingy\x0A")
#g_warning("%s: invalid %s id %u for \"%s\" of type `%s\' in `%s\'", "", pname,
# `property_id`, `pspec` . name,
# g_type_name(G_PARAM_SPEC_TYPE(`pspec`)),
# G_OBJECT_TYPE_NAME(theobject))
proc G_TYPE_TYPE_PLUGIN*(): GType =
result = g_type_plugin_get_type()
proc G_TYPE_PLUGIN*(inst: Pointer): PGTypePlugin =
result = PGTypePlugin(G_TYPE_CHECK_INSTANCE_CAST(inst, G_TYPE_TYPE_PLUGIN()))
proc G_TYPE_PLUGIN_CLASS*(vtable: Pointer): PGTypePluginClass =
result = cast[PGTypePluginClass](G_TYPE_CHECK_CLASS_CAST(vtable,
G_TYPE_TYPE_PLUGIN()))
proc G_IS_TYPE_PLUGIN*(inst: Pointer): bool =
result = G_TYPE_CHECK_INSTANCE_TYPE(inst, G_TYPE_TYPE_PLUGIN())
proc G_IS_TYPE_PLUGIN_CLASS*(vtable: Pointer): bool =
result = G_TYPE_CHECK_CLASS_TYPE(vtable, G_TYPE_TYPE_PLUGIN())
proc G_TYPE_PLUGIN_GET_CLASS*(inst: Pointer): PGTypePluginClass =
result = cast[PGTypePluginClass](G_TYPE_INSTANCE_GET_INTERFACE(inst,
G_TYPE_TYPE_PLUGIN()))
proc G_TYPE_IS_ENUM*(theType: GType): gboolean =
result = (G_TYPE_FUNDAMENTAL(theType) == G_TYPE_ENUM)
proc G_ENUM_CLASS*(class: pointer): PGEnumClass =
result = cast[PGEnumClass](G_TYPE_CHECK_CLASS_CAST(class, G_TYPE_ENUM))
proc G_IS_ENUM_CLASS*(class: pointer): gboolean =
result = G_TYPE_CHECK_CLASS_TYPE(class, G_TYPE_ENUM)
proc G_ENUM_CLASS_TYPE*(class: pointer): GType =
result = G_TYPE_FROM_CLASS(class)
proc G_ENUM_CLASS_TYPE_NAME*(class: pointer): cstring =
result = g_type_name(G_ENUM_CLASS_TYPE(class))
proc G_TYPE_IS_FLAGS*(theType: GType): gboolean =
result = (G_TYPE_FUNDAMENTAL(theType)) == G_TYPE_FLAGS
proc G_FLAGS_CLASS*(class: pointer): PGFlagsClass =
result = cast[PGFlagsClass](G_TYPE_CHECK_CLASS_CAST(class, G_TYPE_FLAGS))
proc G_IS_FLAGS_CLASS*(class: pointer): gboolean =
result = G_TYPE_CHECK_CLASS_TYPE(class, G_TYPE_FLAGS)
proc G_FLAGS_CLASS_TYPE*(class: pointer): GType =
result = G_TYPE_FROM_CLASS(class)
proc G_FLAGS_CLASS_TYPE_NAME*(class: pointer): cstring =
result = g_type_name(G_FLAGS_TYPE(cast[TAddress](class)))
proc G_VALUE_HOLDS_ENUM*(value: pointer): gboolean =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_ENUM)
proc G_VALUE_HOLDS_FLAGS*(value: pointer): gboolean =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_FLAGS)
proc CLAMP*(x, MinX, MaxX: int): int =
if x < MinX:
result = MinX
elif x > MaxX:
result = MaxX
else:
result = x
proc GPOINTER_TO_SIZE*(p: GPointer): GSize =
result = GSize(cast[TAddress](p))
proc GSIZE_TO_POINTER*(s: GSize): GPointer =
result = cast[GPointer](s)
proc G_VALUE_HOLDS_CHAR*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_CHAR)
proc G_VALUE_HOLDS_UCHAR*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_UCHAR)
proc G_VALUE_HOLDS_BOOLEAN*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_BOOLEAN)
proc G_VALUE_HOLDS_INT*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_INT)
proc G_VALUE_HOLDS_UINT*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_UINT)
proc G_VALUE_HOLDS_LONG*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_LONG)
proc G_VALUE_HOLDS_ULONG*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_ULONG)
proc G_VALUE_HOLDS_INT64*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_INT64)
proc G_VALUE_HOLDS_UINT64*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_UINT64)
proc G_VALUE_HOLDS_FLOAT*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_FLOAT)
proc G_VALUE_HOLDS_DOUBLE*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_DOUBLE)
proc G_VALUE_HOLDS_STRING*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_STRING)
proc G_VALUE_HOLDS_POINTER*(value: PGValue): bool =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_POINTER)
proc G_TYPE_IS_BOXED*(theType: GType): gboolean =
result = (G_TYPE_FUNDAMENTAL(theType)) == G_TYPE_BOXED
proc G_VALUE_HOLDS_BOXED*(value: PGValue): gboolean =
result = G_TYPE_CHECK_VALUE_TYPE(value, G_TYPE_BOXED)
proc G_TYPE_CLOSURE*(): GType =
result = g_closure_get_type()
proc G_TYPE_VALUE*(): GType =
result = g_value_get_type()
proc G_TYPE_VALUE_ARRAY*(): GType =
result = g_value_array_get_type()
proc G_TYPE_GSTRING*(): GType =
result = g_gstring_get_type()