diff options
Diffstat (limited to 'lib/newwrap/gtk/glib2.nim')
| -rw-r--r-- | lib/newwrap/gtk/glib2.nim | 4500 |
1 files changed, 4500 insertions, 0 deletions
diff --git a/lib/newwrap/gtk/glib2.nim b/lib/newwrap/gtk/glib2.nim new file mode 100644 index 000000000..0f1d45340 --- /dev/null +++ b/lib/newwrap/gtk/glib2.nim @@ -0,0 +1,4500 @@ +{.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() |