{ This is an autogenerated unit using gobject introspection (gir2pascal). Do not Edit. }
unit uGLib2;

{$MODE OBJFPC}{$H+}

{$PACKRECORDS C}
{$MODESWITCH DUPLICATELOCALS+}

{$LINKLIB libglib-2.0.so.0}
{$LINKLIB libgobject-2.0.so.0}
interface
uses
  CTypes;

const
  GLib2_library = 'libglib-2.0.so.0';

  ASCII_DTOSTR_BUF_SIZE = 39;
  BIG_ENDIAN = 4321;
  CAN_INLINE = 1;
  CSET_A_2_Z_UPPER = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  CSET_DIGITS = '0123456789';
  CSET_a_2_z_lower = 'abcdefghijklmnopqrstuvwxyz';
  DATALIST_FLAGS_MASK = 3;
  DATE_BAD_DAY = 0;
  DATE_BAD_JULIAN = 0;
  DATE_BAD_YEAR = 0;
  DIR_SEPARATOR = 92;
  DIR_SEPARATOR_S = '\';
  E = 2.718282;
  GINT16_FORMAT = 'hi';
  GINT16_MODIFIER = 'h';
  GINT32_FORMAT = 'i';
  GINT32_MODIFIER = '';
  GINT64_FORMAT = 'li';
  GINT64_MODIFIER = 'l';
  GINTPTR_FORMAT = 'li';
  GINTPTR_MODIFIER = 'l';
  GNUC_FUNCTION = '';
  GNUC_PRETTY_FUNCTION = '';
  GSIZE_FORMAT = 'lu';
  GSIZE_MODIFIER = 'l';
  GSSIZE_FORMAT = 'li';
  GUINT16_FORMAT = 'hu';
  GUINT32_FORMAT = 'u';
  GUINT64_FORMAT = 'lu';
  GUINTPTR_FORMAT = 'lu';
  HAVE_GINT64 = 1;
  HAVE_GNUC_VARARGS = 1;
  HAVE_GNUC_VISIBILITY = 1;
  HAVE_GROWING_STACK = 1;
  HAVE_INLINE = 1;
  HAVE_ISO_VARARGS = 1;
  HAVE___INLINE = 1;
  HAVE___INLINE__ = 1;
  HOOK_FLAG_USER_SHIFT = 4;
  IEEE754_DOUBLE_BIAS = 1023;
  IEEE754_FLOAT_BIAS = 127;
  KEY_FILE_DESKTOP_GROUP = 'Desktop Entry';
  KEY_FILE_DESKTOP_KEY_CATEGORIES = 'Categories';
  KEY_FILE_DESKTOP_KEY_COMMENT = 'Comment';
  KEY_FILE_DESKTOP_KEY_EXEC = 'Exec';
  KEY_FILE_DESKTOP_KEY_FULLNAME = 'X-GNOME-FullName';
  KEY_FILE_DESKTOP_KEY_GENERIC_NAME = 'GenericName';
  KEY_FILE_DESKTOP_KEY_GETTEXT_DOMAIN = 'X-GNOME-Gettext-Domain';
  KEY_FILE_DESKTOP_KEY_HIDDEN = 'Hidden';
  KEY_FILE_DESKTOP_KEY_ICON = 'Icon';
  KEY_FILE_DESKTOP_KEY_KEYWORDS = 'Keywords';
  KEY_FILE_DESKTOP_KEY_MIME_TYPE = 'MimeType';
  KEY_FILE_DESKTOP_KEY_NAME = 'Name';
  KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN = 'NotShowIn';
  KEY_FILE_DESKTOP_KEY_NO_DISPLAY = 'NoDisplay';
  KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN = 'OnlyShowIn';
  KEY_FILE_DESKTOP_KEY_PATH = 'Path';
  KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY = 'StartupNotify';
  KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS = 'StartupWMClass';
  KEY_FILE_DESKTOP_KEY_TERMINAL = 'Terminal';
  KEY_FILE_DESKTOP_KEY_TRY_EXEC = 'TryExec';
  KEY_FILE_DESKTOP_KEY_TYPE = 'Type';
  KEY_FILE_DESKTOP_KEY_URL = 'URL';
  KEY_FILE_DESKTOP_KEY_VERSION = 'Version';
  KEY_FILE_DESKTOP_TYPE_APPLICATION = 'Application';
  KEY_FILE_DESKTOP_TYPE_DIRECTORY = 'Directory';
  KEY_FILE_DESKTOP_TYPE_LINK = 'Link';
  LITTLE_ENDIAN = 1234;
  LN10 = 2.302585;
  LN2 = 0.693147;
  LOG_2_BASE_10 = 0.301030;
  LOG_DOMAIN = 0;
  LOG_FATAL_MASK = 0;
  LOG_LEVEL_USER_SHIFT = 8;
  MAJOR_VERSION = 2;
  MAXINT16 = 32767;
  MAXINT32 = 2147483647;
  MAXINT64 = 9223372036854775807;
  MAXINT8 = 127;
  MAXUINT16 = 65535;
  MAXUINT32 = 4294967295;
  MAXUINT64 = 18446744073709551615;
  MAXUINT8 = 255;
  MICRO_VERSION = 1;
  MININT16 = 32768;
  MININT32 = 2147483648;
  MININT64 = -9223372036854775808;
  MININT8 = 128;
  MINOR_VERSION = 36;
  MODULE_SUFFIX = 'so';
  OPTION_REMAINING = '';
  PDP_ENDIAN = 3412;
  PI = 3.141593;
  PI_2 = 1.570796;
  PI_4 = 0.785398;
  POLLFD_FORMAT = '%#I64x';
  PRIORITY_DEFAULT = 0;
  PRIORITY_DEFAULT_IDLE = 200;
  PRIORITY_HIGH = -100;
  PRIORITY_HIGH_IDLE = 100;
  PRIORITY_LOW = 300;
  SEARCHPATH_SEPARATOR = 59;
  SEARCHPATH_SEPARATOR_S = ';';
  SIZEOF_LONG = 8;
  SIZEOF_SIZE_T = 8;
  SIZEOF_VOID_P = 8;
  SQRT2 = 1.414214;
  STR_DELIMITERS = '_-|> <.';
  SYSDEF_AF_INET = 2;
  SYSDEF_AF_INET6 = 10;
  SYSDEF_AF_UNIX = 1;
  SYSDEF_MSG_DONTROUTE = 4;
  SYSDEF_MSG_OOB = 1;
  SYSDEF_MSG_PEEK = 2;
  TIME_SPAN_DAY = 86400000000;
  TIME_SPAN_HOUR = 3600000000;
  TIME_SPAN_MILLISECOND = 1000;
  TIME_SPAN_MINUTE = 60000000;
  TIME_SPAN_SECOND = 1000000;
  UNICHAR_MAX_DECOMPOSITION_LENGTH = 18;
  URI_RESERVED_CHARS_GENERIC_DELIMITERS = ':/?#[]@';
  URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS = '!$&''()*+,;=';
  USEC_PER_SEC = 1000000;
  VA_COPY_AS_ARRAY = 1;
  VERSION_MIN_REQUIRED = 2;
  WIN32_MSG_HANDLE = 19981206;

type
  TGAsciiType = Integer;
const
  { GAsciiType }
  G_ASCII_ALNUM: TGAsciiType = 1;
  G_ASCII_ALPHA: TGAsciiType = 2;
  G_ASCII_CNTRL: TGAsciiType = 4;
  G_ASCII_DIGIT: TGAsciiType = 8;
  G_ASCII_GRAPH: TGAsciiType = 16;
  G_ASCII_LOWER: TGAsciiType = 32;
  G_ASCII_PRINT: TGAsciiType = 64;
  G_ASCII_PUNCT: TGAsciiType = 128;
  G_ASCII_SPACE: TGAsciiType = 256;
  G_ASCII_UPPER: TGAsciiType = 512;
  G_ASCII_XDIGIT: TGAsciiType = 1024;

type
  TGBookmarkFileError = Integer;
const
  { GBookmarkFileError }
  G_BOOKMARK_FILE_ERROR_INVALID_URI: TGBookmarkFileError = 0;
  G_BOOKMARK_FILE_ERROR_INVALID_VALUE: TGBookmarkFileError = 1;
  G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED: TGBookmarkFileError = 2;
  G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND: TGBookmarkFileError = 3;
  G_BOOKMARK_FILE_ERROR_READ: TGBookmarkFileError = 4;
  G_BOOKMARK_FILE_ERROR_UNKNOWN_ENCODING: TGBookmarkFileError = 5;
  G_BOOKMARK_FILE_ERROR_WRITE: TGBookmarkFileError = 6;
  G_BOOKMARK_FILE_ERROR_FILE_NOT_FOUND: TGBookmarkFileError = 7;

type
  TGChecksumType = Integer;
const
  { GChecksumType }
  G_CHECKSUM_MD5: TGChecksumType = 0;
  G_CHECKSUM_SHA1: TGChecksumType = 1;
  G_CHECKSUM_SHA256: TGChecksumType = 2;
  G_CHECKSUM_SHA512: TGChecksumType = 3;

type
  TGConvertError = Integer;
const
  { GConvertError }
  G_CONVERT_ERROR_NO_CONVERSION: TGConvertError = 0;
  G_CONVERT_ERROR_ILLEGAL_SEQUENCE: TGConvertError = 1;
  G_CONVERT_ERROR_FAILED: TGConvertError = 2;
  G_CONVERT_ERROR_PARTIAL_INPUT: TGConvertError = 3;
  G_CONVERT_ERROR_BAD_URI: TGConvertError = 4;
  G_CONVERT_ERROR_NOT_ABSOLUTE_PATH: TGConvertError = 5;

type
  TGDateMonth = Integer;
const
  { GDateMonth }
  G_DATE_BAD_MONTH: TGDateMonth = 0;
  G_DATE_JANUARY: TGDateMonth = 1;
  G_DATE_FEBRUARY: TGDateMonth = 2;
  G_DATE_MARCH: TGDateMonth = 3;
  G_DATE_APRIL: TGDateMonth = 4;
  G_DATE_MAY: TGDateMonth = 5;
  G_DATE_JUNE: TGDateMonth = 6;
  G_DATE_JULY: TGDateMonth = 7;
  G_DATE_AUGUST: TGDateMonth = 8;
  G_DATE_SEPTEMBER: TGDateMonth = 9;
  G_DATE_OCTOBER: TGDateMonth = 10;
  G_DATE_NOVEMBER: TGDateMonth = 11;
  G_DATE_DECEMBER: TGDateMonth = 12;

type
  TGDateWeekday = Integer;
const
  { GDateWeekday }
  G_DATE_BAD_WEEKDAY: TGDateWeekday = 0;
  G_DATE_MONDAY: TGDateWeekday = 1;
  G_DATE_TUESDAY: TGDateWeekday = 2;
  G_DATE_WEDNESDAY: TGDateWeekday = 3;
  G_DATE_THURSDAY: TGDateWeekday = 4;
  G_DATE_FRIDAY: TGDateWeekday = 5;
  G_DATE_SATURDAY: TGDateWeekday = 6;
  G_DATE_SUNDAY: TGDateWeekday = 7;

type
  TGDateDMY = Integer;
const
  { GDateDMY }
  G_DATE_DAY: TGDateDMY = 0;
  G_DATE_MONTH: TGDateDMY = 1;
  G_DATE_YEAR: TGDateDMY = 2;

type
  TGTimeType = Integer;
const
  { GTimeType }
  G_TIME_TYPE_STANDARD: TGTimeType = 0;
  G_TIME_TYPE_DAYLIGHT: TGTimeType = 1;
  G_TIME_TYPE_UNIVERSAL: TGTimeType = 2;

type
  TGErrorType = Integer;
const
  { GErrorType }
  G_ERR_UNKNOWN: TGErrorType = 0;
  G_ERR_UNEXP_EOF: TGErrorType = 1;
  G_ERR_UNEXP_EOF_IN_STRING: TGErrorType = 2;
  G_ERR_UNEXP_EOF_IN_COMMENT: TGErrorType = 3;
  G_ERR_NON_DIGIT_IN_CONST: TGErrorType = 4;
  G_ERR_DIGIT_RADIX: TGErrorType = 5;
  G_ERR_FLOAT_RADIX: TGErrorType = 6;
  G_ERR_FLOAT_MALFORMED: TGErrorType = 7;

type
  TGFileError = Integer;
const
  { GFileError }
  G_FILE_ERROR_EXIST: TGFileError = 0;
  G_FILE_ERROR_ISDIR: TGFileError = 1;
  G_FILE_ERROR_ACCES: TGFileError = 2;
  G_FILE_ERROR_NAMETOOLONG: TGFileError = 3;
  G_FILE_ERROR_NOENT: TGFileError = 4;
  G_FILE_ERROR_NOTDIR: TGFileError = 5;
  G_FILE_ERROR_NXIO: TGFileError = 6;
  G_FILE_ERROR_NODEV: TGFileError = 7;
  G_FILE_ERROR_ROFS: TGFileError = 8;
  G_FILE_ERROR_TXTBSY: TGFileError = 9;
  G_FILE_ERROR_FAULT: TGFileError = 10;
  G_FILE_ERROR_LOOP: TGFileError = 11;
  G_FILE_ERROR_NOSPC: TGFileError = 12;
  G_FILE_ERROR_NOMEM: TGFileError = 13;
  G_FILE_ERROR_MFILE: TGFileError = 14;
  G_FILE_ERROR_NFILE: TGFileError = 15;
  G_FILE_ERROR_BADF: TGFileError = 16;
  G_FILE_ERROR_INVAL: TGFileError = 17;
  G_FILE_ERROR_PIPE: TGFileError = 18;
  G_FILE_ERROR_AGAIN: TGFileError = 19;
  G_FILE_ERROR_INTR: TGFileError = 20;
  G_FILE_ERROR_IO: TGFileError = 21;
  G_FILE_ERROR_PERM: TGFileError = 22;
  G_FILE_ERROR_NOSYS: TGFileError = 23;
  G_FILE_ERROR_FAILED: TGFileError = 24;

type
  TGFileTest = Integer;
const
  { GFileTest }
  G_FILE_TEST_IS_REGULAR: TGFileTest = 1;
  G_FILE_TEST_IS_SYMLINK: TGFileTest = 2;
  G_FILE_TEST_IS_DIR: TGFileTest = 4;
  G_FILE_TEST_IS_EXECUTABLE: TGFileTest = 8;
  G_FILE_TEST_EXISTS: TGFileTest = 16;

type
  TGFormatSizeFlags = Integer;
const
  { GFormatSizeFlags }
  G_FORMAT_SIZE_DEFAULT: TGFormatSizeFlags = 0;
  G_FORMAT_SIZE_LONG_FORMAT: TGFormatSizeFlags = 1;
  G_FORMAT_SIZE_IEC_UNITS: TGFormatSizeFlags = 2;

type
  TGHookFlagMask = Integer;
const
  { GHookFlagMask }
  G_HOOK_FLAG_ACTIVE: TGHookFlagMask = 1;
  G_HOOK_FLAG_IN_CALL: TGHookFlagMask = 2;
  G_HOOK_FLAG_MASK: TGHookFlagMask = 15;

type
  TGSeekType = Integer;
const
  { GSeekType }
  G_SEEK_CUR: TGSeekType = 0;
  G_SEEK_SET: TGSeekType = 1;
  G_SEEK_END: TGSeekType = 2;

type
  TGIOCondition = Integer;
const
  { GIOCondition }
  G_IO_IN: TGIOCondition = 1;
  G_IO_OUT: TGIOCondition = 4;
  G_IO_PRI: TGIOCondition = 2;
  G_IO_ERR: TGIOCondition = 8;
  G_IO_HUP: TGIOCondition = 16;
  G_IO_NVAL: TGIOCondition = 32;

type
  TGIOFlags = Integer;
const
  { GIOFlags }
  G_IO_FLAG_APPEND: TGIOFlags = 1;
  G_IO_FLAG_NONBLOCK: TGIOFlags = 2;
  G_IO_FLAG_IS_READABLE: TGIOFlags = 4;
  G_IO_FLAG_IS_WRITABLE: TGIOFlags = 8;
  G_IO_FLAG_IS_WRITEABLE: TGIOFlags = 8;
  G_IO_FLAG_IS_SEEKABLE: TGIOFlags = 16;
  G_IO_FLAG_MASK: TGIOFlags = 31;
  G_IO_FLAG_GET_MASK: TGIOFlags = 31;
  G_IO_FLAG_SET_MASK: TGIOFlags = 3;

type
  TGIOStatus = Integer;
const
  { GIOStatus }
  G_IO_STATUS_ERROR: TGIOStatus = 0;
  G_IO_STATUS_NORMAL: TGIOStatus = 1;
  G_IO_STATUS_EOF: TGIOStatus = 2;
  G_IO_STATUS_AGAIN: TGIOStatus = 3;

type
  TGIOError = Integer;
const
  { GIOError }
  G_IO_ERROR_NONE: TGIOError = 0;
  G_IO_ERROR_AGAIN: TGIOError = 1;
  G_IO_ERROR_INVAL: TGIOError = 2;
  G_IO_ERROR_UNKNOWN: TGIOError = 3;

type
  TGIOChannelError = Integer;
const
  { GIOChannelError }
  G_IO_CHANNEL_ERROR_FBIG: TGIOChannelError = 0;
  G_IO_CHANNEL_ERROR_INVAL: TGIOChannelError = 1;
  G_IO_CHANNEL_ERROR_IO: TGIOChannelError = 2;
  G_IO_CHANNEL_ERROR_ISDIR: TGIOChannelError = 3;
  G_IO_CHANNEL_ERROR_NOSPC: TGIOChannelError = 4;
  G_IO_CHANNEL_ERROR_NXIO: TGIOChannelError = 5;
  G_IO_CHANNEL_ERROR_OVERFLOW: TGIOChannelError = 6;
  G_IO_CHANNEL_ERROR_PIPE: TGIOChannelError = 7;
  G_IO_CHANNEL_ERROR_FAILED: TGIOChannelError = 8;

type
  TGKeyFileFlags = Integer;
const
  { GKeyFileFlags }
  G_KEY_FILE_NONE: TGKeyFileFlags = 0;
  G_KEY_FILE_KEEP_COMMENTS: TGKeyFileFlags = 1;
  G_KEY_FILE_KEEP_TRANSLATIONS: TGKeyFileFlags = 2;

type
  TGKeyFileError = Integer;
const
  { GKeyFileError }
  G_KEY_FILE_ERROR_UNKNOWN_ENCODING: TGKeyFileError = 0;
  G_KEY_FILE_ERROR_PARSE: TGKeyFileError = 1;
  G_KEY_FILE_ERROR_NOT_FOUND: TGKeyFileError = 2;
  G_KEY_FILE_ERROR_KEY_NOT_FOUND: TGKeyFileError = 3;
  G_KEY_FILE_ERROR_GROUP_NOT_FOUND: TGKeyFileError = 4;
  G_KEY_FILE_ERROR_INVALID_VALUE: TGKeyFileError = 5;

type
  TGLogLevelFlags = Integer;
const
  { GLogLevelFlags }
  G_LOG_FLAG_RECURSION: TGLogLevelFlags = 1;
  G_LOG_FLAG_FATAL: TGLogLevelFlags = 2;
  G_LOG_LEVEL_ERROR: TGLogLevelFlags = 4;
  G_LOG_LEVEL_CRITICAL: TGLogLevelFlags = 8;
  G_LOG_LEVEL_WARNING: TGLogLevelFlags = 16;
  G_LOG_LEVEL_MESSAGE: TGLogLevelFlags = 32;
  G_LOG_LEVEL_INFO: TGLogLevelFlags = 64;
  G_LOG_LEVEL_DEBUG: TGLogLevelFlags = 128;
  G_LOG_LEVEL_MASK: TGLogLevelFlags = -4;

type
  TGMarkupCollectType = Integer;
const
  { GMarkupCollectType }
  G_MARKUP_COLLECT_INVALID: TGMarkupCollectType = 0;
  G_MARKUP_COLLECT_STRING: TGMarkupCollectType = 1;
  G_MARKUP_COLLECT_STRDUP: TGMarkupCollectType = 2;
  G_MARKUP_COLLECT_BOOLEAN: TGMarkupCollectType = 3;
  G_MARKUP_COLLECT_TRISTATE: TGMarkupCollectType = 4;
  G_MARKUP_COLLECT_OPTIONAL: TGMarkupCollectType = 65536;

type
  TGMarkupError = Integer;
const
  { GMarkupError }
  G_MARKUP_ERROR_BAD_UTF8: TGMarkupError = 0;
  G_MARKUP_ERROR_EMPTY: TGMarkupError = 1;
  G_MARKUP_ERROR_PARSE: TGMarkupError = 2;
  G_MARKUP_ERROR_UNKNOWN_ELEMENT: TGMarkupError = 3;
  G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE: TGMarkupError = 4;
  G_MARKUP_ERROR_INVALID_CONTENT: TGMarkupError = 5;
  G_MARKUP_ERROR_MISSING_ATTRIBUTE: TGMarkupError = 6;

type
  TGMarkupParseFlags = Integer;
const
  { GMarkupParseFlags }
  G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG: TGMarkupParseFlags = 1;
  G_MARKUP_TREAT_CDATA_AS_TEXT: TGMarkupParseFlags = 2;
  G_MARKUP_PREFIX_ERROR_POSITION: TGMarkupParseFlags = 4;

type
  TGRegexCompileFlags = Integer;
const
  { GRegexCompileFlags }
  G_REGEX_CASELESS: TGRegexCompileFlags = 1;
  G_REGEX_MULTILINE: TGRegexCompileFlags = 2;
  G_REGEX_DOTALL: TGRegexCompileFlags = 4;
  G_REGEX_EXTENDED: TGRegexCompileFlags = 8;
  G_REGEX_ANCHORED: TGRegexCompileFlags = 16;
  G_REGEX_DOLLAR_ENDONLY: TGRegexCompileFlags = 32;
  G_REGEX_UNGREEDY: TGRegexCompileFlags = 512;
  G_REGEX_RAW: TGRegexCompileFlags = 2048;
  G_REGEX_NO_AUTO_CAPTURE: TGRegexCompileFlags = 4096;
  G_REGEX_OPTIMIZE: TGRegexCompileFlags = 8192;
  G_REGEX_FIRSTLINE: TGRegexCompileFlags = 262144;
  G_REGEX_DUPNAMES: TGRegexCompileFlags = 524288;
  G_REGEX_NEWLINE_CR: TGRegexCompileFlags = 1048576;
  G_REGEX_NEWLINE_LF: TGRegexCompileFlags = 2097152;
  G_REGEX_NEWLINE_CRLF: TGRegexCompileFlags = 3145728;
  G_REGEX_NEWLINE_ANYCRLF: TGRegexCompileFlags = 5242880;
  G_REGEX_BSR_ANYCRLF: TGRegexCompileFlags = 8388608;
  G_REGEX_JAVASCRIPT_COMPAT: TGRegexCompileFlags = 33554432;

type
  TGRegexMatchFlags = Integer;
const
  { GRegexMatchFlags }
  G_REGEX_MATCH_ANCHORED: TGRegexMatchFlags = 16;
  G_REGEX_MATCH_NOTBOL: TGRegexMatchFlags = 128;
  G_REGEX_MATCH_NOTEOL: TGRegexMatchFlags = 256;
  G_REGEX_MATCH_NOTEMPTY: TGRegexMatchFlags = 1024;
  G_REGEX_MATCH_PARTIAL: TGRegexMatchFlags = 32768;
  G_REGEX_MATCH_NEWLINE_CR: TGRegexMatchFlags = 1048576;
  G_REGEX_MATCH_NEWLINE_LF: TGRegexMatchFlags = 2097152;
  G_REGEX_MATCH_NEWLINE_CRLF: TGRegexMatchFlags = 3145728;
  G_REGEX_MATCH_NEWLINE_ANY: TGRegexMatchFlags = 4194304;
  G_REGEX_MATCH_NEWLINE_ANYCRLF: TGRegexMatchFlags = 5242880;
  G_REGEX_MATCH_BSR_ANYCRLF: TGRegexMatchFlags = 8388608;
  G_REGEX_MATCH_BSR_ANY: TGRegexMatchFlags = 16777216;
  G_REGEX_MATCH_PARTIAL_SOFT: TGRegexMatchFlags = 32768;
  G_REGEX_MATCH_PARTIAL_HARD: TGRegexMatchFlags = 134217728;
  G_REGEX_MATCH_NOTEMPTY_ATSTART: TGRegexMatchFlags = 268435456;

type
  TGTraverseFlags = Integer;
const
  { GTraverseFlags }
  G_TRAVERSE_LEAVES: TGTraverseFlags = 1;
  G_TRAVERSE_NON_LEAVES: TGTraverseFlags = 2;
  G_TRAVERSE_ALL: TGTraverseFlags = 3;
  G_TRAVERSE_MASK: TGTraverseFlags = 3;
  G_TRAVERSE_LEAFS: TGTraverseFlags = 1;
  G_TRAVERSE_NON_LEAFS: TGTraverseFlags = 2;

type
  TGTraverseType = Integer;
const
  { GTraverseType }
  G_IN_ORDER: TGTraverseType = 0;
  G_PRE_ORDER: TGTraverseType = 1;
  G_POST_ORDER: TGTraverseType = 2;
  G_LEVEL_ORDER: TGTraverseType = 3;

type
  TGNormalizeMode = Integer;
const
  { GNormalizeMode }
  G_NORMALIZE_DEFAULT: TGNormalizeMode = 0;
  G_NORMALIZE_NFD: TGNormalizeMode = 0;
  G_NORMALIZE_DEFAULT_COMPOSE: TGNormalizeMode = 1;
  G_NORMALIZE_NFC: TGNormalizeMode = 1;
  G_NORMALIZE_ALL: TGNormalizeMode = 2;
  G_NORMALIZE_NFKD: TGNormalizeMode = 2;
  G_NORMALIZE_ALL_COMPOSE: TGNormalizeMode = 3;
  G_NORMALIZE_NFKC: TGNormalizeMode = 3;

type
  TGOnceStatus = Integer;
const
  { GOnceStatus }
  G_ONCE_STATUS_NOTCALLED: TGOnceStatus = 0;
  G_ONCE_STATUS_PROGRESS: TGOnceStatus = 1;
  G_ONCE_STATUS_READY: TGOnceStatus = 2;

type
  TGOptionArg = Integer;
const
  { GOptionArg }
  G_OPTION_ARG_NONE: TGOptionArg = 0;
  G_OPTION_ARG_STRING: TGOptionArg = 1;
  G_OPTION_ARG_INT: TGOptionArg = 2;
  G_OPTION_ARG_CALLBACK: TGOptionArg = 3;
  G_OPTION_ARG_FILENAME: TGOptionArg = 4;
  G_OPTION_ARG_STRING_ARRAY: TGOptionArg = 5;
  G_OPTION_ARG_FILENAME_ARRAY: TGOptionArg = 6;
  G_OPTION_ARG_DOUBLE: TGOptionArg = 7;
  G_OPTION_ARG_INT64: TGOptionArg = 8;

type
  TGOptionError = Integer;
const
  { GOptionError }
  G_OPTION_ERROR_UNKNOWN_OPTION: TGOptionError = 0;
  G_OPTION_ERROR_BAD_VALUE: TGOptionError = 1;
  G_OPTION_ERROR_FAILED: TGOptionError = 2;

type
  TGOptionFlags = Integer;
const
  { GOptionFlags }
  G_OPTION_FLAG_HIDDEN: TGOptionFlags = 1;
  G_OPTION_FLAG_IN_MAIN: TGOptionFlags = 2;
  G_OPTION_FLAG_REVERSE: TGOptionFlags = 4;
  G_OPTION_FLAG_NO_ARG: TGOptionFlags = 8;
  G_OPTION_FLAG_FILENAME: TGOptionFlags = 16;
  G_OPTION_FLAG_OPTIONAL_ARG: TGOptionFlags = 32;
  G_OPTION_FLAG_NOALIAS: TGOptionFlags = 64;

type
  TGRegexError = Integer;
