/* * Licensed under the GNU Lesser General Public License Version 3 * * This library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the license, or * (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this library. If not, see . */ // generated automatically - do not change module gi.glibtypes; public alias uint uid_t; public alias int pid_t; version( Windows ) { alias int glong; alias uint gulong; } else version( X86_64 ) { alias long glong; alias ulong gulong; } else { alias int glong; alias uint gulong; } version( Windows ) enum _utfPostfix = "_utf8"; else enum _utfPostfix = ""; version (Windows) { private import core.stdc.stdio; static if( !is(typeof(fdopen(0, null))) ) { extern (C) FILE* fdopen(int, char*); } } static if ( __VERSION__ >= 2063 ) { public import std.typecons : scoped; template Scoped(T) { alias typeof(scoped!T(cast(typeof(T.tupleof[0]))null)) Scoped; } } else { // I'm getting the following error on the older dmd versions: // this for Scoped_store needs to be type Scoped not type inout(Scoped!(T)). // Unlike the phobos version this does use GC alocated memory for the object. // Within GtkD this is used to make sure destroy is called on the object // so it releases the resources it holds. struct Scoped(T) { T payload; alias payload this; @disable this(); @disable this(this); ~this() { .destroy(payload); } } auto scoped(T, Args...)(auto ref Args args) if (is(T == class)) { Scoped!(T) result = void; result.payload = new T(args); return result; } } /** * Get the length of a zero terminated array. */ size_t getArrayLength(T)(T* arr) { size_t len; for ( ; arr[len]; len++ ){} return len; } unittest { assert(getArrayLength("aaaaaaaaa\0".ptr) == 9); } Type* gMalloc(Type)() { import gi.glib; return cast(Type*)g_malloc0(Type.sizeof); } alias void* GIConv; public alias void* GArrayAutoptr; public alias void* GAsyncQueueAutoptr; public alias void* GBookmarkFileAutoptr; public alias void* GByteArrayAutoptr; public alias void* GBytesAutoptr; public alias void* GChecksumAutoptr; /** * Integer representing a day of the month; between 1 and 31. * #G_DATE_BAD_DAY represents an invalid day of the month. */ public alias ubyte GDateDay; public alias void* GDateTimeAutoptr; /** * Integer representing a year; #G_DATE_BAD_YEAR is the invalid * value. The year must be 1 or higher; negative (BC) years are not * allowed. The year is represented with four digits. */ public alias ushort GDateYear; public alias void* GDirAutoptr; public alias void* GErrorAutoptr; public alias void* GHashTableAutoptr; public alias void* GHmacAutoptr; public alias void* GIOChannelAutoptr; public alias void* GKeyFileAutoptr; public alias void* GListAutoptr; public alias void* GMainContextAutoptr; public alias void* GMainLoopAutoptr; public alias void* GMappedFileAutoptr; public alias void* GMarkupParseContextAutoptr; public alias void* GMatchInfoAutoptr; /** * Opaque type. See g_mutex_locker_new() for details. */ public alias void* GMutexLocker; public alias void* GMutexLockerAutoptr; public alias void* GNodeAutoptr; public alias void* GOptionContextAutoptr; public alias void* GOptionGroupAutoptr; public alias void* GPatternSpecAutoptr; /** * A type which is used to hold a process identification. * * On UNIX, processes are identified by a process id (an integer), * while Windows uses process handles (which are pointers). * * GPid is used in GLib only for descendant processes spawned with * the g_spawn functions. */ public alias int GPid; public alias void* GPtrArrayAutoptr; /** * A GQuark is a non-zero integer which uniquely identifies a * particular string. A GQuark value of zero is associated to %NULL. */ public alias uint GQuark; public alias void* GQueueAutoptr; public alias void* GRandAutoptr; public alias void* GRegexAutoptr; public alias void* GSListAutoptr; public alias void* GScannerAutoptr; public alias void* GSequenceAutoptr; public alias void* GSourceAutoptr; public alias void* GStringChunkAutoptr; public alias void* GStringAutoptr; public alias void* GStrv; public alias void* GThreadAutoptr; /** * Simply a replacement for time_t. It has been deprecated * since it is not equivalent to time_t on 64-bit platforms * with a 64-bit time_t. Unrelated to #GTimer. * * Note that #GTime is defined to always be a 32-bit integer, * unlike time_t which may be 64-bit on some systems. Therefore, * #GTime will overflow in the year 2038, and you cannot use the * address of a #GTime variable as argument to the UNIX time() * function. * * Instead, do the following: * |[ * time_t ttime; * GTime gtime; * * time (&ttime); * gtime = (GTime)ttime; * ]| */ public alias int GTime; /** * A value representing an interval of time, in microseconds. */ public alias long GTimeSpan; public alias void* GTimeZoneAutoptr; public alias void* GTimerAutoptr; public alias void* GTreeAutoptr; public alias void* GVariantBuilderAutoptr; public alias void* GVariantDictAutoptr; public alias void* GVariantIterAutoptr; public alias void* GVariantTypeAutoptr; public alias void* GVariantAutoptr; enum GPriority { HIGH = -100, DEFAULT = 0, HIGH_IDLE = 100, DEFAULT_IDLE = 200, LOW = 300 } public enum GAsciiType { ALNUM = 1, ALPHA = 2, CNTRL = 4, DIGIT = 8, GRAPH = 16, LOWER = 32, PRINT = 64, PUNCT = 128, SPACE = 256, UPPER = 512, XDIGIT = 1024, } alias GAsciiType AsciiType; /** * Error codes returned by bookmark file parsing. */ public enum GBookmarkFileError { /** * URI was ill-formed */ INVALID_URI = 0, /** * a requested field was not found */ INVALID_VALUE = 1, /** * a requested application did * not register a bookmark */ APP_NOT_REGISTERED = 2, /** * a requested URI was not found */ URI_NOT_FOUND = 3, /** * document was ill formed */ READ = 4, /** * the text being parsed was * in an unknown encoding */ UNKNOWN_ENCODING = 5, /** * an error occurred while writing */ WRITE = 6, /** * requested file was not found */ FILE_NOT_FOUND = 7, } alias GBookmarkFileError BookmarkFileError; /** * The hashing algorithm to be used by #GChecksum when performing the * digest of some data. * * Note that the #GChecksumType enumeration may be extended at a later * date to include new hashing algorithm types. * * Since: 2.16 */ public enum GChecksumType { /** * Use the MD5 hashing algorithm */ MD5 = 0, /** * Use the SHA-1 hashing algorithm */ SHA1 = 1, /** * Use the SHA-256 hashing algorithm */ SHA256 = 2, /** * Use the SHA-512 hashing algorithm */ SHA512 = 3, } alias GChecksumType ChecksumType; /** * Error codes returned by character set conversion routines. */ public enum GConvertError { /** * Conversion between the requested character * sets is not supported. */ NO_CONVERSION = 0, /** * Invalid byte sequence in conversion input. */ ILLEGAL_SEQUENCE = 1, /** * Conversion failed for some reason. */ FAILED = 2, /** * Partial character sequence at end of input. */ PARTIAL_INPUT = 3, /** * URI is invalid. */ BAD_URI = 4, /** * Pathname is not an absolute path. */ NOT_ABSOLUTE_PATH = 5, /** * No memory available. Since: 2.40 */ NO_MEMORY = 6, } alias GConvertError ConvertError; /** * This enumeration isn't used in the API, but may be useful if you need * to mark a number as a day, month, or year. */ public enum GDateDMY { /** * a day */ DAY = 0, /** * a month */ MONTH = 1, /** * a year */ YEAR = 2, } alias GDateDMY DateDMY; /** * Enumeration representing a month; values are #G_DATE_JANUARY, * #G_DATE_FEBRUARY, etc. #G_DATE_BAD_MONTH is the invalid value. */ public enum GDateMonth { /** * invalid value */ BAD_MONTH = 0, /** * January */ JANUARY = 1, /** * February */ FEBRUARY = 2, /** * March */ MARCH = 3, /** * April */ APRIL = 4, /** * May */ MAY = 5, /** * June */ JUNE = 6, /** * July */ JULY = 7, /** * August */ AUGUST = 8, /** * September */ SEPTEMBER = 9, /** * October */ OCTOBER = 10, /** * November */ NOVEMBER = 11, /** * December */ DECEMBER = 12, } alias GDateMonth DateMonth; /** * Enumeration representing a day of the week; #G_DATE_MONDAY, * #G_DATE_TUESDAY, etc. #G_DATE_BAD_WEEKDAY is an invalid weekday. */ public enum GDateWeekday { /** * invalid value */ BAD_WEEKDAY = 0, /** * Monday */ MONDAY = 1, /** * Tuesday */ TUESDAY = 2, /** * Wednesday */ WEDNESDAY = 3, /** * Thursday */ THURSDAY = 4, /** * Friday */ FRIDAY = 5, /** * Saturday */ SATURDAY = 6, /** * Sunday */ SUNDAY = 7, } alias GDateWeekday DateWeekday; /** * The possible errors, used in the @v_error field * of #GTokenValue, when the token is a %G_TOKEN_ERROR. */ public enum GErrorType { /** * unknown error */ UNKNOWN = 0, /** * unexpected end of file */ UNEXP_EOF = 1, /** * unterminated string constant */ UNEXP_EOF_IN_STRING = 2, /** * unterminated comment */ UNEXP_EOF_IN_COMMENT = 3, /** * non-digit character in a number */ NON_DIGIT_IN_CONST = 4, /** * digit beyond radix in a number */ DIGIT_RADIX = 5, /** * non-decimal floating point number */ FLOAT_RADIX = 6, /** * malformed floating point number */ FLOAT_MALFORMED = 7, } alias GErrorType ErrorType; /** * Values corresponding to @errno codes returned from file operations * on UNIX. Unlike @errno codes, GFileError values are available on * all systems, even Windows. The exact meaning of each code depends * on what sort of file operation you were performing; the UNIX * documentation gives more details. The following error code descriptions * come from the GNU C Library manual, and are under the copyright * of that manual. * * It's not very portable to make detailed assumptions about exactly * which errors will be returned from a given operation. Some errors * don't occur on some systems, etc., sometimes there are subtle * differences in when a system will report a given error, etc. */ public enum GFileError { /** * Operation not permitted; only the owner of * the file (or other resource) or processes with special privileges * can perform the operation. */ EXIST = 0, /** * File is a directory; you cannot open a directory * for writing, or create or remove hard links to it. */ ISDIR = 1, /** * Permission denied; the file permissions do not * allow the attempted operation. */ ACCES = 2, /** * Filename too long. */ NAMETOOLONG = 3, /** * No such file or directory. This is a "file * doesn't exist" error for ordinary files that are referenced in * contexts where they are expected to already exist. */ NOENT = 4, /** * A file that isn't a directory was specified when * a directory is required. */ NOTDIR = 5, /** * No such device or address. The system tried to * use the device represented by a file you specified, and it * couldn't find the device. This can mean that the device file was * installed incorrectly, or that the physical device is missing or * not correctly attached to the computer. */ NXIO = 6, /** * The underlying file system of the specified file * does not support memory mapping. */ NODEV = 7, /** * The directory containing the new link can't be * modified because it's on a read-only file system. */ ROFS = 8, /** * Text file busy. */ TXTBSY = 9, /** * You passed in a pointer to bad memory. * (GLib won't reliably return this, don't pass in pointers to bad * memory.) */ FAULT = 10, /** * Too many levels of symbolic links were encountered * in looking up a file name. This often indicates a cycle of symbolic * links. */ LOOP = 11, /** * No space left on device; write operation on a * file failed because the disk is full. */ NOSPC = 12, /** * No memory available. The system cannot allocate * more virtual memory because its capacity is full. */ NOMEM = 13, /** * The current process has too many files open and * can't open any more. Duplicate descriptors do count toward this * limit. */ MFILE = 14, /** * There are too many distinct file openings in the * entire system. */ NFILE = 15, /** * Bad file descriptor; for example, I/O on a * descriptor that has been closed or reading from a descriptor open * only for writing (or vice versa). */ BADF = 16, /** * Invalid argument. This is used to indicate * various kinds of problems with passing the wrong argument to a * library function. */ INVAL = 17, /** * Broken pipe; there is no process reading from the * other end of a pipe. Every library function that returns this * error code also generates a 'SIGPIPE' signal; this signal * terminates the program if not handled or blocked. Thus, your * program will never actually see this code unless it has handled * or blocked 'SIGPIPE'. */ PIPE = 18, /** * Resource temporarily unavailable; the call might * work if you try again later. */ AGAIN = 19, /** * Interrupted function call; an asynchronous signal * occurred and prevented completion of the call. When this * happens, you should try the call again. */ INTR = 20, /** * Input/output error; usually used for physical read * or write errors. i.e. the disk or other physical device hardware * is returning errors. */ IO = 21, /** * Operation not permitted; only the owner of the * file (or other resource) or processes with special privileges can * perform the operation. */ PERM = 22, /** * Function not implemented; this indicates that * the system is missing some functionality. */ NOSYS = 23, /** * Does not correspond to a UNIX error code; this * is the standard "failed for unspecified reason" error code present * in all #GError error code enumerations. Returned if no specific * code applies. */ FAILED = 24, } alias GFileError FileError; /** * A test to perform on a file using g_file_test(). */ public enum GFileTest { /** * %TRUE if the file is a regular file * (not a directory). Note that this test will also return %TRUE * if the tested file is a symlink to a regular file. */ IS_REGULAR = 1, /** * %TRUE if the file is a symlink. */ IS_SYMLINK = 2, /** * %TRUE if the file is a directory. */ IS_DIR = 4, /** * %TRUE if the file is executable. */ IS_EXECUTABLE = 8, /** * %TRUE if the file exists. It may or may not * be a regular file. */ EXISTS = 16, } alias GFileTest FileTest; /** * Flags to modify the format of the string returned by g_format_size_full(). */ public enum GFormatSizeFlags { /** * behave the same as g_format_size() */ DEFAULT = 0, /** * include the exact number of bytes as part * of the returned string. For example, "45.6 kB (45,612 bytes)". */ LONG_FORMAT = 1, /** * use IEC (base 1024) units with "KiB"-style * suffixes. IEC units should only be used for reporting things with * a strong "power of 2" basis, like RAM sizes or RAID stripe sizes. * Network and storage sizes should be reported in the normal SI units. */ IEC_UNITS = 2, } alias GFormatSizeFlags FormatSizeFlags; /** * Flags used internally in the #GHook implementation. */ public enum GHookFlagMask { /** * set if the hook has not been destroyed */ ACTIVE = 1, /** * set if the hook is currently being run */ IN_CALL = 2, /** * A mask covering all bits reserved for * hook flags; see %G_HOOK_FLAG_USER_SHIFT */ MASK = 15, } alias GHookFlagMask HookFlagMask; /** * Error codes returned by #GIOChannel operations. */ public enum GIOChannelError { /** * File too large. */ FBIG = 0, /** * Invalid argument. */ INVAL = 1, /** * IO error. */ IO = 2, /** * File is a directory. */ ISDIR = 3, /** * No space left on device. */ NOSPC = 4, /** * No such device or address. */ NXIO = 5, /** * Value too large for defined datatype. */ OVERFLOW = 6, /** * Broken pipe. */ PIPE = 7, /** * Some other error. */ FAILED = 8, } alias GIOChannelError IOChannelError; /** * A bitwise combination representing a condition to watch for on an * event source. */ public enum GIOCondition { /** * There is data to read. */ IN = 1, /** * Data can be written (without blocking). */ OUT = 4, /** * There is urgent data to read. */ PRI = 2, /** * Error condition. */ ERR = 8, /** * Hung up (the connection has been broken, usually for * pipes and sockets). */ HUP = 16, /** * Invalid request. The file descriptor is not open. */ NVAL = 32, } alias GIOCondition IOCondition; /** * #GIOError is only used by the deprecated functions * g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek(). */ public enum GIOError { /** * no error */ NONE = 0, /** * an EAGAIN error occurred */ AGAIN = 1, /** * an EINVAL error occurred */ INVAL = 2, /** * another error occurred */ UNKNOWN = 3, } alias GIOError IOError; /** * Specifies properties of a #GIOChannel. Some of the flags can only be * read with g_io_channel_get_flags(), but not changed with * g_io_channel_set_flags(). */ public enum GIOFlags { /** * turns on append mode, corresponds to %O_APPEND * (see the documentation of the UNIX open() syscall) */ APPEND = 1, /** * turns on nonblocking mode, corresponds to * %O_NONBLOCK/%O_NDELAY (see the documentation of the UNIX open() * syscall) */ NONBLOCK = 2, /** * indicates that the io channel is readable. * This flag cannot be changed. */ IS_READABLE = 4, /** * indicates that the io channel is writable. * This flag cannot be changed. */ IS_WRITABLE = 8, /** * a misspelled version of @G_IO_FLAG_IS_WRITABLE * that existed before the spelling was fixed in GLib 2.30. It is kept * here for compatibility reasons. Deprecated since 2.30 */ IS_WRITEABLE = 8, /** * indicates that the io channel is seekable, * i.e. that g_io_channel_seek_position() can be used on it. * This flag cannot be changed. */ IS_SEEKABLE = 16, /** * the mask that specifies all the valid flags. */ MASK = 31, /** * the mask of the flags that are returned from * g_io_channel_get_flags() */ GET_MASK = 31, /** * the mask of the flags that the user can modify * with g_io_channel_set_flags() */ SET_MASK = 3, } alias GIOFlags IOFlags; /** * Stati returned by most of the #GIOFuncs functions. */ public enum GIOStatus { /** * An error occurred. */ ERROR = 0, /** * Success. */ NORMAL = 1, /** * End of file. */ EOF = 2, /** * Resource temporarily unavailable. */ AGAIN = 3, } alias GIOStatus IOStatus; /** * Error codes returned by key file parsing. */ public enum GKeyFileError { /** * the text being parsed was in * an unknown encoding */ UNKNOWN_ENCODING = 0, /** * document was ill-formed */ PARSE = 1, /** * the file was not found */ NOT_FOUND = 2, /** * a requested key was not found */ KEY_NOT_FOUND = 3, /** * a requested group was not found */ GROUP_NOT_FOUND = 4, /** * a value could not be parsed */ INVALID_VALUE = 5, } alias GKeyFileError KeyFileError; /** * Flags which influence the parsing. */ public enum GKeyFileFlags { /** * No flags, default behaviour */ NONE = 0, /** * Use this flag if you plan to write the * (possibly modified) contents of the key file back to a file; * otherwise all comments will be lost when the key file is * written back. */ KEEP_COMMENTS = 1, /** * Use this flag if you plan to write the * (possibly modified) contents of the key file back to a file; * otherwise only the translations for the current language will be * written back. */ KEEP_TRANSLATIONS = 2, } alias GKeyFileFlags KeyFileFlags; /** * Flags specifying the level of log messages. * * It is possible to change how GLib treats messages of the various * levels using g_log_set_handler() and g_log_set_fatal_mask(). */ public enum GLogLevelFlags { /** * internal flag */ FLAG_RECURSION = 1, /** * internal flag */ FLAG_FATAL = 2, /** * log level for errors, see g_error(). * This level is also used for messages produced by g_assert(). */ LEVEL_ERROR = 4, /** * log level for critical messages, see g_critical(). * This level is also used for messages produced by g_return_if_fail() * and g_return_val_if_fail(). */ LEVEL_CRITICAL = 8, /** * log level for warnings, see g_warning() */ LEVEL_WARNING = 16, /** * log level for messages, see g_message() */ LEVEL_MESSAGE = 32, /** * log level for informational messages, see g_info() */ LEVEL_INFO = 64, /** * log level for debug messages, see g_debug() */ LEVEL_DEBUG = 128, /** * a mask including all log levels */ LEVEL_MASK = -4, } alias GLogLevelFlags LogLevelFlags; /** * A mixed enumerated type and flags field. You must specify one type * (string, strdup, boolean, tristate). Additionally, you may optionally * bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL. * * It is likely that this enum will be extended in the future to * support other types. */ public enum GMarkupCollectType { /** * used to terminate the list of attributes * to collect */ INVALID = 0, /** * collect the string pointer directly from * the attribute_values[] array. Expects a parameter of type (const * char **). If %G_MARKUP_COLLECT_OPTIONAL is specified and the * attribute isn't present then the pointer will be set to %NULL */ STRING = 1, /** * as with %G_MARKUP_COLLECT_STRING, but * expects a parameter of type (char **) and g_strdup()s the * returned pointer. The pointer must be freed with g_free() */ STRDUP = 2, /** * expects a parameter of type (gboolean *) * and parses the attribute value as a boolean. Sets %FALSE if the * attribute isn't present. Valid boolean values consist of * (case-insensitive) "false", "f", "no", "n", "0" and "true", "t", * "yes", "y", "1" */ BOOLEAN = 3, /** * as with %G_MARKUP_COLLECT_BOOLEAN, but * in the case of a missing attribute a value is set that compares * equal to neither %FALSE nor %TRUE G_MARKUP_COLLECT_OPTIONAL is * implied */ TRISTATE = 4, /** * can be bitwise ORed with the other fields. * If present, allows the attribute not to appear. A default value * is set depending on what value type is used */ OPTIONAL = 65536, } alias GMarkupCollectType MarkupCollectType; /** * Error codes returned by markup parsing. */ public enum GMarkupError { /** * text being parsed was not valid UTF-8 */ BAD_UTF8 = 0, /** * document contained nothing, or only whitespace */ EMPTY = 1, /** * document was ill-formed */ PARSE = 2, /** * error should be set by #GMarkupParser * functions; element wasn't known */ UNKNOWN_ELEMENT = 3, /** * error should be set by #GMarkupParser * functions; attribute wasn't known */ UNKNOWN_ATTRIBUTE = 4, /** * error should be set by #GMarkupParser * functions; content was invalid */ INVALID_CONTENT = 5, /** * error should be set by #GMarkupParser * functions; a required attribute was missing */ MISSING_ATTRIBUTE = 6, } alias GMarkupError MarkupError; /** * Flags that affect the behaviour of the parser. */ public enum GMarkupParseFlags { /** * flag you should not use */ DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1, /** * When this flag is set, CDATA marked * sections are not passed literally to the @passthrough function of * the parser. Instead, the content of the section (without the * ``) is * passed to the @text function. This flag was added in GLib 2.12 */ TREAT_CDATA_AS_TEXT = 2, /** * Normally errors caught by GMarkup * itself have line/column information prefixed to them to let the * caller know the location of the error. When this flag is set the * location information is also prefixed to errors generated by the * #GMarkupParser implementation functions */ PREFIX_ERROR_POSITION = 4, /** * Ignore (don't report) qualified * attributes and tags, along with their contents. A qualified * attribute or tag is one that contains ':' in its name (ie: is in * another namespace). Since: 2.40. */ IGNORE_QUALIFIED = 8, } alias GMarkupParseFlags MarkupParseFlags; /** * Defines how a Unicode string is transformed in a canonical * form, standardizing such issues as whether a character with * an accent is represented as a base character and combining * accent or as a single precomposed character. Unicode strings * should generally be normalized before comparing them. */ public enum GNormalizeMode { /** * standardize differences that do not affect the * text content, such as the above-mentioned accent representation */ DEFAULT = 0, /** * another name for %G_NORMALIZE_DEFAULT */ NFD = 0, /** * like %G_NORMALIZE_DEFAULT, but with * composed forms rather than a maximally decomposed form */ DEFAULT_COMPOSE = 1, /** * another name for %G_NORMALIZE_DEFAULT_COMPOSE */ NFC = 1, /** * beyond %G_NORMALIZE_DEFAULT also standardize the * "compatibility" characters in Unicode, such as SUPERSCRIPT THREE * to the standard forms (in this case DIGIT THREE). Formatting * information may be lost but for most text operations such * characters should be considered the same */ ALL = 2, /** * another name for %G_NORMALIZE_ALL */ NFKD = 2, /** * like %G_NORMALIZE_ALL, but with composed * forms rather than a maximally decomposed form */ ALL_COMPOSE = 3, /** * another name for %G_NORMALIZE_ALL_COMPOSE */ NFKC = 3, } alias GNormalizeMode NormalizeMode; /** * The possible statuses of a one-time initialization function * controlled by a #GOnce struct. * * Since: 2.4 */ public enum GOnceStatus { /** * the function has not been called yet. */ NOTCALLED = 0, /** * the function call is currently in progress. */ PROGRESS = 1, /** * the function has been called. */ READY = 2, } alias GOnceStatus OnceStatus; /** * The #GOptionArg enum values determine which type of extra argument the * options expect to find. If an option expects an extra argument, it can * be specified in several ways; with a short option: `-x arg`, with a long * option: `--name arg` or combined in a single argument: `--name=arg`. */ public enum GOptionArg { /** * No extra argument. This is useful for simple flags. */ NONE = 0, /** * The option takes a string argument. */ STRING = 1, /** * The option takes an integer argument. */ INT = 2, /** * The option provides a callback (of type * #GOptionArgFunc) to parse the extra argument. */ CALLBACK = 3, /** * The option takes a filename as argument. */ FILENAME = 4, /** * The option takes a string argument, multiple * uses of the option are collected into an array of strings. */ STRING_ARRAY = 5, /** * The option takes a filename as argument, * multiple uses of the option are collected into an array of strings. */ FILENAME_ARRAY = 6, /** * The option takes a double argument. The argument * can be formatted either for the user's locale or for the "C" locale. * Since 2.12 */ DOUBLE = 7, /** * The option takes a 64-bit integer. Like * %G_OPTION_ARG_INT but for larger numbers. The number can be in * decimal base, or in hexadecimal (when prefixed with `0x`, for * example, `0xffffffff`). Since 2.12 */ INT64 = 8, } alias GOptionArg OptionArg; /** * Error codes returned by option parsing. */ public enum GOptionError { /** * An option was not known to the parser. * This error will only be reported, if the parser hasn't been instructed * to ignore unknown options, see g_option_context_set_ignore_unknown_options(). */ UNKNOWN_OPTION = 0, /** * A value couldn't be parsed. */ BAD_VALUE = 1, /** * A #GOptionArgFunc callback failed. */ FAILED = 2, } alias GOptionError OptionError; /** * Flags which modify individual options. */ public enum GOptionFlags { /** * No flags. Since: 2.42. */ NONE = 0, /** * The option doesn't appear in `--help` output. */ HIDDEN = 1, /** * The option appears in the main section of the * `--help` output, even if it is defined in a group. */ IN_MAIN = 2, /** * For options of the %G_OPTION_ARG_NONE kind, this * flag indicates that the sense of the option is reversed. */ REVERSE = 4, /** * For options of the %G_OPTION_ARG_CALLBACK kind, * this flag indicates that the callback does not take any argument * (like a %G_OPTION_ARG_NONE option). Since 2.8 */ NO_ARG = 8, /** * For options of the %G_OPTION_ARG_CALLBACK * kind, this flag indicates that the argument should be passed to the * callback in the GLib filename encoding rather than UTF-8. Since 2.8 */ FILENAME = 16, /** * For options of the %G_OPTION_ARG_CALLBACK * kind, this flag indicates that the argument supply is optional. * If no argument is given then data of %GOptionParseFunc will be * set to NULL. Since 2.8 */ OPTIONAL_ARG = 32, /** * This flag turns off the automatic conflict * resolution which prefixes long option names with `groupname-` if * there is a conflict. This option should only be used in situations * where aliasing is necessary to model some legacy commandline interface. * It is not safe to use this option, unless all option groups are under * your direct control. Since 2.8. */ NOALIAS = 64, } alias GOptionFlags OptionFlags; /** * Flags specifying compile-time options. * * Since: 2.14 */ public enum GRegexCompileFlags { /** * Letters in the pattern match both upper- and * lowercase letters. This option can be changed within a pattern * by a "(?i)" option setting. */ CASELESS = 1, /** * By default, GRegex treats the strings as consisting * of a single line of characters (even if it actually contains * newlines). The "start of line" metacharacter ("^") matches only * at the start of the string, while the "end of line" metacharacter * ("$") matches only at the end of the string, or before a terminating * newline (unless #G_REGEX_DOLLAR_ENDONLY is set). When * #G_REGEX_MULTILINE is set, the "start of line" and "end of line" * constructs match immediately following or immediately before any * newline in the string, respectively, as well as at the very start * and end. This can be changed within a pattern by a "(?m)" option * setting. */ MULTILINE = 2, /** * A dot metacharater (".") in the pattern matches all * characters, including newlines. Without it, newlines are excluded. * This option can be changed within a pattern by a ("?s") option setting. */ DOTALL = 4, /** * Whitespace data characters in the pattern are * totally ignored except when escaped or inside a character class. * Whitespace does not include the VT character (code 11). In addition, * characters between an unescaped "#" outside a character class and * the next newline character, inclusive, are also ignored. This can * be changed within a pattern by a "(?x)" option setting. */ EXTENDED = 8, /** * The pattern is forced to be "anchored", that is, * it is constrained to match only at the first matching point in the * string that is being searched. This effect can also be achieved by * appropriate constructs in the pattern itself such as the "^" * metacharater. */ ANCHORED = 16, /** * A dollar metacharacter ("$") in the pattern * matches only at the end of the string. Without this option, a * dollar also matches immediately before the final character if * it is a newline (but not before any other newlines). This option * is ignored if #G_REGEX_MULTILINE is set. */ DOLLAR_ENDONLY = 32, /** * Inverts the "greediness" of the quantifiers so that * they are not greedy by default, but become greedy if followed by "?". * It can also be set by a "(?U)" option setting within the pattern. */ UNGREEDY = 512, /** * Usually strings must be valid UTF-8 strings, using this * flag they are considered as a raw sequence of bytes. */ RAW = 2048, /** * Disables the use of numbered capturing * parentheses in the pattern. Any opening parenthesis that is not * followed by "?" behaves as if it were followed by "?:" but named * parentheses can still be used for capturing (and they acquire numbers * in the usual way). */ NO_AUTO_CAPTURE = 4096, /** * Optimize the regular expression. If the pattern will * be used many times, then it may be worth the effort to optimize it * to improve the speed of matches. */ OPTIMIZE = 8192, /** * Limits an unanchored pattern to match before (or at) the * first newline. Since: 2.34 */ FIRSTLINE = 262144, /** * Names used to identify capturing subpatterns need not * be unique. This can be helpful for certain types of pattern when it * is known that only one instance of the named subpattern can ever be * matched. */ DUPNAMES = 524288, /** * Usually any newline character or character sequence is * recognized. If this option is set, the only recognized newline character * is '\r'. */ NEWLINE_CR = 1048576, /** * Usually any newline character or character sequence is * recognized. If this option is set, the only recognized newline character * is '\n'. */ NEWLINE_LF = 2097152, /** * Usually any newline character or character sequence is * recognized. If this option is set, the only recognized newline character * sequence is '\r\n'. */ NEWLINE_CRLF = 3145728, /** * Usually any newline character or character sequence * is recognized. If this option is set, the only recognized newline character * sequences are '\r', '\n', and '\r\n'. Since: 2.34 */ NEWLINE_ANYCRLF = 5242880, /** * Usually any newline character or character sequence * is recognised. If this option is set, then "\R" only recognizes the newline * characters '\r', '\n' and '\r\n'. Since: 2.34 */ BSR_ANYCRLF = 8388608, /** * Changes behaviour so that it is compatible with * JavaScript rather than PCRE. Since: 2.34 */ JAVASCRIPT_COMPAT = 33554432, } alias GRegexCompileFlags RegexCompileFlags; /** * Error codes returned by regular expressions functions. * * Since: 2.14 */ public enum GRegexError { /** * Compilation of the regular expression failed. */ COMPILE = 0, /** * Optimization of the regular expression failed. */ OPTIMIZE = 1, /** * Replacement failed due to an ill-formed replacement * string. */ REPLACE = 2, /** * The match process failed. */ MATCH = 3, /** * Internal error of the regular expression engine. * Since 2.16 */ INTERNAL = 4, /** * "\\" at end of pattern. Since 2.16 */ STRAY_BACKSLASH = 101, /** * "\\c" at end of pattern. Since 2.16 */ MISSING_CONTROL_CHAR = 102, /** * Unrecognized character follows "\\". * Since 2.16 */ UNRECOGNIZED_ESCAPE = 103, /** * Numbers out of order in "{}" * quantifier. Since 2.16 */ QUANTIFIERS_OUT_OF_ORDER = 104, /** * Number too big in "{}" quantifier. * Since 2.16 */ QUANTIFIER_TOO_BIG = 105, /** * Missing terminating "]" for * character class. Since 2.16 */ UNTERMINATED_CHARACTER_CLASS = 106, /** * Invalid escape sequence * in character class. Since 2.16 */ INVALID_ESCAPE_IN_CHARACTER_CLASS = 107, /** * Range out of order in character class. * Since 2.16 */ RANGE_OUT_OF_ORDER = 108, /** * Nothing to repeat. Since 2.16 */ NOTHING_TO_REPEAT = 109, /** * Unrecognized character after "(?", * "(?<" or "(?P". Since 2.16 */ UNRECOGNIZED_CHARACTER = 112, /** * POSIX named classes are * supported only within a class. Since 2.16 */ POSIX_NAMED_CLASS_OUTSIDE_CLASS = 113, /** * Missing terminating ")" or ")" * without opening "(". Since 2.16 */ UNMATCHED_PARENTHESIS = 114, /** * Reference to non-existent * subpattern. Since 2.16 */ INEXISTENT_SUBPATTERN_REFERENCE = 115, /** * Missing terminating ")" after comment. * Since 2.16 */ UNTERMINATED_COMMENT = 118, /** * Regular expression too large. * Since 2.16 */ EXPRESSION_TOO_LARGE = 120, /** * Failed to get memory. Since 2.16 */ MEMORY_ERROR = 121, /** * Lookbehind assertion is not * fixed length. Since 2.16 */ VARIABLE_LENGTH_LOOKBEHIND = 125, /** * Malformed number or name after "(?(". * Since 2.16 */ MALFORMED_CONDITION = 126, /** * Conditional group contains * more than two branches. Since 2.16 */ TOO_MANY_CONDITIONAL_BRANCHES = 127, /** * Assertion expected after "(?(". * Since 2.16 */ ASSERTION_EXPECTED = 128, /** * Unknown POSIX class name. * Since 2.16 */ UNKNOWN_POSIX_CLASS_NAME = 130, /** * POSIX collating * elements are not supported. Since 2.16 */ POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED = 131, /** * Character value in "\\x{...}" sequence * is too large. Since 2.16 */ HEX_CODE_TOO_LARGE = 134, /** * Invalid condition "(?(0)". Since 2.16 */ INVALID_CONDITION = 135, /** * \\C not allowed in * lookbehind assertion. Since 2.16 */ SINGLE_BYTE_MATCH_IN_LOOKBEHIND = 136, /** * Recursive call could loop indefinitely. * Since 2.16 */ INFINITE_LOOP = 140, /** * Missing terminator * in subpattern name. Since 2.16 */ MISSING_SUBPATTERN_NAME_TERMINATOR = 142, /** * Two named subpatterns have * the same name. Since 2.16 */ DUPLICATE_SUBPATTERN_NAME = 143, /** * Malformed "\\P" or "\\p" sequence. * Since 2.16 */ MALFORMED_PROPERTY = 146, /** * Unknown property name after "\\P" or * "\\p". Since 2.16 */ UNKNOWN_PROPERTY = 147, /** * Subpattern name is too long * (maximum 32 characters). Since 2.16 */ SUBPATTERN_NAME_TOO_LONG = 148, /** * Too many named subpatterns (maximum * 10,000). Since 2.16 */ TOO_MANY_SUBPATTERNS = 149, /** * Octal value is greater than "\\377". * Since 2.16 */ INVALID_OCTAL_VALUE = 151, /** * "DEFINE" group contains more * than one branch. Since 2.16 */ TOO_MANY_BRANCHES_IN_DEFINE = 154, /** * Repeating a "DEFINE" group is not allowed. * This error is never raised. Since: 2.16 Deprecated: 2.34 */ DEFINE_REPETION = 155, /** * Inconsistent newline options. * Since 2.16 */ INCONSISTENT_NEWLINE_OPTIONS = 156, /** * "\\g" is not followed by a braced, * angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16 */ MISSING_BACK_REFERENCE = 157, /** * relative reference must not be zero. Since: 2.34 */ INVALID_RELATIVE_REFERENCE = 158, /** * the backtracing * control verb used does not allow an argument. Since: 2.34 */ BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN = 159, /** * unknown backtracing * control verb. Since: 2.34 */ UNKNOWN_BACKTRACKING_CONTROL_VERB = 160, /** * number is too big in escape sequence. Since: 2.34 */ NUMBER_TOO_BIG = 161, /** * Missing subpattern name. Since: 2.34 */ MISSING_SUBPATTERN_NAME = 162, /** * Missing digit. Since 2.34 */ MISSING_DIGIT = 163, /** * In JavaScript compatibility mode, * "[" is an invalid data character. Since: 2.34 */ INVALID_DATA_CHARACTER = 164, /** * different names for subpatterns of the * same number are not allowed. Since: 2.34 */ EXTRA_SUBPATTERN_NAME = 165, /** * the backtracing control * verb requires an argument. Since: 2.34 */ BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED = 166, /** * "\\c" must be followed by an ASCII * character. Since: 2.34 */ INVALID_CONTROL_CHAR = 168, /** * "\\k" is not followed by a braced, angle-bracketed, or * quoted name. Since: 2.34 */ MISSING_NAME = 169, /** * "\\N" is not supported in a class. Since: 2.34 */ NOT_SUPPORTED_IN_CLASS = 171, /** * too many forward references. Since: 2.34 */ TOO_MANY_FORWARD_REFERENCES = 172, /** * the name is too long in "(*MARK)", "(*PRUNE)", * "(*SKIP)", or "(*THEN)". Since: 2.34 */ NAME_TOO_LONG = 175, /** * the character value in the \\u sequence is * too large. Since: 2.34 */ CHARACTER_VALUE_TOO_LARGE = 176, } alias GRegexError RegexError; /** * Flags specifying match-time options. * * Since: 2.14 */ public enum GRegexMatchFlags { /** * The pattern is forced to be "anchored", that is, * it is constrained to match only at the first matching point in the * string that is being searched. This effect can also be achieved by * appropriate constructs in the pattern itself such as the "^" * metacharater. */ ANCHORED = 16, /** * Specifies that first character of the string is * not the beginning of a line, so the circumflex metacharacter should * not match before it. Setting this without #G_REGEX_MULTILINE (at * compile time) causes circumflex never to match. This option affects * only the behaviour of the circumflex metacharacter, it does not * affect "\A". */ NOTBOL = 128, /** * Specifies that the end of the subject string is * not the end of a line, so the dollar metacharacter should not match * it nor (except in multiline mode) a newline immediately before it. * Setting this without #G_REGEX_MULTILINE (at compile time) causes * dollar never to match. This option affects only the behaviour of * the dollar metacharacter, it does not affect "\Z" or "\z". */ NOTEOL = 256, /** * An empty string is not considered to be a valid * match if this option is set. If there are alternatives in the pattern, * they are tried. If all the alternatives match the empty string, the * entire match fails. For example, if the pattern "a?b?" is applied to * a string not beginning with "a" or "b", it matches the empty string * at the start of the string. With this flag set, this match is not * valid, so GRegex searches further into the string for occurrences * of "a" or "b". */ NOTEMPTY = 1024, /** * Turns on the partial matching feature, for more * documentation on partial matching see g_match_info_is_partial_match(). */ PARTIAL = 32768, /** * Overrides the newline definition set when * creating a new #GRegex, setting the '\r' character as line terminator. */ NEWLINE_CR = 1048576, /** * Overrides the newline definition set when * creating a new #GRegex, setting the '\n' character as line terminator. */ NEWLINE_LF = 2097152, /** * Overrides the newline definition set when * creating a new #GRegex, setting the '\r\n' characters sequence as line terminator. */ NEWLINE_CRLF = 3145728, /** * Overrides the newline definition set when * creating a new #GRegex, any Unicode newline sequence * is recognised as a newline. These are '\r', '\n' and '\rn', and the * single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), * U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and * U+2029 PARAGRAPH SEPARATOR. */ NEWLINE_ANY = 4194304, /** * Overrides the newline definition set when * creating a new #GRegex; any '\r', '\n', or '\r\n' character sequence * is recognized as a newline. Since: 2.34 */ NEWLINE_ANYCRLF = 5242880, /** * Overrides the newline definition for "\R" set when * creating a new #GRegex; only '\r', '\n', or '\r\n' character sequences * are recognized as a newline by "\R". Since: 2.34 */ BSR_ANYCRLF = 8388608, /** * Overrides the newline definition for "\R" set when * creating a new #GRegex; any Unicode newline character or character sequence * are recognized as a newline by "\R". These are '\r', '\n' and '\rn', and the * single characters U+000B LINE TABULATION, U+000C FORM FEED (FF), * U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and * U+2029 PARAGRAPH SEPARATOR. Since: 2.34 */ BSR_ANY = 16777216, /** * An alias for #G_REGEX_MATCH_PARTIAL. Since: 2.34 */ PARTIAL_SOFT = 32768, /** * Turns on the partial matching feature. In contrast to * to #G_REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match * is found, without continuing to search for a possible complete match. See * g_match_info_is_partial_match() for more information. Since: 2.34 */ PARTIAL_HARD = 134217728, /** * Like #G_REGEX_MATCH_NOTEMPTY, but only applied to * the start of the matched string. For anchored * patterns this can only happen for pattern containing "\K". Since: 2.34 */ NOTEMPTY_ATSTART = 268435456, } alias GRegexMatchFlags RegexMatchFlags; /** * An enumeration specifying the base position for a * g_io_channel_seek_position() operation. */ public enum GSeekType { /** * the current position in the file. */ CUR = 0, /** * the start of the file. */ SET = 1, /** * the end of the file. */ END = 2, } alias GSeekType SeekType; /** * Error codes returned by shell functions. */ public enum GShellError { /** * Mismatched or otherwise mangled quoting. */ BAD_QUOTING = 0, /** * String to be parsed was empty. */ EMPTY_STRING = 1, /** * Some other error. */ FAILED = 2, } alias GShellError ShellError; public enum GSliceConfig { ALWAYS_MALLOC = 1, BYPASS_MAGAZINES = 2, WORKING_SET_MSECS = 3, COLOR_INCREMENT = 4, CHUNK_SIZES = 5, CONTENTION_COUNTER = 6, } alias GSliceConfig SliceConfig; /** * Error codes returned by spawning processes. */ public enum GSpawnError { /** * Fork failed due to lack of memory. */ FORK = 0, /** * Read or select on pipes failed. */ READ = 1, /** * Changing to working directory failed. */ CHDIR = 2, /** * execv() returned `EACCES` */ ACCES = 3, /** * execv() returned `EPERM` */ PERM = 4, /** * execv() returned `E2BIG` */ TOO_BIG = 5, /** * execv() returned `ENOEXEC` */ NOEXEC = 6, /** * execv() returned `ENAMETOOLONG` */ NAMETOOLONG = 7, /** * execv() returned `ENOENT` */ NOENT = 8, /** * execv() returned `ENOMEM` */ NOMEM = 9, /** * execv() returned `ENOTDIR` */ NOTDIR = 10, /** * execv() returned `ELOOP` */ LOOP = 11, /** * execv() returned `ETXTBUSY` */ TXTBUSY = 12, /** * execv() returned `EIO` */ IO = 13, /** * execv() returned `ENFILE` */ NFILE = 14, /** * execv() returned `EMFILE` */ MFILE = 15, /** * execv() returned `EINVAL` */ INVAL = 16, /** * execv() returned `EISDIR` */ ISDIR = 17, /** * execv() returned `ELIBBAD` */ LIBBAD = 18, /** * Some other fatal failure, * `error->message` should explain. */ FAILED = 19, } alias GSpawnError SpawnError; /** * Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes(). */ public enum GSpawnFlags { /** * no flags, default behaviour */ DEFAULT = 0, /** * the parent's open file descriptors will * be inherited by the child; otherwise all descriptors except stdin, * stdout and stderr will be closed before calling exec() in the child. */ LEAVE_DESCRIPTORS_OPEN = 1, /** * the child will not be automatically reaped; * you must use g_child_watch_add() yourself (or call waitpid() or handle * `SIGCHLD` yourself), or the child will become a zombie. */ DO_NOT_REAP_CHILD = 2, /** * `argv[0]` need not be an absolute path, it will be * looked for in the user's `PATH`. */ SEARCH_PATH = 4, /** * the child's standard output will be discarded, * instead of going to the same location as the parent's standard output. */ STDOUT_TO_DEV_NULL = 8, /** * the child's standard error will be discarded. */ STDERR_TO_DEV_NULL = 16, /** * the child will inherit the parent's standard * input (by default, the child's standard input is attached to `/dev/null`). */ CHILD_INHERITS_STDIN = 32, /** * the first element of `argv` is the file to * execute, while the remaining elements are the actual argument vector * to pass to the file. Normally g_spawn_async_with_pipes() uses `argv[0]` * as the file to execute, and passes all of `argv` to the child. */ FILE_AND_ARGV_ZERO = 64, /** * if `argv[0]` is not an abolute path, * it will be looked for in the `PATH` from the passed child environment. * Since: 2.34 */ SEARCH_PATH_FROM_ENVP = 128, /** * create all pipes with the `O_CLOEXEC` flag set. * Since: 2.40 */ CLOEXEC_PIPES = 256, } alias GSpawnFlags SpawnFlags; /** * The type of file to return the filename for, when used with * g_test_build_filename(). * * These two options correspond rather directly to the 'dist' and * 'built' terminology that automake uses and are explicitly used to * distinguish between the 'srcdir' and 'builddir' being separate. All * files in your project should either be dist (in the * `DIST_EXTRA` or `dist_schema_DATA` * sense, in which case they will always be in the srcdir) or built (in * the `BUILT_SOURCES` sense, in which case they will * always be in the builddir). * * Note: as a general rule of automake, files that are generated only as * part of the build-from-git process (but then are distributed with the * tarball) always go in srcdir (even if doing a srcdir != builddir * build from git) and are considered as distributed files. * * Since: 2.38 */ public enum GTestFileType { /** * a file that was included in the distribution tarball */ DIST = 0, /** * a file that was built on the compiling machine */ BUILT = 1, } alias GTestFileType TestFileType; public enum GTestLogType { NONE = 0, ERROR = 1, START_BINARY = 2, LIST_CASE = 3, SKIP_CASE = 4, START_CASE = 5, STOP_CASE = 6, MIN_RESULT = 7, MAX_RESULT = 8, MESSAGE = 9, START_SUITE = 10, STOP_SUITE = 11, } alias GTestLogType TestLogType; /** * Flags to pass to g_test_trap_subprocess() to control input and output. * * Note that in contrast with g_test_trap_fork(), the default is to * not show stdout and stderr. */ public enum GTestSubprocessFlags { /** * If this flag is given, the child * process will inherit the parent's stdin. Otherwise, the child's * stdin is redirected to `/dev/null`. */ STDIN = 1, /** * If this flag is given, the child * process will inherit the parent's stdout. Otherwise, the child's * stdout will not be visible, but it will be captured to allow * later tests with g_test_trap_assert_stdout(). */ STDOUT = 2, /** * If this flag is given, the child * process will inherit the parent's stderr. Otherwise, the child's * stderr will not be visible, but it will be captured to allow * later tests with g_test_trap_assert_stderr(). */ STDERR = 4, } alias GTestSubprocessFlags TestSubprocessFlags; /** * Test traps are guards around forked tests. * These flags determine what traps to set. * * Deprecated: #GTestTrapFlags is used only with g_test_trap_fork(), * which is deprecated. g_test_trap_subprocess() uses * #GTestTrapSubprocessFlags. */ public enum GTestTrapFlags { /** * Redirect stdout of the test child to * `/dev/null` so it cannot be observed on the console during test * runs. The actual output is still captured though to allow later * tests with g_test_trap_assert_stdout(). */ SILENCE_STDOUT = 128, /** * Redirect stderr of the test child to * `/dev/null` so it cannot be observed on the console during test * runs. The actual output is still captured though to allow later * tests with g_test_trap_assert_stderr(). */ SILENCE_STDERR = 256, /** * If this flag is given, stdin of the * child process is shared with stdin of its parent process. * It is redirected to `/dev/null` otherwise. */ INHERIT_STDIN = 512, } alias GTestTrapFlags TestTrapFlags; /** * Possible errors of thread related functions. */ public enum GThreadError { /** * a thread couldn't be created due to resource * shortage. Try again later. */ THREAD_ERROR_AGAIN = 0, } alias GThreadError ThreadError; /** * Disambiguates a given time in two ways. * * First, specifies if the given time is in universal or local time. * * Second, if the time is in local time, specifies if it is local * standard time or local daylight time. This is important for the case * where the same local time occurs twice (during daylight savings time * transitions, for example). */ public enum GTimeType { /** * the time is in local standard time */ STANDARD = 0, /** * the time is in local daylight time */ DAYLIGHT = 1, /** * the time is in UTC */ UNIVERSAL = 2, } alias GTimeType TimeType; /** * The possible types of token returned from each * g_scanner_get_next_token() call. */ public enum GTokenType { /** * the end of the file */ EOF = 0, /** * a '(' character */ LEFT_PAREN = 40, /** * a ')' character */ RIGHT_PAREN = 41, /** * a '{' character */ LEFT_CURLY = 123, /** * a '}' character */ RIGHT_CURLY = 125, /** * a '[' character */ LEFT_BRACE = 91, /** * a ']' character */ RIGHT_BRACE = 93, /** * a '=' character */ EQUAL_SIGN = 61, /** * a ',' character */ COMMA = 44, /** * not a token */ NONE = 256, /** * an error occurred */ ERROR = 257, /** * a character */ CHAR = 258, /** * a binary integer */ BINARY = 259, /** * an octal integer */ OCTAL = 260, /** * an integer */ INT = 261, /** * a hex integer */ HEX = 262, /** * a floating point number */ FLOAT = 263, /** * a string */ STRING = 264, /** * a symbol */ SYMBOL = 265, /** * an identifier */ IDENTIFIER = 266, /** * a null identifier */ IDENTIFIER_NULL = 267, /** * one line comment */ COMMENT_SINGLE = 268, /** * multi line comment */ COMMENT_MULTI = 269, } alias GTokenType TokenType; /** * Specifies which nodes are visited during several of the tree * functions, including g_node_traverse() and g_node_find(). */ public enum GTraverseFlags { /** * only leaf nodes should be visited. This name has * been introduced in 2.6, for older version use * %G_TRAVERSE_LEAFS. */ LEAVES = 1, /** * only non-leaf nodes should be visited. This * name has been introduced in 2.6, for older * version use %G_TRAVERSE_NON_LEAFS. */ NON_LEAVES = 2, /** * all nodes should be visited. */ ALL = 3, /** * a mask of all traverse flags. */ MASK = 3, /** * identical to %G_TRAVERSE_LEAVES. */ LEAFS = 1, /** * identical to %G_TRAVERSE_NON_LEAVES. */ NON_LEAFS = 2, } alias GTraverseFlags TraverseFlags; /** * Specifies the type of traveral performed by g_tree_traverse(), * g_node_traverse() and g_node_find(). The different orders are * illustrated here: * - In order: A, B, C, D, E, F, G, H, I * ![](Sorted_binary_tree_inorder.svg) * - Pre order: F, B, A, D, C, E, G, I, H * ![](Sorted_binary_tree_preorder.svg) * - Post order: A, C, E, D, B, H, I, G, F * ![](Sorted_binary_tree_postorder.svg) * - Level order: F, B, G, A, D, I, C, E, H * ![](Sorted_binary_tree_breadth-first_traversal.svg) */ public enum GTraverseType { /** * vists a node's left child first, then the node itself, * then its right child. This is the one to use if you * want the output sorted according to the compare * function. */ IN_ORDER = 0, /** * visits a node, then its children. */ PRE_ORDER = 1, /** * visits the node's children, then the node itself. */ POST_ORDER = 2, /** * is not implemented for * [balanced binary trees][glib-Balanced-Binary-Trees]. * For [n-ary trees][glib-N-ary-Trees], it * vists the root node first, then its children, then * its grandchildren, and so on. Note that this is less * efficient than the other orders. */ LEVEL_ORDER = 3, } alias GTraverseType TraverseType; /** * These are the possible line break classifications. * * Since new unicode versions may add new types here, applications should be ready * to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN. * * See http://www.unicode.org/unicode/reports/tr14/. */ public enum GUnicodeBreakType { /** * Mandatory Break (BK) */ MANDATORY = 0, /** * Carriage Return (CR) */ CARRIAGE_RETURN = 1, /** * Line Feed (LF) */ LINE_FEED = 2, /** * Attached Characters and Combining Marks (CM) */ COMBINING_MARK = 3, /** * Surrogates (SG) */ SURROGATE = 4, /** * Zero Width Space (ZW) */ ZERO_WIDTH_SPACE = 5, /** * Inseparable (IN) */ INSEPARABLE = 6, /** * Non-breaking ("Glue") (GL) */ NON_BREAKING_GLUE = 7, /** * Contingent Break Opportunity (CB) */ CONTINGENT = 8, /** * Space (SP) */ SPACE = 9, /** * Break Opportunity After (BA) */ AFTER = 10, /** * Break Opportunity Before (BB) */ BEFORE = 11, /** * Break Opportunity Before and After (B2) */ BEFORE_AND_AFTER = 12, /** * Hyphen (HY) */ HYPHEN = 13, /** * Nonstarter (NS) */ NON_STARTER = 14, /** * Opening Punctuation (OP) */ OPEN_PUNCTUATION = 15, /** * Closing Punctuation (CL) */ CLOSE_PUNCTUATION = 16, /** * Ambiguous Quotation (QU) */ QUOTATION = 17, /** * Exclamation/Interrogation (EX) */ EXCLAMATION = 18, /** * Ideographic (ID) */ IDEOGRAPHIC = 19, /** * Numeric (NU) */ NUMERIC = 20, /** * Infix Separator (Numeric) (IS) */ INFIX_SEPARATOR = 21, /** * Symbols Allowing Break After (SY) */ SYMBOL = 22, /** * Ordinary Alphabetic and Symbol Characters (AL) */ ALPHABETIC = 23, /** * Prefix (Numeric) (PR) */ PREFIX = 24, /** * Postfix (Numeric) (PO) */ POSTFIX = 25, /** * Complex Content Dependent (South East Asian) (SA) */ COMPLEX_CONTEXT = 26, /** * Ambiguous (Alphabetic or Ideographic) (AI) */ AMBIGUOUS = 27, /** * Unknown (XX) */ UNKNOWN = 28, /** * Next Line (NL) */ NEXT_LINE = 29, /** * Word Joiner (WJ) */ WORD_JOINER = 30, /** * Hangul L Jamo (JL) */ HANGUL_L_JAMO = 31, /** * Hangul V Jamo (JV) */ HANGUL_V_JAMO = 32, /** * Hangul T Jamo (JT) */ HANGUL_T_JAMO = 33, /** * Hangul LV Syllable (H2) */ HANGUL_LV_SYLLABLE = 34, /** * Hangul LVT Syllable (H3) */ HANGUL_LVT_SYLLABLE = 35, /** * Closing Parenthesis (CP). Since 2.28 */ CLOSE_PARANTHESIS = 36, /** * Conditional Japanese Starter (CJ). Since: 2.32 */ CONDITIONAL_JAPANESE_STARTER = 37, /** * Hebrew Letter (HL). Since: 2.32 */ HEBREW_LETTER = 38, /** * Regional Indicator (RI). Since: 2.36 */ REGIONAL_INDICATOR = 39, } alias GUnicodeBreakType UnicodeBreakType; /** * The #GUnicodeScript enumeration identifies different writing * systems. The values correspond to the names as defined in the * Unicode standard. The enumeration has been added in GLib 2.14, * and is interchangeable with #PangoScript. * * Note that new types may be added in the future. Applications * should be ready to handle unknown values. * See Unicode Standard Annex * #24: Script names. */ public enum GUnicodeScript { /** * a value never returned from g_unichar_get_script() */ INVALID_CODE = -1, /** * a character used by multiple different scripts */ COMMON = 0, /** * a mark glyph that takes its script from the * base glyph to which it is attached */ INHERITED = 1, /** * Arabic */ ARABIC = 2, /** * Armenian */ ARMENIAN = 3, /** * Bengali */ BENGALI = 4, /** * Bopomofo */ BOPOMOFO = 5, /** * Cherokee */ CHEROKEE = 6, /** * Coptic */ COPTIC = 7, /** * Cyrillic */ CYRILLIC = 8, /** * Deseret */ DESERET = 9, /** * Devanagari */ DEVANAGARI = 10, /** * Ethiopic */ ETHIOPIC = 11, /** * Georgian */ GEORGIAN = 12, /** * Gothic */ GOTHIC = 13, /** * Greek */ GREEK = 14, /** * Gujarati */ GUJARATI = 15, /** * Gurmukhi */ GURMUKHI = 16, /** * Han */ HAN = 17, /** * Hangul */ HANGUL = 18, /** * Hebrew */ HEBREW = 19, /** * Hiragana */ HIRAGANA = 20, /** * Kannada */ KANNADA = 21, /** * Katakana */ KATAKANA = 22, /** * Khmer */ KHMER = 23, /** * Lao */ LAO = 24, /** * Latin */ LATIN = 25, /** * Malayalam */ MALAYALAM = 26, /** * Mongolian */ MONGOLIAN = 27, /** * Myanmar */ MYANMAR = 28, /** * Ogham */ OGHAM = 29, /** * Old Italic */ OLD_ITALIC = 30, /** * Oriya */ ORIYA = 31, /** * Runic */ RUNIC = 32, /** * Sinhala */ SINHALA = 33, /** * Syriac */ SYRIAC = 34, /** * Tamil */ TAMIL = 35, /** * Telugu */ TELUGU = 36, /** * Thaana */ THAANA = 37, /** * Thai */ THAI = 38, /** * Tibetan */ TIBETAN = 39, /** * Canadian Aboriginal */ CANADIAN_ABORIGINAL = 40, /** * Yi */ YI = 41, /** * Tagalog */ TAGALOG = 42, /** * Hanunoo */ HANUNOO = 43, /** * Buhid */ BUHID = 44, /** * Tagbanwa */ TAGBANWA = 45, /** * Braille */ BRAILLE = 46, /** * Cypriot */ CYPRIOT = 47, /** * Limbu */ LIMBU = 48, /** * Osmanya */ OSMANYA = 49, /** * Shavian */ SHAVIAN = 50, /** * Linear B */ LINEAR_B = 51, /** * Tai Le */ TAI_LE = 52, /** * Ugaritic */ UGARITIC = 53, /** * New Tai Lue */ NEW_TAI_LUE = 54, /** * Buginese */ BUGINESE = 55, /** * Glagolitic */ GLAGOLITIC = 56, /** * Tifinagh */ TIFINAGH = 57, /** * Syloti Nagri */ SYLOTI_NAGRI = 58, /** * Old Persian */ OLD_PERSIAN = 59, /** * Kharoshthi */ KHAROSHTHI = 60, /** * an unassigned code point */ UNKNOWN = 61, /** * Balinese */ BALINESE = 62, /** * Cuneiform */ CUNEIFORM = 63, /** * Phoenician */ PHOENICIAN = 64, /** * Phags-pa */ PHAGS_PA = 65, /** * N'Ko */ NKO = 66, /** * Kayah Li. Since 2.16.3 */ KAYAH_LI = 67, /** * Lepcha. Since 2.16.3 */ LEPCHA = 68, /** * Rejang. Since 2.16.3 */ REJANG = 69, /** * Sundanese. Since 2.16.3 */ SUNDANESE = 70, /** * Saurashtra. Since 2.16.3 */ SAURASHTRA = 71, /** * Cham. Since 2.16.3 */ CHAM = 72, /** * Ol Chiki. Since 2.16.3 */ OL_CHIKI = 73, /** * Vai. Since 2.16.3 */ VAI = 74, /** * Carian. Since 2.16.3 */ CARIAN = 75, /** * Lycian. Since 2.16.3 */ LYCIAN = 76, /** * Lydian. Since 2.16.3 */ LYDIAN = 77, /** * Avestan. Since 2.26 */ AVESTAN = 78, /** * Bamum. Since 2.26 */ BAMUM = 79, /** * Egyptian Hieroglpyhs. Since 2.26 */ EGYPTIAN_HIEROGLYPHS = 80, /** * Imperial Aramaic. Since 2.26 */ IMPERIAL_ARAMAIC = 81, /** * Inscriptional Pahlavi. Since 2.26 */ INSCRIPTIONAL_PAHLAVI = 82, /** * Inscriptional Parthian. Since 2.26 */ INSCRIPTIONAL_PARTHIAN = 83, /** * Javanese. Since 2.26 */ JAVANESE = 84, /** * Kaithi. Since 2.26 */ KAITHI = 85, /** * Lisu. Since 2.26 */ LISU = 86, /** * Meetei Mayek. Since 2.26 */ MEETEI_MAYEK = 87, /** * Old South Arabian. Since 2.26 */ OLD_SOUTH_ARABIAN = 88, /** * Old Turkic. Since 2.28 */ OLD_TURKIC = 89, /** * Samaritan. Since 2.26 */ SAMARITAN = 90, /** * Tai Tham. Since 2.26 */ TAI_THAM = 91, /** * Tai Viet. Since 2.26 */ TAI_VIET = 92, /** * Batak. Since 2.28 */ BATAK = 93, /** * Brahmi. Since 2.28 */ BRAHMI = 94, /** * Mandaic. Since 2.28 */ MANDAIC = 95, /** * Chakma. Since: 2.32 */ CHAKMA = 96, /** * Meroitic Cursive. Since: 2.32 */ MEROITIC_CURSIVE = 97, /** * Meroitic Hieroglyphs. Since: 2.32 */ MEROITIC_HIEROGLYPHS = 98, /** * Miao. Since: 2.32 */ MIAO = 99, /** * Sharada. Since: 2.32 */ SHARADA = 100, /** * Sora Sompeng. Since: 2.32 */ SORA_SOMPENG = 101, /** * Takri. Since: 2.32 */ TAKRI = 102, /** * Bassa. Since: 2.42 */ BASSA_VAH = 103, /** * Caucasian Albanian. Since: 2.42 */ CAUCASIAN_ALBANIAN = 104, /** * Duployan. Since: 2.42 */ DUPLOYAN = 105, /** * Elbasan. Since: 2.42 */ ELBASAN = 106, /** * Grantha. Since: 2.42 */ GRANTHA = 107, /** * Kjohki. Since: 2.42 */ KHOJKI = 108, /** * Khudawadi, Sindhi. Since: 2.42 */ KHUDAWADI = 109, /** * Linear A. Since: 2.42 */ LINEAR_A = 110, /** * Mahajani. Since: 2.42 */ MAHAJANI = 111, /** * Manichaean. Since: 2.42 */ MANICHAEAN = 112, /** * Mende Kikakui. Since: 2.42 */ MENDE_KIKAKUI = 113, /** * Modi. Since: 2.42 */ MODI = 114, /** * Mro. Since: 2.42 */ MRO = 115, /** * Nabataean. Since: 2.42 */ NABATAEAN = 116, /** * Old North Arabian. Since: 2.42 */ OLD_NORTH_ARABIAN = 117, /** * Old Permic. Since: 2.42 */ OLD_PERMIC = 118, /** * Pahawh Hmong. Since: 2.42 */ PAHAWH_HMONG = 119, /** * Palmyrene. Since: 2.42 */ PALMYRENE = 120, /** * Pau Cin Hau. Since: 2.42 */ PAU_CIN_HAU = 121, /** * Psalter Pahlavi. Since: 2.42 */ PSALTER_PAHLAVI = 122, /** * Siddham. Since: 2.42 */ SIDDHAM = 123, /** * Tirhuta. Since: 2.42 */ TIRHUTA = 124, /** * Warang Citi. Since: 2.42 */ WARANG_CITI = 125, /** * Ahom. Since 2.48 */ AHOM = 126, /** * Anatolian Hieroglyphs. Since 2.48 */ ANATOLIAN_HIEROGLYPHS = 127, /** * Hatran. Since 2.48 */ HATRAN = 128, /** * Multani. Since 2.48 */ MULTANI = 129, /** * Old Hungarian. Since 2.48 */ OLD_HUNGARIAN = 130, /** * Signwriting. Since 2.48 */ SIGNWRITING = 131, } alias GUnicodeScript UnicodeScript; /** * These are the possible character classifications from the * Unicode specification. * See http://www.unicode.org/Public/UNIDATA/UnicodeData.html. */ public enum GUnicodeType { /** * General category "Other, Control" (Cc) */ CONTROL = 0, /** * General category "Other, Format" (Cf) */ FORMAT = 1, /** * General category "Other, Not Assigned" (Cn) */ UNASSIGNED = 2, /** * General category "Other, Private Use" (Co) */ PRIVATE_USE = 3, /** * General category "Other, Surrogate" (Cs) */ SURROGATE = 4, /** * General category "Letter, Lowercase" (Ll) */ LOWERCASE_LETTER = 5, /** * General category "Letter, Modifier" (Lm) */ MODIFIER_LETTER = 6, /** * General category "Letter, Other" (Lo) */ OTHER_LETTER = 7, /** * General category "Letter, Titlecase" (Lt) */ TITLECASE_LETTER = 8, /** * General category "Letter, Uppercase" (Lu) */ UPPERCASE_LETTER = 9, /** * General category "Mark, Spacing" (Mc) */ SPACING_MARK = 10, /** * General category "Mark, Enclosing" (Me) */ ENCLOSING_MARK = 11, /** * General category "Mark, Nonspacing" (Mn) */ NON_SPACING_MARK = 12, /** * General category "Number, Decimal Digit" (Nd) */ DECIMAL_NUMBER = 13, /** * General category "Number, Letter" (Nl) */ LETTER_NUMBER = 14, /** * General category "Number, Other" (No) */ OTHER_NUMBER = 15, /** * General category "Punctuation, Connector" (Pc) */ CONNECT_PUNCTUATION = 16, /** * General category "Punctuation, Dash" (Pd) */ DASH_PUNCTUATION = 17, /** * General category "Punctuation, Close" (Pe) */ CLOSE_PUNCTUATION = 18, /** * General category "Punctuation, Final quote" (Pf) */ FINAL_PUNCTUATION = 19, /** * General category "Punctuation, Initial quote" (Pi) */ INITIAL_PUNCTUATION = 20, /** * General category "Punctuation, Other" (Po) */ OTHER_PUNCTUATION = 21, /** * General category "Punctuation, Open" (Ps) */ OPEN_PUNCTUATION = 22, /** * General category "Symbol, Currency" (Sc) */ CURRENCY_SYMBOL = 23, /** * General category "Symbol, Modifier" (Sk) */ MODIFIER_SYMBOL = 24, /** * General category "Symbol, Math" (Sm) */ MATH_SYMBOL = 25, /** * General category "Symbol, Other" (So) */ OTHER_SYMBOL = 26, /** * General category "Separator, Line" (Zl) */ LINE_SEPARATOR = 27, /** * General category "Separator, Paragraph" (Zp) */ PARAGRAPH_SEPARATOR = 28, /** * General category "Separator, Space" (Zs) */ SPACE_SEPARATOR = 29, } alias GUnicodeType UnicodeType; /** * These are logical ids for special directories which are defined * depending on the platform used. You should use g_get_user_special_dir() * to retrieve the full path associated to the logical id. * * The #GUserDirectory enumeration can be extended at later date. Not * every platform has a directory for every logical id in this * enumeration. * * Since: 2.14 */ public enum GUserDirectory { /** * the user's Desktop directory */ DIRECTORY_DESKTOP = 0, /** * the user's Documents directory */ DIRECTORY_DOCUMENTS = 1, /** * the user's Downloads directory */ DIRECTORY_DOWNLOAD = 2, /** * the user's Music directory */ DIRECTORY_MUSIC = 3, /** * the user's Pictures directory */ DIRECTORY_PICTURES = 4, /** * the user's shared directory */ DIRECTORY_PUBLIC_SHARE = 5, /** * the user's Templates directory */ DIRECTORY_TEMPLATES = 6, /** * the user's Movies directory */ DIRECTORY_VIDEOS = 7, /** * the number of enum values */ N_DIRECTORIES = 8, } alias GUserDirectory UserDirectory; /** * The range of possible top-level types of #GVariant instances. * * Since: 2.24 */ public enum GVariantClass { /** * The #GVariant is a boolean. */ BOOLEAN = 98, /** * The #GVariant is a byte. */ BYTE = 121, /** * The #GVariant is a signed 16 bit integer. */ INT16 = 110, /** * The #GVariant is an unsigned 16 bit integer. */ UINT16 = 113, /** * The #GVariant is a signed 32 bit integer. */ INT32 = 105, /** * The #GVariant is an unsigned 32 bit integer. */ UINT32 = 117, /** * The #GVariant is a signed 64 bit integer. */ INT64 = 120, /** * The #GVariant is an unsigned 64 bit integer. */ UINT64 = 116, /** * The #GVariant is a file handle index. */ HANDLE = 104, /** * The #GVariant is a double precision floating * point value. */ DOUBLE = 100, /** * The #GVariant is a normal string. */ STRING = 115, /** * The #GVariant is a D-Bus object path * string. */ OBJECT_PATH = 111, /** * The #GVariant is a D-Bus signature string. */ SIGNATURE = 103, /** * The #GVariant is a variant. */ VARIANT = 118, /** * The #GVariant is a maybe-typed value. */ MAYBE = 109, /** * The #GVariant is an array. */ ARRAY = 97, /** * The #GVariant is a tuple. */ TUPLE = 40, /** * The #GVariant is a dictionary entry. */ DICT_ENTRY = 123, } alias GVariantClass VariantClass; /** * Error codes returned by parsing text-format GVariants. */ public enum GVariantParseError { /** * generic error (unused) */ FAILED = 0, /** * a non-basic #GVariantType was given where a basic type was expected */ BASIC_TYPE_EXPECTED = 1, /** * cannot infer the #GVariantType */ CANNOT_INFER_TYPE = 2, /** * an indefinite #GVariantType was given where a definite type was expected */ DEFINITE_TYPE_EXPECTED = 3, /** * extra data after parsing finished */ INPUT_NOT_AT_END = 4, /** * invalid character in number or unicode escape */ INVALID_CHARACTER = 5, /** * not a valid #GVariant format string */ INVALID_FORMAT_STRING = 6, /** * not a valid object path */ INVALID_OBJECT_PATH = 7, /** * not a valid type signature */ INVALID_SIGNATURE = 8, /** * not a valid #GVariant type string */ INVALID_TYPE_STRING = 9, /** * could not find a common type for array entries */ NO_COMMON_TYPE = 10, /** * the numerical value is out of range of the given type */ NUMBER_OUT_OF_RANGE = 11, /** * the numerical value is out of range for any type */ NUMBER_TOO_BIG = 12, /** * cannot parse as variant of the specified type */ TYPE_ERROR = 13, /** * an unexpected token was encountered */ UNEXPECTED_TOKEN = 14, /** * an unknown keyword was encountered */ UNKNOWN_KEYWORD = 15, /** * unterminated string constant */ UNTERMINATED_STRING_CONSTANT = 16, /** * no value given */ VALUE_EXPECTED = 17, } alias GVariantParseError VariantParseError; /** * Flags passed to g_module_open(). * Note that these flags are not supported on all platforms. */ public enum GModuleFlags { /** * specifies that symbols are only resolved when * needed. The default action is to bind all symbols when the module * is loaded. */ LAZY = 1, /** * specifies that symbols in the module should * not be added to the global name space. The default action on most * platforms is to place symbols in the module in the global name space, * which may cause conflicts with existing symbols. */ LOCAL = 2, /** * mask for all flags. */ MASK = 3, } alias GModuleFlags ModuleFlags; /** * Contains the public fields of a GArray. */ struct GArray { /** * a pointer to the element data. The data may be moved as * elements are added to the #GArray. */ char* data; /** * the number of elements in the #GArray not including the * possible terminating zero element. */ uint len; } struct GAsyncQueue; struct GBookmarkFile; /** * Contains the public fields of a GByteArray. */ struct GByteArray { /** * a pointer to the element data. The data may be moved as * elements are added to the #GByteArray */ ubyte* data; /** * the number of elements in the #GByteArray */ uint len; } struct GBytes; struct GChecksum; struct GCond { void* p; uint[2] i; } /** * The #GData struct is an opaque data structure to represent a * [Keyed Data List][glib-Keyed-Data-Lists]. It should only be * accessed via the following functions. */ struct GData; struct GDate { import std.bitmanip: bitfields; mixin(bitfields!( uint, "julianDays", 32, uint, "julian", 1, uint, "dmy", 1, uint, "day", 6, uint, "month", 4, uint, "year", 16, uint, "", 4 )); } struct GDateTime; /** * Associates a string with a bit flag. * Used in g_parse_debug_string(). */ struct GDebugKey { /** * the string */ const(char)* key; /** * the flag */ uint value; } struct GDir; /** * The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign, * mantissa and exponent of IEEE floats and doubles. These unions are defined * as appropriate for a given platform. IEEE floats and doubles are supported * (used for storage) by at least Intel, PPC and Sparc. */ struct GDoubleIEEE754 { union { /** * the double value */ double vDouble; struct Mpn { import std.bitmanip: bitfields; mixin(bitfields!( uint, "mantissaLow", 32, uint, "mantissaHigh", 20, uint, "biasedExponent", 11, uint, "sign", 1 )); } Mpn mpn; } } struct GError { /** * error domain, e.g. #G_FILE_ERROR */ GQuark domain; /** * error code, e.g. %G_FILE_ERROR_NOENT */ int code; /** * human-readable informative error message */ char* message; } /** * The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign, * mantissa and exponent of IEEE floats and doubles. These unions are defined * as appropriate for a given platform. IEEE floats and doubles are supported * (used for storage) by at least Intel, PPC and Sparc. */ struct GFloatIEEE754 { union { /** * the double value */ float vFloat; struct Mpn { import std.bitmanip: bitfields; mixin(bitfields!( uint, "mantissa", 23, uint, "biasedExponent", 8, uint, "sign", 1 )); } Mpn mpn; } } /** * The #GHashTable struct is an opaque data structure to represent a * [Hash Table][glib-Hash-Tables]. It should only be accessed via the * following functions. */ struct GHashTable; struct GHashTableIter { void* dummy1; void* dummy2; void* dummy3; int dummy4; bool dummy5; void* dummy6; } struct GHmac; struct GHook { /** * data which is passed to func when this hook is invoked */ void* data; /** * pointer to the next hook in the list */ GHook* next; /** * pointer to the previous hook in the list */ GHook* prev; /** * the reference count of this hook */ uint refCount; /** * the id of this hook, which is unique within its list */ gulong hookId; /** * flags which are set for this hook. See #GHookFlagMask for * predefined flags */ uint flags; /** * the function to call when this hook is invoked. The possible * signatures for this function are #GHookFunc and #GHookCheckFunc */ void* func; /** * the default @finalize_hook function of a #GHookList calls * this member of the hook that is being finalized */ GDestroyNotify destroy; } struct GHookList { /** * the next free #GHook id */ gulong seqId; import std.bitmanip: bitfields; mixin(bitfields!( uint, "hookSize", 16, uint, "isSetup", 1, uint, "", 15 )); /** * the first #GHook element in the list */ GHook* hooks; /** * unused */ void* dummy3; /** * the function to call to finalize a #GHook element. * The default behaviour is to call the hooks @destroy function */ GHookFinalizeFunc finalizeHook; /** * unused */ void*[2] dummy; } struct GIOChannel { int refCount; GIOFuncs* funcs; char* encoding; GIConv readCd; GIConv writeCd; char* lineTerm; uint lineTermLen; size_t bufSize; GString* readBuf; GString* encodedReadBuf; GString* writeBuf; char[6] partialWriteBuf; import std.bitmanip: bitfields; mixin(bitfields!( uint, "useBuffer", 1, uint, "doEncode", 1, uint, "closeOnUnref", 1, uint, "isReadable", 1, uint, "isWriteable", 1, uint, "isSeekable", 1, uint, "", 26 )); void* reserved1; void* reserved2; } /** * A table of functions used to handle different types of #GIOChannel * in a generic way. */ struct GIOFuncs { /** */ extern(C) GIOStatus function(GIOChannel* channel, char* buf, size_t count, size_t* bytesRead, GError** err) ioRead; /** */ extern(C) GIOStatus function(GIOChannel* channel, const(char)* buf, size_t count, size_t* bytesWritten, GError** err) ioWrite; /** */ extern(C) GIOStatus function(GIOChannel* channel, long offset, GSeekType type, GError** err) ioSeek; /** */ extern(C) GIOStatus function(GIOChannel* channel, GError** err) ioClose; /** */ extern(C) GSource* function(GIOChannel* channel, GIOCondition condition) ioCreateWatch; /** */ extern(C) void function(GIOChannel* channel) ioFree; /** */ extern(C) GIOStatus function(GIOChannel* channel, GIOFlags flags, GError** err) ioSetFlags; /** */ extern(C) GIOFlags function(GIOChannel* channel) ioGetFlags; } struct GKeyFile; /** * The #GList struct is used for each element in a doubly-linked list. */ struct GList { /** * holds the element's data, which can be a pointer to any kind * of data, or any integer value using the * [Type Conversion Macros][glib-Type-Conversion-Macros] */ void* data; /** * contains the link to the next element in the list */ GList* next; /** * contains the link to the previous element in the list */ GList* prev; } struct GMainContext; struct GMainLoop; struct GMappedFile; struct GMarkupParseContext; /** * Any of the fields in #GMarkupParser can be %NULL, in which case they * will be ignored. Except for the @error function, any of these callbacks * can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT, * %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT * errors are intended to be set from these callbacks. If you set an error * from a callback, g_markup_parse_context_parse() will report that error * back to its caller. */ struct GMarkupParser { /** */ extern(C) void function(GMarkupParseContext* context, const(char)* elementName, char** attributeNames, char** attributeValues, void* userData, GError** err) startElement; /** */ extern(C) void function(GMarkupParseContext* context, const(char)* elementName, void* userData, GError** err) endElement; /** */ extern(C) void function(GMarkupParseContext* context, const(char)* text, size_t textLen, void* userData, GError** err) text; /** */ extern(C) void function(GMarkupParseContext* context, const(char)* passthroughText, size_t textLen, void* userData, GError** err) passthrough; /** */ extern(C) void function(GMarkupParseContext* context, GError* error, void* userData) error; } struct GMatchInfo; /** * A set of functions used to perform memory allocation. The same #GMemVTable must * be used for all allocations in the same program; a call to g_mem_set_vtable(), * if it exists, should be prior to any use of GLib. * * This functions related to this has been deprecated in 2.46, and no longer work. */ struct GMemVTable { /** */ extern(C) void* function(size_t nBytes) malloc; /** */ extern(C) void* function(void* mem, size_t nBytes) realloc; /** */ extern(C) void function(void* mem) free; /** */ extern(C) void* function(size_t nBlocks, size_t nBlockBytes) calloc; /** */ extern(C) void* function(size_t nBytes) tryMalloc; /** */ extern(C) void* function(void* mem, size_t nBytes) tryRealloc; } struct GMutex { union { void* p; uint[2] i; } } struct GNode { /** * contains the actual data of the node. */ void* data; /** * points to the node's next sibling (a sibling is another * #GNode with the same parent). */ GNode* next; /** * points to the node's previous sibling. */ GNode* prev; /** * points to the parent of the #GNode, or is %NULL if the * #GNode is the root of the tree. */ GNode* parent; /** * points to the first child of the #GNode. The other * children are accessed by using the @next pointer of each * child. */ GNode* children; } struct GOnce { /** * the status of the #GOnce */ GOnceStatus status; /** * the value returned by the call to the function, if @status * is %G_ONCE_STATUS_READY */ void* retval; } struct GOptionContext; /** * A GOptionEntry struct defines a single option. To have an effect, they * must be added to a #GOptionGroup with g_option_context_add_main_entries() * or g_option_group_add_entries(). */ struct GOptionEntry { /** * The long name of an option can be used to specify it * in a commandline as `--long_name`. Every option must have a * long name. To resolve conflicts if multiple option groups contain * the same long name, it is also possible to specify the option as * `--groupname-long_name`. */ const(char)* longName; /** * If an option has a short name, it can be specified * `-short_name` in a commandline. @short_name must be a printable * ASCII character different from '-', or zero if the option has no * short name. */ char shortName; /** * Flags from #GOptionFlags */ int flags; /** * The type of the option, as a #GOptionArg */ GOptionArg arg; /** * If the @arg type is %G_OPTION_ARG_CALLBACK, then @arg_data * must point to a #GOptionArgFunc callback function, which will be * called to handle the extra argument. Otherwise, @arg_data is a * pointer to a location to store the value, the required type of * the location depends on the @arg type: * - %G_OPTION_ARG_NONE: %gboolean * - %G_OPTION_ARG_STRING: %gchar* * - %G_OPTION_ARG_INT: %gint * - %G_OPTION_ARG_FILENAME: %gchar* * - %G_OPTION_ARG_STRING_ARRAY: %gchar** * - %G_OPTION_ARG_FILENAME_ARRAY: %gchar** * - %G_OPTION_ARG_DOUBLE: %gdouble * If @arg type is %G_OPTION_ARG_STRING or %G_OPTION_ARG_FILENAME, * the location will contain a newly allocated string if the option * was given. That string needs to be freed by the callee using g_free(). * Likewise if @arg type is %G_OPTION_ARG_STRING_ARRAY or * %G_OPTION_ARG_FILENAME_ARRAY, the data should be freed using g_strfreev(). */ void* argData; /** * the description for the option in `--help` * output. The @description is translated using the @translate_func * of the group, see g_option_group_set_translation_domain(). */ const(char)* description; /** * The placeholder to use for the extra argument parsed * by the option in `--help` output. The @arg_description is translated * using the @translate_func of the group, see * g_option_group_set_translation_domain(). */ const(char)* argDescription; } struct GOptionGroup; struct GPatternSpec; /** * Represents a file descriptor, which events to poll for, and which events * occurred. */ struct GPollFD { /** * the file descriptor to poll (or a HANDLE on Win32) */ int fd; /** * a bitwise combination from #GIOCondition, specifying which * events should be polled for. Typically for reading from a file * descriptor you would use %G_IO_IN | %G_IO_HUP | %G_IO_ERR, and * for writing you would use %G_IO_OUT | %G_IO_ERR. */ ushort events; /** * a bitwise combination of flags from #GIOCondition, returned * from the poll() function to indicate which events occurred. */ ushort revents; } struct GPrivate { void* p; GDestroyNotify notify; void*[2] future; } /** * Contains the public fields of a pointer array. */ struct GPtrArray { /** * points to the array of pointers, which may be moved when the * array grows */ void** pdata; /** * number of pointers in the array */ uint len; } struct GQueue { /** * a pointer to the first element of the queue */ GList* head; /** * a pointer to the last element of the queue */ GList* tail; /** * the number of elements in the queue */ uint length; } struct GRWLock { void* p; uint[2] i; } struct GRand; struct GRecMutex { void* p; uint[2] i; } struct GRegex; /** * The #GSList struct is used for each element in the singly-linked * list. */ struct GSList { /** * holds the element's data, which can be a pointer to any kind * of data, or any integer value using the * [Type Conversion Macros][glib-Type-Conversion-Macros] */ void* data; /** * contains the link to the next element in the list. */ GSList* next; } struct GScanner { /** * unused */ void* userData; /** * unused */ uint maxParseErrors; /** * g_scanner_error() increments this field */ uint parseErrors; /** * name of input stream, featured by the default message handler */ const(char)* inputName; /** * quarked data */ GData* qdata; /** * link into the scanner configuration */ GScannerConfig* config; /** * token parsed by the last g_scanner_get_next_token() */ GTokenType token; /** * value of the last token from g_scanner_get_next_token() */ GTokenValue value; /** * line number of the last token from g_scanner_get_next_token() */ uint line; /** * char number of the last token from g_scanner_get_next_token() */ uint position; /** * token parsed by the last g_scanner_peek_next_token() */ GTokenType nextToken; /** * value of the last token from g_scanner_peek_next_token() */ GTokenValue nextValue; /** * line number of the last token from g_scanner_peek_next_token() */ uint nextLine; /** * char number of the last token from g_scanner_peek_next_token() */ uint nextPosition; GHashTable* symbolTable; int inputFd; const(char)* text; const(char)* textEnd; char* buffer; uint scopeId; /** * handler function for _warn and _error */ GScannerMsgFunc msgHandler; } /** * Specifies the #GScanner parser configuration. Most settings can * be changed during the parsing phase and will affect the lexical * parsing of the next unpeeked token. */ struct GScannerConfig { /** * specifies which characters should be skipped * by the scanner (the default is the whitespace characters: space, * tab, carriage-return and line-feed). */ char* csetSkipCharacters; /** * specifies the characters which can start * identifiers (the default is #G_CSET_a_2_z, "_", and #G_CSET_A_2_Z). */ char* csetIdentifierFirst; /** * specifies the characters which can be used * in identifiers, after the first character (the default is * #G_CSET_a_2_z, "_0123456789", #G_CSET_A_2_Z, #G_CSET_LATINS, * #G_CSET_LATINC). */ char* csetIdentifierNth; /** * specifies the characters at the start and * end of single-line comments. The default is "#\n" which means * that single-line comments start with a '#' and continue until * a '\n' (end of line). */ char* cpairCommentSingle; import std.bitmanip: bitfields; mixin(bitfields!( uint, "caseSensitive", 1, uint, "skipCommentMulti", 1, uint, "skipCommentSingle", 1, uint, "scanCommentMulti", 1, uint, "scanIdentifier", 1, uint, "scanIdentifier1char", 1, uint, "scanIdentifierNULL", 1, uint, "scanSymbols", 1, uint, "scanBinary", 1, uint, "scanOctal", 1, uint, "scanFloat", 1, uint, "scanHex", 1, uint, "scanHexDollar", 1, uint, "scanStringSq", 1, uint, "scanStringDq", 1, uint, "numbers2Int", 1, uint, "int2Float", 1, uint, "identifier2String", 1, uint, "char2Token", 1, uint, "symbol2Token", 1, uint, "scope0Fallback", 1, uint, "storeInt64", 1, uint, "", 10 )); uint paddingDummy; } struct GSequence; struct GSequenceIter; struct GSource { void* callbackData; GSourceCallbackFuncs* callbackFuncs; GSourceFuncs* sourceFuncs; uint refCount; GMainContext* context; int priority; uint flags; uint sourceId; GSList* pollFds; GSource* prev; GSource* next; char* name; GSourcePrivate* priv; } /** * The `GSourceCallbackFuncs` struct contains * functions for managing callback objects. */ struct GSourceCallbackFuncs { /** */ extern(C) void function(void* cbData) doref; /** */ extern(C) void function(void* cbData) unref; /** */ extern(C) void function(void* cbData, GSource* source, GSourceFunc* func, void** data) get; } /** * The `GSourceFuncs` struct contains a table of * functions used to handle event sources in a generic manner. * * For idle sources, the prepare and check functions always return %TRUE * to indicate that the source is always ready to be processed. The prepare * function also returns a timeout value of 0 to ensure that the poll() call * doesn't block (since that would be time wasted which could have been spent * running the idle function). * * For timeout sources, the prepare and check functions both return %TRUE * if the timeout interval has expired. The prepare function also returns * a timeout value to ensure that the poll() call doesn't block too long * and miss the next timeout. * * For file descriptor sources, the prepare function typically returns %FALSE, * since it must wait until poll() has been called before it knows whether * any events need to be processed. It sets the returned timeout to -1 to * indicate that it doesn't mind how long the poll() call blocks. In the * check function, it tests the results of the poll() call to see if the * required condition has been met, and returns %TRUE if so. */ struct GSourceFuncs { /** */ extern(C) int function(GSource* source, int* timeout) prepare; /** */ extern(C) int function(GSource* source) check; /** */ extern(C) int function(GSource* source, GSourceFunc callback, void* userData) dispatch; /** */ extern(C) void function(GSource* source) finalize; GSourceFunc closureCallback; GSourceDummyMarshal closureMarshal; } struct GSourcePrivate; /** * A type corresponding to the appropriate struct type for the stat() * system call, depending on the platform and/or compiler being used. * * See g_stat() for more information. */ struct GStatBuf; struct GString { /** * points to the character data. It may move as text is added. * The @str field is null-terminated and so * can be used as an ordinary C string. */ char* str; /** * contains the length of the string, not including the * terminating nul byte. */ size_t len; /** * the number of bytes that can be stored in the * string before it needs to be reallocated. May be larger than @len. */ size_t allocatedLen; } struct GStringChunk; /** * An opaque structure representing a test case. */ struct GTestCase; struct GTestConfig { bool testInitialized; bool testQuick; bool testPerf; bool testVerbose; bool testQuiet; bool testUndefined; } struct GTestLogBuffer { GString* data; GSList* msgs; } struct GTestLogMsg { GTestLogType logType; uint nStrings; char** strings; uint nNums; long* nums; } struct GTestSuite; struct GThread; struct GThreadPool { /** * the function to execute in the threads of this pool */ GFunc func; /** * the user data for the threads of this pool */ void* userData; /** * are all threads exclusive to this pool */ bool exclusive; } struct GTimeVal { /** * seconds */ glong tvSec; /** * microseconds */ glong tvUsec; } struct GTimeZone; struct GTimer; /** * A union holding the value of the token. */ struct GTokenValue { union { /** * token symbol value */ void* vSymbol; /** * token identifier value */ char* vIdentifier; /** * token binary integer value */ gulong vBinary; /** * octal integer value */ gulong vOctal; /** * integer value */ gulong vInt; /** * 64-bit integer value */ ulong vInt64; /** * floating point value */ double vFloat; /** * hex integer value */ gulong vHex; /** * string value */ char* vString; /** * comment value */ char* vComment; /** * character value */ char vChar; /** * error value */ uint vError; } } /** * Each piece of memory that is pushed onto the stack * is cast to a GTrashStack*. */ struct GTrashStack { /** * pointer to the previous element of the stack, * gets stored in the first `sizeof (gpointer)` * bytes of the element */ GTrashStack* next; } struct GTree; struct GVariant; struct GVariantBuilder { size_t[16] x; } struct GVariantDict { size_t[16] x; } struct GVariantIter { size_t[16] x; } struct GVariantType; struct GModule; /** * Prototype of a #GChildWatchSource callback, called when a child * process has exited. To interpret @status, see the documentation * for g_spawn_check_exit_status(). * * Params: * pid = the process id of the child process * status = Status information about the child process, encoded * in a platform-specific manner * userData = user data passed to g_child_watch_add() */ public alias extern(C) void function(GPid pid, int status, void* userData) GChildWatchFunc; /** * Specifies the type of a comparison function used to compare two * values. The function should return a negative integer if the first * value comes before the second, 0 if they are equal, or a positive * integer if the first value comes after the second. * * Params: * a = a value * b = a value to compare with * userData = user data * * Returns: negative value if @a < @b; zero if @a = @b; positive * value if @a > @b */ public alias extern(C) int function(void* a, void* b, void* userData) GCompareDataFunc; /** * Specifies the type of a comparison function used to compare two * values. The function should return a negative integer if the first * value comes before the second, 0 if they are equal, or a positive * integer if the first value comes after the second. * * Params: * a = a value * b = a value to compare with * * Returns: negative value if @a < @b; zero if @a = @b; positive * value if @a > @b */ public alias extern(C) int function(void* a, void* b) GCompareFunc; /** * A function of this signature is used to copy the node data * when doing a deep-copy of a tree. * * Params: * src = A pointer to the data which should be copied * data = Additional data * * Returns: A pointer to the copy * * Since: 2.4 */ public alias extern(C) void* function(void* src, void* data) GCopyFunc; /** * Specifies the type of function passed to g_dataset_foreach(). It is * called with each #GQuark id and associated data element, together * with the @user_data parameter supplied to g_dataset_foreach(). * * Params: * keyId = the #GQuark id to identifying the data element. * data = the data element. * userData = user data passed to g_dataset_foreach(). */ public alias extern(C) void function(GQuark keyId, void* data, void* userData) GDataForeachFunc; /** * Specifies the type of function which is called when a data element * is destroyed. It is passed the pointer to the data element and * should free any memory and resources allocated for it. * * Params: * data = the data element. */ public alias extern(C) void function(void* data) GDestroyNotify; /** * The type of functions that are used to 'duplicate' an object. * What this means depends on the context, it could just be * incrementing the reference count, if @data is a ref-counted * object. * * Params: * data = the data to duplicate * userData = user data that was specified in g_datalist_id_dup_data() * * Returns: a duplicate of data */ public alias extern(C) void* function(void* data, void* userData) GDuplicateFunc; /** * Specifies the type of a function used to test two values for * equality. The function should return %TRUE if both values are equal * and %FALSE otherwise. * * Params: * a = a value * b = a value to compare with * * Returns: %TRUE if @a = @b; %FALSE otherwise */ public alias extern(C) int function(void* a, void* b) GEqualFunc; /** * Declares a type of function which takes an arbitrary * data pointer argument and has no return value. It is * not currently used in GLib or GTK+. * * Params: * data = a data pointer */ public alias extern(C) void function(void* data) GFreeFunc; /** * Specifies the type of functions passed to g_list_foreach() and * g_slist_foreach(). * * Params: * data = the element's data * userData = user data passed to g_list_foreach() or g_slist_foreach() */ public alias extern(C) void function(void* data, void* userData) GFunc; /** * Specifies the type of the function passed to g_hash_table_foreach(). * It is called with each key/value pair, together with the @user_data * parameter which is passed to g_hash_table_foreach(). * * Params: * key = a key * value = the value corresponding to the key * userData = user data passed to g_hash_table_foreach() */ public alias extern(C) void function(void* key, void* value, void* userData) GHFunc; /** * Specifies the type of the function passed to * g_hash_table_foreach_remove(). It is called with each key/value * pair, together with the @user_data parameter passed to * g_hash_table_foreach_remove(). It should return %TRUE if the * key/value pair should be removed from the #GHashTable. * * Params: * key = a key * value = the value associated with the key * userData = user data passed to g_hash_table_remove() * * Returns: %TRUE if the key/value pair should be removed from the * #GHashTable */ public alias extern(C) int function(void* key, void* value, void* userData) GHRFunc; /** * Specifies the type of the hash function which is passed to * g_hash_table_new() when a #GHashTable is created. * * The function is passed a key and should return a #guint hash value. * The functions g_direct_hash(), g_int_hash() and g_str_hash() provide * hash functions which can be used when the key is a #gpointer, #gint*, * and #gchar* respectively. * * g_direct_hash() is also the appropriate hash function for keys * of the form `GINT_TO_POINTER (n)` (or similar macros). * * A good hash functions should produce * hash values that are evenly distributed over a fairly large range. * The modulus is taken with the hash table size (a prime number) to * find the 'bucket' to place each key into. The function should also * be very fast, since it is called for each key lookup. * * Note that the hash functions provided by GLib have these qualities, * but are not particularly robust against manufactured keys that * cause hash collisions. Therefore, you should consider choosing * a more secure hash function when using a GHashTable with keys * that originate in untrusted data (such as HTTP requests). * Using g_str_hash() in that situation might make your application * vulerable to * [Algorithmic Complexity Attacks](https://lwn.net/Articles/474912/). * * The key to choosing a good hash is unpredictability. Even * cryptographic hashes are very easy to find collisions for when the * remainder is taken modulo a somewhat predictable prime number. There * must be an element of randomness that an attacker is unable to guess. * * Params: * key = a key * * Returns: the hash value corresponding to the key */ public alias extern(C) uint function(void* key) GHashFunc; /** * Defines the type of a hook function that can be invoked * by g_hook_list_invoke_check(). * * Params: * data = the data field of the #GHook is passed to the hook function here * * Returns: %FALSE if the #GHook should be destroyed */ public alias extern(C) int function(void* data) GHookCheckFunc; /** * Defines the type of function used by g_hook_list_marshal_check(). * * Params: * hook = a #GHook * marshalData = user data * * Returns: %FALSE if @hook should be destroyed */ public alias extern(C) int function(GHook* hook, void* marshalData) GHookCheckMarshaller; /** * Defines the type of function used to compare #GHook elements in * g_hook_insert_sorted(). * * Params: * newHook = the #GHook being inserted * sibling = the #GHook to compare with @new_hook * * Returns: a value <= 0 if @new_hook should be before @sibling */ public alias extern(C) int function(GHook* newHook, GHook* sibling) GHookCompareFunc; /** * Defines the type of function to be called when a hook in a * list of hooks gets finalized. * * Params: * hookList = a #GHookList * hook = the hook in @hook_list that gets finalized */ public alias extern(C) void function(GHookList* hookList, GHook* hook) GHookFinalizeFunc; /** * Defines the type of the function passed to g_hook_find(). * * Params: * hook = a #GHook * data = user data passed to g_hook_find_func() * * Returns: %TRUE if the required #GHook has been found */ public alias extern(C) int function(GHook* hook, void* data) GHookFindFunc; /** * Defines the type of a hook function that can be invoked * by g_hook_list_invoke(). * * Params: * data = the data field of the #GHook is passed to the hook function here */ public alias extern(C) void function(void* data) GHookFunc; /** * Defines the type of function used by g_hook_list_marshal(). * * Params: * hook = a #GHook * marshalData = user data */ public alias extern(C) void function(GHook* hook, void* marshalData) GHookMarshaller; /** * Specifies the type of function passed to g_io_add_watch() or * g_io_add_watch_full(), which is called when the requested condition * on a #GIOChannel is satisfied. * * Params: * source = the #GIOChannel event source * condition = the condition which has been satisfied * data = user data set in g_io_add_watch() or g_io_add_watch_full() * * Returns: the function should return %FALSE if the event source * should be removed */ public alias extern(C) int function(GIOChannel* source, GIOCondition condition, void* data) GIOFunc; /** * Specifies the prototype of log handler functions. * * The default log handler, g_log_default_handler(), automatically appends a * new-line character to @message when printing it. It is advised that any * custom log handler functions behave similarly, so that logging calls in user * code do not need modifying to add a new-line character to the message if the * log handler is changed. * * Params: * logDomain = the log domain of the message * logLevel = the log level of the message (including the * fatal and recursion flags) * message = the message to process * userData = user data, set in g_log_set_handler() */ public alias extern(C) void function(const(char)* logDomain, GLogLevelFlags logLevel, const(char)* message, void* userData) GLogFunc; /** * Specifies the type of function passed to g_node_children_foreach(). * The function is called with each child node, together with the user * data passed to g_node_children_foreach(). * * Params: * node = a #GNode. * data = user data passed to g_node_children_foreach(). */ public alias extern(C) void function(GNode* node, void* data) GNodeForeachFunc; /** * Specifies the type of function passed to g_node_traverse(). The * function is called with each of the nodes visited, together with the * user data passed to g_node_traverse(). If the function returns * %TRUE, then the traversal is stopped. * * Params: * node = a #GNode. * data = user data passed to g_node_traverse(). * * Returns: %TRUE to stop the traversal. */ public alias extern(C) int function(GNode* node, void* data) GNodeTraverseFunc; /** * The type of function to be passed as callback for %G_OPTION_ARG_CALLBACK * options. * * Params: * optionName = The name of the option being parsed. This will be either a * single dash followed by a single letter (for a short name) or two dashes * followed by a long option name. * value = The value to be parsed. * data = User data added to the #GOptionGroup containing the option when it * was created with g_option_group_new() * * Returns: %TRUE if the option was successfully parsed, %FALSE if an error * occurred, in which case @error should be set with g_set_error() * * Throws: GException on failure. */ public alias extern(C) int function(const(char)* optionName, const(char)* value, void* data, GError** err) GOptionArgFunc; /** * The type of function to be used as callback when a parse error occurs. * * Params: * context = The active #GOptionContext * group = The group to which the function belongs * data = User data added to the #GOptionGroup containing the option when it * was created with g_option_group_new() * * Throws: GException on failure. */ public alias extern(C) void function(GOptionContext* context, GOptionGroup* group, void* data, GError** err) GOptionErrorFunc; /** * The type of function that can be called before and after parsing. * * Params: * context = The active #GOptionContext * group = The group to which the function belongs * data = User data added to the #GOptionGroup containing the option when it * was created with g_option_group_new() * * Returns: %TRUE if the function completed successfully, %FALSE if an error * occurred, in which case @error should be set with g_set_error() * * Throws: GException on failure. */ public alias extern(C) int function(GOptionContext* context, GOptionGroup* group, void* data, GError** err) GOptionParseFunc; /** * Specifies the type of function passed to g_main_context_set_poll_func(). * The semantics of the function should match those of the poll() system call. * * Params: * ufds = an array of #GPollFD elements * nfsd = the number of elements in @ufds * timeout = the maximum time to wait for an event of the file descriptors. * A negative value indicates an infinite timeout. * * Returns: the number of #GPollFD elements which have events or errors * reported, or -1 if an error occurred. */ public alias extern(C) int function(GPollFD* ufds, uint nfsd, int timeout) GPollFunc; /** * Specifies the type of the print handler functions. * These are called with the complete formatted string to output. * * Params: * str = the message to output */ public alias extern(C) void function(const(char)* str) GPrintFunc; /** * Specifies the type of the function passed to g_regex_replace_eval(). * It is called for each occurrence of the pattern in the string passed * to g_regex_replace_eval(), and it should append the replacement to * @result. * * Params: * matchInfo = the #GMatchInfo generated by the match. * Use g_match_info_get_regex() and g_match_info_get_string() if you * need the #GRegex or the matched string. * result = a #GString containing the new string * userData = user data passed to g_regex_replace_eval() * * Returns: %FALSE to continue the replacement process, %TRUE to stop it * * Since: 2.14 */ public alias extern(C) int function(GMatchInfo* matchInfo, GString* result, void* userData) GRegexEvalCallback; /** * Specifies the type of the message handler function. * * Params: * scanner = a #GScanner * message = the message * error = %TRUE if the message signals an error, * %FALSE if it signals a warning. */ public alias extern(C) void function(GScanner* scanner, char* message, int error) GScannerMsgFunc; /** * A #GSequenceIterCompareFunc is a function used to compare iterators. * It must return zero if the iterators compare equal, a negative value * if @a comes before @b, and a positive value if @b comes before @a. * * Params: * a = a #GSequenceIter * b = a #GSequenceIter * data = user data * * Returns: zero if the iterators are equal, a negative value if @a * comes before @b, and a positive value if @b comes before @a. */ public alias extern(C) int function(GSequenceIter* a, GSequenceIter* b, void* data) GSequenceIterCompareFunc; /** * This is just a placeholder for #GClosureMarshal, * which cannot be used here for dependency reasons. */ public alias extern(C) void function() GSourceDummyMarshal; /** * Specifies the type of function passed to g_timeout_add(), * g_timeout_add_full(), g_idle_add(), and g_idle_add_full(). * * Params: * userData = data passed to the function, set when the source was * created with one of the above functions * * Returns: %FALSE if the source should be removed. #G_SOURCE_CONTINUE and * #G_SOURCE_REMOVE are more memorable names for the return value. */ public alias extern(C) int function(void* userData) GSourceFunc; /** * Specifies the type of the setup function passed to g_spawn_async(), * g_spawn_sync() and g_spawn_async_with_pipes(), which can, in very * limited ways, be used to affect the child's execution. * * On POSIX platforms, the function is called in the child after GLib * has performed all the setup it plans to perform, but before calling * exec(). Actions taken in this function will only affect the child, * not the parent. * * On Windows, the function is called in the parent. Its usefulness on * Windows is thus questionable. In many cases executing the child setup * function in the parent can have ill effects, and you should be very * careful when porting software to Windows that uses child setup * functions. * * However, even on POSIX, you are extremely limited in what you can * safely do from a #GSpawnChildSetupFunc, because any mutexes that were * held by other threads in the parent process at the time of the fork() * will still be locked in the child process, and they will never be * unlocked (since the threads that held them don't exist in the child). * POSIX allows only async-signal-safe functions (see signal(7)) to be * called in the child between fork() and exec(), which drastically limits * the usefulness of child setup functions. * * In particular, it is not safe to call any function which may * call malloc(), which includes POSIX functions such as setenv(). * If you need to set up the child environment differently from * the parent, you should use g_get_environ(), g_environ_setenv(), * and g_environ_unsetenv(), and then pass the complete environment * list to the `g_spawn...` function. * * Params: * userData = user data to pass to the function. */ public alias extern(C) void function(void* userData) GSpawnChildSetupFunc; /** * The type used for test case functions that take an extra pointer * argument. * * Params: * userData = the data provided when registering the test * * Since: 2.28 */ public alias extern(C) void function(void* userData) GTestDataFunc; /** * The type used for functions that operate on test fixtures. This is * used for the fixture setup and teardown functions as well as for the * testcases themselves. * * @user_data is a pointer to the data that was given when registering * the test case. * * @fixture will be a pointer to the area of memory allocated by the * test framework, of the size requested. If the requested size was * zero then @fixture will be equal to @user_data. * * Params: * fixture = the test fixture * userData = the data provided when registering the test * * Since: 2.28 */ public alias extern(C) void function(void* fixture, void* userData) GTestFixtureFunc; /** * The type used for test case functions. * * Since: 2.28 */ public alias extern(C) void function() GTestFunc; /** * Specifies the prototype of fatal log handler functions. * * Params: * logDomain = the log domain of the message * logLevel = the log level of the message (including the fatal and recursion flags) * message = the message to process * userData = user data, set in g_test_log_set_fatal_handler() * * Returns: %TRUE if the program should abort, %FALSE otherwise * * Since: 2.22 */ public alias extern(C) int function(const(char)* logDomain, GLogLevelFlags logLevel, const(char)* message, void* userData) GTestLogFatalFunc; /** * Specifies the type of the @func functions passed to g_thread_new() * or g_thread_try_new(). * * Params: * data = data passed to the thread * * Returns: the return value of the thread */ public alias extern(C) void* function(void* data) GThreadFunc; /** * The type of functions which are used to translate user-visible * strings, for output. * * Params: * str = the untranslated string * data = user data specified when installing the function, e.g. * in g_option_group_set_translate_func() * * Returns: a translation of the string for the current locale. * The returned string is owned by GLib and must not be freed. */ public alias extern(C) const(char)* function(const(char)* str, void* data) GTranslateFunc; /** * Specifies the type of function passed to g_tree_traverse(). It is * passed the key and value of each node, together with the @user_data * parameter passed to g_tree_traverse(). If the function returns * %TRUE, the traversal is stopped. * * Params: * key = a key of a #GTree node * value = the value corresponding to the key * data = user data passed to g_tree_traverse() * * Returns: %TRUE to stop the traversal */ public alias extern(C) int function(void* key, void* value, void* data) GTraverseFunc; /** * The type of functions to be called when a UNIX fd watch source * triggers. * * Params: * fd = the fd that triggered the event * condition = the IO conditions reported on @fd * userData = user data passed to g_unix_fd_add() * * Returns: %FALSE if the source should be removed */ public alias extern(C) int function(int fd, GIOCondition condition, void* userData) GUnixFDSourceFunc; /** * Declares a type of function which takes no arguments * and has no return value. It is used to specify the type * function passed to g_atexit(). */ public alias extern(C) void function() GVoidFunc; /** * Specifies the type of the module initialization function. * If a module contains a function named g_module_check_init() it is called * automatically when the module is loaded. It is passed the #GModule structure * and should return %NULL on success or a string describing the initialization * error. * * Params: * modul = the #GModule corresponding to the module which has just been loaded * * Returns: %NULL on success, or a string describing the initialization error */ public alias extern(C) const(char)* function(GModule* modul) GModuleCheckInit; /** * Specifies the type of the module function called when it is unloaded. * If a module contains a function named g_module_unload() it is called * automatically when the module is unloaded. * It is passed the #GModule structure. * * Params: * modul = the #GModule about to be unloaded */ public alias extern(C) void function(GModule* modul) GModuleUnload;