const
  { GRegexError }
  G_REGEX_ERROR_COMPILE: TGRegexError = 0;
  G_REGEX_ERROR_OPTIMIZE: TGRegexError = 1;
  G_REGEX_ERROR_REPLACE: TGRegexError = 2;
  G_REGEX_ERROR_MATCH: TGRegexError = 3;
  G_REGEX_ERROR_INTERNAL: TGRegexError = 4;
  G_REGEX_ERROR_STRAY_BACKSLASH: TGRegexError = 101;
  G_REGEX_ERROR_MISSING_CONTROL_CHAR: TGRegexError = 102;
  G_REGEX_ERROR_UNRECOGNIZED_ESCAPE: TGRegexError = 103;
  G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER: TGRegexError = 104;
  G_REGEX_ERROR_QUANTIFIER_TOO_BIG: TGRegexError = 105;
  G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS: TGRegexError = 106;
  G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS: TGRegexError = 107;
  G_REGEX_ERROR_RANGE_OUT_OF_ORDER: TGRegexError = 108;
  G_REGEX_ERROR_NOTHING_TO_REPEAT: TGRegexError = 109;
  G_REGEX_ERROR_UNRECOGNIZED_CHARACTER: TGRegexError = 112;
  G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS: TGRegexError = 113;
  G_REGEX_ERROR_UNMATCHED_PARENTHESIS: TGRegexError = 114;
  G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE: TGRegexError = 115;
  G_REGEX_ERROR_UNTERMINATED_COMMENT: TGRegexError = 118;
  G_REGEX_ERROR_EXPRESSION_TOO_LARGE: TGRegexError = 120;
  G_REGEX_ERROR_MEMORY_ERROR: TGRegexError = 121;
  G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND: TGRegexError = 125;
  G_REGEX_ERROR_MALFORMED_CONDITION: TGRegexError = 126;
  G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES: TGRegexError = 127;
  G_REGEX_ERROR_ASSERTION_EXPECTED: TGRegexError = 128;
  G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME: TGRegexError = 130;
  G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED: TGRegexError = 131;
  G_REGEX_ERROR_HEX_CODE_TOO_LARGE: TGRegexError = 134;
  G_REGEX_ERROR_INVALID_CONDITION: TGRegexError = 135;
  G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND: TGRegexError = 136;
  G_REGEX_ERROR_INFINITE_LOOP: TGRegexError = 140;
  G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR: TGRegexError = 142;
  G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME: TGRegexError = 143;
  G_REGEX_ERROR_MALFORMED_PROPERTY: TGRegexError = 146;
  G_REGEX_ERROR_UNKNOWN_PROPERTY: TGRegexError = 147;
  G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG: TGRegexError = 148;
  G_REGEX_ERROR_TOO_MANY_SUBPATTERNS: TGRegexError = 149;
  G_REGEX_ERROR_INVALID_OCTAL_VALUE: TGRegexError = 151;
  G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE: TGRegexError = 154;
  G_REGEX_ERROR_DEFINE_REPETION: TGRegexError = 155;
  G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS: TGRegexError = 156;
  G_REGEX_ERROR_MISSING_BACK_REFERENCE: TGRegexError = 157;
  G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE: TGRegexError = 158;
  G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN: TGRegexError = 159;
  G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB: TGRegexError = 160;
  G_REGEX_ERROR_NUMBER_TOO_BIG: TGRegexError = 161;
  G_REGEX_ERROR_MISSING_SUBPATTERN_NAME: TGRegexError = 162;
  G_REGEX_ERROR_MISSING_DIGIT: TGRegexError = 163;
  G_REGEX_ERROR_INVALID_DATA_CHARACTER: TGRegexError = 164;
  G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME: TGRegexError = 165;
  G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED: TGRegexError = 166;
  G_REGEX_ERROR_INVALID_CONTROL_CHAR: TGRegexError = 168;
  G_REGEX_ERROR_MISSING_NAME: TGRegexError = 169;
  G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS: TGRegexError = 171;
  G_REGEX_ERROR_TOO_MANY_FORWARD_REFERENCES: TGRegexError = 172;
  G_REGEX_ERROR_NAME_TOO_LONG: TGRegexError = 175;
  G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE: TGRegexError = 176;

type
  TGTokenType = Integer;
const
  { GTokenType }
  G_TOKEN_EOF: TGTokenType = 0;
  G_TOKEN_LEFT_PAREN: TGTokenType = 40;
  G_TOKEN_RIGHT_PAREN: TGTokenType = 41;
  G_TOKEN_LEFT_CURLY: TGTokenType = 123;
  G_TOKEN_RIGHT_CURLY: TGTokenType = 125;
  G_TOKEN_LEFT_BRACE: TGTokenType = 91;
  G_TOKEN_RIGHT_BRACE: TGTokenType = 93;
  G_TOKEN_EQUAL_SIGN: TGTokenType = 61;
  G_TOKEN_COMMA: TGTokenType = 44;
  G_TOKEN_NONE: TGTokenType = 256;
  G_TOKEN_ERROR: TGTokenType = 257;
  G_TOKEN_CHAR: TGTokenType = 258;
  G_TOKEN_BINARY: TGTokenType = 259;
  G_TOKEN_OCTAL: TGTokenType = 260;
  G_TOKEN_INT: TGTokenType = 261;
  G_TOKEN_HEX: TGTokenType = 262;
  G_TOKEN_FLOAT: TGTokenType = 263;
  G_TOKEN_STRING: TGTokenType = 264;
  G_TOKEN_SYMBOL: TGTokenType = 265;
  G_TOKEN_IDENTIFIER: TGTokenType = 266;
  G_TOKEN_IDENTIFIER_NULL: TGTokenType = 267;
  G_TOKEN_COMMENT_SINGLE: TGTokenType = 268;
  G_TOKEN_COMMENT_MULTI: TGTokenType = 269;

type
  TGShellError = Integer;
const
  { GShellError }
  G_SHELL_ERROR_BAD_QUOTING: TGShellError = 0;
  G_SHELL_ERROR_EMPTY_STRING: TGShellError = 1;
  G_SHELL_ERROR_FAILED: TGShellError = 2;

type
  TGSliceConfig = Integer;
const
  { GSliceConfig }
  G_SLICE_CONFIG_ALWAYS_MALLOC: TGSliceConfig = 1;
  G_SLICE_CONFIG_BYPASS_MAGAZINES: TGSliceConfig = 2;
  G_SLICE_CONFIG_WORKING_SET_MSECS: TGSliceConfig = 3;
  G_SLICE_CONFIG_COLOR_INCREMENT: TGSliceConfig = 4;
  G_SLICE_CONFIG_CHUNK_SIZES: TGSliceConfig = 5;
  G_SLICE_CONFIG_CONTENTION_COUNTER: TGSliceConfig = 6;

type
  TGSpawnError = Integer;
const
  { GSpawnError }
  G_SPAWN_ERROR_FORK: TGSpawnError = 0;
  G_SPAWN_ERROR_READ: TGSpawnError = 1;
  G_SPAWN_ERROR_CHDIR: TGSpawnError = 2;
  G_SPAWN_ERROR_ACCES: TGSpawnError = 3;
  G_SPAWN_ERROR_PERM: TGSpawnError = 4;
  G_SPAWN_ERROR_TOO_BIG: TGSpawnError = 5;
  G_SPAWN_ERROR_2BIG: TGSpawnError = 5;
  G_SPAWN_ERROR_NOEXEC: TGSpawnError = 6;
  G_SPAWN_ERROR_NAMETOOLONG: TGSpawnError = 7;
  G_SPAWN_ERROR_NOENT: TGSpawnError = 8;
  G_SPAWN_ERROR_NOMEM: TGSpawnError = 9;
  G_SPAWN_ERROR_NOTDIR: TGSpawnError = 10;
  G_SPAWN_ERROR_LOOP: TGSpawnError = 11;
  G_SPAWN_ERROR_TXTBUSY: TGSpawnError = 12;
  G_SPAWN_ERROR_IO: TGSpawnError = 13;
  G_SPAWN_ERROR_NFILE: TGSpawnError = 14;
  G_SPAWN_ERROR_MFILE: TGSpawnError = 15;
  G_SPAWN_ERROR_INVAL: TGSpawnError = 16;
  G_SPAWN_ERROR_ISDIR: TGSpawnError = 17;
  G_SPAWN_ERROR_LIBBAD: TGSpawnError = 18;
  G_SPAWN_ERROR_FAILED: TGSpawnError = 19;

type
  TGSpawnFlags = Integer;
const
  { GSpawnFlags }
  G_SPAWN_LEAVE_DESCRIPTORS_OPEN: TGSpawnFlags = 1;
  G_SPAWN_DO_NOT_REAP_CHILD: TGSpawnFlags = 2;
  G_SPAWN_SEARCH_PATH: TGSpawnFlags = 4;
  G_SPAWN_STDOUT_TO_DEV_NULL: TGSpawnFlags = 8;
  G_SPAWN_STDERR_TO_DEV_NULL: TGSpawnFlags = 16;
  G_SPAWN_CHILD_INHERITS_STDIN: TGSpawnFlags = 32;
  G_SPAWN_FILE_AND_ARGV_ZERO: TGSpawnFlags = 64;
  G_SPAWN_SEARCH_PATH_FROM_ENVP: TGSpawnFlags = 128;

type
  TGTestLogType = Integer;
const
  { GTestLogType }
  G_TEST_LOG_NONE: TGTestLogType = 0;
  G_TEST_LOG_ERROR: TGTestLogType = 1;
  G_TEST_LOG_START_BINARY: TGTestLogType = 2;
  G_TEST_LOG_LIST_CASE: TGTestLogType = 3;
  G_TEST_LOG_SKIP_CASE: TGTestLogType = 4;
  G_TEST_LOG_START_CASE: TGTestLogType = 5;
  G_TEST_LOG_STOP_CASE: TGTestLogType = 6;
  G_TEST_LOG_MIN_RESULT: TGTestLogType = 7;
  G_TEST_LOG_MAX_RESULT: TGTestLogType = 8;
  G_TEST_LOG_MESSAGE: TGTestLogType = 9;

type
  TGTestTrapFlags = Integer;
const
  { GTestTrapFlags }
  G_TEST_TRAP_SILENCE_STDOUT: TGTestTrapFlags = 128;
  G_TEST_TRAP_SILENCE_STDERR: TGTestTrapFlags = 256;
  G_TEST_TRAP_INHERIT_STDIN: TGTestTrapFlags = 512;

type
  TGThreadError = Integer;
const
  { GThreadError }
  G_THREAD_ERROR_AGAIN: TGThreadError = 0;

type
  TGUnicodeBreakType = Integer;
const
  { GUnicodeBreakType }
  G_UNICODE_BREAK_MANDATORY: TGUnicodeBreakType = 0;
  G_UNICODE_BREAK_CARRIAGE_RETURN: TGUnicodeBreakType = 1;
  G_UNICODE_BREAK_LINE_FEED: TGUnicodeBreakType = 2;
  G_UNICODE_BREAK_COMBINING_MARK: TGUnicodeBreakType = 3;
  G_UNICODE_BREAK_SURROGATE: TGUnicodeBreakType = 4;
  G_UNICODE_BREAK_ZERO_WIDTH_SPACE: TGUnicodeBreakType = 5;
  G_UNICODE_BREAK_INSEPARABLE: TGUnicodeBreakType = 6;
  G_UNICODE_BREAK_NON_BREAKING_GLUE: TGUnicodeBreakType = 7;
  G_UNICODE_BREAK_CONTINGENT: TGUnicodeBreakType = 8;
  G_UNICODE_BREAK_SPACE: TGUnicodeBreakType = 9;
  G_UNICODE_BREAK_AFTER: TGUnicodeBreakType = 10;
  G_UNICODE_BREAK_BEFORE: TGUnicodeBreakType = 11;
  G_UNICODE_BREAK_BEFORE_AND_AFTER: TGUnicodeBreakType = 12;
  G_UNICODE_BREAK_HYPHEN: TGUnicodeBreakType = 13;
  G_UNICODE_BREAK_NON_STARTER: TGUnicodeBreakType = 14;
  G_UNICODE_BREAK_OPEN_PUNCTUATION: TGUnicodeBreakType = 15;
  G_UNICODE_BREAK_CLOSE_PUNCTUATION: TGUnicodeBreakType = 16;
  G_UNICODE_BREAK_QUOTATION: TGUnicodeBreakType = 17;
  G_UNICODE_BREAK_EXCLAMATION: TGUnicodeBreakType = 18;
  G_UNICODE_BREAK_IDEOGRAPHIC: TGUnicodeBreakType = 19;
  G_UNICODE_BREAK_NUMERIC: TGUnicodeBreakType = 20;
  G_UNICODE_BREAK_INFIX_SEPARATOR: TGUnicodeBreakType = 21;
  G_UNICODE_BREAK_SYMBOL: TGUnicodeBreakType = 22;
  G_UNICODE_BREAK_ALPHABETIC: TGUnicodeBreakType = 23;
  G_UNICODE_BREAK_PREFIX: TGUnicodeBreakType = 24;
  G_UNICODE_BREAK_POSTFIX: TGUnicodeBreakType = 25;
  G_UNICODE_BREAK_COMPLEX_CONTEXT: TGUnicodeBreakType = 26;
  G_UNICODE_BREAK_AMBIGUOUS: TGUnicodeBreakType = 27;
  G_UNICODE_BREAK_UNKNOWN: TGUnicodeBreakType = 28;
  G_UNICODE_BREAK_NEXT_LINE: TGUnicodeBreakType = 29;
  G_UNICODE_BREAK_WORD_JOINER: TGUnicodeBreakType = 30;
  G_UNICODE_BREAK_HANGUL_L_JAMO: TGUnicodeBreakType = 31;
  G_UNICODE_BREAK_HANGUL_V_JAMO: TGUnicodeBreakType = 32;
  G_UNICODE_BREAK_HANGUL_T_JAMO: TGUnicodeBreakType = 33;
  G_UNICODE_BREAK_HANGUL_LV_SYLLABLE: TGUnicodeBreakType = 34;
  G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE: TGUnicodeBreakType = 35;
  G_UNICODE_BREAK_CLOSE_PARANTHESIS: TGUnicodeBreakType = 36;
  G_UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER: TGUnicodeBreakType = 37;
  G_UNICODE_BREAK_HEBREW_LETTER: TGUnicodeBreakType = 38;
  G_UNICODE_BREAK_REGIONAL_INDICATOR: TGUnicodeBreakType = 39;

type
  TGUnicodeScript = Integer;
const
  { GUnicodeScript }
  G_UNICODE_SCRIPT_INVALID_CODE: TGUnicodeScript = -1;
  G_UNICODE_SCRIPT_COMMON: TGUnicodeScript = 0;
  G_UNICODE_SCRIPT_INHERITED: TGUnicodeScript = 1;
  G_UNICODE_SCRIPT_ARABIC: TGUnicodeScript = 2;
  G_UNICODE_SCRIPT_ARMENIAN: TGUnicodeScript = 3;
  G_UNICODE_SCRIPT_BENGALI: TGUnicodeScript = 4;
  G_UNICODE_SCRIPT_BOPOMOFO: TGUnicodeScript = 5;
  G_UNICODE_SCRIPT_CHEROKEE: TGUnicodeScript = 6;
  G_UNICODE_SCRIPT_COPTIC: TGUnicodeScript = 7;
  G_UNICODE_SCRIPT_CYRILLIC: TGUnicodeScript = 8;
  G_UNICODE_SCRIPT_DESERET: TGUnicodeScript = 9;
  G_UNICODE_SCRIPT_DEVANAGARI: TGUnicodeScript = 10;
  G_UNICODE_SCRIPT_ETHIOPIC: TGUnicodeScript = 11;
  G_UNICODE_SCRIPT_GEORGIAN: TGUnicodeScript = 12;
  G_UNICODE_SCRIPT_GOTHIC: TGUnicodeScript = 13;
  G_UNICODE_SCRIPT_GREEK: TGUnicodeScript = 14;
  G_UNICODE_SCRIPT_GUJARATI: TGUnicodeScript = 15;
  G_UNICODE_SCRIPT_GURMUKHI: TGUnicodeScript = 16;
  G_UNICODE_SCRIPT_HAN: TGUnicodeScript = 17;
  G_UNICODE_SCRIPT_HANGUL: TGUnicodeScript = 18;
  G_UNICODE_SCRIPT_HEBREW: TGUnicodeScript = 19;
  G_UNICODE_SCRIPT_HIRAGANA: TGUnicodeScript = 20;
  G_UNICODE_SCRIPT_KANNADA: TGUnicodeScript = 21;
  G_UNICODE_SCRIPT_KATAKANA: TGUnicodeScript = 22;
  G_UNICODE_SCRIPT_KHMER: TGUnicodeScript = 23;
  G_UNICODE_SCRIPT_LAO: TGUnicodeScript = 24;
  G_UNICODE_SCRIPT_LATIN: TGUnicodeScript = 25;
  G_UNICODE_SCRIPT_MALAYALAM: TGUnicodeScript = 26;
  G_UNICODE_SCRIPT_MONGOLIAN: TGUnicodeScript = 27;
  G_UNICODE_SCRIPT_MYANMAR: TGUnicodeScript = 28;
  G_UNICODE_SCRIPT_OGHAM: TGUnicodeScript = 29;
  G_UNICODE_SCRIPT_OLD_ITALIC: TGUnicodeScript = 30;
  G_UNICODE_SCRIPT_ORIYA: TGUnicodeScript = 31;
  G_UNICODE_SCRIPT_RUNIC: TGUnicodeScript = 32;
  G_UNICODE_SCRIPT_SINHALA: TGUnicodeScript = 33;
  G_UNICODE_SCRIPT_SYRIAC: TGUnicodeScript = 34;
  G_UNICODE_SCRIPT_TAMIL: TGUnicodeScript = 35;
  G_UNICODE_SCRIPT_TELUGU: TGUnicodeScript = 36;
  G_UNICODE_SCRIPT_THAANA: TGUnicodeScript = 37;
  G_UNICODE_SCRIPT_THAI: TGUnicodeScript = 38;
  G_UNICODE_SCRIPT_TIBETAN: TGUnicodeScript = 39;
  G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL: TGUnicodeScript = 40;
  G_UNICODE_SCRIPT_YI: TGUnicodeScript = 41;
  G_UNICODE_SCRIPT_TAGALOG: TGUnicodeScript = 42;
  G_UNICODE_SCRIPT_HANUNOO: TGUnicodeScript = 43;
  G_UNICODE_SCRIPT_BUHID: TGUnicodeScript = 44;
  G_UNICODE_SCRIPT_TAGBANWA: TGUnicodeScript = 45;
  G_UNICODE_SCRIPT_BRAILLE: TGUnicodeScript = 46;
  G_UNICODE_SCRIPT_CYPRIOT: TGUnicodeScript = 47;
  G_UNICODE_SCRIPT_LIMBU: TGUnicodeScript = 48;
  G_UNICODE_SCRIPT_OSMANYA: TGUnicodeScript = 49;
  G_UNICODE_SCRIPT_SHAVIAN: TGUnicodeScript = 50;
  G_UNICODE_SCRIPT_LINEAR_B: TGUnicodeScript = 51;
  G_UNICODE_SCRIPT_TAI_LE: TGUnicodeScript = 52;
  G_UNICODE_SCRIPT_UGARITIC: TGUnicodeScript = 53;
  G_UNICODE_SCRIPT_NEW_TAI_LUE: TGUnicodeScript = 54;
  G_UNICODE_SCRIPT_BUGINESE: TGUnicodeScript = 55;
  G_UNICODE_SCRIPT_GLAGOLITIC: TGUnicodeScript = 56;
  G_UNICODE_SCRIPT_TIFINAGH: TGUnicodeScript = 57;
  G_UNICODE_SCRIPT_SYLOTI_NAGRI: TGUnicodeScript = 58;
  G_UNICODE_SCRIPT_OLD_PERSIAN: TGUnicodeScript = 59;
  G_UNICODE_SCRIPT_KHAROSHTHI: TGUnicodeScript = 60;
  G_UNICODE_SCRIPT_UNKNOWN: TGUnicodeScript = 61;
  G_UNICODE_SCRIPT_BALINESE: TGUnicodeScript = 62;
  G_UNICODE_SCRIPT_CUNEIFORM: TGUnicodeScript = 63;
  G_UNICODE_SCRIPT_PHOENICIAN: TGUnicodeScript = 64;
  G_UNICODE_SCRIPT_PHAGS_PA: TGUnicodeScript = 65;
  G_UNICODE_SCRIPT_NKO: TGUnicodeScript = 66;
  G_UNICODE_SCRIPT_KAYAH_LI: TGUnicodeScript = 67;
  G_UNICODE_SCRIPT_LEPCHA: TGUnicodeScript = 68;
  G_UNICODE_SCRIPT_REJANG: TGUnicodeScript = 69;
  G_UNICODE_SCRIPT_SUNDANESE: TGUnicodeScript = 70;
  G_UNICODE_SCRIPT_SAURASHTRA: TGUnicodeScript = 71;
  G_UNICODE_SCRIPT_CHAM: TGUnicodeScript = 72;
  G_UNICODE_SCRIPT_OL_CHIKI: TGUnicodeScript = 73;
  G_UNICODE_SCRIPT_VAI: TGUnicodeScript = 74;
  G_UNICODE_SCRIPT_CARIAN: TGUnicodeScript = 75;
  G_UNICODE_SCRIPT_LYCIAN: TGUnicodeScript = 76;
  G_UNICODE_SCRIPT_LYDIAN: TGUnicodeScript = 77;
  G_UNICODE_SCRIPT_AVESTAN: TGUnicodeScript = 78;
  G_UNICODE_SCRIPT_BAMUM: TGUnicodeScript = 79;
  G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS: TGUnicodeScript = 80;
  G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC: TGUnicodeScript = 81;
  G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI: TGUnicodeScript = 82;
  G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN: TGUnicodeScript = 83;
  G_UNICODE_SCRIPT_JAVANESE: TGUnicodeScript = 84;
  G_UNICODE_SCRIPT_KAITHI: TGUnicodeScript = 85;
  G_UNICODE_SCRIPT_LISU: TGUnicodeScript = 86;
  G_UNICODE_SCRIPT_MEETEI_MAYEK: TGUnicodeScript = 87;
  G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN: TGUnicodeScript = 88;
  G_UNICODE_SCRIPT_OLD_TURKIC: TGUnicodeScript = 89;
  G_UNICODE_SCRIPT_SAMARITAN: TGUnicodeScript = 90;
  G_UNICODE_SCRIPT_TAI_THAM: TGUnicodeScript = 91;
  G_UNICODE_SCRIPT_TAI_VIET: TGUnicodeScript = 92;
  G_UNICODE_SCRIPT_BATAK: TGUnicodeScript = 93;
  G_UNICODE_SCRIPT_BRAHMI: TGUnicodeScript = 94;
  G_UNICODE_SCRIPT_MANDAIC: TGUnicodeScript = 95;
  G_UNICODE_SCRIPT_CHAKMA: TGUnicodeScript = 96;
  G_UNICODE_SCRIPT_MEROITIC_CURSIVE: TGUnicodeScript = 97;
  G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS: TGUnicodeScript = 98;
  G_UNICODE_SCRIPT_MIAO: TGUnicodeScript = 99;
  G_UNICODE_SCRIPT_SHARADA: TGUnicodeScript = 100;
  G_UNICODE_SCRIPT_SORA_SOMPENG: TGUnicodeScript = 101;
  G_UNICODE_SCRIPT_TAKRI: TGUnicodeScript = 102;

type
  TGUnicodeType = Integer;
const
  { GUnicodeType }
  G_UNICODE_CONTROL: TGUnicodeType = 0;
  G_UNICODE_FORMAT: TGUnicodeType = 1;
  G_UNICODE_UNASSIGNED: TGUnicodeType = 2;
  G_UNICODE_PRIVATE_USE: TGUnicodeType = 3;
  G_UNICODE_SURROGATE: TGUnicodeType = 4;
  G_UNICODE_LOWERCASE_LETTER: TGUnicodeType = 5;
  G_UNICODE_MODIFIER_LETTER: TGUnicodeType = 6;
  G_UNICODE_OTHER_LETTER: TGUnicodeType = 7;
  G_UNICODE_TITLECASE_LETTER: TGUnicodeType = 8;
  G_UNICODE_UPPERCASE_LETTER: TGUnicodeType = 9;
  G_UNICODE_SPACING_MARK: TGUnicodeType = 10;
  G_UNICODE_ENCLOSING_MARK: TGUnicodeType = 11;
  G_UNICODE_NON_SPACING_MARK: TGUnicodeType = 12;
  G_UNICODE_DECIMAL_NUMBER: TGUnicodeType = 13;
  G_UNICODE_LETTER_NUMBER: TGUnicodeType = 14;
  G_UNICODE_OTHER_NUMBER: TGUnicodeType = 15;
  G_UNICODE_CONNECT_PUNCTUATION: TGUnicodeType = 16;
  G_UNICODE_DASH_PUNCTUATION: TGUnicodeType = 17;
  G_UNICODE_CLOSE_PUNCTUATION: TGUnicodeType = 18;
  G_UNICODE_FINAL_PUNCTUATION: TGUnicodeType = 19;
  G_UNICODE_INITIAL_PUNCTUATION: TGUnicodeType = 20;
  G_UNICODE_OTHER_PUNCTUATION: TGUnicodeType = 21;
  G_UNICODE_OPEN_PUNCTUATION: TGUnicodeType = 22;
  G_UNICODE_CURRENCY_SYMBOL: TGUnicodeType = 23;
  G_UNICODE_MODIFIER_SYMBOL: TGUnicodeType = 24;
  G_UNICODE_MATH_SYMBOL: TGUnicodeType = 25;
  G_UNICODE_OTHER_SYMBOL: TGUnicodeType = 26;
  G_UNICODE_LINE_SEPARATOR: TGUnicodeType = 27;
  G_UNICODE_PARAGRAPH_SEPARATOR: TGUnicodeType = 28;
  G_UNICODE_SPACE_SEPARATOR: TGUnicodeType = 29;

type
  TGUserDirectory = Integer;
const
  { GUserDirectory }
  G_USER_DIRECTORY_DESKTOP: TGUserDirectory = 0;
  G_USER_DIRECTORY_DOCUMENTS: TGUserDirectory = 1;
  G_USER_DIRECTORY_DOWNLOAD: TGUserDirectory = 2;
  G_USER_DIRECTORY_MUSIC: TGUserDirectory = 3;
  G_USER_DIRECTORY_PICTURES: TGUserDirectory = 4;
  G_USER_DIRECTORY_PUBLIC_SHARE: TGUserDirectory = 5;
  G_USER_DIRECTORY_TEMPLATES: TGUserDirectory = 6;
  G_USER_DIRECTORY_VIDEOS: TGUserDirectory = 7;
  G_USER_N_DIRECTORIES: TGUserDirectory = 8;

type
  TGVariantClass = Integer;
const
  { GVariantClass }
  G_VARIANT_CLASS_BOOLEAN: TGVariantClass = 98;
  G_VARIANT_CLASS_BYTE: TGVariantClass = 121;
  G_VARIANT_CLASS_INT16: TGVariantClass = 110;
  G_VARIANT_CLASS_UINT16: TGVariantClass = 113;
  G_VARIANT_CLASS_INT32: TGVariantClass = 105;
  G_VARIANT_CLASS_UINT32: TGVariantClass = 117;
  G_VARIANT_CLASS_INT64: TGVariantClass = 120;
  G_VARIANT_CLASS_UINT64: TGVariantClass = 116;
  G_VARIANT_CLASS_HANDLE: TGVariantClass = 104;
  G_VARIANT_CLASS_DOUBLE: TGVariantClass = 100;
  G_VARIANT_CLASS_STRING: TGVariantClass = 115;
  G_VARIANT_CLASS_OBJECT_PATH: TGVariantClass = 111;
  G_VARIANT_CLASS_SIGNATURE: TGVariantClass = 103;
  G_VARIANT_CLASS_VARIANT: TGVariantClass = 118;
  G_VARIANT_CLASS_MAYBE: TGVariantClass = 109;
  G_VARIANT_CLASS_ARRAY: TGVariantClass = 97;
  G_VARIANT_CLASS_TUPLE: TGVariantClass = 40;
  G_VARIANT_CLASS_DICT_ENTRY: TGVariantClass = 123;

type
  TGVariantParseError = Integer;
const
  { GVariantParseError }
  G_VARIANT_PARSE_ERROR_FAILED: TGVariantParseError = 0;
  G_VARIANT_PARSE_ERROR_BASIC_TYPE_EXPECTED: TGVariantParseError = 1;
  G_VARIANT_PARSE_ERROR_CANNOT_INFER_TYPE: TGVariantParseError = 2;
  G_VARIANT_PARSE_ERROR_DEFINITE_TYPE_EXPECTED: TGVariantParseError = 3;
  G_VARIANT_PARSE_ERROR_INPUT_NOT_AT_END: TGVariantParseError = 4;
  G_VARIANT_PARSE_ERROR_INVALID_CHARACTER: TGVariantParseError = 5;
  G_VARIANT_PARSE_ERROR_INVALID_FORMAT_STRING: TGVariantParseError = 6;
  G_VARIANT_PARSE_ERROR_INVALID_OBJECT_PATH: TGVariantParseError = 7;
  G_VARIANT_PARSE_ERROR_INVALID_SIGNATURE: TGVariantParseError = 8;
  G_VARIANT_PARSE_ERROR_INVALID_TYPE_STRING: TGVariantParseError = 9;
  G_VARIANT_PARSE_ERROR_NO_COMMON_TYPE: TGVariantParseError = 10;
  G_VARIANT_PARSE_ERROR_NUMBER_OUT_OF_RANGE: TGVariantParseError = 11;
  G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG: TGVariantParseError = 12;
  G_VARIANT_PARSE_ERROR_TYPE_ERROR: TGVariantParseError = 13;
  G_VARIANT_PARSE_ERROR_UNEXPECTED_TOKEN: TGVariantParseError = 14;
  G_VARIANT_PARSE_ERROR_UNKNOWN_KEYWORD: TGVariantParseError = 15;
  G_VARIANT_PARSE_ERROR_UNTERMINATED_STRING_CONSTANT: TGVariantParseError = 16;
  G_VARIANT_PARSE_ERROR_VALUE_EXPECTED: TGVariantParseError = 17;
type
  guint1 = 0..(1 shl 1-1);
  guint2 = 0..(1 shl 2-1);
  guint3 = 0..(1 shl 3-1);
  guint4 = 0..(1 shl 4-1);
  guint5 = 0..(1 shl 5-1);
  guint6 = 0..(1 shl 6-1);
  guint7 = 0..(1 shl 7-1);
  guint9 = 0..(1 shl 9-1);
  guint10 = 0..(1 shl 10-1);
  guint11 = 0..(1 shl 11-1);
  guint12 = 0..(1 shl 12-1);
  guint13 = 0..(1 shl 13-1);
  guint14 = 0..(1 shl 14-1);
  guint15 = 0..(1 shl 15-1);
  guint17 = 0..(1 shl 17-1);
  guint18 = 0..(1 shl 18-1);
  guint19 = 0..(1 shl 19-1);
  guint20 = 0..(1 shl 20-1);
  guint21 = 0..(1 shl 21-1);
  guint22 = 0..(1 shl 22-1);
  guint23 = 0..(1 shl 23-1);
  guint24 = 0..(1 shl 24-1);
  guint25 = 0..(1 shl 25-1);
  guint26 = 0..(1 shl 26-1);
  guint27 = 0..(1 shl 27-1);
  guint28 = 0..(1 shl 28-1);
  guint29 = 0..(1 shl 29-1);
  guint30 = 0..(1 shl 30-1);
  guint31 = 0..(1 shl 31-1);
  gpointer = pointer;
  int = cint;
  gint = cint;
  guint = cuint;
  guint8 = cuint8;
  guint16 = cuint16;
  guint32 = cuint32;
  guint64 = cuint64;
  gint8 = cint8;
  gint16 = cint16;
  gint32 = cint32;
  gint64 = cint64;
  gsize = csize_t;
  glong = clong;
  gulong = culong;
  gushort = cushort;
  gshort = cshort;
  gchar = char;
  guchar = byte;
  gboolean = Boolean32;
  gssize = PtrInt;
  size_t = csize_t;
  gconstpointer = gpointer;
  gfloat = cfloat;
  gdouble = cdouble;
  double = cdouble;
  goffset = Int64;
  long_double = Extended;
  gunichar = guint32;
  gunichar2 = guint32;
  unsigned_long_long = qword;

  PPGDateDay = ^PGDateDay;
  PGDateDay = ^TGDateDay;
  TGDateDay = guint8;

  PPGDateYear = ^PGDateYear;
  PGDateYear = ^TGDateYear;
  TGDateYear = guint16;

  PPGPid = ^PGPid;
  PGPid = ^TGPid;
  TGPid = gint;

  PPGQuark = ^PGQuark;
  PGQuark = ^TGQuark;
  TGQuark = guint32;

  PPGStrv = ^PGStrv;
  PGStrv = ^TGStrv;
  TGStrv = gpointer;

  PPGTime = ^PGTime;
  PGTime = ^TGTime;
  TGTime = gint32;

  PPGTimeSpan = ^PGTimeSpan;
  PGTimeSpan = ^TGTimeSpan;
  TGTimeSpan = gint64;

  PPPGType = ^PPGType;
  PPGType = ^PGType;
  PGType = ^TGType;
  TGType = gsize;

  PPPgpointer = ^PPgpointer;
  PPgpointer = ^Pgpointer;
  Pgpointer = ^gpointer;
  TGDestroyNotify = procedure(data: gpointer); cdecl;

  PPPgint = ^PPgint;
  PPgint = ^Pgint;
  Pgint = ^gint;
  TGCompareFunc = function(a: Pgpointer; b: Pgpointer): gint; cdecl;
  TGCompareDataFunc = function(a: Pgpointer; b: Pgpointer; user_data: gpointer): gint; cdecl;

  PPGArray = ^PGArray;
  PGArray = ^TGArray;

  PPPguint = ^PPguint;
  PPguint = ^Pguint;
  Pguint = ^guint;

  PPPgchar = ^PPgchar;
  PPgchar = ^Pgchar;
  Pgchar = ^gchar;

  PPPgboolean = ^PPgboolean;
  PPgboolean = ^Pgboolean;
  Pgboolean = ^gboolean;

  PPGDestroyNotify = ^PGDestroyNotify;
  PGDestroyNotify = ^TGDestroyNotify;

  PPGCompareFunc = ^PGCompareFunc;
  PGCompareFunc = ^TGCompareFunc;

  PPGCompareDataFunc = ^PGCompareDataFunc;
  PGCompareDataFunc = ^TGCompareDataFunc;
  TGArray = object
    data: Pgchar;
    len: guint;
  end;

  PPGAsciiType = ^PGAsciiType;
  PGAsciiType = ^TGAsciiType;

  PPGAsyncQueue = ^PGAsyncQueue;
  PGAsyncQueue = ^TGAsyncQueue;

  PPPguint64 = ^PPguint64;
  PPguint64 = ^Pguint64;
  Pguint64 = ^guint64;
  TGAsyncQueue = object
  end;

  PPGTimeVal = ^PGTimeVal;
  PGTimeVal = ^TGTimeVal;

  PPPglong = ^PPglong;
  PPglong = ^Pglong;
  Pglong = ^glong;
  TGTimeVal = object
    tv_sec: glong;
    tv_usec: glong;
  end;

  PPGBookmarkFile = ^PGBookmarkFile;
  PGBookmarkFile = ^TGBookmarkFile;

  PPGError = ^PGError;
  PGError = ^TGError;

  PPPgsize = ^PPgsize;
  PPgsize = ^Pgsize;
  Pgsize = ^gsize;
  TGBookmarkFile = object
  end;

  Pva_list = ^Tva_list;

  { va_list }
  Tva_list = record
    { opaque type }
    Unknown: Pointer;
  end;

  TGError = object
    domain: TGQuark;
    code: gint;
    message: Pgchar;
  end;

  PPGBookmarkFileError = ^PGBookmarkFileError;
  PGBookmarkFileError = ^TGBookmarkFileError;

  PPGBytes = ^PGBytes;
  PGBytes = ^TGBytes;

  PPPguint8 = ^PPguint8;
  PPguint8 = ^Pguint8;
  Pguint8 = ^guint8;
  TGBytes = object
  end;

  PPGByteArray = ^PGByteArray;
  PGByteArray = ^TGByteArray;
  TGByteArray = object
    data: Pguint8;
    len: guint;
  end;

  PPGChecksum = ^PGChecksum;
  PGChecksum = ^TGChecksum;

  PPGChecksumType = ^PGChecksumType;
  PGChecksumType = ^TGChecksumType;

  PPPgssize = ^PPgssize;
  PPgssize = ^Pgssize;
  Pgssize = ^gssize;
  TGChecksum = object
  end;
  TGChildWatchFunc = procedure(pid: TGPid; status: gint; user_data: gpointer); cdecl;

  PPGCond = ^PGCond;
  PGCond = ^TGCond;

  PPGMutex = ^PGMutex;
  PGMutex = ^TGMutex;

  PPPgint64 = ^PPgint64;
  PPgint64 = ^Pgint64;
  Pgint64 = ^gint64;
  TGCond = object
    p: gpointer;
    i: array [0..1] of guint;
  end;
  TGMutex = record
    case longint of
      0 : (p: gpointer);
      1 : (i: array [0..1] of guint);
    //
    //
    //
    //
    //
  end;



  PPGConvertError = ^PGConvertError;
  PGConvertError = ^TGConvertError;
  TGCopyFunc = function(src: Pgpointer; data: gpointer): gpointer; cdecl;

  PPGData = ^PGData;
  PGData = ^TGData;

  TGData = record
  end;


  TGDataForeachFunc = procedure(key_id: TGQuark; data: gpointer; user_data: gpointer); cdecl;

  PPGDate = ^PGDate;
  PGDate = ^TGDate;

  PPGDateMonth = ^PGDateMonth;
  PGDateMonth = ^TGDateMonth;

  PPPguint32 = ^PPguint32;
  PPguint32 = ^Pguint32;
  Pguint32 = ^guint32;

  PPGDateWeekday = ^PGDateWeekday;
  PGDateWeekday = ^TGDateWeekday;
  TGDateBitfield0 = bitpacked record
    julian_days: guint32 { changed from guint to accomodate 32 bitsize requirement };
    julian: guint1 { changed from guint to accomodate 1 bitsize requirement };
    dmy: guint1 { changed from guint to accomodate 1 bitsize requirement };
    day: guint6 { changed from guint to accomodate 6 bitsize requirement };
    month: guint4 { changed from guint to accomodate 4 bitsize requirement };
    year: guint16 { changed from guint to accomodate 16 bitsize requirement };
  end;

  TGDate = object
    Bitfield0 : TGDateBitfield0; { auto generated type }
  end;

  PPGDateDMY = ^PGDateDMY;
  PGDateDMY = ^TGDateDMY;

  PPGDateTime = ^PGDateTime;
  PGDateTime = ^TGDateTime;

  PPGTimeZone = ^PGTimeZone;
  PGTimeZone = ^TGTimeZone;

  PPPgdouble = ^PPgdouble;
  PPgdouble = ^Pgdouble;
  Pgdouble = ^gdouble;
  TGDateTime = object
  end;

  PPGTimeType = ^PGTimeType;
  PGTimeType = ^TGTimeType;

  PPPgint32 = ^PPgint32;
  PPgint32 = ^Pgint32;
  Pgint32 = ^gint32;
  TGTimeZone = object
  end;

  PPGDebugKey = ^PGDebugKey;
  PGDebugKey = ^TGDebugKey;

  TGDebugKey = record
    key: Pgchar;
    value: guint;
  end;



  PPGDir = ^PGDir;
  PGDir = ^TGDir;
  TGDir = object
  end;
  TGDoubleIEEE754 = record
    case longint of
      0 : (v_double: gdouble);
      1 : (
        mpn : record
          mantissa_low: guint32 { changed from guint to accomodate 32 bitsize requirement };
          mantissa_high: guint20 { changed from guint to accomodate 20 bitsize requirement };
          biased_exponent: guint11 { changed from guint to accomodate 11 bitsize requirement };
          sign: guint1 { changed from guint to accomodate 1 bitsize requirement };
        end;

);
  end;


  TGDuplicateFunc = function(data: gpointer; user_data: gpointer): gpointer; cdecl;
  TGEqualFunc = function(a: Pgpointer; b: Pgpointer): gboolean; cdecl;

  PPGErrorType = ^PGErrorType;
  PGErrorType = ^TGErrorType;

  PPGFileError = ^PGFileError;
  PGFileError = ^TGFileError;

  PPGFileTest = ^PGFileTest;
  PGFileTest = ^TGFileTest;

  PPPgfloat = ^PPgfloat;
  PPgfloat = ^Pgfloat;
  Pgfloat = ^gfloat;
  TGFloatIEEE754 = record
    case longint of
      0 : (v_float: gfloat);
      1 : (
        mpn : record
          mantissa: guint23 { changed from guint to accomodate 23 bitsize requirement };
          biased_exponent: guint8 { changed from guint to accomodate 8 bitsize requirement };
          sign: guint1 { changed from guint to accomodate 1 bitsize requirement };
        end;

);
  end;



  PPGFormatSizeFlags = ^PGFormatSizeFlags;
  PGFormatSizeFlags = ^TGFormatSizeFlags;
  TGFreeFunc = procedure(data: gpointer); cdecl;
  TGFunc = procedure(data: gpointer; user_data: gpointer); cdecl;
  TGHFunc = procedure(key: gpointer; value: gpointer; user_data: gpointer); cdecl;
  TGHRFunc = function(key: gpointer; value: gpointer; user_data: gpointer): gboolean; cdecl;
  TGHashFunc = function(key: Pgpointer): guint; cdecl;

  PPGHashTable = ^PGHashTable;
  PGHashTable = ^TGHashTable;

  PPGHRFunc = ^PGHRFunc;
  PGHRFunc = ^TGHRFunc;

  PPGHFunc = ^PGHFunc;
  PGHFunc = ^TGHFunc;

  PPGList = ^PGList;
  PGList = ^TGList;

  PPGHashFunc = ^PGHashFunc;
  PGHashFunc = ^TGHashFunc;

  PPGEqualFunc = ^PGEqualFunc;
  PGEqualFunc = ^TGEqualFunc;
  TGHashTable = object
  end;

  PPGCopyFunc = ^PGCopyFunc;
  PGCopyFunc = ^TGCopyFunc;

  PPGFunc = ^PGFunc;
  PGFunc = ^TGFunc;
  TGList = object
    data: gpointer;
    next: PGList;
    prev: PGList;
  end;

  PPGHashTableIter = ^PGHashTableIter;
  PGHashTableIter = ^TGHashTableIter;
  TGHashTableIter = object
    dummy1: gpointer;
    dummy2: gpointer;
    dummy3: gpointer;
    dummy4: gint;
    dummy5: gboolean;
    dummy6: gpointer;
  end;

  PPGHmac = ^PGHmac;
  PGHmac = ^TGHmac;
  TGHmac = object
  end;

  PPGHook = ^PGHook;
  PGHook = ^TGHook;

  PPGHookList = ^PGHookList;
  PGHookList = ^TGHookList;

  PPPgulong = ^PPgulong;
  PPgulong = ^Pgulong;
  Pgulong = ^gulong;

  PPGHookFindFunc = ^PGHookFindFunc;
  PGHookFindFunc = ^TGHookFindFunc;
  TGHookFindFunc = function(hook: PGHook; data: gpointer): gboolean; cdecl;

  PPGHookCompareFunc = ^PGHookCompareFunc;
  PGHookCompareFunc = ^TGHookCompareFunc;
  TGHookCompareFunc = function(new_hook: PGHook; sibling: PGHook): gint; cdecl;
  TGHook = object
    data: gpointer;
    next: PGHook;
    prev: PGHook;
    ref_count: guint;
    hook_id: gulong;
    flags: guint;
    func: gpointer;
    destroy_1: TGDestroyNotify;
  end;

  PPGHookMarshaller = ^PGHookMarshaller;
  PGHookMarshaller = ^TGHookMarshaller;
  TGHookMarshaller = procedure(hook: PGHook; marshal_data: gpointer); cdecl;

  PPGHookCheckMarshaller = ^PGHookCheckMarshaller;
  PGHookCheckMarshaller = ^TGHookCheckMarshaller;
  TGHookCheckMarshaller = function(hook: PGHook; marshal_data: gpointer): gboolean; cdecl;
  TGHookListBitfield0 = bitpacked record
    hook_size: guint16 { changed from guint to accomodate 16 bitsize requirement };
    is_setup: guint1 { changed from guint to accomodate 1 bitsize requirement };
  end;


  PPGHookFinalizeFunc = ^PGHookFinalizeFunc;
  PGHookFinalizeFunc = ^TGHookFinalizeFunc;
  TGHookFinalizeFunc = procedure(hook_list: PGHookList; hook: PGHook); cdecl;
  TGHookList = object
    seq_id: gulong;
    Bitfield0 : TGHookListBitfield0; { auto generated type }
    hooks: PGHook;
    dummy3: gpointer;
    finalize_hook: TGHookFinalizeFunc;
    dummy: array [0..1] of gpointer;
  end;
  TGHookCheckFunc = function(data: gpointer): gboolean; cdecl;

  PPGHookFlagMask = ^PGHookFlagMask;
  PGHookFlagMask = ^TGHookFlagMask;
  TGHookFunc = procedure(data: gpointer); cdecl;

  PPGIConv = ^PGIConv;
  PGIConv = ^TGIConv;
  TGIConv = object
  end;

  PPGIOFuncs = ^PGIOFuncs;
  PGIOFuncs = ^TGIOFuncs;

  PPGIOStatus = ^PGIOStatus;
  PGIOStatus = ^TGIOStatus;

  PPGIOChannel = ^PGIOChannel;
  PGIOChannel = ^TGIOChannel;

  PPGSeekType = ^PGSeekType;
  PGSeekType = ^TGSeekType;

  PPGSource = ^PGSource;
  PGSource = ^TGSource;

  PPGIOCondition = ^PGIOCondition;
  PGIOCondition = ^TGIOCondition;

  PPGIOFlags = ^PGIOFlags;
  PGIOFlags = ^TGIOFlags;

  TGIOFuncs = record
    io_read: function(channel: PGIOChannel; buf: Pgchar; count: gsize; bytes_read: Pgsize; error: PPGError): TGIOStatus; cdecl;
    io_write: function(channel: PGIOChannel; buf: Pgchar; count: gsize; bytes_written: Pgsize; error: PPGError): TGIOStatus; cdecl;
    io_seek: function(channel: PGIOChannel; offset: gint64; type_: TGSeekType; error: PPGError): TGIOStatus; cdecl;
    io_close: function(channel: PGIOChannel; error: PPGError): TGIOStatus; cdecl;
    io_create_watch: function(channel: PGIOChannel; condition: TGIOCondition): PGSource; cdecl;
    io_free: procedure(channel: PGIOChannel); cdecl;
    io_set_flags: function(channel: PGIOChannel; flags: TGIOFlags; error: PPGError): TGIOStatus; cdecl;
    io_get_flags: function(channel: PGIOChannel): TGIOFlags; cdecl;
  end;



  PPGString = ^PGString;
  PGString = ^TGString;

  PPPgunichar = ^PPgunichar;
  PPgunichar = ^Pgunichar;
  Pgunichar = ^gunichar;
  TGString = object
    str: Pgchar;
    len: gsize;
    allocated_len: gsize;
  end;

  PPGIOChannelError = ^PGIOChannelError;
  PGIOChannelError = ^TGIOChannelError;
  TGIOChannelBitfield0 = bitpacked record
    use_buffer: guint1 { changed from guint to accomodate 1 bitsize requirement };
    do_encode: guint1 { changed from guint to accomodate 1 bitsize requirement };
    close_on_unref: guint1 { changed from guint to accomodate 1 bitsize requirement };
    is_readable: guint1 { changed from guint to accomodate 1 bitsize requirement };
    is_writeable: guint1 { changed from guint to accomodate 1 bitsize requirement };
    is_seekable: guint1 { changed from guint to accomodate 1 bitsize requirement };
  end;

  TGIOChannel = object
    ref_count: gint;
    funcs: PGIOFuncs;
    encoding: Pgchar;
    read_cd: TGIConv;
    write_cd: TGIConv;
    line_term: Pgchar;
    line_term_len: guint;
    buf_size: gsize;
    read_buf: PGString;
    encoded_read_buf: PGString;
    write_buf: PGString;
    partial_write_buf: array [0..5] of gchar;
    Bitfield0 : TGIOChannelBitfield0; { auto generated type }
    reserved1: gpointer;
    reserved2: gpointer;
  end;

  PPGIOError = ^PGIOError;
  PGIOError = ^TGIOError;
  TGIOFunc = function(source: PGIOChannel; condition: TGIOCondition; data: gpointer): gboolean; cdecl;

  PPGSourceFuncs = ^PGSourceFuncs;
  PGSourceFuncs = ^TGSourceFuncs;

  PPPGPollFD = ^PPGPollFD;
  PPGPollFD = ^PGPollFD;
  PGPollFD = ^TGPollFD;

  PPGMainContext = ^PGMainContext;
  PGMainContext = ^TGMainContext;

  PPGSourceFunc = ^PGSourceFunc;
  PGSourceFunc = ^TGSourceFunc;
  TGSourceFunc = function(user_data: gpointer): gboolean; cdecl;

  PPGSourceCallbackFuncs = ^PGSourceCallbackFuncs;
  PGSourceCallbackFuncs = ^TGSourceCallbackFuncs;

  PPGSList = ^PGSList;
  PGSList = ^TGSList;

  PPGSourcePrivate = ^PGSourcePrivate;
  PGSourcePrivate = ^TGSourcePrivate;
  TGSource = object
    callback_data: gpointer;
    callback_funcs: PGSourceCallbackFuncs;
    source_funcs: PGSourceFuncs;
    ref_count: guint;
    context: PGMainContext;
    priority: gint;
    flags: guint;
    source_id: guint;
    poll_fds: PGSList;
    prev: PGSource;
    next: PGSource;
    name: Pgchar;
    priv: PGSourcePrivate;
  end;

  PPGKeyFile = ^PGKeyFile;
  PGKeyFile = ^TGKeyFile;

  PPGKeyFileFlags = ^PGKeyFileFlags;
  PGKeyFileFlags = ^TGKeyFileFlags;
  TGKeyFile = object
  end;

  PPGKeyFileError = ^PGKeyFileError;
  PGKeyFileError = ^TGKeyFileError;

  PPGLogLevelFlags = ^PGLogLevelFlags;
  PGLogLevelFlags = ^TGLogLevelFlags;
  TGLogFunc = procedure(log_domain: Pgchar; log_level: TGLogLevelFlags; message: Pgchar; user_data: gpointer); cdecl;

  PPGPollFunc = ^PGPollFunc;
  PGPollFunc = ^TGPollFunc;
  TGPollFunc = function(ufds: PGPollFD; nfsd: guint; timeout_: gint): gint; cdecl;
  TGMainContext = object
  end;

  PPPgushort = ^PPgushort;
  PPgushort = ^Pgushort;
  Pgushort = ^gushort;
  TGPollFD = object
    fd: gint;
    events: gushort;
    revents: gushort;
  end;

  PPGSourceDummyMarshal = ^PGSourceDummyMarshal;
  PGSourceDummyMarshal = ^TGSourceDummyMarshal;
  TGSourceDummyMarshal = procedure; cdecl;

  TGSourceFuncs = record
    prepare: function(source: PGSource; timeout_: Pgint): gboolean; cdecl;
    check: function(source: PGSource): gboolean; cdecl;
    dispatch: function(source: PGSource; callback: TGSourceFunc; user_data: gpointer): gboolean; cdecl;
    finalize: procedure(source: PGSource); cdecl;
    closure_callback: TGSourceFunc;
    closure_marshal: TGSourceDummyMarshal;
  end;



  PPGMainLoop = ^PGMainLoop;
  PGMainLoop = ^TGMainLoop;
  TGMainLoop = object
  end;

  PPGMappedFile = ^PGMappedFile;
  PGMappedFile = ^TGMappedFile;
  TGMappedFile = object
  end;

  PPGMarkupCollectType = ^PGMarkupCollectType;
  PGMarkupCollectType = ^TGMarkupCollectType;

  PPGMarkupError = ^PGMarkupError;
  PGMarkupError = ^TGMarkupError;

  PPGMarkupParseContext = ^PGMarkupParseContext;
  PGMarkupParseContext = ^TGMarkupParseContext;

  PPGMarkupParser = ^PGMarkupParser;
  PGMarkupParser = ^TGMarkupParser;

  PPGMarkupParseFlags = ^PGMarkupParseFlags;
  PGMarkupParseFlags = ^TGMarkupParseFlags;
  TGMarkupParseContext = object
  end;

  TGMarkupParser = record
    start_element: procedure(context: PGMarkupParseContext; element_name: Pgchar; attribute_names: PPgchar; attribute_values: PPgchar; user_data: gpointer; error: PPGError); cdecl;
    end_element: procedure(context: PGMarkupParseContext; element_name: Pgchar; user_data: gpointer; error: PPGError); cdecl;
    text: procedure(context: PGMarkupParseContext; text: Pgchar; text_len: gsize; user_data: gpointer; error: PPGError); cdecl;
    passthrough: procedure(context: PGMarkupParseContext; passthrough_text: Pgchar; text_len: gsize; user_data: gpointer; error: PPGError); cdecl;
    error: procedure(context: PGMarkupParseContext; error: PGError; user_data: gpointer); cdecl;
  end;


  TGSList = object
    data: gpointer;
    next: PGSList;
  end;

  PPGMatchInfo = ^PGMatchInfo;
  PGMatchInfo = ^TGMatchInfo;

  PPGRegex = ^PGRegex;
  PGRegex = ^TGRegex;
  TGMatchInfo = object
  end;

  PPGRegexCompileFlags = ^PGRegexCompileFlags;
  PGRegexCompileFlags = ^TGRegexCompileFlags;

  PPGRegexMatchFlags = ^PGRegexMatchFlags;
  PGRegexMatchFlags = ^TGRegexMatchFlags;

  PPGRegexEvalCallback = ^PGRegexEvalCallback;
  PGRegexEvalCallback = ^TGRegexEvalCallback;
  TGRegexEvalCallback = function(match_info: PGMatchInfo; result_: PGString; user_data: gpointer): gboolean; cdecl;
  TGRegex = object
  end;

  PPGMemVTable = ^PGMemVTable;
  PGMemVTable = ^TGMemVTable;

  TGMemVTable = record
    malloc: function(n_bytes: gsize): gpointer; cdecl;
    realloc: function(mem: gpointer; n_bytes: gsize): gpointer; cdecl;
    free: procedure(mem: gpointer); cdecl;
    calloc: function(n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl;
    try_malloc: function(n_bytes: gsize): gpointer; cdecl;
    try_realloc: function(mem: gpointer; n_bytes: gsize): gpointer; cdecl;
  end;



  PPGNode = ^PGNode;
  PGNode = ^TGNode;

  PPGTraverseFlags = ^PGTraverseFlags;
  PGTraverseFlags = ^TGTraverseFlags;

  PPGNodeForeachFunc = ^PGNodeForeachFunc;
  PGNodeForeachFunc = ^TGNodeForeachFunc;
  TGNodeForeachFunc = procedure(node: PGNode; data: gpointer); cdecl;

  PPGTraverseType = ^PGTraverseType;
  PGTraverseType = ^TGTraverseType;

  PPGNodeTraverseFunc = ^PGNodeTraverseFunc;
  PGNodeTraverseFunc = ^TGNodeTraverseFunc;
  TGNodeTraverseFunc = function(node: PGNode; data: gpointer): gboolean; cdecl;
  TGNode = object
    data: gpointer;
    next: PGNode;
    prev: PGNode;
    parent: PGNode;
    children: PGNode;
  end;

  PPGNormalizeMode = ^PGNormalizeMode;
  PGNormalizeMode = ^TGNormalizeMode;

  PPGOnceStatus = ^PGOnceStatus;
  PGOnceStatus = ^TGOnceStatus;

  PPGOnce = ^PGOnce;
  PGOnce = ^TGOnce;

  PPGThreadFunc = ^PGThreadFunc;
  PGThreadFunc = ^TGThreadFunc;
  TGThreadFunc = function(data: gpointer): gpointer; cdecl;
  TGOnce = object
    status: TGOnceStatus;
    retval: gpointer;
  end;

  PPGOptionArg = ^PGOptionArg;
  PGOptionArg = ^TGOptionArg;
  TGOptionArgFunc = function(option_name: Pgchar; value: Pgchar; data: gpointer; error: PPGError): gboolean; cdecl;

  PPGOptionContext = ^PGOptionContext;
  PGOptionContext = ^TGOptionContext;

  PPGOptionGroup = ^PGOptionGroup;
  PGOptionGroup = ^TGOptionGroup;

  PPGOptionEntry = ^PGOptionEntry;
  PGOptionEntry = ^TGOptionEntry;

  PPGTranslateFunc = ^PGTranslateFunc;
  PGTranslateFunc = ^TGTranslateFunc;
  TGTranslateFunc = function(str: Pgchar; data: gpointer): Pgchar; cdecl;
  TGOptionContext = object
  end;

  PPGOptionErrorFunc = ^PGOptionErrorFunc;
  PGOptionErrorFunc = ^TGOptionErrorFunc;
  TGOptionErrorFunc = procedure(context: PGOptionContext; group: PGOptionGroup; data: gpointer; error: PPGError); cdecl;

  PPGOptionParseFunc = ^PGOptionParseFunc;
  PGOptionParseFunc = ^TGOptionParseFunc;
  TGOptionParseFunc = function(context: PGOptionContext; group: PGOptionGroup; data: gpointer; error: PPGError): gboolean; cdecl;
  TGOptionGroup = object
  end;

  TGOptionEntry = record
    long_name: Pgchar;
    short_name: gchar;
    flags: gint;
    arg: TGOptionArg;
    arg_data: gpointer;
    description: Pgchar;
    arg_description: Pgchar;
  end;



  PPGOptionError = ^PGOptionError;
  PGOptionError = ^TGOptionError;

  PPGOptionFlags = ^PGOptionFlags;
  PGOptionFlags = ^TGOptionFlags;

  PPGPatternSpec = ^PGPatternSpec;
  PGPatternSpec = ^TGPatternSpec;
  TGPatternSpec = object
  end;
  TGPrintFunc = procedure(string_: Pgchar); cdecl;

  PPGPrivate = ^PGPrivate;
  PGPrivate = ^TGPrivate;
  TGPrivate = object
    p: gpointer;
    notify: TGDestroyNotify;
    future: array [0..1] of gpointer;
  end;

  PPGPtrArray = ^PGPtrArray;
  PGPtrArray = ^TGPtrArray;
  TGPtrArray = object
    pdata: Pgpointer;
    len: guint;
  end;

  PPGQueue = ^PGQueue;
  PGQueue = ^TGQueue;
  TGQueue = object
    head: PGList;
    tail: PGList;
    length: guint;
  end;

  PPGRWLock = ^PGRWLock;
  PGRWLock = ^TGRWLock;
  TGRWLock = object
    p: gpointer;
    i: array [0..1] of guint;
  end;

  PPGRand = ^PGRand;
  PGRand = ^TGRand;
  TGRand = object
  end;

  PPGRecMutex = ^PGRecMutex;
  PGRecMutex = ^TGRecMutex;
  TGRecMutex = object
    p: gpointer;
    i: array [0..1] of guint;
  end;

  PPGRegexError = ^PGRegexError;
  PGRegexError = ^TGRegexError;

  PPGScannerConfig = ^PGScannerConfig;
  PGScannerConfig = ^TGScannerConfig;
  TGScannerConfigBitfield0 = bitpacked record
    case_sensitive: guint1 { changed from guint to accomodate 1 bitsize requirement };
    skip_comment_multi: guint1 { changed from guint to accomodate 1 bitsize requirement };
    skip_comment_single: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_comment_multi: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_identifier: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_identifier_1char: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_identifier_NULL: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_symbols: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_binary: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_octal: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_float: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_hex: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_hex_dollar: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_string_sq: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scan_string_dq: guint1 { changed from guint to accomodate 1 bitsize requirement };
    numbers_2_int: guint1 { changed from guint to accomodate 1 bitsize requirement };
    int_2_float: guint1 { changed from guint to accomodate 1 bitsize requirement };
    identifier_2_string: guint1 { changed from guint to accomodate 1 bitsize requirement };
    char_2_token: guint1 { changed from guint to accomodate 1 bitsize requirement };
    symbol_2_token: guint1 { changed from guint to accomodate 1 bitsize requirement };
    scope_0_fallback: guint1 { changed from guint to accomodate 1 bitsize requirement };
    store_int64: guint1 { changed from guint to accomodate 1 bitsize requirement };
  end;


  TGScannerConfig = record
    cset_skip_characters: Pgchar;
    cset_identifier_first: Pgchar;
    cset_identifier_nth: Pgchar;
    cpair_comment_single: Pgchar;
    Bitfield0 : TGScannerConfigBitfield0; { auto generated type }
    padding_dummy: guint;
  end;



  PPGTokenType = ^PGTokenType;
  PGTokenType = ^TGTokenType;
  TGTokenValue = record
    case longint of
      0 : (v_symbol: gpointer);
      1 : (v_identifier: Pgchar);
      2 : (v_binary: gulong);
      3 : (v_octal: gulong);
      4 : (v_int: gulong);
      5 : (v_int64: guint64);
      6 : (v_float: gdouble);
      7 : (v_hex: gulong);
      8 : (v_string: Pgchar);
      9 : (v_comment: Pgchar);
      10 : (v_char: guint8);
      11 : (v_error: guint);
  end;



  PPGScanner = ^PGScanner;
  PGScanner = ^TGScanner;
  TGScannerMsgFunc = procedure(scanner: PGScanner; message: Pgchar; error: gboolean); cdecl;

  PPGTokenValue = ^PGTokenValue;
  PGTokenValue = ^TGTokenValue;

  PPGScannerMsgFunc = ^PGScannerMsgFunc;
  PGScannerMsgFunc = ^TGScannerMsgFunc;
  TGScanner = object
    user_data: gpointer;
    max_parse_errors: guint;
    parse_errors: guint;
    input_name: Pgchar;
    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: Pgchar;
    text_end: Pgchar;
    buffer: Pgchar;
    scope_id: guint;
    msg_handler: TGScannerMsgFunc;
  end;

  PPGSequenceIter = ^PGSequenceIter;
  PGSequenceIter = ^TGSequenceIter;

  PPGSequence = ^PGSequence;
  PGSequence = ^TGSequence;
  TGSequenceIter = object
  end;

  PPGSequenceIterCompareFunc = ^PGSequenceIterCompareFunc;
  PGSequenceIterCompareFunc = ^TGSequenceIterCompareFunc;
  TGSequenceIterCompareFunc = function(a: PGSequenceIter; b: PGSequenceIter; data: gpointer): gint; cdecl;
  TGSequence = object
  end;

  PPGShellError = ^PGShellError;
  PGShellError = ^TGShellError;

  PPGSliceConfig = ^PGSliceConfig;
  PGSliceConfig = ^TGSliceConfig;

  TGSourceCallbackFuncs = record
    ref: procedure(cb_data: gpointer); cdecl;
    unref: procedure(cb_data: gpointer); cdecl;
    get: procedure(cb_data: gpointer; source: PGSource; func: PGSourceFunc; data: Pgpointer); cdecl;
  end;



  TGSourcePrivate = record
  end;


  TGSpawnChildSetupFunc = procedure(user_data: gpointer); cdecl;

  PPGSpawnError = ^PGSpawnError;
  PGSpawnError = ^TGSpawnError;

  PPGSpawnFlags = ^PGSpawnFlags;
  PGSpawnFlags = ^TGSpawnFlags;

  PPGStatBuf = ^PGStatBuf;
  PGStatBuf = ^TGStatBuf;

  TGStatBuf = record
  end;



  PPGStringChunk = ^PGStringChunk;
  PGStringChunk = ^TGStringChunk;
  TGStringChunk = object
  end;

  PPGTestCase = ^PGTestCase;
  PGTestCase = ^TGTestCase;

  TGTestCase = record
  end;



  PPGTestConfig = ^PGTestConfig;
  PGTestConfig = ^TGTestConfig;

  TGTestConfig = record
    test_initialized: gboolean;
    test_quick: gboolean;
    test_perf: gboolean;
    test_verbose: gboolean;
    test_quiet: gboolean;
    test_undefined: gboolean;
  end;


  TGTestDataFunc = procedure(user_data: Pgpointer); cdecl;
  TGTestFixtureFunc = procedure(fixture: gpointer; user_data: Pgpointer); cdecl;
  TGTestFunc = procedure; cdecl;

  PPGTestLogBuffer = ^PGTestLogBuffer;
  PGTestLogBuffer = ^TGTestLogBuffer;

  PPGTestLogMsg = ^PGTestLogMsg;
  PGTestLogMsg = ^TGTestLogMsg;
  TGTestLogBuffer = object
    data: PGString;
    msgs: PGSList;
  end;

  PPGTestLogType = ^PGTestLogType;
  PGTestLogType = ^TGTestLogType;
  TGTestLogMsg = object
    log_type: TGTestLogType;
    n_strings: guint;
    strings: PPgchar;
    n_nums: guint;
    nums: Pglong;
  end;
  TGTestLogFatalFunc = function(log_domain: Pgchar; log_level: TGLogLevelFlags; message: Pgchar; user_data: gpointer): gboolean; cdecl;

  PPGTestSuite = ^PGTestSuite;
  PGTestSuite = ^TGTestSuite;
  TGTestSuite = object
  end;

  PPGTestTrapFlags = ^PGTestTrapFlags;
  PGTestTrapFlags = ^TGTestTrapFlags;

  PPGThread = ^PGThread;
  PGThread = ^TGThread;
  TGThread = object
  end;

  PPGThreadError = ^PGThreadError;
  PGThreadError = ^TGThreadError;

  PPGThreadPool = ^PGThreadPool;
  PGThreadPool = ^TGThreadPool;
  TGThreadPool = object
    func: TGFunc;
    user_data: gpointer;
    exclusive: gboolean;
  end;

  PPGTimer = ^PGTimer;
  PGTimer = ^TGTimer;
  TGTimer = object
  end;

  PPGTrashStack = ^PGTrashStack;
  PGTrashStack = ^TGTrashStack;
  TGTrashStack = object
    next: PGTrashStack;
  end;
  TGTraverseFunc = function(key: gpointer; value: gpointer; data: gpointer): gboolean; cdecl;

  PPGTree = ^PGTree;
  PGTree = ^TGTree;

  PPGTraverseFunc = ^PGTraverseFunc;
  PGTraverseFunc = ^TGTraverseFunc;
  TGTree = object
  end;

  PPGUnicodeBreakType = ^PGUnicodeBreakType;
  PGUnicodeBreakType = ^TGUnicodeBreakType;

  PPGUnicodeScript = ^PGUnicodeScript;
  PGUnicodeScript = ^TGUnicodeScript;

  PPGUnicodeType = ^PGUnicodeType;
  PGUnicodeType = ^TGUnicodeType;
  TGUnixFDSourceFunc = function(fd: gint; condition: TGIOCondition; user_data: gpointer): gboolean; cdecl;

  PPGUserDirectory = ^PGUserDirectory;
  PGUserDirectory = ^TGUserDirectory;

  PPGVariant = ^PGVariant;
  PGVariant = ^TGVariant;

  PPGVariantType = ^PGVariantType;
  PGVariantType = ^TGVariantType;

  PPPgint16 = ^PPgint16;
  PPgint16 = ^Pgint16;
  Pgint16 = ^gint16;

  PPPguint16 = ^PPguint16;
  PPguint16 = ^Pguint16;
  Pguint16 = ^guint16;

  PPGVariantClass = ^PGVariantClass;
  PGVariantClass = ^TGVariantClass;

  PPGVariantIter = ^PGVariantIter;
  PGVariantIter = ^TGVariantIter;
  TGVariant = object
  end;
  TGVariantType = object
  end;
  TGVariantIter = object
    x: array [0..15] of gsize;
  end;

  PPGVariantBuilder = ^PGVariantBuilder;
  PGVariantBuilder = ^TGVariantBuilder;
  TGVariantBuilder = object
    x: array [0..15] of gsize;
  end;

  PPGVariantParseError = ^PGVariantParseError;
  PGVariantParseError = ^TGVariantParseError;
  TGVoidFunc = procedure; cdecl;

function g_access(filename: Pgchar; mode: gint): gint; cdecl; external;
function g_array_append_vals(array_: Pgpointer; data: Pgpointer; len: guint): Pgpointer; cdecl; external;
function g_array_free(array_: Pgpointer; free_segment: gboolean): Pgchar; cdecl; external;
function g_array_get_element_size(array_: Pgpointer): guint; cdecl; external;
function g_array_get_type: TGType; cdecl; external;
function g_array_insert_vals(array_: Pgpointer; index_: guint; data: Pgpointer; len: guint): Pgpointer; cdecl; external;
function g_array_new(zero_terminated: gboolean; clear_: gboolean; element_size: guint): Pgpointer; cdecl; external;
function g_array_prepend_vals(array_: Pgpointer; data: Pgpointer; len: guint): Pgpointer; cdecl; external;
function g_array_ref(array_: Pgpointer): Pgpointer; cdecl; external;
function g_array_remove_index(array_: Pgpointer; index_: guint): Pgpointer; cdecl; external;
function g_array_remove_index_fast(array_: Pgpointer; index_: guint): Pgpointer; cdecl; external;
function g_array_remove_range(array_: Pgpointer; index_: guint; length: guint): Pgpointer; cdecl; external;
function g_array_set_size(array_: Pgpointer; length: guint): Pgpointer; cdecl; external;
function g_array_sized_new(zero_terminated: gboolean; clear_: gboolean; element_size: guint; reserved_size: guint): Pgpointer; cdecl; external;
function g_ascii_digit_value(c: gchar): gint; cdecl; external;
function g_ascii_dtostr(buffer: Pgchar; buf_len: gint; d: gdouble): Pgchar; cdecl; external;
function g_ascii_formatd(buffer: Pgchar; buf_len: gint; format: Pgchar; d: gdouble): Pgchar; cdecl; external;
function g_ascii_strcasecmp(s1: Pgchar; s2: Pgchar): gint; cdecl; external;
function g_ascii_strdown(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_ascii_strncasecmp(s1: Pgchar; s2: Pgchar; n: gsize): gint; cdecl; external;
function g_ascii_strtod(nptr: Pgchar; endptr: PPgchar): gdouble; cdecl; external;
function g_ascii_strtoll(nptr: Pgchar; endptr: PPgchar; base: guint): gint64; cdecl; external;
function g_ascii_strtoull(nptr: Pgchar; endptr: PPgchar; base: guint): guint64; cdecl; external;
function g_ascii_strup(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_ascii_tolower(c: gchar): gchar; cdecl; external;
function g_ascii_toupper(c: gchar): gchar; cdecl; external;
function g_ascii_xdigit_value(c: gchar): gint; cdecl; external;
function g_async_queue_length(queue: PGAsyncQueue): gint; cdecl; external;
function g_async_queue_length_unlocked(queue: PGAsyncQueue): gint; cdecl; external;
function g_async_queue_new: PGAsyncQueue; cdecl; external;
function g_async_queue_new_full(item_free_func: TGDestroyNotify): PGAsyncQueue; cdecl; external;
function g_async_queue_pop(queue: PGAsyncQueue): gpointer; cdecl; external;
function g_async_queue_pop_unlocked(queue: PGAsyncQueue): gpointer; cdecl; external;
function g_async_queue_ref(queue: PGAsyncQueue): PGAsyncQueue; cdecl; external;
function g_async_queue_timeout_pop(queue: PGAsyncQueue; timeout: guint64): gpointer; cdecl; external;
function g_async_queue_timeout_pop_unlocked(queue: PGAsyncQueue; timeout: guint64): gpointer; cdecl; external;
function g_async_queue_try_pop(queue: PGAsyncQueue): gpointer; cdecl; external;
function g_async_queue_try_pop_unlocked(queue: PGAsyncQueue): gpointer; cdecl; external;
function g_atomic_int_add(atomic: Pgint; val: gint): gint; cdecl; external;
function g_atomic_int_and(atomic: Pguint; val: guint): guint; cdecl; external;
function g_atomic_int_compare_and_exchange(atomic: Pgint; oldval: gint; newval: gint): gboolean; cdecl; external;
function g_atomic_int_dec_and_test(atomic: Pgint): gboolean; cdecl; external;
function g_atomic_int_exchange_and_add(atomic: Pgint; val: gint): gint; cdecl; external;
function g_atomic_int_get(atomic: Pgint): gint; cdecl; external;
function g_atomic_int_or(atomic: Pguint; val: guint): guint; cdecl; external;
function g_atomic_int_xor(atomic: Pguint; val: guint): guint; cdecl; external;
function g_atomic_pointer_add(atomic: Pgpointer; val: gssize): gssize; cdecl; external;
function g_atomic_pointer_and(atomic: Pgpointer; val: gsize): gsize; cdecl; external;
function g_atomic_pointer_compare_and_exchange(atomic: Pgpointer; oldval: gpointer; newval: gpointer): gboolean; cdecl; external;
function g_atomic_pointer_get(atomic: Pgpointer): gpointer; cdecl; external;
function g_atomic_pointer_or(atomic: Pgpointer; val: gsize): gsize; cdecl; external;
function g_atomic_pointer_xor(atomic: Pgpointer; val: gsize): gsize; cdecl; external;
function g_base64_decode(text: Pgchar; out_len: Pgsize): Pguint8; cdecl; external;
function g_base64_decode_inplace(text: Pgchar; out_len: Pgsize): Pguint8; cdecl; external;
function g_base64_decode_step(in_: Pgchar; len: gsize; out_: Pguint8; state: Pgint; save: Pguint): gsize; cdecl; external;
function g_base64_encode(data: Pguint8; len: gsize): Pgchar; cdecl; external;
function g_base64_encode_close(break_lines: gboolean; out_: Pgchar; state: Pgint; save: Pgint): gsize; cdecl; external;
function g_base64_encode_step(in_: Pguint8; len: gsize; break_lines: gboolean; out_: Pgchar; state: Pgint; save: Pgint): gsize; cdecl; external;
function g_basename(file_name: Pgchar): Pgchar; cdecl; external;
function g_bit_nth_lsf(mask: gulong; nth_bit: gint): gint; cdecl; external;
function g_bit_nth_msf(mask: gulong; nth_bit: gint): gint; cdecl; external;
function g_bit_storage(number: gulong): guint; cdecl; external;
function g_bit_trylock(address: Pgint; lock_bit: gint): gboolean; cdecl; external;
function g_bookmark_file_error_quark: TGQuark; cdecl; external;
function g_bookmark_file_get_added(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): glong; cdecl; external;
function g_bookmark_file_get_app_info(bookmark: PGBookmarkFile; uri: Pgchar; name: Pgchar; exec: PPgchar; count: Pguint; stamp: Pglong; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_get_applications(bookmark: PGBookmarkFile; uri: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; external;
function g_bookmark_file_get_description(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_bookmark_file_get_groups(bookmark: PGBookmarkFile; uri: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; external;
function g_bookmark_file_get_icon(bookmark: PGBookmarkFile; uri: Pgchar; href: PPgchar; mime_type: PPgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_get_is_private(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_get_mime_type(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_bookmark_file_get_modified(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): glong; cdecl; external;
function g_bookmark_file_get_size(bookmark: PGBookmarkFile): gint; cdecl; external;
function g_bookmark_file_get_title(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_bookmark_file_get_uris(bookmark: PGBookmarkFile; length: Pgsize): PPgchar; cdecl; external;
function g_bookmark_file_get_visited(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): glong; cdecl; external;
function g_bookmark_file_has_application(bookmark: PGBookmarkFile; uri: Pgchar; name: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_has_group(bookmark: PGBookmarkFile; uri: Pgchar; group: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_has_item(bookmark: PGBookmarkFile; uri: Pgchar): gboolean; cdecl; external;
function g_bookmark_file_load_from_data(bookmark: PGBookmarkFile; data: Pgchar; length: gsize; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_load_from_data_dirs(bookmark: PGBookmarkFile; file_: Pgchar; full_path: PPgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_load_from_file(bookmark: PGBookmarkFile; filename: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_move_item(bookmark: PGBookmarkFile; old_uri: Pgchar; new_uri: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_new: PGBookmarkFile; cdecl; external;
function g_bookmark_file_remove_application(bookmark: PGBookmarkFile; uri: Pgchar; name: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_remove_group(bookmark: PGBookmarkFile; uri: Pgchar; group: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_remove_item(bookmark: PGBookmarkFile; uri: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_set_app_info(bookmark: PGBookmarkFile; uri: Pgchar; name: Pgchar; exec: Pgchar; count: gint; stamp: glong; error: PPGError): gboolean; cdecl; external;
function g_bookmark_file_to_data(bookmark: PGBookmarkFile; length: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_bookmark_file_to_file(bookmark: PGBookmarkFile; filename: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_build_filename(first_element: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_build_filenamev(args: PPgchar): Pgchar; cdecl; external;
function g_build_path(separator: Pgchar; first_element: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_build_pathv(separator: Pgchar; args: PPgchar): Pgchar; cdecl; external;
function g_byte_array_append(array_: Pguint8; data: Pguint8; len: guint): Pguint8; cdecl; external;
function g_byte_array_free(array_: Pguint8; free_segment: gboolean): Pguint8; cdecl; external;
function g_byte_array_free_to_bytes(array_: Pguint8): PGBytes; cdecl; external;
function g_byte_array_get_type: TGType; cdecl; external;
function g_byte_array_new: Pguint8; cdecl; external;
function g_byte_array_new_take(data: Pguint8; len: gsize): Pguint8; cdecl; external;
function g_byte_array_prepend(array_: Pguint8; data: Pguint8; len: guint): Pguint8; cdecl; external;
function g_byte_array_ref(array_: Pguint8): Pguint8; cdecl; external;
function g_byte_array_remove_index(array_: Pguint8; index_: guint): Pguint8; cdecl; external;
function g_byte_array_remove_index_fast(array_: Pguint8; index_: guint): Pguint8; cdecl; external;
function g_byte_array_remove_range(array_: Pguint8; index_: guint; length: guint): Pguint8; cdecl; external;
function g_byte_array_set_size(array_: Pguint8; length: guint): Pguint8; cdecl; external;
function g_byte_array_sized_new(reserved_size: guint): Pguint8; cdecl; external;
function g_bytes_compare(bytes1: PGBytes; bytes2: PGBytes): gint; cdecl; external;
function g_bytes_equal(bytes1: PGBytes; bytes2: PGBytes): gboolean; cdecl; external;
function g_bytes_get_data(bytes: PGBytes; size: Pgsize): guint8; cdecl; external;
function g_bytes_get_size(bytes: PGBytes): gsize; cdecl; external;
function g_bytes_get_type: TGType; cdecl; external;
function g_bytes_hash(bytes: PGBytes): guint; cdecl; external;
function g_bytes_new(data: guint8; size: gsize): PGBytes; cdecl; external;
function g_bytes_new_from_bytes(bytes: PGBytes; offset: gsize; length: gsize): PGBytes; cdecl; external;
function g_bytes_new_static(data: guint8; size: gsize): PGBytes; cdecl; external;
function g_bytes_new_take(data: guint8; size: gsize): PGBytes; cdecl; external;
function g_bytes_new_with_free_func(data: gpointer; size: gsize; free_func: TGDestroyNotify; user_data: gpointer): PGBytes; cdecl; external;
function g_bytes_ref(bytes: PGBytes): PGBytes; cdecl; external;
function g_bytes_unref_to_array(bytes: PGBytes): Pguint8; cdecl; external;
function g_bytes_unref_to_data(bytes: PGBytes; size: Pgsize): gpointer; cdecl; external;
function g_chdir(path: Pgchar): gint; cdecl; external;
function g_checksum_copy(checksum: PGChecksum): PGChecksum; cdecl; external;
function g_checksum_get_string(checksum: PGChecksum): Pgchar; cdecl; external;
function g_checksum_get_type: TGType; cdecl; external;
function g_checksum_new(checksum_type: TGChecksumType): PGChecksum; cdecl; external;
function g_checksum_type_get_length(checksum_type: TGChecksumType): gssize; cdecl; external;
function g_child_watch_add(pid: TGPid; function_: TGChildWatchFunc; data: gpointer): guint; cdecl; external;
function g_child_watch_add_full(priority: gint; pid: TGPid; function_: TGChildWatchFunc; data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_child_watch_source_new(pid: TGPid): PGSource; cdecl; external;
function g_close(fd: gint; error: PPGError): gboolean; cdecl; external;
function g_compute_checksum_for_bytes(checksum_type: TGChecksumType; data: PGBytes): Pgchar; cdecl; external;
function g_compute_checksum_for_data(checksum_type: TGChecksumType; data: Pguint8; length: gsize): Pgchar; cdecl; external;
function g_compute_checksum_for_string(checksum_type: TGChecksumType; str: Pgchar; length: gssize): Pgchar; cdecl; external;
function g_compute_hmac_for_data(digest_type: TGChecksumType; key: Pguint8; key_len: gsize; data: Pguint8; length: gsize): Pgchar; cdecl; external;
function g_compute_hmac_for_string(digest_type: TGChecksumType; key: Pguint8; key_len: gsize; str: Pgchar; length: gssize): Pgchar; cdecl; external;
function g_cond_wait_until(cond: PGCond; mutex: PGMutex; end_time: gint64): gboolean; cdecl; external;
function g_convert(str: Pgchar; len: gssize; to_codeset: Pgchar; from_codeset: Pgchar; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_convert_error_quark: TGQuark; cdecl; external;
function g_convert_with_fallback(str: Pgchar; len: gssize; to_codeset: Pgchar; from_codeset: Pgchar; fallback: Pgchar; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_convert_with_iconv(str: Pgchar; len: gssize; converter: TGIConv; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_datalist_get_data(datalist: PPGData; key: Pgchar): gpointer; cdecl; external;
function g_datalist_get_flags(datalist: PPGData): guint; cdecl; external;
function g_datalist_id_dup_data(datalist: PPGData; key_id: TGQuark; dup_func: TGDuplicateFunc; user_data: gpointer): gpointer; cdecl; external;
function g_datalist_id_get_data(datalist: PPGData; key_id: TGQuark): gpointer; cdecl; external;
function g_datalist_id_remove_no_notify(datalist: PPGData; key_id: TGQuark): gpointer; cdecl; external;
function g_datalist_id_replace_data(datalist: PPGData; key_id: TGQuark; oldval: gpointer; newval: gpointer; destroy_: TGDestroyNotify; old_destroy: PGDestroyNotify): gboolean; cdecl; external;
function g_dataset_id_get_data(dataset_location: Pgpointer; key_id: TGQuark): gpointer; cdecl; external;
function g_dataset_id_remove_no_notify(dataset_location: Pgpointer; key_id: TGQuark): gpointer; cdecl; external;
function g_date_compare(lhs: PGDate; rhs: PGDate): gint; cdecl; external;
function g_date_days_between(date1: PGDate; date2: PGDate): gint; cdecl; external;
function g_date_get_day(date: PGDate): TGDateDay; cdecl; external;
function g_date_get_day_of_year(date: PGDate): guint; cdecl; external;
function g_date_get_days_in_month(month: TGDateMonth; year: TGDateYear): guint8; cdecl; external;
function g_date_get_iso8601_week_of_year(date: PGDate): guint; cdecl; external;
function g_date_get_julian(date: PGDate): guint32; cdecl; external;
function g_date_get_monday_week_of_year(date: PGDate): guint; cdecl; external;
function g_date_get_monday_weeks_in_year(year: TGDateYear): guint8; cdecl; external;
function g_date_get_month(date: PGDate): TGDateMonth; cdecl; external;
function g_date_get_sunday_week_of_year(date: PGDate): guint; cdecl; external;
function g_date_get_sunday_weeks_in_year(year: TGDateYear): guint8; cdecl; external;
function g_date_get_type: TGType; cdecl; external;
function g_date_get_weekday(date: PGDate): TGDateWeekday; cdecl; external;
function g_date_get_year(date: PGDate): TGDateYear; cdecl; external;
function g_date_is_first_of_month(date: PGDate): gboolean; cdecl; external;
function g_date_is_last_of_month(date: PGDate): gboolean; cdecl; external;
function g_date_is_leap_year(year: TGDateYear): gboolean; cdecl; external;
function g_date_new: PGDate; cdecl; external;
function g_date_new_dmy(day: TGDateDay; month: TGDateMonth; year: TGDateYear): PGDate; cdecl; external;
function g_date_new_julian(julian_day: guint32): PGDate; cdecl; external;
function g_date_strftime(s: Pgchar; slen: gsize; format: Pgchar; date: PGDate): gsize; cdecl; external;
function g_date_time_add(datetime: PGDateTime; timespan: TGTimeSpan): PGDateTime; cdecl; external;
function g_date_time_add_days(datetime: PGDateTime; days: gint): PGDateTime; cdecl; external;
function g_date_time_add_full(datetime: PGDateTime; years: gint; months: gint; days: gint; hours: gint; minutes: gint; seconds: gdouble): PGDateTime; cdecl; external;
function g_date_time_add_hours(datetime: PGDateTime; hours: gint): PGDateTime; cdecl; external;
function g_date_time_add_minutes(datetime: PGDateTime; minutes: gint): PGDateTime; cdecl; external;
function g_date_time_add_months(datetime: PGDateTime; months: gint): PGDateTime; cdecl; external;
function g_date_time_add_seconds(datetime: PGDateTime; seconds: gdouble): PGDateTime; cdecl; external;
function g_date_time_add_weeks(datetime: PGDateTime; weeks: gint): PGDateTime; cdecl; external;
function g_date_time_add_years(datetime: PGDateTime; years: gint): PGDateTime; cdecl; external;
function g_date_time_compare(dt1: Pgpointer; dt2: Pgpointer): gint; cdecl; external;
function g_date_time_difference(end_: PGDateTime; begin_: PGDateTime): TGTimeSpan; cdecl; external;
function g_date_time_equal(dt1: Pgpointer; dt2: Pgpointer): gboolean; cdecl; external;
function g_date_time_format(datetime: PGDateTime; format: Pgchar): Pgchar; cdecl; external;
function g_date_time_get_day_of_month(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_day_of_week(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_day_of_year(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_hour(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_microsecond(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_minute(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_month(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_second(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_seconds(datetime: PGDateTime): gdouble; cdecl; external;
function g_date_time_get_timezone_abbreviation(datetime: PGDateTime): Pgchar; cdecl; external;
function g_date_time_get_type: TGType; cdecl; external;
function g_date_time_get_utc_offset(datetime: PGDateTime): TGTimeSpan; cdecl; external;
function g_date_time_get_week_numbering_year(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_week_of_year(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_get_year(datetime: PGDateTime): gint; cdecl; external;
function g_date_time_hash(datetime: Pgpointer): guint; cdecl; external;
function g_date_time_is_daylight_savings(datetime: PGDateTime): gboolean; cdecl; external;
function g_date_time_new(tz: PGTimeZone; year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl; external;
function g_date_time_new_from_timeval_local(tv: PGTimeVal): PGDateTime; cdecl; external;
function g_date_time_new_from_timeval_utc(tv: PGTimeVal): PGDateTime; cdecl; external;
function g_date_time_new_from_unix_local(t: gint64): PGDateTime; cdecl; external;
function g_date_time_new_from_unix_utc(t: gint64): PGDateTime; cdecl; external;
function g_date_time_new_local(year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl; external;
function g_date_time_new_now(tz: PGTimeZone): PGDateTime; cdecl; external;
function g_date_time_new_now_local: PGDateTime; cdecl; external;
function g_date_time_new_now_utc: PGDateTime; cdecl; external;
function g_date_time_new_utc(year: gint; month: gint; day: gint; hour: gint; minute: gint; seconds: gdouble): PGDateTime; cdecl; external;
function g_date_time_ref(datetime: PGDateTime): PGDateTime; cdecl; external;
function g_date_time_to_local(datetime: PGDateTime): PGDateTime; cdecl; external;
function g_date_time_to_timeval(datetime: PGDateTime; tv: PGTimeVal): gboolean; cdecl; external;
function g_date_time_to_timezone(datetime: PGDateTime; tz: PGTimeZone): PGDateTime; cdecl; external;
function g_date_time_to_unix(datetime: PGDateTime): gint64; cdecl; external;
function g_date_time_to_utc(datetime: PGDateTime): PGDateTime; cdecl; external;
function g_date_valid(date: PGDate): gboolean; cdecl; external;
function g_date_valid_day(day: TGDateDay): gboolean; cdecl; external;
function g_date_valid_dmy(day: TGDateDay; month: TGDateMonth; year: TGDateYear): gboolean; cdecl; external;
function g_date_valid_julian(julian_date: guint32): gboolean; cdecl; external;
function g_date_valid_month(month: TGDateMonth): gboolean; cdecl; external;
function g_date_valid_weekday(weekday: TGDateWeekday): gboolean; cdecl; external;
function g_date_valid_year(year: TGDateYear): gboolean; cdecl; external;
function g_dcgettext(domain: Pgchar; msgid: Pgchar; category: gint): Pgchar; cdecl; external;
function g_dgettext(domain: Pgchar; msgid: Pgchar): Pgchar; cdecl; external;
function g_dir_make_tmp(tmpl: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_dir_open(path: Pgchar; flags: guint; error: PPGError): PGDir; cdecl; external;
function g_dir_read_name(dir: PGDir): Pgchar; cdecl; external;
function g_direct_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external;
function g_direct_hash(v: Pgpointer): guint; cdecl; external;
function g_dngettext(domain: Pgchar; msgid: Pgchar; msgid_plural: Pgchar; n: gulong): Pgchar; cdecl; external;
function g_double_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external;
function g_double_hash(v: Pgpointer): guint; cdecl; external;
function g_dpgettext(domain: Pgchar; msgctxtid: Pgchar; msgidoffset: gsize): Pgchar; cdecl; external;
function g_dpgettext2(domain: Pgchar; context: Pgchar; msgid: Pgchar): Pgchar; cdecl; external;
function g_environ_getenv(envp: PPgchar; variable: Pgchar): Pgchar; cdecl; external;
function g_environ_setenv(envp: PPgchar; variable: Pgchar; value: Pgchar; overwrite: gboolean): PPgchar; cdecl; external;
function g_environ_unsetenv(envp: PPgchar; variable: Pgchar): PPgchar; cdecl; external;
function g_error_copy(error: PGError): PGError; cdecl; external;
function g_error_get_type: TGType; cdecl; external;
function g_error_matches(error: PGError; domain: TGQuark; code: gint): gboolean; cdecl; external;
function g_error_new(domain: TGQuark; code: gint; format: Pgchar; args: array of const): PGError; cdecl; external;
function g_error_new_literal(domain: TGQuark; code: gint; message: Pgchar): PGError; cdecl; external;
function g_error_new_valist(domain: TGQuark; code: gint; format: Pgchar; args: Tva_list): PGError; cdecl; external;
function g_file_error_from_errno(err_no: gint): TGFileError; cdecl; external;
function g_file_error_quark: TGQuark; cdecl; external;
function g_file_get_contents(filename: Pgchar; contents: PPgchar; length: Pgsize; error: PPGError): gboolean; cdecl; external;
function g_file_open_tmp(tmpl: Pgchar; name_used: PPgchar; error: PPGError): gint; cdecl; external;
function g_file_read_link(filename: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_file_set_contents(filename: Pgchar; contents: Pgchar; length: gssize; error: PPGError): gboolean; cdecl; external;
function g_file_test(filename: Pgchar; test: TGFileTest): gboolean; cdecl; external;
function g_filename_display_basename(filename: Pgchar): Pgchar; cdecl; external;
function g_filename_display_name(filename: Pgchar): Pgchar; cdecl; external;
function g_filename_from_uri(uri: Pgchar; hostname: PPgchar; error: PPGError): Pgchar; cdecl; external;
function g_filename_from_utf8(utf8string: Pgchar; len: gssize; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_filename_to_uri(filename: Pgchar; hostname: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_filename_to_utf8(opsysstring: Pgchar; len: gssize; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_find_program_in_path(program_: Pgchar): Pgchar; cdecl; external;
function g_format_size(size: guint64): Pgchar; cdecl; external;
function g_format_size_for_display(size: gint64): Pgchar; cdecl; external;
function g_format_size_full(size: guint64; flags: TGFormatSizeFlags): Pgchar; cdecl; external;
function g_fprintf(file_: Pgpointer; format: Pgchar; args: array of const): gint; cdecl; external;
function g_get_application_name: Pgchar; cdecl; external;
function g_get_charset(charset: PPgchar): gboolean; cdecl; external;
function g_get_codeset: Pgchar; cdecl; external;
function g_get_current_dir: Pgchar; cdecl; external;
function g_get_environ: PPgchar; cdecl; external;
function g_get_filename_charsets(charsets: PPPgchar): gboolean; cdecl; external;
function g_get_home_dir: Pgchar; cdecl; external;
function g_get_host_name: Pgchar; cdecl; external;
function g_get_language_names: PPgchar; cdecl; external;
function g_get_locale_variants(locale: Pgchar): PPgchar; cdecl; external;
function g_get_monotonic_time: gint64; cdecl; external;
function g_get_num_processors: guint; cdecl; external;
function g_get_prgname: Pgchar; cdecl; external;
function g_get_real_name: Pgchar; cdecl; external;
function g_get_real_time: gint64; cdecl; external;
function g_get_system_config_dirs: PPgchar; cdecl; external;
function g_get_system_data_dirs: PPgchar; cdecl; external;
function g_get_tmp_dir: Pgchar; cdecl; external;
function g_get_user_cache_dir: Pgchar; cdecl; external;
function g_get_user_config_dir: Pgchar; cdecl; external;
function g_get_user_data_dir: Pgchar; cdecl; external;
function g_get_user_name: Pgchar; cdecl; external;
function g_get_user_runtime_dir: Pgchar; cdecl; external;
function g_get_user_special_dir(directory: TGUserDirectory): Pgchar; cdecl; external;
function g_getenv(variable: Pgchar): Pgchar; cdecl; external;
function g_gstring_get_type: TGType; cdecl; external;
function g_hash_table_contains(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl; external;
function g_hash_table_find(hash_table: PGHashTable; predicate: TGHRFunc; user_data: gpointer): gpointer; cdecl; external;
function g_hash_table_foreach_remove(hash_table: PGHashTable; func: TGHRFunc; user_data: gpointer): guint; cdecl; external;
function g_hash_table_foreach_steal(hash_table: PGHashTable; func: TGHRFunc; user_data: gpointer): guint; cdecl; external;
function g_hash_table_get_keys(hash_table: PGHashTable): PGList; cdecl; external;
function g_hash_table_get_type: TGType; cdecl; external;
function g_hash_table_get_values(hash_table: PGHashTable): PGList; cdecl; external;
function g_hash_table_iter_get_hash_table(iter: PGHashTableIter): PGHashTable; cdecl; external;
function g_hash_table_iter_next(iter: PGHashTableIter; key: Pgpointer; value: Pgpointer): gboolean; cdecl; external;
function g_hash_table_lookup(hash_table: PGHashTable; key: Pgpointer): gpointer; cdecl; external;
function g_hash_table_lookup_extended(hash_table: PGHashTable; lookup_key: Pgpointer; orig_key: Pgpointer; value: Pgpointer): gboolean; cdecl; external;
function g_hash_table_new(hash_func: TGHashFunc; key_equal_func: TGEqualFunc): PGHashTable; cdecl; external;
function g_hash_table_new_full(hash_func: TGHashFunc; key_equal_func: TGEqualFunc; key_destroy_func: TGDestroyNotify; value_destroy_func: TGDestroyNotify): PGHashTable; cdecl; external;
function g_hash_table_ref(hash_table: PGHashTable): PGHashTable; cdecl; external;
function g_hash_table_remove(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl; external;
function g_hash_table_size(hash_table: PGHashTable): guint; cdecl; external;
function g_hash_table_steal(hash_table: PGHashTable; key: Pgpointer): gboolean; cdecl; external;
function g_hmac_copy(hmac: PGHmac): PGHmac; cdecl; external;
function g_hmac_get_string(hmac: PGHmac): Pgchar; cdecl; external;
function g_hmac_new(digest_type: TGChecksumType; key: Pguint8; key_len: gsize): PGHmac; cdecl; external;
function g_hmac_ref(hmac: PGHmac): PGHmac; cdecl; external;
function g_hook_alloc(hook_list: PGHookList): PGHook; cdecl; external;
function g_hook_compare_ids(new_hook: PGHook; sibling: PGHook): gint; cdecl; external;
function g_hook_destroy(hook_list: PGHookList; hook_id: gulong): gboolean; cdecl; external;
function g_hook_find(hook_list: PGHookList; need_valids: gboolean; func: TGHookFindFunc; data: gpointer): PGHook; cdecl; external;
function g_hook_find_data(hook_list: PGHookList; need_valids: gboolean; data: gpointer): PGHook; cdecl; external;
function g_hook_find_func(hook_list: PGHookList; need_valids: gboolean; func: gpointer): PGHook; cdecl; external;
function g_hook_find_func_data(hook_list: PGHookList; need_valids: gboolean; func: gpointer; data: gpointer): PGHook; cdecl; external;
function g_hook_first_valid(hook_list: PGHookList; may_be_in_call: gboolean): PGHook; cdecl; external;
function g_hook_get(hook_list: PGHookList; hook_id: gulong): PGHook; cdecl; external;
function g_hook_next_valid(hook_list: PGHookList; hook: PGHook; may_be_in_call: gboolean): PGHook; cdecl; external;
function g_hook_ref(hook_list: PGHookList; hook: PGHook): PGHook; cdecl; external;
function g_hostname_is_ascii_encoded(hostname: Pgchar): gboolean; cdecl; external;
function g_hostname_is_ip_address(hostname: Pgchar): gboolean; cdecl; external;
function g_hostname_is_non_ascii(hostname: Pgchar): gboolean; cdecl; external;
function g_hostname_to_ascii(hostname: Pgchar): Pgchar; cdecl; external;
function g_hostname_to_unicode(hostname: Pgchar): Pgchar; cdecl; external;
function g_iconv(converter: TGIConv; inbuf: PPgchar; inbytes_left: Pgsize; outbuf: PPgchar; outbytes_left: Pgsize): gsize; cdecl; external;
function g_iconv_close(converter: TGIConv): gint; cdecl; external;
function g_iconv_open(to_codeset: Pgchar; from_codeset: Pgchar): TGIConv; cdecl; external;
function g_idle_add(function_: TGSourceFunc; data: gpointer): guint; cdecl; external;
function g_idle_add_full(priority: gint; function_: TGSourceFunc; data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_idle_remove_by_data(data: gpointer): gboolean; cdecl; external;
function g_idle_source_new: PGSource; cdecl; external;
function g_int64_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external;
function g_int64_hash(v: Pgpointer): guint; cdecl; external;
function g_int_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external;
function g_int_hash(v: Pgpointer): guint; cdecl; external;
function g_intern_static_string(string_: Pgchar): Pgchar; cdecl; external;
function g_intern_string(string_: Pgchar): Pgchar; cdecl; external;
function g_io_add_watch(channel: PGIOChannel; condition: TGIOCondition; func: TGIOFunc; user_data: gpointer): guint; cdecl; external;
function g_io_add_watch_full(channel: PGIOChannel; priority: gint; condition: TGIOCondition; func: TGIOFunc; user_data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_io_channel_error_from_errno(en: gint): TGIOChannelError; cdecl; external;
function g_io_channel_error_quark: TGQuark; cdecl; external;
function g_io_channel_flush(channel: PGIOChannel; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_get_buffer_condition(channel: PGIOChannel): TGIOCondition; cdecl; external;
function g_io_channel_get_buffer_size(channel: PGIOChannel): gsize; cdecl; external;
function g_io_channel_get_buffered(channel: PGIOChannel): gboolean; cdecl; external;
function g_io_channel_get_close_on_unref(channel: PGIOChannel): gboolean; cdecl; external;
function g_io_channel_get_encoding(channel: PGIOChannel): Pgchar; cdecl; external;
function g_io_channel_get_flags(channel: PGIOChannel): TGIOFlags; cdecl; external;
function g_io_channel_get_line_term(channel: PGIOChannel; length: Pgint): Pgchar; cdecl; external;
function g_io_channel_get_type: TGType; cdecl; external;
function g_io_channel_new_file(filename: Pgchar; mode: Pgchar; error: PPGError): PGIOChannel; cdecl; external;
function g_io_channel_read_chars(channel: PGIOChannel; buf: Pgchar; count: gsize; bytes_read: Pgsize; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_read_line(channel: PGIOChannel; str_return: PPgchar; length: Pgsize; terminator_pos: Pgsize; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_read_line_string(channel: PGIOChannel; buffer: PGString; terminator_pos: Pgsize; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_read_to_end(channel: PGIOChannel; str_return: PPgchar; length: Pgsize; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_read_unichar(channel: PGIOChannel; thechar: Pgunichar; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_ref(channel: PGIOChannel): PGIOChannel; cdecl; external;
function g_io_channel_seek_position(channel: PGIOChannel; offset: gint64; type_: TGSeekType; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_set_encoding(channel: PGIOChannel; encoding: Pgchar; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_set_flags(channel: PGIOChannel; flags: TGIOFlags; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_shutdown(channel: PGIOChannel; flush: gboolean; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_unix_get_fd(channel: PGIOChannel): gint; cdecl; external;
function g_io_channel_unix_new(fd: gint): PGIOChannel; cdecl; external;
function g_io_channel_write_chars(channel: PGIOChannel; buf: Pgchar; count: gssize; bytes_written: Pgsize; error: PPGError): TGIOStatus; cdecl; external;
function g_io_channel_write_unichar(channel: PGIOChannel; thechar: gunichar; error: PPGError): TGIOStatus; cdecl; external;
function g_io_create_watch(channel: PGIOChannel; condition: TGIOCondition): PGSource; cdecl; external;
function g_key_file_error_quark: TGQuark; cdecl; external;
function g_key_file_get_boolean(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_get_boolean_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgboolean; cdecl; external;
function g_key_file_get_comment(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_key_file_get_double(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gdouble; cdecl; external;
function g_key_file_get_double_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgdouble; cdecl; external;
function g_key_file_get_groups(key_file: PGKeyFile; length: Pgsize): PPgchar; cdecl; external;
function g_key_file_get_int64(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gint64; cdecl; external;
function g_key_file_get_integer(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gint; cdecl; external;
function g_key_file_get_integer_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): Pgint; cdecl; external;
function g_key_file_get_keys(key_file: PGKeyFile; group_name: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; external;
function g_key_file_get_locale_string(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; locale: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_key_file_get_locale_string_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; locale: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; external;
function g_key_file_get_start_group(key_file: PGKeyFile): Pgchar; cdecl; external;
function g_key_file_get_string(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_key_file_get_string_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; length: Pgsize; error: PPGError): PPgchar; cdecl; external;
function g_key_file_get_type: TGType; cdecl; external;
function g_key_file_get_uint64(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): guint64; cdecl; external;
function g_key_file_get_value(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_key_file_has_group(key_file: PGKeyFile; group_name: Pgchar): gboolean; cdecl; external;
function g_key_file_has_key(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_load_from_data(key_file: PGKeyFile; data: Pgchar; length: gsize; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; external;
function g_key_file_load_from_data_dirs(key_file: PGKeyFile; file_: Pgchar; full_path: PPgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; external;
function g_key_file_load_from_dirs(key_file: PGKeyFile; file_: Pgchar; search_dirs: PPgchar; full_path: PPgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; external;
function g_key_file_load_from_file(key_file: PGKeyFile; file_: Pgchar; flags: TGKeyFileFlags; error: PPGError): gboolean; cdecl; external;
function g_key_file_new: PGKeyFile; cdecl; external;
function g_key_file_ref(key_file: PGKeyFile): PGKeyFile; cdecl; external;
function g_key_file_remove_comment(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_remove_group(key_file: PGKeyFile; group_name: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_remove_key(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_set_comment(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; comment: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_key_file_to_data(key_file: PGKeyFile; length: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_list_alloc: PGList; cdecl; external;
function g_list_append(list: PGList; data: gpointer): PGList; cdecl; external;
function g_list_concat(list1: PGList; list2: PGList): PGList; cdecl; external;
function g_list_copy(list: PGList): PGList; cdecl; external;
function g_list_copy_deep(list: PGList; func: TGCopyFunc; user_data: gpointer): PGList; cdecl; external;
function g_list_delete_link(list: PGList; link_: PGList): PGList; cdecl; external;
function g_list_find(list: PGList; data: Pgpointer): PGList; cdecl; external;
function g_list_find_custom(list: PGList; data: Pgpointer; func: TGCompareFunc): PGList; cdecl; external;
function g_list_first(list: PGList): PGList; cdecl; external;
function g_list_index(list: PGList; data: Pgpointer): gint; cdecl; external;
function g_list_insert(list: PGList; data: gpointer; position: gint): PGList; cdecl; external;
function g_list_insert_before(list: PGList; sibling: PGList; data: gpointer): PGList; cdecl; external;
function g_list_insert_sorted(list: PGList; data: gpointer; func: TGCompareFunc): PGList; cdecl; external;
function g_list_insert_sorted_with_data(list: PGList; data: gpointer; func: TGCompareDataFunc; user_data: gpointer): PGList; cdecl; external;
function g_list_last(list: PGList): PGList; cdecl; external;
function g_list_length(list: PGList): guint; cdecl; external;
function g_list_nth(list: PGList; n: guint): PGList; cdecl; external;
function g_list_nth_data(list: PGList; n: guint): gpointer; cdecl; external;
function g_list_nth_prev(list: PGList; n: guint): PGList; cdecl; external;
function g_list_position(list: PGList; llink: PGList): gint; cdecl; external;
function g_list_prepend(list: PGList; data: gpointer): PGList; cdecl; external;
function g_list_remove(list: PGList; data: Pgpointer): PGList; cdecl; external;
function g_list_remove_all(list: PGList; data: Pgpointer): PGList; cdecl; external;
function g_list_remove_link(list: PGList; llink: PGList): PGList; cdecl; external;
function g_list_reverse(list: PGList): PGList; cdecl; external;
function g_list_sort(list: PGList; compare_func: TGCompareFunc): PGList; cdecl; external;
function g_list_sort_with_data(list: PGList; compare_func: TGCompareDataFunc; user_data: gpointer): PGList; cdecl; external;
function g_listenv: PPgchar; cdecl; external;
function g_locale_from_utf8(utf8string: Pgchar; len: gssize; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_locale_to_utf8(opsysstring: Pgchar; len: gssize; bytes_read: Pgsize; bytes_written: Pgsize; error: PPGError): Pgchar; cdecl; external;
function g_log_set_always_fatal(fatal_mask: TGLogLevelFlags): TGLogLevelFlags; cdecl; external;
function g_log_set_default_handler(log_func: TGLogFunc; user_data: gpointer): TGLogFunc; cdecl; external;
function g_log_set_fatal_mask(log_domain: Pgchar; fatal_mask: TGLogLevelFlags): TGLogLevelFlags; cdecl; external;
function g_log_set_handler(log_domain: Pgchar; log_levels: TGLogLevelFlags; log_func: TGLogFunc; user_data: gpointer): guint; cdecl; external;
function g_main_context_acquire(context: PGMainContext): gboolean; cdecl; external;
function g_main_context_check(context: PGMainContext; max_priority: gint; fds: PGPollFD; n_fds: gint): gint; cdecl; external;
function g_main_context_default: PGMainContext; cdecl; external;
function g_main_context_find_source_by_funcs_user_data(context: PGMainContext; funcs: PGSourceFuncs; user_data: gpointer): PGSource; cdecl; external;
function g_main_context_find_source_by_id(context: PGMainContext; source_id: guint): PGSource; cdecl; external;
function g_main_context_find_source_by_user_data(context: PGMainContext; user_data: gpointer): PGSource; cdecl; external;
function g_main_context_get_poll_func(context: PGMainContext): TGPollFunc; cdecl; external;
function g_main_context_get_thread_default: PGMainContext; cdecl; external;
function g_main_context_get_type: TGType; cdecl; external;
function g_main_context_is_owner(context: PGMainContext): gboolean; cdecl; external;
function g_main_context_iteration(context: PGMainContext; may_block: gboolean): gboolean; cdecl; external;
function g_main_context_new: PGMainContext; cdecl; external;
function g_main_context_pending(context: PGMainContext): gboolean; cdecl; external;
function g_main_context_prepare(context: PGMainContext; priority: Pgint): gboolean; cdecl; external;
function g_main_context_query(context: PGMainContext; max_priority: gint; timeout_: Pgint; fds: PGPollFD; n_fds: gint): gint; cdecl; external;
function g_main_context_ref(context: PGMainContext): PGMainContext; cdecl; external;
function g_main_context_ref_thread_default: PGMainContext; cdecl; external;
function g_main_context_wait(context: PGMainContext; cond: PGCond; mutex: PGMutex): gboolean; cdecl; external;
function g_main_current_source: PGSource; cdecl; external;
function g_main_depth: gint; cdecl; external;
function g_main_loop_get_context(loop: PGMainLoop): PGMainContext; cdecl; external;
function g_main_loop_get_type: TGType; cdecl; external;
function g_main_loop_is_running(loop: PGMainLoop): gboolean; cdecl; external;
function g_main_loop_new(context: PGMainContext; is_running: gboolean): PGMainLoop; cdecl; external;
function g_main_loop_ref(loop: PGMainLoop): PGMainLoop; cdecl; external;
function g_malloc(n_bytes: gsize): gpointer; cdecl; external;
function g_malloc0(n_bytes: gsize): gpointer; cdecl; external;
function g_malloc0_n(n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_malloc_n(n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_mapped_file_get_bytes(file_: PGMappedFile): PGBytes; cdecl; external;
function g_mapped_file_get_contents(file_: PGMappedFile): Pgchar; cdecl; external;
function g_mapped_file_get_length(file_: PGMappedFile): gsize; cdecl; external;
function g_mapped_file_new(filename: Pgchar; writable: gboolean; error: PPGError): PGMappedFile; cdecl; external;
function g_mapped_file_new_from_fd(fd: gint; writable: gboolean; error: PPGError): PGMappedFile; cdecl; external;
function g_mapped_file_ref(file_: PGMappedFile): PGMappedFile; cdecl; external;
function g_markup_collect_attributes(element_name: Pgchar; attribute_names: PPgchar; attribute_values: PPgchar; error: PPGError; first_type: TGMarkupCollectType; first_attr: Pgchar; args: array of const): gboolean; cdecl; external;
function g_markup_error_quark: TGQuark; cdecl; external;
function g_markup_escape_text(text: Pgchar; length: gssize): Pgchar; cdecl; external;
function g_markup_parse_context_end_parse(context: PGMarkupParseContext; error: PPGError): gboolean; cdecl; external;
function g_markup_parse_context_get_element(context: PGMarkupParseContext): Pgchar; cdecl; external;
function g_markup_parse_context_get_element_stack(context: PGMarkupParseContext): PGSList; cdecl; external;
function g_markup_parse_context_get_type: TGType; cdecl; external;
function g_markup_parse_context_get_user_data(context: PGMarkupParseContext): gpointer; cdecl; external;
function g_markup_parse_context_new(parser: PGMarkupParser; flags: TGMarkupParseFlags; user_data: gpointer; user_data_dnotify: TGDestroyNotify): PGMarkupParseContext; cdecl; external;
function g_markup_parse_context_parse(context: PGMarkupParseContext; text: Pgchar; text_len: gssize; error: PPGError): gboolean; cdecl; external;
function g_markup_parse_context_pop(context: PGMarkupParseContext): gpointer; cdecl; external;
function g_markup_parse_context_ref(context: PGMarkupParseContext): PGMarkupParseContext; cdecl; external;
function g_markup_printf_escaped(format: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_markup_vprintf_escaped(format: Pgchar; args: Tva_list): Pgchar; cdecl; external;
function g_match_info_expand_references(match_info: PGMatchInfo; string_to_expand: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_match_info_fetch(match_info: PGMatchInfo; match_num: gint): Pgchar; cdecl; external;
function g_match_info_fetch_all(match_info: PGMatchInfo): PPgchar; cdecl; external;
function g_match_info_fetch_named(match_info: PGMatchInfo; name: Pgchar): Pgchar; cdecl; external;
function g_match_info_fetch_named_pos(match_info: PGMatchInfo; name: Pgchar; start_pos: Pgint; end_pos: Pgint): gboolean; cdecl; external;
function g_match_info_fetch_pos(match_info: PGMatchInfo; match_num: gint; start_pos: Pgint; end_pos: Pgint): gboolean; cdecl; external;
function g_match_info_get_match_count(match_info: PGMatchInfo): gint; cdecl; external;
function g_match_info_get_regex(match_info: PGMatchInfo): PGRegex; cdecl; external;
function g_match_info_get_string(match_info: PGMatchInfo): Pgchar; cdecl; external;
function g_match_info_get_type: TGType; cdecl; external;
function g_match_info_is_partial_match(match_info: PGMatchInfo): gboolean; cdecl; external;
function g_match_info_matches(match_info: PGMatchInfo): gboolean; cdecl; external;
function g_match_info_next(match_info: PGMatchInfo; error: PPGError): gboolean; cdecl; external;
function g_match_info_ref(match_info: PGMatchInfo): PGMatchInfo; cdecl; external;
function g_mem_is_system_malloc: gboolean; cdecl; external;
function g_memdup(mem: Pgpointer; byte_size: guint): gpointer; cdecl; external;
function g_mkdir_with_parents(pathname: Pgchar; mode: gint): gint; cdecl; external;
function g_mkdtemp(tmpl: Pgchar): Pgchar; cdecl; external;
function g_mkdtemp_full(tmpl: Pgchar; mode: gint): Pgchar; cdecl; external;
function g_mkstemp(tmpl: Pgchar): gint; cdecl; external;
function g_mkstemp_full(tmpl: Pgchar; flags: gint; mode: gint): gint; cdecl; external;
function g_mutex_trylock(mutex: PGMutex): gboolean; cdecl; external;
function g_node_child_index(node: PGNode; data: gpointer): gint; cdecl; external;
function g_node_child_position(node: PGNode; child: PGNode): gint; cdecl; external;
function g_node_copy(node: PGNode): PGNode; cdecl; external;
function g_node_copy_deep(node: PGNode; copy_func: TGCopyFunc; data: gpointer): PGNode; cdecl; external;
function g_node_depth(node: PGNode): guint; cdecl; external;
function g_node_find(root: PGNode; order: TGTraverseType; flags: TGTraverseFlags; data: gpointer): PGNode; cdecl; external;
function g_node_find_child(node: PGNode; flags: TGTraverseFlags; data: gpointer): PGNode; cdecl; external;
function g_node_first_sibling(node: PGNode): PGNode; cdecl; external;
function g_node_get_root(node: PGNode): PGNode; cdecl; external;
function g_node_insert(parent: PGNode; position: gint; node: PGNode): PGNode; cdecl; external;
function g_node_insert_after(parent: PGNode; sibling: PGNode; node: PGNode): PGNode; cdecl; external;
function g_node_insert_before(parent: PGNode; sibling: PGNode; node: PGNode): PGNode; cdecl; external;
function g_node_is_ancestor(node: PGNode; descendant: PGNode): gboolean; cdecl; external;
function g_node_last_child(node: PGNode): PGNode; cdecl; external;
function g_node_last_sibling(node: PGNode): PGNode; cdecl; external;
function g_node_max_height(root: PGNode): guint; cdecl; external;
function g_node_n_children(node: PGNode): guint; cdecl; external;
function g_node_n_nodes(root: PGNode; flags: TGTraverseFlags): guint; cdecl; external;
function g_node_new(data: gpointer): PGNode; cdecl; external;
function g_node_nth_child(node: PGNode; n: guint): PGNode; cdecl; external;
function g_node_prepend(parent: PGNode; node: PGNode): PGNode; cdecl; external;
function g_once_impl(once: PGOnce; func: TGThreadFunc; arg: gpointer): gpointer; cdecl; external;
function g_once_init_enter(location: Pgpointer): gboolean; cdecl; external;
function g_option_context_get_description(context: PGOptionContext): Pgchar; cdecl; external;
function g_option_context_get_help(context: PGOptionContext; main_help: gboolean; group: PGOptionGroup): Pgchar; cdecl; external;
function g_option_context_get_help_enabled(context: PGOptionContext): gboolean; cdecl; external;
function g_option_context_get_ignore_unknown_options(context: PGOptionContext): gboolean; cdecl; external;
function g_option_context_get_main_group(context: PGOptionContext): PGOptionGroup; cdecl; external;
function g_option_context_get_summary(context: PGOptionContext): Pgchar; cdecl; external;
function g_option_context_new(parameter_string: Pgchar): PGOptionContext; cdecl; external;
function g_option_context_parse(context: PGOptionContext; argc: Pgint; argv: PPPgchar; error: PPGError): gboolean; cdecl; external;
function g_option_error_quark: TGQuark; cdecl; external;
function g_option_group_new(name: Pgchar; description: Pgchar; help_description: Pgchar; user_data: gpointer; destroy_: TGDestroyNotify): PGOptionGroup; cdecl; external;
function g_parse_debug_string(string_: Pgchar; keys: PGDebugKey; nkeys: guint): guint; cdecl; external;
function g_path_get_basename(file_name: Pgchar): Pgchar; cdecl; external;
function g_path_get_dirname(file_name: Pgchar): Pgchar; cdecl; external;
function g_path_is_absolute(file_name: Pgchar): gboolean; cdecl; external;
function g_path_skip_root(file_name: Pgchar): Pgchar; cdecl; external;
function g_pattern_match(pspec: PGPatternSpec; string_length: guint; string_: Pgchar; string_reversed: Pgchar): gboolean; cdecl; external;
function g_pattern_match_simple(pattern: Pgchar; string_: Pgchar): gboolean; cdecl; external;
function g_pattern_match_string(pspec: PGPatternSpec; string_: Pgchar): gboolean; cdecl; external;
function g_pattern_spec_equal(pspec1: PGPatternSpec; pspec2: PGPatternSpec): gboolean; cdecl; external;
function g_pattern_spec_new(pattern: Pgchar): PGPatternSpec; cdecl; external;
function g_pointer_bit_trylock(address: Pgpointer; lock_bit: gint): gboolean; cdecl; external;
function g_poll(fds: PGPollFD; nfds: guint; timeout: gint): gint; cdecl; external;
function g_pollfd_get_type: TGType; cdecl; external;
function g_printf(format: Pgchar; args: array of const): gint; cdecl; external;
function g_printf_string_upper_bound(format: Pgchar; args: Tva_list): gsize; cdecl; external;
function g_private_get(key: PGPrivate): gpointer; cdecl; external;
function g_ptr_array_free(array_: Pgpointer; free_seg: gboolean): Pgpointer; cdecl; external;
function g_ptr_array_get_type: TGType; cdecl; external;
function g_ptr_array_new: Pgpointer; cdecl; external;
function g_ptr_array_new_full(reserved_size: guint; element_free_func: TGDestroyNotify): Pgpointer; cdecl; external;
function g_ptr_array_new_with_free_func(element_free_func: TGDestroyNotify): Pgpointer; cdecl; external;
function g_ptr_array_ref(array_: Pgpointer): Pgpointer; cdecl; external;
function g_ptr_array_remove(array_: Pgpointer; data: gpointer): gboolean; cdecl; external;
function g_ptr_array_remove_fast(array_: Pgpointer; data: gpointer): gboolean; cdecl; external;
function g_ptr_array_remove_index(array_: Pgpointer; index_: guint): gpointer; cdecl; external;
function g_ptr_array_remove_index_fast(array_: Pgpointer; index_: guint): gpointer; cdecl; external;
function g_ptr_array_sized_new(reserved_size: guint): Pgpointer; cdecl; external;
function g_quark_from_static_string(string_: Pgchar): TGQuark; cdecl; external;
function g_quark_from_string(string_: Pgchar): TGQuark; cdecl; external;
function g_quark_to_string(quark: TGQuark): Pgchar; cdecl; external;
function g_quark_try_string(string_: Pgchar): TGQuark; cdecl; external;
function g_queue_copy(queue: PGQueue): PGQueue; cdecl; external;
function g_queue_find(queue: PGQueue; data: Pgpointer): PGList; cdecl; external;
function g_queue_find_custom(queue: PGQueue; data: Pgpointer; func: TGCompareFunc): PGList; cdecl; external;
function g_queue_get_length(queue: PGQueue): guint; cdecl; external;
function g_queue_index(queue: PGQueue; data: Pgpointer): gint; cdecl; external;
function g_queue_is_empty(queue: PGQueue): gboolean; cdecl; external;
function g_queue_link_index(queue: PGQueue; link_: PGList): gint; cdecl; external;
function g_queue_new: PGQueue; cdecl; external;
function g_queue_peek_head(queue: PGQueue): gpointer; cdecl; external;
function g_queue_peek_head_link(queue: PGQueue): PGList; cdecl; external;
function g_queue_peek_nth(queue: PGQueue; n: guint): gpointer; cdecl; external;
function g_queue_peek_nth_link(queue: PGQueue; n: guint): PGList; cdecl; external;
function g_queue_peek_tail(queue: PGQueue): gpointer; cdecl; external;
function g_queue_peek_tail_link(queue: PGQueue): PGList; cdecl; external;
function g_queue_pop_head(queue: PGQueue): gpointer; cdecl; external;
function g_queue_pop_head_link(queue: PGQueue): PGList; cdecl; external;
function g_queue_pop_nth(queue: PGQueue; n: guint): gpointer; cdecl; external;
function g_queue_pop_nth_link(queue: PGQueue; n: guint): PGList; cdecl; external;
function g_queue_pop_tail(queue: PGQueue): gpointer; cdecl; external;
function g_queue_pop_tail_link(queue: PGQueue): PGList; cdecl; external;
function g_queue_remove(queue: PGQueue; data: Pgpointer): gboolean; cdecl; external;
function g_queue_remove_all(queue: PGQueue; data: Pgpointer): guint; cdecl; external;
function g_rand_copy(rand_: PGRand): PGRand; cdecl; external;
function g_rand_double(rand_: PGRand): gdouble; cdecl; external;
function g_rand_double_range(rand_: PGRand; begin_: gdouble; end_: gdouble): gdouble; cdecl; external;
function g_rand_int(rand_: PGRand): guint32; cdecl; external;
function g_rand_int_range(rand_: PGRand; begin_: gint32; end_: gint32): gint32; cdecl; external;
function g_rand_new: PGRand; cdecl; external;
function g_rand_new_with_seed(seed: guint32): PGRand; cdecl; external;
function g_rand_new_with_seed_array(seed: Pguint32; seed_length: guint): PGRand; cdecl; external;
function g_random_double: gdouble; cdecl; external;
function g_random_double_range(begin_: gdouble; end_: gdouble): gdouble; cdecl; external;
function g_random_int: guint32; cdecl; external;
function g_random_int_range(begin_: gint32; end_: gint32): gint32; cdecl; external;
function g_realloc(mem: gpointer; n_bytes: gsize): gpointer; cdecl; external;
function g_realloc_n(mem: gpointer; n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_rec_mutex_trylock(rec_mutex: PGRecMutex): gboolean; cdecl; external;
function g_regex_check_replacement(replacement: Pgchar; has_references: Pgboolean; error: PPGError): gboolean; cdecl; external;
function g_regex_error_quark: TGQuark; cdecl; external;
function g_regex_escape_nul(string_: Pgchar; length: gint): Pgchar; cdecl; external;
function g_regex_escape_string(string_: Pgchar; length: gint): Pgchar; cdecl; external;
function g_regex_get_capture_count(regex: PGRegex): gint; cdecl; external;
function g_regex_get_compile_flags(regex: PGRegex): TGRegexCompileFlags; cdecl; external;
function g_regex_get_has_cr_or_lf(regex: PGRegex): gboolean; cdecl; external;
function g_regex_get_match_flags(regex: PGRegex): TGRegexMatchFlags; cdecl; external;
function g_regex_get_max_backref(regex: PGRegex): gint; cdecl; external;
function g_regex_get_pattern(regex: PGRegex): Pgchar; cdecl; external;
function g_regex_get_string_number(regex: PGRegex; name: Pgchar): gint; cdecl; external;
function g_regex_get_type: TGType; cdecl; external;
function g_regex_match(regex: PGRegex; string_: Pgchar; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo): gboolean; cdecl; external;
function g_regex_match_all(regex: PGRegex; string_: Pgchar; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo): gboolean; cdecl; external;
function g_regex_match_all_full(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo; error: PPGError): gboolean; cdecl; external;
function g_regex_match_full(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; match_info: PPGMatchInfo; error: PPGError): gboolean; cdecl; external;
function g_regex_match_simple(pattern: Pgchar; string_: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags): gboolean; cdecl; external;
function g_regex_new(pattern: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags; error: PPGError): PGRegex; cdecl; external;
function g_regex_ref(regex: PGRegex): PGRegex; cdecl; external;
function g_regex_replace(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; replacement: Pgchar; match_options: TGRegexMatchFlags; error: PPGError): Pgchar; cdecl; external;
function g_regex_replace_eval(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; eval: TGRegexEvalCallback; user_data: gpointer; error: PPGError): Pgchar; cdecl; external;
function g_regex_replace_literal(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; replacement: Pgchar; match_options: TGRegexMatchFlags; error: PPGError): Pgchar; cdecl; external;
function g_regex_split(regex: PGRegex; string_: Pgchar; match_options: TGRegexMatchFlags): PPgchar; cdecl; external;
function g_regex_split_full(regex: PGRegex; string_: Pgchar; string_len: gssize; start_position: gint; match_options: TGRegexMatchFlags; max_tokens: gint; error: PPGError): PPgchar; cdecl; external;
function g_regex_split_simple(pattern: Pgchar; string_: Pgchar; compile_options: TGRegexCompileFlags; match_options: TGRegexMatchFlags): PPgchar; cdecl; external;
function g_rmdir(filename: Pgchar): gint; cdecl; external;
function g_rw_lock_reader_trylock(rw_lock: PGRWLock): gboolean; cdecl; external;
function g_rw_lock_writer_trylock(rw_lock: PGRWLock): gboolean; cdecl; external;
function g_scanner_cur_line(scanner: PGScanner): guint; cdecl; external;
function g_scanner_cur_position(scanner: PGScanner): guint; cdecl; external;
function g_scanner_cur_token(scanner: PGScanner): TGTokenType; cdecl; external;
function g_scanner_cur_value(scanner: PGScanner): TGTokenValue; cdecl; external;
function g_scanner_eof(scanner: PGScanner): gboolean; cdecl; external;
function g_scanner_get_next_token(scanner: PGScanner): TGTokenType; cdecl; external;
function g_scanner_lookup_symbol(scanner: PGScanner; symbol: Pgchar): gpointer; cdecl; external;
function g_scanner_new(config_templ: PGScannerConfig): PGScanner; cdecl; external;
function g_scanner_peek_next_token(scanner: PGScanner): TGTokenType; cdecl; external;
function g_scanner_scope_lookup_symbol(scanner: PGScanner; scope_id: guint; symbol: Pgchar): gpointer; cdecl; external;
function g_scanner_set_scope(scanner: PGScanner; scope_id: guint): guint; cdecl; external;
function g_sequence_append(seq: PGSequence; data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_get(iter: PGSequenceIter): gpointer; cdecl; external;
function g_sequence_get_begin_iter(seq: PGSequence): PGSequenceIter; cdecl; external;
function g_sequence_get_end_iter(seq: PGSequence): PGSequenceIter; cdecl; external;
function g_sequence_get_iter_at_pos(seq: PGSequence; pos: gint): PGSequenceIter; cdecl; external;
function g_sequence_get_length(seq: PGSequence): gint; cdecl; external;
function g_sequence_insert_before(iter: PGSequenceIter; data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_insert_sorted(seq: PGSequence; data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_insert_sorted_iter(seq: PGSequence; data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_iter_compare(a: PGSequenceIter; b: PGSequenceIter): gint; cdecl; external;
function g_sequence_iter_get_position(iter: PGSequenceIter): gint; cdecl; external;
function g_sequence_iter_get_sequence(iter: PGSequenceIter): PGSequence; cdecl; external;
function g_sequence_iter_is_begin(iter: PGSequenceIter): gboolean; cdecl; external;
function g_sequence_iter_is_end(iter: PGSequenceIter): gboolean; cdecl; external;
function g_sequence_iter_move(iter: PGSequenceIter; delta: gint): PGSequenceIter; cdecl; external;
function g_sequence_iter_next(iter: PGSequenceIter): PGSequenceIter; cdecl; external;
function g_sequence_iter_prev(iter: PGSequenceIter): PGSequenceIter; cdecl; external;
function g_sequence_lookup(seq: PGSequence; data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_lookup_iter(seq: PGSequence; data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_new(data_destroy: TGDestroyNotify): PGSequence; cdecl; external;
function g_sequence_prepend(seq: PGSequence; data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_range_get_midpoint(begin_: PGSequenceIter; end_: PGSequenceIter): PGSequenceIter; cdecl; external;
function g_sequence_search(seq: PGSequence; data: gpointer; cmp_func: TGCompareDataFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_sequence_search_iter(seq: PGSequence; data: gpointer; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer): PGSequenceIter; cdecl; external;
function g_set_print_handler(func: TGPrintFunc): TGPrintFunc; cdecl; external;
function g_set_printerr_handler(func: TGPrintFunc): TGPrintFunc; cdecl; external;
function g_setenv(variable: Pgchar; value: Pgchar; overwrite: gboolean): gboolean; cdecl; external;
function g_shell_error_quark: TGQuark; cdecl; external;
function g_shell_parse_argv(command_line: Pgchar; argcp: Pgint; argvp: PPPgchar; error: PPGError): gboolean; cdecl; external;
function g_shell_quote(unquoted_string: Pgchar): Pgchar; cdecl; external;
function g_shell_unquote(quoted_string: Pgchar; error: PPGError): Pgchar; cdecl; external;
function g_slice_alloc(block_size: gsize): gpointer; cdecl; external;
function g_slice_alloc0(block_size: gsize): gpointer; cdecl; external;
function g_slice_copy(block_size: gsize; mem_block: Pgpointer): gpointer; cdecl; external;
function g_slice_get_config(ckey: TGSliceConfig): gint64; cdecl; external;
function g_slice_get_config_state(ckey: TGSliceConfig; address: gint64; n_values: Pguint): Pgint64; cdecl; external;
function g_slist_alloc: PGSList; cdecl; external;
function g_slist_append(list: PGSList; data: gpointer): PGSList; cdecl; external;
function g_slist_concat(list1: PGSList; list2: PGSList): PGSList; cdecl; external;
function g_slist_copy(list: PGSList): PGSList; cdecl; external;
function g_slist_copy_deep(list: PGSList; func: TGCopyFunc; user_data: gpointer): PGSList; cdecl; external;
function g_slist_delete_link(list: PGSList; link_: PGSList): PGSList; cdecl; external;
function g_slist_find(list: PGSList; data: Pgpointer): PGSList; cdecl; external;
function g_slist_find_custom(list: PGSList; data: Pgpointer; func: TGCompareFunc): PGSList; cdecl; external;
function g_slist_index(list: PGSList; data: Pgpointer): gint; cdecl; external;
function g_slist_insert(list: PGSList; data: gpointer; position: gint): PGSList; cdecl; external;
function g_slist_insert_before(slist: PGSList; sibling: PGSList; data: gpointer): PGSList; cdecl; external;
function g_slist_insert_sorted(list: PGSList; data: gpointer; func: TGCompareFunc): PGSList; cdecl; external;
function g_slist_insert_sorted_with_data(list: PGSList; data: gpointer; func: TGCompareDataFunc; user_data: gpointer): PGSList; cdecl; external;
function g_slist_last(list: PGSList): PGSList; cdecl; external;
function g_slist_length(list: PGSList): guint; cdecl; external;
function g_slist_nth(list: PGSList; n: guint): PGSList; cdecl; external;
function g_slist_nth_data(list: PGSList; n: guint): gpointer; cdecl; external;
function g_slist_position(list: PGSList; llink: PGSList): gint; cdecl; external;
function g_slist_prepend(list: PGSList; data: gpointer): PGSList; cdecl; external;
function g_slist_remove(list: PGSList; data: Pgpointer): PGSList; cdecl; external;
function g_slist_remove_all(list: PGSList; data: Pgpointer): PGSList; cdecl; external;
function g_slist_remove_link(list: PGSList; link_: PGSList): PGSList; cdecl; external;
function g_slist_reverse(list: PGSList): PGSList; cdecl; external;
function g_slist_sort(list: PGSList; compare_func: TGCompareFunc): PGSList; cdecl; external;
function g_slist_sort_with_data(list: PGSList; compare_func: TGCompareDataFunc; user_data: gpointer): PGSList; cdecl; external;
function g_snprintf(string_: Pgchar; n: gulong; format: Pgchar; args: array of const): gint; cdecl; external;
function g_source_add_unix_fd(source: PGSource; fd: gint; events: TGIOCondition): gpointer; cdecl; external;
function g_source_attach(source: PGSource; context: PGMainContext): guint; cdecl; external;
function g_source_get_can_recurse(source: PGSource): gboolean; cdecl; external;
function g_source_get_context(source: PGSource): PGMainContext; cdecl; external;
function g_source_get_id(source: PGSource): guint; cdecl; external;
function g_source_get_name(source: PGSource): Pgchar; cdecl; external;
function g_source_get_priority(source: PGSource): gint; cdecl; external;
function g_source_get_ready_time(source: PGSource): gint64; cdecl; external;
function g_source_get_time(source: PGSource): gint64; cdecl; external;
function g_source_get_type: TGType; cdecl; external;
function g_source_is_destroyed(source: PGSource): gboolean; cdecl; external;
function g_source_new(source_funcs: PGSourceFuncs; struct_size: guint): PGSource; cdecl; external;
function g_source_query_unix_fd(source: PGSource; tag: gpointer): TGIOCondition; cdecl; external;
function g_source_ref(source: PGSource): PGSource; cdecl; external;
function g_source_remove(tag: guint): gboolean; cdecl; external;
function g_source_remove_by_funcs_user_data(funcs: PGSourceFuncs; user_data: gpointer): gboolean; cdecl; external;
function g_source_remove_by_user_data(user_data: gpointer): gboolean; cdecl; external;
function g_spaced_primes_closest(num: guint): guint; cdecl; external;
function g_spawn_async(working_directory: Pgchar; argv: PPgchar; envp: PPgchar; flags: TGSpawnFlags; child_setup: TGSpawnChildSetupFunc; user_data: gpointer; child_pid: PGPid; error: PPGError): gboolean; cdecl; external;
function g_spawn_async_with_pipes(working_directory: Pgchar; argv: PPgchar; envp: PPgchar; flags: TGSpawnFlags; child_setup: TGSpawnChildSetupFunc; user_data: gpointer; child_pid: PGPid; standard_input: Pgint; standard_output: Pgint; standard_error: Pgint; error: PPGError): gboolean; cdecl; external;
function g_spawn_check_exit_status(exit_status: gint; error: PPGError): gboolean; cdecl; external;
function g_spawn_command_line_async(command_line: Pgchar; error: PPGError): gboolean; cdecl; external;
function g_spawn_command_line_sync(command_line: Pgchar; standard_output: PPgchar; standard_error: PPgchar; exit_status: Pgint; error: PPGError): gboolean; cdecl; external;
function g_spawn_error_quark: TGQuark; cdecl; external;
function g_spawn_exit_error_quark: TGQuark; cdecl; external;
function g_spawn_sync(working_directory: Pgchar; argv: PPgchar; envp: PPgchar; flags: TGSpawnFlags; child_setup: TGSpawnChildSetupFunc; user_data: gpointer; standard_output: PPgchar; standard_error: PPgchar; exit_status: Pgint; error: PPGError): gboolean; cdecl; external;
function g_sprintf(string_: Pgchar; format: Pgchar; args: array of const): gint; cdecl; external;
function g_stpcpy(dest: Pgchar; src: Pgchar): Pgchar; cdecl; external;
function g_str_equal(v1: Pgpointer; v2: Pgpointer): gboolean; cdecl; external;
function g_str_has_prefix(str: Pgchar; prefix: Pgchar): gboolean; cdecl; external;
function g_str_has_suffix(str: Pgchar; suffix: Pgchar): gboolean; cdecl; external;
function g_str_hash(v: Pgpointer): guint; cdecl; external;
function g_strcanon(string_: Pgchar; valid_chars: Pgchar; substitutor: gchar): Pgchar; cdecl; external;
function g_strcasecmp(s1: Pgchar; s2: Pgchar): gint; cdecl; external;
function g_strchomp(string_: Pgchar): Pgchar; cdecl; external;
function g_strchug(string_: Pgchar): Pgchar; cdecl; external;
function g_strcmp0(str1: Pgchar; str2: Pgchar): gint; cdecl; external;
function g_strcompress(source: Pgchar): Pgchar; cdecl; external;
function g_strconcat(string1: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_strdelimit(string_: Pgchar; delimiters: Pgchar; new_delimiter: gchar): Pgchar; cdecl; external;
function g_strdown(string_: Pgchar): Pgchar; cdecl; external;
function g_strdup(str: Pgchar): Pgchar; cdecl; external;
function g_strdup_printf(format: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_strdup_vprintf(format: Pgchar; args: Tva_list): Pgchar; cdecl; external;
function g_strdupv(str_array: PPgchar): PPgchar; cdecl; external;
function g_strerror(errnum: gint): Pgchar; cdecl; external;
function g_strescape(source: Pgchar; exceptions: Pgchar): Pgchar; cdecl; external;
function g_string_append(string_: PGString; val: Pgchar): PGString; cdecl; external;
function g_string_append_c(string_: PGString; c: gchar): PGString; cdecl; external;
function g_string_append_len(string_: PGString; val: Pgchar; len: gssize): PGString; cdecl; external;
function g_string_append_unichar(string_: PGString; wc: gunichar): PGString; cdecl; external;
function g_string_append_uri_escaped(string_: PGString; unescaped: Pgchar; reserved_chars_allowed: Pgchar; allow_utf8: gboolean): PGString; cdecl; external;
function g_string_ascii_down(string_: PGString): PGString; cdecl; external;
function g_string_ascii_up(string_: PGString): PGString; cdecl; external;
function g_string_assign(string_: PGString; rval: Pgchar): PGString; cdecl; external;
function g_string_chunk_insert(chunk: PGStringChunk; string_: Pgchar): Pgchar; cdecl; external;
function g_string_chunk_insert_const(chunk: PGStringChunk; string_: Pgchar): Pgchar; cdecl; external;
function g_string_chunk_insert_len(chunk: PGStringChunk; string_: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_string_chunk_new(size: gsize): PGStringChunk; cdecl; external;
function g_string_equal(v: PGString; v2: PGString): gboolean; cdecl; external;
function g_string_erase(string_: PGString; pos: gssize; len: gssize): PGString; cdecl; external;
function g_string_free(string_: PGString; free_segment: gboolean): Pgchar; cdecl; external;
function g_string_free_to_bytes(string_: PGString): PGBytes; cdecl; external;
function g_string_hash(str: PGString): guint; cdecl; external;
function g_string_insert(string_: PGString; pos: gssize; val: Pgchar): PGString; cdecl; external;
function g_string_insert_c(string_: PGString; pos: gssize; c: gchar): PGString; cdecl; external;
function g_string_insert_len(string_: PGString; pos: gssize; val: Pgchar; len: gssize): PGString; cdecl; external;
function g_string_insert_unichar(string_: PGString; pos: gssize; wc: gunichar): PGString; cdecl; external;
function g_string_new(init: Pgchar): PGString; cdecl; external;
function g_string_new_len(init: Pgchar; len: gssize): PGString; cdecl; external;
function g_string_overwrite(string_: PGString; pos: gsize; val: Pgchar): PGString; cdecl; external;
function g_string_overwrite_len(string_: PGString; pos: gsize; val: Pgchar; len: gssize): PGString; cdecl; external;
function g_string_prepend(string_: PGString; val: Pgchar): PGString; cdecl; external;
function g_string_prepend_c(string_: PGString; c: gchar): PGString; cdecl; external;
function g_string_prepend_len(string_: PGString; val: Pgchar; len: gssize): PGString; cdecl; external;
function g_string_prepend_unichar(string_: PGString; wc: gunichar): PGString; cdecl; external;
function g_string_set_size(string_: PGString; len: gsize): PGString; cdecl; external;
function g_string_sized_new(dfl_size: gsize): PGString; cdecl; external;
function g_string_truncate(string_: PGString; len: gsize): PGString; cdecl; external;
function g_strip_context(msgid: Pgchar; msgval: Pgchar): Pgchar; cdecl; external;
function g_strjoin(separator: Pgchar; args: array of const): Pgchar; cdecl; external;
function g_strjoinv(separator: Pgchar; str_array: PPgchar): Pgchar; cdecl; external;
function g_strlcat(dest: Pgchar; src: Pgchar; dest_size: gsize): gsize; cdecl; external;
function g_strlcpy(dest: Pgchar; src: Pgchar; dest_size: gsize): gsize; cdecl; external;
function g_strncasecmp(s1: Pgchar; s2: Pgchar; n: guint): gint; cdecl; external;
function g_strndup(str: Pgchar; n: gsize): Pgchar; cdecl; external;
function g_strnfill(length: gsize; fill_char: gchar): Pgchar; cdecl; external;
function g_strreverse(string_: Pgchar): Pgchar; cdecl; external;
function g_strrstr(haystack: Pgchar; needle: Pgchar): Pgchar; cdecl; external;
function g_strrstr_len(haystack: Pgchar; haystack_len: gssize; needle: Pgchar): Pgchar; cdecl; external;
function g_strsignal(signum: gint): Pgchar; cdecl; external;
function g_strsplit(string_: Pgchar; delimiter: Pgchar; max_tokens: gint): PPgchar; cdecl; external;
function g_strsplit_set(string_: Pgchar; delimiters: Pgchar; max_tokens: gint): PPgchar; cdecl; external;
function g_strstr_len(haystack: Pgchar; haystack_len: gssize; needle: Pgchar): Pgchar; cdecl; external;
function g_strtod(nptr: Pgchar; endptr: PPgchar): gdouble; cdecl; external;
function g_strup(string_: Pgchar): Pgchar; cdecl; external;
function g_strv_get_type: TGType; cdecl; external;
function g_strv_length(str_array: PPgchar): guint; cdecl; external;
function g_test_create_case(test_name: Pgchar; data_size: gsize; test_data: Pgpointer; data_setup: TGTestFixtureFunc; data_test: TGTestFixtureFunc; data_teardown: TGTestFixtureFunc): PGTestCase; cdecl; external;
function g_test_create_suite(suite_name: Pgchar): PGTestSuite; cdecl; external;
function g_test_get_root: PGTestSuite; cdecl; external;
function g_test_log_buffer_new: PGTestLogBuffer; cdecl; external;
function g_test_log_buffer_pop(tbuffer: PGTestLogBuffer): PGTestLogMsg; cdecl; external;
function g_test_log_type_name(log_type: TGTestLogType): Pgchar; cdecl; external;
function g_test_rand_double: gdouble; cdecl; external;
function g_test_rand_double_range(range_start: gdouble; range_end: gdouble): gdouble; cdecl; external;
function g_test_rand_int: gint32; cdecl; external;
function g_test_rand_int_range(begin_: gint32; end_: gint32): gint32; cdecl; external;
function g_test_run: gint; cdecl; external;
function g_test_run_suite(suite: PGTestSuite): gint; cdecl; external;
function g_test_timer_elapsed: gdouble; cdecl; external;
function g_test_timer_last: gdouble; cdecl; external;
function g_test_trap_fork(usec_timeout: guint64; test_trap_flags: TGTestTrapFlags): gboolean; cdecl; external;
function g_test_trap_has_passed: gboolean; cdecl; external;
function g_test_trap_reached_timeout: gboolean; cdecl; external;
function g_thread_error_quark: TGQuark; cdecl; external;
function g_thread_get_type: TGType; cdecl; external;
function g_thread_join(thread: PGThread): gpointer; cdecl; external;
function g_thread_new(name: Pgchar; func: TGThreadFunc; data: gpointer): PGThread; cdecl; external;
function g_thread_pool_get_max_idle_time: guint; cdecl; external;
function g_thread_pool_get_max_threads(pool: PGThreadPool): gint; cdecl; external;
function g_thread_pool_get_max_unused_threads: gint; cdecl; external;
function g_thread_pool_get_num_threads(pool: PGThreadPool): guint; cdecl; external;
function g_thread_pool_get_num_unused_threads: guint; cdecl; external;
function g_thread_pool_new(func: TGFunc; user_data: gpointer; max_threads: gint; exclusive: gboolean; error: PPGError): PGThreadPool; cdecl; external;
function g_thread_pool_push(pool: PGThreadPool; data: gpointer; error: PPGError): gboolean; cdecl; external;
function g_thread_pool_set_max_threads(pool: PGThreadPool; max_threads: gint; error: PPGError): gboolean; cdecl; external;
function g_thread_pool_unprocessed(pool: PGThreadPool): guint; cdecl; external;
function g_thread_ref(thread: PGThread): PGThread; cdecl; external;
function g_thread_self: PGThread; cdecl; external;
function g_thread_try_new(name: Pgchar; func: TGThreadFunc; data: gpointer; error: PPGError): PGThread; cdecl; external;
function g_time_val_from_iso8601(iso_date: Pgchar; time_: PGTimeVal): gboolean; cdecl; external;
function g_time_val_to_iso8601(time_: PGTimeVal): Pgchar; cdecl; external;
function g_time_zone_adjust_time(tz: PGTimeZone; type_: TGTimeType; time_: Pgint64): gint; cdecl; external;
function g_time_zone_find_interval(tz: PGTimeZone; type_: TGTimeType; time_: gint64): gint; cdecl; external;
function g_time_zone_get_abbreviation(tz: PGTimeZone; interval: gint): Pgchar; cdecl; external;
function g_time_zone_get_offset(tz: PGTimeZone; interval: gint): gint32; cdecl; external;
function g_time_zone_get_type: TGType; cdecl; external;
function g_time_zone_is_dst(tz: PGTimeZone; interval: gint): gboolean; cdecl; external;
function g_time_zone_new(identifier: Pgchar): PGTimeZone; cdecl; external;
function g_time_zone_new_local: PGTimeZone; cdecl; external;
function g_time_zone_new_utc: PGTimeZone; cdecl; external;
function g_time_zone_ref(tz: PGTimeZone): PGTimeZone; cdecl; external;
function g_timeout_add(interval: guint; function_: TGSourceFunc; data: gpointer): guint; cdecl; external;
function g_timeout_add_full(priority: gint; interval: guint; function_: TGSourceFunc; data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_timeout_add_seconds(interval: guint; function_: TGSourceFunc; data: gpointer): guint; cdecl; external;
function g_timeout_add_seconds_full(priority: gint; interval: guint; function_: TGSourceFunc; data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_timeout_source_new(interval: guint): PGSource; cdecl; external;
function g_timeout_source_new_seconds(interval: guint): PGSource; cdecl; external;
function g_timer_elapsed(timer: PGTimer; microseconds: Pgulong): gdouble; cdecl; external;
function g_timer_new: PGTimer; cdecl; external;
function g_trash_stack_height(stack_p: PPGTrashStack): guint; cdecl; external;
function g_trash_stack_peek(stack_p: PPGTrashStack): gpointer; cdecl; external;
function g_trash_stack_pop(stack_p: PPGTrashStack): gpointer; cdecl; external;
function g_tree_height(tree: PGTree): gint; cdecl; external;
function g_tree_lookup(tree: PGTree; key: Pgpointer): gpointer; cdecl; external;
function g_tree_lookup_extended(tree: PGTree; lookup_key: Pgpointer; orig_key: Pgpointer; value: Pgpointer): gboolean; cdecl; external;
function g_tree_new(key_compare_func: TGCompareFunc): PGTree; cdecl; external;
function g_tree_new_full(key_compare_func: TGCompareDataFunc; key_compare_data: gpointer; key_destroy_func: TGDestroyNotify; value_destroy_func: TGDestroyNotify): PGTree; cdecl; external;
function g_tree_new_with_data(key_compare_func: TGCompareDataFunc; key_compare_data: gpointer): PGTree; cdecl; external;
function g_tree_nnodes(tree: PGTree): gint; cdecl; external;
function g_tree_ref(tree: PGTree): PGTree; cdecl; external;
function g_tree_remove(tree: PGTree; key: Pgpointer): gboolean; cdecl; external;
function g_tree_search(tree: PGTree; search_func: TGCompareFunc; user_data: Pgpointer): gpointer; cdecl; external;
function g_tree_steal(tree: PGTree; key: Pgpointer): gboolean; cdecl; external;
function g_try_malloc(n_bytes: gsize): gpointer; cdecl; external;
function g_try_malloc0(n_bytes: gsize): gpointer; cdecl; external;
function g_try_malloc0_n(n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_try_malloc_n(n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_try_realloc(mem: gpointer; n_bytes: gsize): gpointer; cdecl; external;
function g_try_realloc_n(mem: gpointer; n_blocks: gsize; n_block_bytes: gsize): gpointer; cdecl; external;
function g_ucs4_to_utf16(str: Pgunichar; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pguint16; cdecl; external;
function g_ucs4_to_utf8(str: Pgunichar; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pgchar; cdecl; external;
function g_unichar_break_type(c: gunichar): TGUnicodeBreakType; cdecl; external;
function g_unichar_combining_class(uc: gunichar): gint; cdecl; external;
function g_unichar_compose(a: gunichar; b: gunichar; ch: Pgunichar): gboolean; cdecl; external;
function g_unichar_decompose(ch: gunichar; a: Pgunichar; b: Pgunichar): gboolean; cdecl; external;
function g_unichar_digit_value(c: gunichar): gint; cdecl; external;
function g_unichar_fully_decompose(ch: gunichar; compat: gboolean; result_: Pgunichar; result_len: gsize): gsize; cdecl; external;
function g_unichar_get_mirror_char(ch: gunichar; mirrored_ch: Pgunichar): gboolean; cdecl; external;
function g_unichar_get_script(ch: gunichar): TGUnicodeScript; cdecl; external;
function g_unichar_isalnum(c: gunichar): gboolean; cdecl; external;
function g_unichar_isalpha(c: gunichar): gboolean; cdecl; external;
function g_unichar_iscntrl(c: gunichar): gboolean; cdecl; external;
function g_unichar_isdefined(c: gunichar): gboolean; cdecl; external;
function g_unichar_isdigit(c: gunichar): gboolean; cdecl; external;
function g_unichar_isgraph(c: gunichar): gboolean; cdecl; external;
function g_unichar_islower(c: gunichar): gboolean; cdecl; external;
function g_unichar_ismark(c: gunichar): gboolean; cdecl; external;
function g_unichar_isprint(c: gunichar): gboolean; cdecl; external;
function g_unichar_ispunct(c: gunichar): gboolean; cdecl; external;
function g_unichar_isspace(c: gunichar): gboolean; cdecl; external;
function g_unichar_istitle(c: gunichar): gboolean; cdecl; external;
function g_unichar_isupper(c: gunichar): gboolean; cdecl; external;
function g_unichar_iswide(c: gunichar): gboolean; cdecl; external;
function g_unichar_iswide_cjk(c: gunichar): gboolean; cdecl; external;
function g_unichar_isxdigit(c: gunichar): gboolean; cdecl; external;
function g_unichar_iszerowidth(c: gunichar): gboolean; cdecl; external;
function g_unichar_to_utf8(c: gunichar; outbuf: Pgchar): gint; cdecl; external;
function g_unichar_tolower(c: gunichar): gunichar; cdecl; external;
function g_unichar_totitle(c: gunichar): gunichar; cdecl; external;
function g_unichar_toupper(c: gunichar): gunichar; cdecl; external;
function g_unichar_type(c: gunichar): TGUnicodeType; cdecl; external;
function g_unichar_validate(ch: gunichar): gboolean; cdecl; external;
function g_unichar_xdigit_value(c: gunichar): gint; cdecl; external;
function g_unicode_canonical_decomposition(ch: gunichar; result_len: Pgsize): Pgunichar; cdecl; external;
function g_unicode_script_from_iso15924(iso15924: guint32): TGUnicodeScript; cdecl; external;
function g_unicode_script_to_iso15924(script: TGUnicodeScript): guint32; cdecl; external;
function g_unix_error_quark: TGQuark; cdecl; external;
function g_unix_fd_add(fd: gint; condition: TGIOCondition; function_: TGUnixFDSourceFunc; user_data: gpointer): guint; cdecl; external;
function g_unix_fd_add_full(priority: gint; fd: gint; condition: TGIOCondition; function_: TGUnixFDSourceFunc; user_data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_unix_fd_source_new(fd: gint; condition: TGIOCondition): PGSource; cdecl; external;
function g_unix_open_pipe(fds: Pgint; flags: gint; error: PPGError): gboolean; cdecl; external;
function g_unix_set_fd_nonblocking(fd: gint; nonblock: gboolean; error: PPGError): gboolean; cdecl; external;
function g_unix_signal_add(signum: gint; handler: TGSourceFunc; user_data: gpointer): guint; cdecl; external;
function g_unix_signal_add_full(priority: gint; signum: gint; handler: TGSourceFunc; user_data: gpointer; notify: TGDestroyNotify): guint; cdecl; external;
function g_unix_signal_source_new(signum: gint): PGSource; cdecl; external;
function g_unlink(filename: Pgchar): gint; cdecl; external;
function g_uri_escape_string(unescaped: Pgchar; reserved_chars_allowed: Pgchar; allow_utf8: gboolean): Pgchar; cdecl; external;
function g_uri_list_extract_uris(uri_list: Pgchar): PPgchar; cdecl; external;
function g_uri_parse_scheme(uri: Pgchar): Pgchar; cdecl; external;
function g_uri_unescape_segment(escaped_string: Pgchar; escaped_string_end: Pgchar; illegal_characters: Pgchar): Pgchar; cdecl; external;
function g_uri_unescape_string(escaped_string: Pgchar; illegal_characters: Pgchar): Pgchar; cdecl; external;
function g_utf16_to_ucs4(str: Pguint16; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pgunichar; cdecl; external;
function g_utf16_to_utf8(str: Pguint16; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pgchar; cdecl; external;
function g_utf8_casefold(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_collate(str1: Pgchar; str2: Pgchar): gint; cdecl; external;
function g_utf8_collate_key(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_collate_key_for_filename(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_find_next_char(p: Pgchar; end_: Pgchar): Pgchar; cdecl; external;
function g_utf8_find_prev_char(str: Pgchar; p: Pgchar): Pgchar; cdecl; external;
function g_utf8_get_char(p: Pgchar): gunichar; cdecl; external;
function g_utf8_get_char_validated(p: Pgchar; max_len: gssize): gunichar; cdecl; external;
function g_utf8_normalize(str: Pgchar; len: gssize; mode: TGNormalizeMode): Pgchar; cdecl; external;
function g_utf8_offset_to_pointer(str: Pgchar; offset: glong): Pgchar; cdecl; external;
function g_utf8_pointer_to_offset(str: Pgchar; pos: Pgchar): glong; cdecl; external;
function g_utf8_prev_char(p: Pgchar): Pgchar; cdecl; external;
function g_utf8_strchr(p: Pgchar; len: gssize; c: gunichar): Pgchar; cdecl; external;
function g_utf8_strdown(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_strlen(p: Pgchar; max: gssize): glong; cdecl; external;
function g_utf8_strncpy(dest: Pgchar; src: Pgchar; n: gsize): Pgchar; cdecl; external;
function g_utf8_strrchr(p: Pgchar; len: gssize; c: gunichar): Pgchar; cdecl; external;
function g_utf8_strreverse(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_strup(str: Pgchar; len: gssize): Pgchar; cdecl; external;
function g_utf8_substring(str: Pgchar; start_pos: glong; end_pos: glong): Pgchar; cdecl; external;
function g_utf8_to_ucs4(str: Pgchar; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pgunichar; cdecl; external;
function g_utf8_to_ucs4_fast(str: Pgchar; len: glong; items_written: Pglong): Pgunichar; cdecl; external;
function g_utf8_to_utf16(str: Pgchar; len: glong; items_read: Pglong; items_written: Pglong; error: PPGError): Pguint16; cdecl; external;
function g_utf8_validate(str: Pgchar; max_len: gssize; end_: PPgchar): gboolean; cdecl; external;
function g_variant_builder_end(builder: PGVariantBuilder): PGVariant; cdecl; external;
function g_variant_builder_get_type: TGType; cdecl; external;
function g_variant_builder_new(type_: PGVariantType): PGVariantBuilder; cdecl; external;
function g_variant_builder_ref(builder: PGVariantBuilder): PGVariantBuilder; cdecl; external;
function g_variant_byteswap(value: PGVariant): PGVariant; cdecl; external;
function g_variant_check_format_string(value: PGVariant; format_string: Pgchar; copy_only: gboolean): gboolean; cdecl; external;
function g_variant_classify(value: PGVariant): TGVariantClass; cdecl; external;
function g_variant_compare(one: PGVariant; two: PGVariant): gint; cdecl; external;
function g_variant_dup_bytestring(value: PGVariant; length: Pgsize): Pgchar; cdecl; external;
function g_variant_dup_bytestring_array(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_dup_objv(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_dup_string(value: PGVariant; length: Pgsize): Pgchar; cdecl; external;
function g_variant_dup_strv(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_equal(one: PGVariant; two: PGVariant): gboolean; cdecl; external;
function g_variant_get_boolean(value: PGVariant): gboolean; cdecl; external;
function g_variant_get_byte(value: PGVariant): guint8; cdecl; external;
function g_variant_get_bytestring(value: PGVariant): Pgchar; cdecl; external;
function g_variant_get_bytestring_array(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_get_child_value(value: PGVariant; index_: gsize): PGVariant; cdecl; external;
function g_variant_get_data(value: PGVariant): Pgpointer; cdecl; external;
function g_variant_get_data_as_bytes(value: PGVariant): PGBytes; cdecl; external;
function g_variant_get_double(value: PGVariant): gdouble; cdecl; external;
function g_variant_get_fixed_array(value: PGVariant; n_elements: Pgsize; element_size: gsize): gpointer; cdecl; external;
function g_variant_get_gtype: TGType; cdecl; external;
function g_variant_get_handle(value: PGVariant): gint32; cdecl; external;
function g_variant_get_int16(value: PGVariant): gint16; cdecl; external;
function g_variant_get_int32(value: PGVariant): gint32; cdecl; external;
function g_variant_get_int64(value: PGVariant): gint64; cdecl; external;
function g_variant_get_maybe(value: PGVariant): PGVariant; cdecl; external;
function g_variant_get_normal_form(value: PGVariant): PGVariant; cdecl; external;
function g_variant_get_objv(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_get_size(value: PGVariant): gsize; cdecl; external;
function g_variant_get_string(value: PGVariant; length: Pgsize): Pgchar; cdecl; external;
function g_variant_get_strv(value: PGVariant; length: Pgsize): PPgchar; cdecl; external;
function g_variant_get_type(value: PGVariant): PGVariantType; cdecl; external;
function g_variant_get_type_string(value: PGVariant): Pgchar; cdecl; external;
function g_variant_get_uint16(value: PGVariant): guint16; cdecl; external;
function g_variant_get_uint32(value: PGVariant): guint32; cdecl; external;
function g_variant_get_uint64(value: PGVariant): guint64; cdecl; external;
function g_variant_get_variant(value: PGVariant): PGVariant; cdecl; external;
function g_variant_hash(value: PGVariant): guint; cdecl; external;
function g_variant_is_container(value: PGVariant): gboolean; cdecl; external;
function g_variant_is_floating(value: PGVariant): gboolean; cdecl; external;
function g_variant_is_normal_form(value: PGVariant): gboolean; cdecl; external;
function g_variant_is_object_path(string_: Pgchar): gboolean; cdecl; external;
function g_variant_is_of_type(value: PGVariant; type_: PGVariantType): gboolean; cdecl; external;
function g_variant_is_signature(string_: Pgchar): gboolean; cdecl; external;
function g_variant_iter_copy(iter: PGVariantIter): PGVariantIter; cdecl; external;
function g_variant_iter_init(iter: PGVariantIter; value: PGVariant): gsize; cdecl; external;
function g_variant_iter_loop(iter: PGVariantIter; format_string: Pgchar; args: array of const): gboolean; cdecl; external;
function g_variant_iter_n_children(iter: PGVariantIter): gsize; cdecl; external;
function g_variant_iter_new(value: PGVariant): PGVariantIter; cdecl; external;
function g_variant_iter_next(iter: PGVariantIter; format_string: Pgchar; args: array of const): gboolean; cdecl; external;
function g_variant_iter_next_value(iter: PGVariantIter): PGVariant; cdecl; external;
function g_variant_lookup(dictionary: PGVariant; key: Pgchar; format_string: Pgchar; args: array of const): gboolean; cdecl; external;
function g_variant_lookup_value(dictionary: PGVariant; key: Pgchar; expected_type: PGVariantType): PGVariant; cdecl; external;
function g_variant_n_children(value: PGVariant): gsize; cdecl; external;
function g_variant_new(format_string: Pgchar; args: array of const): PGVariant; cdecl; external;
function g_variant_new_array(child_type: PGVariantType; children: PPGVariant; n_children: gsize): PGVariant; cdecl; external;
function g_variant_new_boolean(value: gboolean): PGVariant; cdecl; external;
function g_variant_new_byte(value: guint8): PGVariant; cdecl; external;
function g_variant_new_bytestring(string_: Pgchar): PGVariant; cdecl; external;
function g_variant_new_bytestring_array(strv: PPgchar; length: gssize): PGVariant; cdecl; external;
function g_variant_new_dict_entry(key: PGVariant; value: PGVariant): PGVariant; cdecl; external;
function g_variant_new_double(value: gdouble): PGVariant; cdecl; external;
function g_variant_new_fixed_array(element_type: PGVariantType; elements: Pgpointer; n_elements: gsize; element_size: gsize): PGVariant; cdecl; external;
function g_variant_new_from_bytes(type_: PGVariantType; bytes: PGBytes; trusted: gboolean): PGVariant; cdecl; external;
function g_variant_new_from_data(type_: PGVariantType; data: guint8; size: gsize; trusted: gboolean; notify: TGDestroyNotify; user_data: gpointer): PGVariant; cdecl; external;
function g_variant_new_handle(value: gint32): PGVariant; cdecl; external;
function g_variant_new_int16(value: gint16): PGVariant; cdecl; external;
function g_variant_new_int32(value: gint32): PGVariant; cdecl; external;
function g_variant_new_int64(value: gint64): PGVariant; cdecl; external;
function g_variant_new_maybe(child_type: PGVariantType; child: PGVariant): PGVariant; cdecl; external;
function g_variant_new_object_path(object_path: Pgchar): PGVariant; cdecl; external;
function g_variant_new_objv(strv: PPgchar; length: gssize): PGVariant; cdecl; external;
function g_variant_new_parsed(format: Pgchar; args: array of const): PGVariant; cdecl; external;
function g_variant_new_parsed_va(format: Pgchar; app: Pva_list): PGVariant; cdecl; external;
function g_variant_new_signature(signature: Pgchar): PGVariant; cdecl; external;
function g_variant_new_string(string_: Pgchar): PGVariant; cdecl; external;
function g_variant_new_strv(strv: PPgchar; length: gssize): PGVariant; cdecl; external;
function g_variant_new_tuple(children: PPGVariant; n_children: gsize): PGVariant; cdecl; external;
function g_variant_new_uint16(value: guint16): PGVariant; cdecl; external;
function g_variant_new_uint32(value: guint32): PGVariant; cdecl; external;
function g_variant_new_uint64(value: guint64): PGVariant; cdecl; external;
function g_variant_new_va(format_string: Pgchar; endptr: PPgchar; app: Pva_list): PGVariant; cdecl; external;
function g_variant_new_variant(value: PGVariant): PGVariant; cdecl; external;
function g_variant_parse(type_: PGVariantType; text: Pgchar; limit: Pgchar; endptr: PPgchar; error: PPGError): PGVariant; cdecl; external;
function g_variant_parser_get_error_quark: TGQuark; cdecl; external;
function g_variant_print(value: PGVariant; type_annotate: gboolean): Pgchar; cdecl; external;
function g_variant_print_string(value: PGVariant; string_: PGString; type_annotate: gboolean): PGString; cdecl; external;
function g_variant_ref(value: PGVariant): PGVariant; cdecl; external;
function g_variant_ref_sink(value: PGVariant): PGVariant; cdecl; external;
function g_variant_take_ref(value: PGVariant): PGVariant; cdecl; external;
function g_variant_type_checked_(arg0: Pgchar): PGVariantType; cdecl; external;
function g_variant_type_copy(type_: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_dup_string(type_: PGVariantType): Pgchar; cdecl; external;
function g_variant_type_element(type_: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_equal(type1: PGVariantType; type2: PGVariantType): gboolean; cdecl; external;
function g_variant_type_first(type_: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_get_gtype: TGType; cdecl; external;
function g_variant_type_get_string_length(type_: PGVariantType): gsize; cdecl; external;
function g_variant_type_hash(type_: PGVariantType): guint; cdecl; external;
function g_variant_type_is_array(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_basic(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_container(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_definite(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_dict_entry(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_maybe(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_subtype_of(type_: PGVariantType; supertype: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_tuple(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_is_variant(type_: PGVariantType): gboolean; cdecl; external;
function g_variant_type_key(type_: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_n_items(type_: PGVariantType): gsize; cdecl; external;
function g_variant_type_new(type_string: Pgchar): PGVariantType; cdecl; external;
function g_variant_type_new_array(element: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_new_dict_entry(key: PGVariantType; value: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_new_maybe(element: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_new_tuple(items: PPGVariantType; length: gint): PGVariantType; cdecl; external;
function g_variant_type_next(type_: PGVariantType): PGVariantType; cdecl; external;
function g_variant_type_peek_string(type_: PGVariantType): Pgchar; cdecl; external;
function g_variant_type_string_is_valid(type_string: Pgchar): gboolean; cdecl; external;
function g_variant_type_string_scan(string_: Pgchar; limit: Pgchar; endptr: PPgchar): gboolean; cdecl; external;
function g_variant_type_value(type_: PGVariantType): PGVariantType; cdecl; external;
function g_vasprintf(string_: PPgchar; format: Pgchar; args: Tva_list): gint; cdecl; external;
function g_vfprintf(file_: Pgpointer; format: Pgchar; args: Tva_list): gint; cdecl; external;
function g_vprintf(format: Pgchar; args: Tva_list): gint; cdecl; external;
function g_vsnprintf(string_: Pgchar; n: gulong; format: Pgchar; args: Tva_list): gint; cdecl; external;
function g_vsprintf(string_: Pgchar; format: Pgchar; args: Tva_list): gint; cdecl; external;
function glib_check_version(required_major: guint; required_minor: guint; required_micro: guint): Pgchar; cdecl; external;
procedure g_array_set_clear_func(array_: Pgpointer; clear_func: TGDestroyNotify); cdecl; external;
procedure g_array_sort(array_: Pgpointer; compare_func: TGCompareFunc); cdecl; external;
procedure g_array_sort_with_data(array_: Pgpointer; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_array_unref(array_: Pgpointer); cdecl; external;
procedure g_assert_warning(log_domain: Pgchar; file_: Pgchar; line: gint; pretty_function: Pgchar; expression: Pgchar); cdecl; external;
procedure g_assertion_message(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; message: Pgchar); cdecl; external;
procedure g_assertion_message_cmpnum(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; expr: Pgchar; arg1: long_double; cmp: Pgchar; arg2: long_double; numtype: gchar); cdecl; external;
procedure g_assertion_message_cmpstr(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; expr: Pgchar; arg1: Pgchar; cmp: Pgchar; arg2: Pgchar); cdecl; external;
procedure g_assertion_message_error(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; expr: Pgchar; error: PGError; error_domain: TGQuark; error_code: gint); cdecl; external;
procedure g_assertion_message_expr(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; expr: Pgchar); cdecl; external;
procedure g_async_queue_lock(queue: PGAsyncQueue); cdecl; external;
procedure g_async_queue_push(queue: PGAsyncQueue; data: gpointer); cdecl; external;
procedure g_async_queue_push_sorted(queue: PGAsyncQueue; data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_async_queue_push_sorted_unlocked(queue: PGAsyncQueue; data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_async_queue_push_unlocked(queue: PGAsyncQueue; data: gpointer); cdecl; external;
procedure g_async_queue_sort(queue: PGAsyncQueue; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_async_queue_sort_unlocked(queue: PGAsyncQueue; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_async_queue_unlock(queue: PGAsyncQueue); cdecl; external;
procedure g_async_queue_unref(queue: PGAsyncQueue); cdecl; external;
procedure g_atexit(func: TGVoidFunc); cdecl; external;
procedure g_atomic_int_inc(atomic: Pgint); cdecl; external;
procedure g_atomic_int_set(atomic: Pgint; newval: gint); cdecl; external;
procedure g_atomic_pointer_set(atomic: Pgpointer; newval: gpointer); cdecl; external;
procedure g_bit_lock(address: Pgint; lock_bit: gint); cdecl; external;
procedure g_bit_unlock(address: Pgint; lock_bit: gint); cdecl; external;
procedure g_bookmark_file_add_application(bookmark: PGBookmarkFile; uri: Pgchar; name: Pgchar; exec: Pgchar); cdecl; external;
procedure g_bookmark_file_add_group(bookmark: PGBookmarkFile; uri: Pgchar; group: Pgchar); cdecl; external;
procedure g_bookmark_file_free(bookmark: PGBookmarkFile); cdecl; external;
procedure g_bookmark_file_set_added(bookmark: PGBookmarkFile; uri: Pgchar; added: glong); cdecl; external;
procedure g_bookmark_file_set_description(bookmark: PGBookmarkFile; uri: Pgchar; description: Pgchar); cdecl; external;
procedure g_bookmark_file_set_groups(bookmark: PGBookmarkFile; uri: Pgchar; groups: PPgchar; length: gsize); cdecl; external;
procedure g_bookmark_file_set_icon(bookmark: PGBookmarkFile; uri: Pgchar; href: Pgchar; mime_type: Pgchar); cdecl; external;
procedure g_bookmark_file_set_is_private(bookmark: PGBookmarkFile; uri: Pgchar; is_private: gboolean); cdecl; external;
procedure g_bookmark_file_set_mime_type(bookmark: PGBookmarkFile; uri: Pgchar; mime_type: Pgchar); cdecl; external;
procedure g_bookmark_file_set_modified(bookmark: PGBookmarkFile; uri: Pgchar; modified: glong); cdecl; external;
procedure g_bookmark_file_set_title(bookmark: PGBookmarkFile; uri: Pgchar; title: Pgchar); cdecl; external;
procedure g_bookmark_file_set_visited(bookmark: PGBookmarkFile; uri: Pgchar; visited: glong); cdecl; external;
procedure g_byte_array_sort(array_: Pguint8; compare_func: TGCompareFunc); cdecl; external;
procedure g_byte_array_sort_with_data(array_: Pguint8; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_byte_array_unref(array_: Pguint8); cdecl; external;
procedure g_bytes_unref(bytes: PGBytes); cdecl; external;
procedure g_checksum_free(checksum: PGChecksum); cdecl; external;
procedure g_checksum_get_digest(checksum: PGChecksum; buffer: Pguint8; digest_len: Pgsize); cdecl; external;
procedure g_checksum_reset(checksum: PGChecksum); cdecl; external;
procedure g_checksum_update(checksum: PGChecksum; data: Pguint8; length: gssize); cdecl; external;
procedure g_clear_error; cdecl; external;
procedure g_clear_pointer(pp: Pgpointer; destroy_: TGDestroyNotify); cdecl; external;
procedure g_cond_broadcast(cond: PGCond); cdecl; external;
procedure g_cond_clear(cond: PGCond); cdecl; external;
procedure g_cond_init(cond: PGCond); cdecl; external;
procedure g_cond_signal(cond: PGCond); cdecl; external;
procedure g_cond_wait(cond: PGCond; mutex: PGMutex); cdecl; external;
procedure g_datalist_clear(datalist: PPGData); cdecl; external;
procedure g_datalist_foreach(datalist: PPGData; func: TGDataForeachFunc; user_data: gpointer); cdecl; external;
procedure g_datalist_id_set_data_full(datalist: PPGData; key_id: TGQuark; data: gpointer; destroy_func: TGDestroyNotify); cdecl; external;
procedure g_datalist_init(datalist: PPGData); cdecl; external;
procedure g_datalist_set_flags(datalist: PPGData; flags: guint); cdecl; external;
procedure g_datalist_unset_flags(datalist: PPGData; flags: guint); cdecl; external;
procedure g_dataset_destroy(dataset_location: Pgpointer); cdecl; external;
procedure g_dataset_foreach(dataset_location: Pgpointer; func: TGDataForeachFunc; user_data: gpointer); cdecl; external;
procedure g_dataset_id_set_data_full(dataset_location: Pgpointer; key_id: TGQuark; data: gpointer; destroy_func: TGDestroyNotify); cdecl; external;
procedure g_date_add_days(date: PGDate; n_days: guint); cdecl; external;
procedure g_date_add_months(date: PGDate; n_months: guint); cdecl; external;
procedure g_date_add_years(date: PGDate; n_years: guint); cdecl; external;
procedure g_date_clamp(date: PGDate; min_date: PGDate; max_date: PGDate); cdecl; external;
procedure g_date_clear(date: PGDate; n_dates: guint); cdecl; external;
procedure g_date_free(date: PGDate); cdecl; external;
procedure g_date_order(date1: PGDate; date2: PGDate); cdecl; external;
procedure g_date_set_day(date: PGDate; day: TGDateDay); cdecl; external;
procedure g_date_set_dmy(date: PGDate; day: TGDateDay; month: TGDateMonth; y: TGDateYear); cdecl; external;
procedure g_date_set_julian(date: PGDate; julian_date: guint32); cdecl; external;
procedure g_date_set_month(date: PGDate; month: TGDateMonth); cdecl; external;
procedure g_date_set_parse(date: PGDate; str: Pgchar); cdecl; external;
procedure g_date_set_time_t(date: PGDate; timet: glong); cdecl; external;
procedure g_date_set_time_val(date: PGDate; timeval: PGTimeVal); cdecl; external;
procedure g_date_set_year(date: PGDate; year: TGDateYear); cdecl; external;
procedure g_date_subtract_days(date: PGDate; n_days: guint); cdecl; external;
procedure g_date_subtract_months(date: PGDate; n_months: guint); cdecl; external;
procedure g_date_subtract_years(date: PGDate; n_years: guint); cdecl; external;
procedure g_date_time_get_ymd(datetime: PGDateTime; year: Pgint; month: Pgint; day: Pgint); cdecl; external;
procedure g_date_time_unref(datetime: PGDateTime); cdecl; external;
procedure g_date_to_struct_tm(date: PGDate; tm: Pgpointer); cdecl; external;
procedure g_dir_close(dir: PGDir); cdecl; external;
procedure g_dir_rewind(dir: PGDir); cdecl; external;
procedure g_error_free(error: PGError); cdecl; external;
procedure g_free(mem: gpointer); cdecl; external;
procedure g_get_current_time(result_: PGTimeVal); cdecl; external;
procedure g_hash_table_add(hash_table: PGHashTable; key: gpointer); cdecl; external;
procedure g_hash_table_destroy(hash_table: PGHashTable); cdecl; external;
procedure g_hash_table_foreach(hash_table: PGHashTable; func: TGHFunc; user_data: gpointer); cdecl; external;
procedure g_hash_table_insert(hash_table: PGHashTable; key: gpointer; value: gpointer); cdecl; external;
procedure g_hash_table_iter_init(iter: PGHashTableIter; hash_table: PGHashTable); cdecl; external;
procedure g_hash_table_iter_remove(iter: PGHashTableIter); cdecl; external;
procedure g_hash_table_iter_replace(iter: PGHashTableIter; value: gpointer); cdecl; external;
procedure g_hash_table_iter_steal(iter: PGHashTableIter); cdecl; external;
procedure g_hash_table_remove_all(hash_table: PGHashTable); cdecl; external;
procedure g_hash_table_replace(hash_table: PGHashTable; key: gpointer; value: gpointer); cdecl; external;
procedure g_hash_table_steal_all(hash_table: PGHashTable); cdecl; external;
procedure g_hash_table_unref(hash_table: PGHashTable); cdecl; external;
procedure g_hmac_get_digest(hmac: PGHmac; buffer: Pguint8; digest_len: Pgsize); cdecl; external;
procedure g_hmac_unref(hmac: PGHmac); cdecl; external;
procedure g_hmac_update(hmac: PGHmac; data: Pguint8; length: gssize); cdecl; external;
procedure g_hook_destroy_link(hook_list: PGHookList; hook: PGHook); cdecl; external;
procedure g_hook_free(hook_list: PGHookList; hook: PGHook); cdecl; external;
procedure g_hook_insert_before(hook_list: PGHookList; sibling: PGHook; hook: PGHook); cdecl; external;
procedure g_hook_insert_sorted(hook_list: PGHookList; hook: PGHook; func: TGHookCompareFunc); cdecl; external;
procedure g_hook_list_clear(hook_list: PGHookList); cdecl; external;
procedure g_hook_list_init(hook_list: PGHookList; hook_size: guint); cdecl; external;
procedure g_hook_list_invoke(hook_list: PGHookList; may_recurse: gboolean); cdecl; external;
procedure g_hook_list_invoke_check(hook_list: PGHookList; may_recurse: gboolean); cdecl; external;
procedure g_hook_list_marshal(hook_list: PGHookList; may_recurse: gboolean; marshaller: TGHookMarshaller; marshal_data: gpointer); cdecl; external;
procedure g_hook_list_marshal_check(hook_list: PGHookList; may_recurse: gboolean; marshaller: TGHookCheckMarshaller; marshal_data: gpointer); cdecl; external;
procedure g_hook_prepend(hook_list: PGHookList; hook: PGHook); cdecl; external;
procedure g_hook_unref(hook_list: PGHookList; hook: PGHook); cdecl; external;
procedure g_io_channel_init(channel: PGIOChannel); cdecl; external;
procedure g_io_channel_set_buffer_size(channel: PGIOChannel; size: gsize); cdecl; external;
procedure g_io_channel_set_buffered(channel: PGIOChannel; buffered: gboolean); cdecl; external;
procedure g_io_channel_set_close_on_unref(channel: PGIOChannel; do_close: gboolean); cdecl; external;
procedure g_io_channel_set_line_term(channel: PGIOChannel; line_term: Pgchar; length: gint); cdecl; external;
procedure g_io_channel_unref(channel: PGIOChannel); cdecl; external;
procedure g_key_file_free(key_file: PGKeyFile); cdecl; external;
procedure g_key_file_set_boolean(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: gboolean); cdecl; external;
procedure g_key_file_set_boolean_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; list: gboolean; length: gsize); cdecl; external;
procedure g_key_file_set_double(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: gdouble); cdecl; external;
procedure g_key_file_set_double_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; list: gdouble; length: gsize); cdecl; external;
procedure g_key_file_set_int64(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: gint64); cdecl; external;
procedure g_key_file_set_integer(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: gint); cdecl; external;
procedure g_key_file_set_integer_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; list: gint; length: gsize); cdecl; external;
procedure g_key_file_set_list_separator(key_file: PGKeyFile; separator: gchar); cdecl; external;
procedure g_key_file_set_locale_string(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; locale: Pgchar; string_: Pgchar); cdecl; external;
procedure g_key_file_set_locale_string_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; locale: Pgchar; list: Pgchar; length: gsize); cdecl; external;
procedure g_key_file_set_string(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; string_: Pgchar); cdecl; external;
procedure g_key_file_set_string_list(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; list: Pgchar; length: gsize); cdecl; external;
procedure g_key_file_set_uint64(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: guint64); cdecl; external;
procedure g_key_file_set_value(key_file: PGKeyFile; group_name: Pgchar; key: Pgchar; value: Pgchar); cdecl; external;
procedure g_key_file_unref(key_file: PGKeyFile); cdecl; external;
procedure g_list_foreach(list: PGList; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_list_free(list: PGList); cdecl; external;
procedure g_list_free_1(list: PGList); cdecl; external;
procedure g_list_free_full(list: PGList; free_func: TGDestroyNotify); cdecl; external;
procedure g_log(log_domain: Pgchar; log_level: TGLogLevelFlags; format: Pgchar; args: array of const); cdecl; external;
procedure g_log_default_handler(log_domain: Pgchar; log_level: TGLogLevelFlags; message: Pgchar; unused_data: gpointer); cdecl; external;
procedure g_log_remove_handler(log_domain: Pgchar; handler_id: guint); cdecl; external;
procedure g_logv(log_domain: Pgchar; log_level: TGLogLevelFlags; format: Pgchar; args: Tva_list); cdecl; external;
procedure g_main_context_add_poll(context: PGMainContext; fd: PGPollFD; priority: gint); cdecl; external;
procedure g_main_context_dispatch(context: PGMainContext); cdecl; external;
procedure g_main_context_invoke(context: PGMainContext; function_: TGSourceFunc; data: gpointer); cdecl; external;
procedure g_main_context_invoke_full(context: PGMainContext; priority: gint; function_: TGSourceFunc; data: gpointer; notify: TGDestroyNotify); cdecl; external;
procedure g_main_context_pop_thread_default(context: PGMainContext); cdecl; external;
procedure g_main_context_push_thread_default(context: PGMainContext); cdecl; external;
procedure g_main_context_release(context: PGMainContext); cdecl; external;
procedure g_main_context_remove_poll(context: PGMainContext; fd: PGPollFD); cdecl; external;
procedure g_main_context_set_poll_func(context: PGMainContext; func: TGPollFunc); cdecl; external;
procedure g_main_context_unref(context: PGMainContext); cdecl; external;
procedure g_main_context_wakeup(context: PGMainContext); cdecl; external;
procedure g_main_loop_quit(loop: PGMainLoop); cdecl; external;
procedure g_main_loop_run(loop: PGMainLoop); cdecl; external;
procedure g_main_loop_unref(loop: PGMainLoop); cdecl; external;
procedure g_mapped_file_unref(file_: PGMappedFile); cdecl; external;
procedure g_markup_parse_context_free(context: PGMarkupParseContext); cdecl; external;
procedure g_markup_parse_context_get_position(context: PGMarkupParseContext; line_number: Pgint; char_number: Pgint); cdecl; external;
procedure g_markup_parse_context_push(context: PGMarkupParseContext; parser: PGMarkupParser; user_data: gpointer); cdecl; external;
procedure g_markup_parse_context_unref(context: PGMarkupParseContext); cdecl; external;
procedure g_match_info_free(match_info: PGMatchInfo); cdecl; external;
procedure g_match_info_unref(match_info: PGMatchInfo); cdecl; external;
procedure g_mem_profile; cdecl; external;
procedure g_mem_set_vtable(vtable: PGMemVTable); cdecl; external;
procedure g_mutex_clear(mutex: PGMutex); cdecl; external;
procedure g_mutex_init(mutex: PGMutex); cdecl; external;
procedure g_mutex_lock(mutex: PGMutex); cdecl; external;
procedure g_mutex_unlock(mutex: PGMutex); cdecl; external;
procedure g_node_children_foreach(node: PGNode; flags: TGTraverseFlags; func: TGNodeForeachFunc; data: gpointer); cdecl; external;
procedure g_node_destroy(root: PGNode); cdecl; external;
procedure g_node_reverse_children(node: PGNode); cdecl; external;
procedure g_node_traverse(root: PGNode; order: TGTraverseType; flags: TGTraverseFlags; max_depth: gint; func: TGNodeTraverseFunc; data: gpointer); cdecl; external;
procedure g_node_unlink(node: PGNode); cdecl; external;
procedure g_nullify_pointer(nullify_location: Pgpointer); cdecl; external;
procedure g_on_error_query(prg_name: Pgchar); cdecl; external;
procedure g_on_error_stack_trace(prg_name: Pgchar); cdecl; external;
procedure g_once_init_leave(location: Pgpointer; result_: gsize); cdecl; external;
procedure g_option_context_add_group(context: PGOptionContext; group: PGOptionGroup); cdecl; external;
procedure g_option_context_add_main_entries(context: PGOptionContext; entries: PGOptionEntry; translation_domain: Pgchar); cdecl; external;
procedure g_option_context_free(context: PGOptionContext); cdecl; external;
procedure g_option_context_set_description(context: PGOptionContext; description: Pgchar); cdecl; external;
procedure g_option_context_set_help_enabled(context: PGOptionContext; help_enabled: gboolean); cdecl; external;
procedure g_option_context_set_ignore_unknown_options(context: PGOptionContext; ignore_unknown: gboolean); cdecl; external;
procedure g_option_context_set_main_group(context: PGOptionContext; group: PGOptionGroup); cdecl; external;
procedure g_option_context_set_summary(context: PGOptionContext; summary: Pgchar); cdecl; external;
procedure g_option_context_set_translate_func(context: PGOptionContext; func: TGTranslateFunc; data: gpointer; destroy_notify: TGDestroyNotify); cdecl; external;
procedure g_option_context_set_translation_domain(context: PGOptionContext; domain: Pgchar); cdecl; external;
procedure g_option_group_add_entries(group: PGOptionGroup; entries: PGOptionEntry); cdecl; external;
procedure g_option_group_free(group: PGOptionGroup); cdecl; external;
procedure g_option_group_set_error_hook(group: PGOptionGroup; error_func: TGOptionErrorFunc); cdecl; external;
procedure g_option_group_set_parse_hooks(group: PGOptionGroup; pre_parse_func: TGOptionParseFunc; post_parse_func: TGOptionParseFunc); cdecl; external;
procedure g_option_group_set_translate_func(group: PGOptionGroup; func: TGTranslateFunc; data: gpointer; destroy_notify: TGDestroyNotify); cdecl; external;
procedure g_option_group_set_translation_domain(group: PGOptionGroup; domain: Pgchar); cdecl; external;
procedure g_pattern_spec_free(pspec: PGPatternSpec); cdecl; external;
procedure g_pointer_bit_lock(address: Pgpointer; lock_bit: gint); cdecl; external;
procedure g_pointer_bit_unlock(address: Pgpointer; lock_bit: gint); cdecl; external;
procedure g_prefix_error(err: PPGError; format: Pgchar; args: array of const); cdecl; external;
procedure g_print(format: Pgchar; args: array of const); cdecl; external;
procedure g_printerr(format: Pgchar; args: array of const); cdecl; external;
procedure g_private_replace(key: PGPrivate; value: gpointer); cdecl; external;
procedure g_private_set(key: PGPrivate; value: gpointer); cdecl; external;
procedure g_propagate_error(dest: PPGError; src: PGError); cdecl; external;
procedure g_propagate_prefixed_error(dest: PPGError; src: PGError; format: Pgchar; args: array of const); cdecl; external;
procedure g_ptr_array_add(array_: Pgpointer; data: gpointer); cdecl; external;
procedure g_ptr_array_foreach(array_: Pgpointer; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_ptr_array_remove_range(array_: Pgpointer; index_: guint; length: guint); cdecl; external;
procedure g_ptr_array_set_free_func(array_: Pgpointer; element_free_func: TGDestroyNotify); cdecl; external;
procedure g_ptr_array_set_size(array_: Pgpointer; length: gint); cdecl; external;
procedure g_ptr_array_sort(array_: Pgpointer; compare_func: TGCompareFunc); cdecl; external;
procedure g_ptr_array_sort_with_data(array_: Pgpointer; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_ptr_array_unref(array_: Pgpointer); cdecl; external;
procedure g_qsort_with_data(pbase: Pgpointer; total_elems: gint; size: gsize; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_queue_clear(queue: PGQueue); cdecl; external;
procedure g_queue_delete_link(queue: PGQueue; link_: PGList); cdecl; external;
procedure g_queue_foreach(queue: PGQueue; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_queue_free(queue: PGQueue); cdecl; external;
procedure g_queue_free_full(queue: PGQueue; free_func: TGDestroyNotify); cdecl; external;
procedure g_queue_init(queue: PGQueue); cdecl; external;
procedure g_queue_insert_after(queue: PGQueue; sibling: PGList; data: gpointer); cdecl; external;
procedure g_queue_insert_before(queue: PGQueue; sibling: PGList; data: gpointer); cdecl; external;
procedure g_queue_insert_sorted(queue: PGQueue; data: gpointer; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_queue_push_head(queue: PGQueue; data: gpointer); cdecl; external;
procedure g_queue_push_head_link(queue: PGQueue; link_: PGList); cdecl; external;
procedure g_queue_push_nth(queue: PGQueue; data: gpointer; n: gint); cdecl; external;
procedure g_queue_push_nth_link(queue: PGQueue; n: gint; link_: PGList); cdecl; external;
procedure g_queue_push_tail(queue: PGQueue; data: gpointer); cdecl; external;
procedure g_queue_push_tail_link(queue: PGQueue; link_: PGList); cdecl; external;
procedure g_queue_reverse(queue: PGQueue); cdecl; external;
procedure g_queue_sort(queue: PGQueue; compare_func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_queue_unlink(queue: PGQueue; link_: PGList); cdecl; external;
procedure g_rand_free(rand_: PGRand); cdecl; external;
procedure g_rand_set_seed(rand_: PGRand; seed: guint32); cdecl; external;
procedure g_rand_set_seed_array(rand_: PGRand; seed: Pguint32; seed_length: guint); cdecl; external;
procedure g_random_set_seed(seed: guint32); cdecl; external;
procedure g_rec_mutex_clear(rec_mutex: PGRecMutex); cdecl; external;
procedure g_rec_mutex_init(rec_mutex: PGRecMutex); cdecl; external;
procedure g_rec_mutex_lock(rec_mutex: PGRecMutex); cdecl; external;
procedure g_rec_mutex_unlock(rec_mutex: PGRecMutex); cdecl; external;
procedure g_regex_unref(regex: PGRegex); cdecl; external;
procedure g_reload_user_special_dirs_cache; cdecl; external;
procedure g_return_if_fail_warning(log_domain: Pgchar; pretty_function: Pgchar; expression: Pgchar); cdecl; external;
procedure g_rw_lock_clear(rw_lock: PGRWLock); cdecl; external;
procedure g_rw_lock_init(rw_lock: PGRWLock); cdecl; external;
procedure g_rw_lock_reader_lock(rw_lock: PGRWLock); cdecl; external;
procedure g_rw_lock_reader_unlock(rw_lock: PGRWLock); cdecl; external;
procedure g_rw_lock_writer_lock(rw_lock: PGRWLock); cdecl; external;
procedure g_rw_lock_writer_unlock(rw_lock: PGRWLock); cdecl; external;
procedure g_scanner_destroy(scanner: PGScanner); cdecl; external;
procedure g_scanner_error(scanner: PGScanner; format: Pgchar; args: array of const); cdecl; external;
procedure g_scanner_input_file(scanner: PGScanner; input_fd: gint); cdecl; external;
procedure g_scanner_input_text(scanner: PGScanner; text: Pgchar; text_len: guint); cdecl; external;
procedure g_scanner_scope_add_symbol(scanner: PGScanner; scope_id: guint; symbol: Pgchar; value: gpointer); cdecl; external;
procedure g_scanner_scope_foreach_symbol(scanner: PGScanner; scope_id: guint; func: TGHFunc; user_data: gpointer); cdecl; external;
procedure g_scanner_scope_remove_symbol(scanner: PGScanner; scope_id: guint; symbol: Pgchar); cdecl; external;
procedure g_scanner_sync_file_offset(scanner: PGScanner); cdecl; external;
procedure g_scanner_unexp_token(scanner: PGScanner; expected_token: TGTokenType; identifier_spec: Pgchar; symbol_spec: Pgchar; symbol_name: Pgchar; message: Pgchar; is_error: gint); cdecl; external;
procedure g_scanner_warn(scanner: PGScanner; format: Pgchar; args: array of const); cdecl; external;
procedure g_sequence_foreach(seq: PGSequence; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_sequence_foreach_range(begin_: PGSequenceIter; end_: PGSequenceIter; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_sequence_free(seq: PGSequence); cdecl; external;
procedure g_sequence_move(src: PGSequenceIter; dest: PGSequenceIter); cdecl; external;
procedure g_sequence_move_range(dest: PGSequenceIter; begin_: PGSequenceIter; end_: PGSequenceIter); cdecl; external;
procedure g_sequence_remove(iter: PGSequenceIter); cdecl; external;
procedure g_sequence_remove_range(begin_: PGSequenceIter; end_: PGSequenceIter); cdecl; external;
procedure g_sequence_set(iter: PGSequenceIter; data: gpointer); cdecl; external;
procedure g_sequence_sort(seq: PGSequence; cmp_func: TGCompareDataFunc; cmp_data: gpointer); cdecl; external;
procedure g_sequence_sort_changed(iter: PGSequenceIter; cmp_func: TGCompareDataFunc; cmp_data: gpointer); cdecl; external;
procedure g_sequence_sort_changed_iter(iter: PGSequenceIter; iter_cmp: TGSequenceIterCompareFunc; cmp_data: gpointer); cdecl; external;
procedure g_sequence_sort_iter(seq: PGSequence; cmp_func: TGSequenceIterCompareFunc; cmp_data: gpointer); cdecl; external;
procedure g_sequence_swap(a: PGSequenceIter; b: PGSequenceIter); cdecl; external;
procedure g_set_application_name(application_name: Pgchar); cdecl; external;
procedure g_set_error(err: PPGError; domain: TGQuark; code: gint; format: Pgchar; args: array of const); cdecl; external;
procedure g_set_error_literal(err: PPGError; domain: TGQuark; code: gint; message: Pgchar); cdecl; external;
procedure g_set_prgname(prgname: Pgchar); cdecl; external;
procedure g_slice_free1(block_size: gsize; mem_block: gpointer); cdecl; external;
procedure g_slice_free_chain_with_offset(block_size: gsize; mem_chain: gpointer; next_offset: gsize); cdecl; external;
procedure g_slice_set_config(ckey: TGSliceConfig; value: gint64); cdecl; external;
procedure g_slist_foreach(list: PGSList; func: TGFunc; user_data: gpointer); cdecl; external;
procedure g_slist_free(list: PGSList); cdecl; external;
procedure g_slist_free_1(list: PGSList); cdecl; external;
procedure g_slist_free_full(list: PGSList; free_func: TGDestroyNotify); cdecl; external;
procedure g_source_add_child_source(source: PGSource; child_source: PGSource); cdecl; external;
procedure g_source_add_poll(source: PGSource; fd: PGPollFD); cdecl; external;
procedure g_source_destroy(source: PGSource); cdecl; external;
procedure g_source_modify_unix_fd(source: PGSource; tag: gpointer; new_events: TGIOCondition); cdecl; external;
procedure g_source_remove_child_source(source: PGSource; child_source: PGSource); cdecl; external;
procedure g_source_remove_poll(source: PGSource; fd: PGPollFD); cdecl; external;
procedure g_source_remove_unix_fd(source: PGSource; tag: gpointer); cdecl; external;
procedure g_source_set_callback(source: PGSource; func: TGSourceFunc; data: gpointer; notify: TGDestroyNotify); cdecl; external;
procedure g_source_set_callback_indirect(source: PGSource; callback_data: gpointer; callback_funcs: PGSourceCallbackFuncs); cdecl; external;
procedure g_source_set_can_recurse(source: PGSource; can_recurse: gboolean); cdecl; external;
procedure g_source_set_funcs(source: PGSource; funcs: PGSourceFuncs); cdecl; external;
procedure g_source_set_name(source: PGSource; name: Pgchar); cdecl; external;
procedure g_source_set_name_by_id(tag: guint; name: Pgchar); cdecl; external;
procedure g_source_set_priority(source: PGSource; priority: gint); cdecl; external;
procedure g_source_set_ready_time(source: PGSource; ready_time: gint64); cdecl; external;
procedure g_source_unref(source: PGSource); cdecl; external;
procedure g_spawn_close_pid(pid: TGPid); cdecl; external;
procedure g_strfreev(str_array: PPgchar); cdecl; external;
procedure g_string_append_printf(string_: PGString; format: Pgchar; args: array of const); cdecl; external;
procedure g_string_append_vprintf(string_: PGString; format: Pgchar; args: Tva_list); cdecl; external;
procedure g_string_chunk_clear(chunk: PGStringChunk); cdecl; external;
procedure g_string_chunk_free(chunk: PGStringChunk); cdecl; external;
procedure g_string_printf(string_: PGString; format: Pgchar; args: array of const); cdecl; external;
procedure g_string_vprintf(string_: PGString; format: Pgchar; args: Tva_list); cdecl; external;
procedure g_test_add_data_func(testpath: Pgchar; test_data: Pgpointer; test_func: TGTestDataFunc); cdecl; external;
procedure g_test_add_data_func_full(testpath: Pgchar; test_data: gpointer; test_func: TGTestDataFunc; data_free_func: TGDestroyNotify); cdecl; external;
procedure g_test_add_func(testpath: Pgchar; test_func: TGTestFunc); cdecl; external;
procedure g_test_add_vtable(testpath: Pgchar; data_size: gsize; test_data: Pgpointer; data_setup: TGTestFixtureFunc; data_test: TGTestFixtureFunc; data_teardown: TGTestFixtureFunc); cdecl; external;
procedure g_test_assert_expected_messages_internal(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar); cdecl; external;
procedure g_test_bug(bug_uri_snippet: Pgchar); cdecl; external;
procedure g_test_bug_base(uri_pattern: Pgchar); cdecl; external;
procedure g_test_expect_message(log_domain: Pgchar; log_level: TGLogLevelFlags; pattern: Pgchar); cdecl; external;
procedure g_test_fail; cdecl; external;
procedure g_test_init(argc: Pgint; argv: PPPgchar; args: array of const); cdecl; external;
procedure g_test_log_buffer_free(tbuffer: PGTestLogBuffer); cdecl; external;
procedure g_test_log_buffer_push(tbuffer: PGTestLogBuffer; n_bytes: guint; bytes: Pguint8); cdecl; external;
procedure g_test_log_msg_free(tmsg: PGTestLogMsg); cdecl; external;
procedure g_test_log_set_fatal_handler(log_func: TGTestLogFatalFunc; user_data: gpointer); cdecl; external;
procedure g_test_maximized_result(maximized_quantity: gdouble; format: Pgchar; args: array of const); cdecl; external;
procedure g_test_message(format: Pgchar; args: array of const); cdecl; external;
procedure g_test_minimized_result(minimized_quantity: gdouble; format: Pgchar; args: array of const); cdecl; external;
procedure g_test_queue_destroy(destroy_func: TGDestroyNotify; destroy_data: gpointer); cdecl; external;
procedure g_test_queue_free(gfree_pointer: gpointer); cdecl; external;
procedure g_test_suite_add(suite: PGTestSuite; test_case: PGTestCase); cdecl; external;
procedure g_test_suite_add_suite(suite: PGTestSuite; nestedsuite: PGTestSuite); cdecl; external;
procedure g_test_timer_start; cdecl; external;
procedure g_test_trap_assertions(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; assertion_flags: guint64; pattern: Pgchar); cdecl; external;
procedure g_thread_exit(retval: gpointer); cdecl; external;
procedure g_thread_pool_free(pool: PGThreadPool; immediate: gboolean; wait_: gboolean); cdecl; external;
procedure g_thread_pool_set_max_idle_time(interval: guint); cdecl; external;
procedure g_thread_pool_set_max_unused_threads(max_threads: gint); cdecl; external;
procedure g_thread_pool_set_sort_function(pool: PGThreadPool; func: TGCompareDataFunc; user_data: gpointer); cdecl; external;
procedure g_thread_pool_stop_unused_threads; cdecl; external;
procedure g_thread_unref(thread: PGThread); cdecl; external;
procedure g_thread_yield; cdecl; external;
procedure g_time_val_add(time_: PGTimeVal; microseconds: glong); cdecl; external;
procedure g_time_zone_unref(tz: PGTimeZone); cdecl; external;
procedure g_timer_continue(timer: PGTimer); cdecl; external;
procedure g_timer_destroy(timer: PGTimer); cdecl; external;
procedure g_timer_reset(timer: PGTimer); cdecl; external;
procedure g_timer_start(timer: PGTimer); cdecl; external;
procedure g_timer_stop(timer: PGTimer); cdecl; external;
procedure g_trash_stack_push(stack_p: PPGTrashStack; data_p: gpointer); cdecl; external;
procedure g_tree_destroy(tree: PGTree); cdecl; external;
procedure g_tree_foreach(tree: PGTree; func: TGTraverseFunc; user_data: gpointer); cdecl; external;
procedure g_tree_insert(tree: PGTree; key: gpointer; value: gpointer); cdecl; external;
procedure g_tree_replace(tree: PGTree; key: gpointer; value: gpointer); cdecl; external;
procedure g_tree_unref(tree: PGTree); cdecl; external;
procedure g_unicode_canonical_ordering(string_: Pgunichar; len: gsize); cdecl; external;
procedure g_unsetenv(variable: Pgchar); cdecl; external;
procedure g_usleep(microseconds: gulong); cdecl; external;
procedure g_variant_builder_add(builder: PGVariantBuilder; format_string: Pgchar; args: array of const); cdecl; external;
procedure g_variant_builder_add_parsed(builder: PGVariantBuilder; format: Pgchar; args: array of const); cdecl; external;
procedure g_variant_builder_add_value(builder: PGVariantBuilder; value: PGVariant); cdecl; external;
procedure g_variant_builder_clear(builder: PGVariantBuilder); cdecl; external;
procedure g_variant_builder_close(builder: PGVariantBuilder); cdecl; external;
procedure g_variant_builder_init(builder: PGVariantBuilder; type_: PGVariantType); cdecl; external;
procedure g_variant_builder_open(builder: PGVariantBuilder; type_: PGVariantType); cdecl; external;
procedure g_variant_builder_unref(builder: PGVariantBuilder); cdecl; external;
procedure g_variant_get(value: PGVariant; format_string: Pgchar; args: array of const); cdecl; external;
procedure g_variant_get_child(value: PGVariant; index_: gsize; format_string: Pgchar; args: array of const); cdecl; external;
procedure g_variant_get_va(value: PGVariant; format_string: Pgchar; endptr: PPgchar; app: Pva_list); cdecl; external;
procedure g_variant_iter_free(iter: PGVariantIter); cdecl; external;
procedure g_variant_store(value: PGVariant; data: gpointer); cdecl; external;
procedure g_variant_type_free(type_: PGVariantType); cdecl; external;
procedure g_variant_unref(value: PGVariant); cdecl; external;
procedure g_warn_message(domain: Pgchar; file_: Pgchar; line: gint; func: Pgchar; warnexpr: Pgchar); cdecl; external;
implementation
end.