1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module glib.c.types;
26 
27 public alias uint uid_t;
28 public alias int pid_t;
29 
30 version( Windows )
31 {
32 	alias int glong;
33 	alias uint gulong;
34 }
35 else version( X86_64 )
36 {
37 	alias long glong;
38 	alias ulong gulong;
39 }
40 else
41 {
42 	alias int glong;
43 	alias uint gulong;
44 }
45 
46 version (Windows)
47 {
48 	private import core.stdc.stdio;
49 
50 	static if( !is(typeof(fdopen(0, null))) )
51 	{
52 		extern (C) FILE*  fdopen(int, char*);
53 	}
54 }
55 
56 struct Scoped(T)
57 {
58 	T payload;
59 
60 	alias payload this;
61 
62 	@disable this();
63 	@disable this(this);
64 
65 	~this()
66 	{
67 		.destroy(payload);
68 	}
69 }
70 
71 auto getScopedGobject(T, Args...)(auto ref Args args) if (is(T == class))
72 {
73 	Scoped!(T) result = void;
74 	result.payload = new T(args);
75 
76 	return result;
77 }
78 
79 /**
80  * Get the length of a zero terminated array.
81  */
82 size_t getArrayLength(T)(T* arr)
83 {
84 	size_t len;
85 
86 	for ( ; arr[len]; len++ ){}
87 
88 	return len;
89 }
90 
91 unittest
92 {
93 	assert(getArrayLength("aaaaaaaaa\0".ptr) == 9);
94 }
95 
96 Type* gMalloc(Type)()
97 {
98 	import glib.c.functions;
99 	return cast(Type*)g_malloc0(Type.sizeof);
100 }
101 
102 alias void* GIConv;
103 
104 /**
105  * Integer representing a day of the month; between 1 and 31.
106  * #G_DATE_BAD_DAY represents an invalid day of the month.
107  */
108 public alias ubyte GDateDay;
109 
110 /**
111  * Integer representing a year; #G_DATE_BAD_YEAR is the invalid
112  * value. The year must be 1 or higher; negative (BC) years are not
113  * allowed. The year is represented with four digits.
114  */
115 public alias ushort GDateYear;
116 
117 /**
118  * Opaque type. See g_mutex_locker_new() for details.
119  */
120 public alias void GMutexLocker;
121 
122 /**
123  * A type which is used to hold a process identification.
124  *
125  * On UNIX, processes are identified by a process id (an integer),
126  * while Windows uses process handles (which are pointers).
127  *
128  * GPid is used in GLib only for descendant processes spawned with
129  * the g_spawn functions.
130  */
131 public alias int GPid;
132 
133 /**
134  * A GQuark is a non-zero integer which uniquely identifies a
135  * particular string. A GQuark value of zero is associated to %NULL.
136  */
137 public alias uint GQuark;
138 
139 /**
140  * A typedef alias for gchar**. This is mostly useful when used together with
141  * g_auto().
142  */
143 public alias char** GStrv;
144 
145 /**
146  * Simply a replacement for time_t. It has been deprecated
147  * since it is not equivalent to time_t on 64-bit platforms
148  * with a 64-bit time_t. Unrelated to #GTimer.
149  *
150  * Note that #GTime is defined to always be a 32-bit integer,
151  * unlike time_t which may be 64-bit on some systems. Therefore,
152  * #GTime will overflow in the year 2038, and you cannot use the
153  * address of a #GTime variable as argument to the UNIX time()
154  * function.
155  *
156  * Instead, do the following:
157  * |[<!-- language="C" -->
158  * time_t ttime;
159  * GTime gtime;
160  *
161  * time (&ttime);
162  * gtime = (GTime)ttime;
163  * ]|
164  */
165 public alias int GTime;
166 
167 /**
168  * A value representing an interval of time, in microseconds.
169  */
170 public alias long GTimeSpan;
171 
172 enum GPriority
173 {
174 	HIGH = -100,
175 	DEFAULT = 0,
176 	HIGH_IDLE = 100,
177 	DEFAULT_IDLE = 200,
178 	LOW = 300
179 }
180 
181 
182 public enum GAsciiType
183 {
184 	ALNUM = 1,
185 	ALPHA = 2,
186 	CNTRL = 4,
187 	DIGIT = 8,
188 	GRAPH = 16,
189 	LOWER = 32,
190 	PRINT = 64,
191 	PUNCT = 128,
192 	SPACE = 256,
193 	UPPER = 512,
194 	XDIGIT = 1024,
195 }
196 alias GAsciiType AsciiType;
197 
198 /**
199  * Error codes returned by bookmark file parsing.
200  */
201 public enum GBookmarkFileError
202 {
203 	/**
204 	 * URI was ill-formed
205 	 */
206 	INVALID_URI = 0,
207 	/**
208 	 * a requested field was not found
209 	 */
210 	INVALID_VALUE = 1,
211 	/**
212 	 * a requested application did
213 	 * not register a bookmark
214 	 */
215 	APP_NOT_REGISTERED = 2,
216 	/**
217 	 * a requested URI was not found
218 	 */
219 	URI_NOT_FOUND = 3,
220 	/**
221 	 * document was ill formed
222 	 */
223 	READ = 4,
224 	/**
225 	 * the text being parsed was
226 	 * in an unknown encoding
227 	 */
228 	UNKNOWN_ENCODING = 5,
229 	/**
230 	 * an error occurred while writing
231 	 */
232 	WRITE = 6,
233 	/**
234 	 * requested file was not found
235 	 */
236 	FILE_NOT_FOUND = 7,
237 }
238 alias GBookmarkFileError BookmarkFileError;
239 
240 /**
241  * The hashing algorithm to be used by #GChecksum when performing the
242  * digest of some data.
243  *
244  * Note that the #GChecksumType enumeration may be extended at a later
245  * date to include new hashing algorithm types.
246  *
247  * Since: 2.16
248  */
249 public enum GChecksumType
250 {
251 	/**
252 	 * Use the MD5 hashing algorithm
253 	 */
254 	MD5 = 0,
255 	/**
256 	 * Use the SHA-1 hashing algorithm
257 	 */
258 	SHA1 = 1,
259 	/**
260 	 * Use the SHA-256 hashing algorithm
261 	 */
262 	SHA256 = 2,
263 	/**
264 	 * Use the SHA-512 hashing algorithm (Since: 2.36)
265 	 */
266 	SHA512 = 3,
267 	/**
268 	 * Use the SHA-384 hashing algorithm (Since: 2.51)
269 	 */
270 	SHA384 = 4,
271 }
272 alias GChecksumType ChecksumType;
273 
274 /**
275  * Error codes returned by character set conversion routines.
276  */
277 public enum GConvertError
278 {
279 	/**
280 	 * Conversion between the requested character
281 	 * sets is not supported.
282 	 */
283 	NO_CONVERSION = 0,
284 	/**
285 	 * Invalid byte sequence in conversion input;
286 	 * or the character sequence could not be represented in the target
287 	 * character set.
288 	 */
289 	ILLEGAL_SEQUENCE = 1,
290 	/**
291 	 * Conversion failed for some reason.
292 	 */
293 	FAILED = 2,
294 	/**
295 	 * Partial character sequence at end of input.
296 	 */
297 	PARTIAL_INPUT = 3,
298 	/**
299 	 * URI is invalid.
300 	 */
301 	BAD_URI = 4,
302 	/**
303 	 * Pathname is not an absolute path.
304 	 */
305 	NOT_ABSOLUTE_PATH = 5,
306 	/**
307 	 * No memory available. Since: 2.40
308 	 */
309 	NO_MEMORY = 6,
310 	/**
311 	 * An embedded NUL character is present in
312 	 * conversion output where a NUL-terminated string is expected.
313 	 * Since: 2.56
314 	 */
315 	EMBEDDED_NUL = 7,
316 }
317 alias GConvertError ConvertError;
318 
319 /**
320  * This enumeration isn't used in the API, but may be useful if you need
321  * to mark a number as a day, month, or year.
322  */
323 public enum GDateDMY
324 {
325 	/**
326 	 * a day
327 	 */
328 	DAY = 0,
329 	/**
330 	 * a month
331 	 */
332 	MONTH = 1,
333 	/**
334 	 * a year
335 	 */
336 	YEAR = 2,
337 }
338 alias GDateDMY DateDMY;
339 
340 /**
341  * Enumeration representing a month; values are #G_DATE_JANUARY,
342  * #G_DATE_FEBRUARY, etc. #G_DATE_BAD_MONTH is the invalid value.
343  */
344 public enum GDateMonth
345 {
346 	/**
347 	 * invalid value
348 	 */
349 	BAD_MONTH = 0,
350 	/**
351 	 * January
352 	 */
353 	JANUARY = 1,
354 	/**
355 	 * February
356 	 */
357 	FEBRUARY = 2,
358 	/**
359 	 * March
360 	 */
361 	MARCH = 3,
362 	/**
363 	 * April
364 	 */
365 	APRIL = 4,
366 	/**
367 	 * May
368 	 */
369 	MAY = 5,
370 	/**
371 	 * June
372 	 */
373 	JUNE = 6,
374 	/**
375 	 * July
376 	 */
377 	JULY = 7,
378 	/**
379 	 * August
380 	 */
381 	AUGUST = 8,
382 	/**
383 	 * September
384 	 */
385 	SEPTEMBER = 9,
386 	/**
387 	 * October
388 	 */
389 	OCTOBER = 10,
390 	/**
391 	 * November
392 	 */
393 	NOVEMBER = 11,
394 	/**
395 	 * December
396 	 */
397 	DECEMBER = 12,
398 }
399 alias GDateMonth DateMonth;
400 
401 /**
402  * Enumeration representing a day of the week; #G_DATE_MONDAY,
403  * #G_DATE_TUESDAY, etc. #G_DATE_BAD_WEEKDAY is an invalid weekday.
404  */
405 public enum GDateWeekday
406 {
407 	/**
408 	 * invalid value
409 	 */
410 	BAD_WEEKDAY = 0,
411 	/**
412 	 * Monday
413 	 */
414 	MONDAY = 1,
415 	/**
416 	 * Tuesday
417 	 */
418 	TUESDAY = 2,
419 	/**
420 	 * Wednesday
421 	 */
422 	WEDNESDAY = 3,
423 	/**
424 	 * Thursday
425 	 */
426 	THURSDAY = 4,
427 	/**
428 	 * Friday
429 	 */
430 	FRIDAY = 5,
431 	/**
432 	 * Saturday
433 	 */
434 	SATURDAY = 6,
435 	/**
436 	 * Sunday
437 	 */
438 	SUNDAY = 7,
439 }
440 alias GDateWeekday DateWeekday;
441 
442 /**
443  * The possible errors, used in the @v_error field
444  * of #GTokenValue, when the token is a %G_TOKEN_ERROR.
445  */
446 public enum GErrorType
447 {
448 	/**
449 	 * unknown error
450 	 */
451 	UNKNOWN = 0,
452 	/**
453 	 * unexpected end of file
454 	 */
455 	UNEXP_EOF = 1,
456 	/**
457 	 * unterminated string constant
458 	 */
459 	UNEXP_EOF_IN_STRING = 2,
460 	/**
461 	 * unterminated comment
462 	 */
463 	UNEXP_EOF_IN_COMMENT = 3,
464 	/**
465 	 * non-digit character in a number
466 	 */
467 	NON_DIGIT_IN_CONST = 4,
468 	/**
469 	 * digit beyond radix in a number
470 	 */
471 	DIGIT_RADIX = 5,
472 	/**
473 	 * non-decimal floating point number
474 	 */
475 	FLOAT_RADIX = 6,
476 	/**
477 	 * malformed floating point number
478 	 */
479 	FLOAT_MALFORMED = 7,
480 }
481 alias GErrorType ErrorType;
482 
483 /**
484  * Values corresponding to @errno codes returned from file operations
485  * on UNIX. Unlike @errno codes, GFileError values are available on
486  * all systems, even Windows. The exact meaning of each code depends
487  * on what sort of file operation you were performing; the UNIX
488  * documentation gives more details. The following error code descriptions
489  * come from the GNU C Library manual, and are under the copyright
490  * of that manual.
491  *
492  * It's not very portable to make detailed assumptions about exactly
493  * which errors will be returned from a given operation. Some errors
494  * don't occur on some systems, etc., sometimes there are subtle
495  * differences in when a system will report a given error, etc.
496  */
497 public enum GFileError
498 {
499 	/**
500 	 * Operation not permitted; only the owner of
501 	 * the file (or other resource) or processes with special privileges
502 	 * can perform the operation.
503 	 */
504 	EXIST = 0,
505 	/**
506 	 * File is a directory; you cannot open a directory
507 	 * for writing, or create or remove hard links to it.
508 	 */
509 	ISDIR = 1,
510 	/**
511 	 * Permission denied; the file permissions do not
512 	 * allow the attempted operation.
513 	 */
514 	ACCES = 2,
515 	/**
516 	 * Filename too long.
517 	 */
518 	NAMETOOLONG = 3,
519 	/**
520 	 * No such file or directory. This is a "file
521 	 * doesn't exist" error for ordinary files that are referenced in
522 	 * contexts where they are expected to already exist.
523 	 */
524 	NOENT = 4,
525 	/**
526 	 * A file that isn't a directory was specified when
527 	 * a directory is required.
528 	 */
529 	NOTDIR = 5,
530 	/**
531 	 * No such device or address. The system tried to
532 	 * use the device represented by a file you specified, and it
533 	 * couldn't find the device. This can mean that the device file was
534 	 * installed incorrectly, or that the physical device is missing or
535 	 * not correctly attached to the computer.
536 	 */
537 	NXIO = 6,
538 	/**
539 	 * The underlying file system of the specified file
540 	 * does not support memory mapping.
541 	 */
542 	NODEV = 7,
543 	/**
544 	 * The directory containing the new link can't be
545 	 * modified because it's on a read-only file system.
546 	 */
547 	ROFS = 8,
548 	/**
549 	 * Text file busy.
550 	 */
551 	TXTBSY = 9,
552 	/**
553 	 * You passed in a pointer to bad memory.
554 	 * (GLib won't reliably return this, don't pass in pointers to bad
555 	 * memory.)
556 	 */
557 	FAULT = 10,
558 	/**
559 	 * Too many levels of symbolic links were encountered
560 	 * in looking up a file name. This often indicates a cycle of symbolic
561 	 * links.
562 	 */
563 	LOOP = 11,
564 	/**
565 	 * No space left on device; write operation on a
566 	 * file failed because the disk is full.
567 	 */
568 	NOSPC = 12,
569 	/**
570 	 * No memory available. The system cannot allocate
571 	 * more virtual memory because its capacity is full.
572 	 */
573 	NOMEM = 13,
574 	/**
575 	 * The current process has too many files open and
576 	 * can't open any more. Duplicate descriptors do count toward this
577 	 * limit.
578 	 */
579 	MFILE = 14,
580 	/**
581 	 * There are too many distinct file openings in the
582 	 * entire system.
583 	 */
584 	NFILE = 15,
585 	/**
586 	 * Bad file descriptor; for example, I/O on a
587 	 * descriptor that has been closed or reading from a descriptor open
588 	 * only for writing (or vice versa).
589 	 */
590 	BADF = 16,
591 	/**
592 	 * Invalid argument. This is used to indicate
593 	 * various kinds of problems with passing the wrong argument to a
594 	 * library function.
595 	 */
596 	INVAL = 17,
597 	/**
598 	 * Broken pipe; there is no process reading from the
599 	 * other end of a pipe. Every library function that returns this
600 	 * error code also generates a 'SIGPIPE' signal; this signal
601 	 * terminates the program if not handled or blocked. Thus, your
602 	 * program will never actually see this code unless it has handled
603 	 * or blocked 'SIGPIPE'.
604 	 */
605 	PIPE = 18,
606 	/**
607 	 * Resource temporarily unavailable; the call might
608 	 * work if you try again later.
609 	 */
610 	AGAIN = 19,
611 	/**
612 	 * Interrupted function call; an asynchronous signal
613 	 * occurred and prevented completion of the call. When this
614 	 * happens, you should try the call again.
615 	 */
616 	INTR = 20,
617 	/**
618 	 * Input/output error; usually used for physical read
619 	 * or write errors. i.e. the disk or other physical device hardware
620 	 * is returning errors.
621 	 */
622 	IO = 21,
623 	/**
624 	 * Operation not permitted; only the owner of the
625 	 * file (or other resource) or processes with special privileges can
626 	 * perform the operation.
627 	 */
628 	PERM = 22,
629 	/**
630 	 * Function not implemented; this indicates that
631 	 * the system is missing some functionality.
632 	 */
633 	NOSYS = 23,
634 	/**
635 	 * Does not correspond to a UNIX error code; this
636 	 * is the standard "failed for unspecified reason" error code present
637 	 * in all #GError error code enumerations. Returned if no specific
638 	 * code applies.
639 	 */
640 	FAILED = 24,
641 }
642 alias GFileError FileError;
643 
644 /**
645  * A test to perform on a file using g_file_test().
646  */
647 public enum GFileTest
648 {
649 	/**
650 	 * %TRUE if the file is a regular file
651 	 * (not a directory). Note that this test will also return %TRUE
652 	 * if the tested file is a symlink to a regular file.
653 	 */
654 	IS_REGULAR = 1,
655 	/**
656 	 * %TRUE if the file is a symlink.
657 	 */
658 	IS_SYMLINK = 2,
659 	/**
660 	 * %TRUE if the file is a directory.
661 	 */
662 	IS_DIR = 4,
663 	/**
664 	 * %TRUE if the file is executable.
665 	 */
666 	IS_EXECUTABLE = 8,
667 	/**
668 	 * %TRUE if the file exists. It may or may not
669 	 * be a regular file.
670 	 */
671 	EXISTS = 16,
672 }
673 alias GFileTest FileTest;
674 
675 /**
676  * Flags to modify the format of the string returned by g_format_size_full().
677  */
678 public enum GFormatSizeFlags
679 {
680 	/**
681 	 * behave the same as g_format_size()
682 	 */
683 	DEFAULT = 0,
684 	/**
685 	 * include the exact number of bytes as part
686 	 * of the returned string.  For example, "45.6 kB (45,612 bytes)".
687 	 */
688 	LONG_FORMAT = 1,
689 	/**
690 	 * use IEC (base 1024) units with "KiB"-style
691 	 * suffixes. IEC units should only be used for reporting things with
692 	 * a strong "power of 2" basis, like RAM sizes or RAID stripe sizes.
693 	 * Network and storage sizes should be reported in the normal SI units.
694 	 */
695 	IEC_UNITS = 2,
696 	/**
697 	 * set the size as a quantity in bits, rather than
698 	 * bytes, and return units in bits. For example, ‘Mb’ rather than ‘MB’.
699 	 */
700 	BITS = 4,
701 }
702 alias GFormatSizeFlags FormatSizeFlags;
703 
704 /**
705  * Flags used internally in the #GHook implementation.
706  */
707 public enum GHookFlagMask
708 {
709 	/**
710 	 * set if the hook has not been destroyed
711 	 */
712 	ACTIVE = 1,
713 	/**
714 	 * set if the hook is currently being run
715 	 */
716 	IN_CALL = 2,
717 	/**
718 	 * A mask covering all bits reserved for
719 	 * hook flags; see %G_HOOK_FLAG_USER_SHIFT
720 	 */
721 	MASK = 15,
722 }
723 alias GHookFlagMask HookFlagMask;
724 
725 /**
726  * Error codes returned by #GIOChannel operations.
727  */
728 public enum GIOChannelError
729 {
730 	/**
731 	 * File too large.
732 	 */
733 	FBIG = 0,
734 	/**
735 	 * Invalid argument.
736 	 */
737 	INVAL = 1,
738 	/**
739 	 * IO error.
740 	 */
741 	IO = 2,
742 	/**
743 	 * File is a directory.
744 	 */
745 	ISDIR = 3,
746 	/**
747 	 * No space left on device.
748 	 */
749 	NOSPC = 4,
750 	/**
751 	 * No such device or address.
752 	 */
753 	NXIO = 5,
754 	/**
755 	 * Value too large for defined datatype.
756 	 */
757 	OVERFLOW = 6,
758 	/**
759 	 * Broken pipe.
760 	 */
761 	PIPE = 7,
762 	/**
763 	 * Some other error.
764 	 */
765 	FAILED = 8,
766 }
767 alias GIOChannelError IOChannelError;
768 
769 /**
770  * A bitwise combination representing a condition to watch for on an
771  * event source.
772  */
773 public enum GIOCondition
774 {
775 	/**
776 	 * There is data to read.
777 	 */
778 	IN = 1,
779 	/**
780 	 * Data can be written (without blocking).
781 	 */
782 	OUT = 4,
783 	/**
784 	 * There is urgent data to read.
785 	 */
786 	PRI = 2,
787 	/**
788 	 * Error condition.
789 	 */
790 	ERR = 8,
791 	/**
792 	 * Hung up (the connection has been broken, usually for
793 	 * pipes and sockets).
794 	 */
795 	HUP = 16,
796 	/**
797 	 * Invalid request. The file descriptor is not open.
798 	 */
799 	NVAL = 32,
800 }
801 alias GIOCondition IOCondition;
802 
803 /**
804  * #GIOError is only used by the deprecated functions
805  * g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().
806  */
807 public enum GIOError
808 {
809 	/**
810 	 * no error
811 	 */
812 	NONE = 0,
813 	/**
814 	 * an EAGAIN error occurred
815 	 */
816 	AGAIN = 1,
817 	/**
818 	 * an EINVAL error occurred
819 	 */
820 	INVAL = 2,
821 	/**
822 	 * another error occurred
823 	 */
824 	UNKNOWN = 3,
825 }
826 alias GIOError IOError;
827 
828 /**
829  * Specifies properties of a #GIOChannel. Some of the flags can only be
830  * read with g_io_channel_get_flags(), but not changed with
831  * g_io_channel_set_flags().
832  */
833 public enum GIOFlags
834 {
835 	/**
836 	 * turns on append mode, corresponds to %O_APPEND
837 	 * (see the documentation of the UNIX open() syscall)
838 	 */
839 	APPEND = 1,
840 	/**
841 	 * turns on nonblocking mode, corresponds to
842 	 * %O_NONBLOCK/%O_NDELAY (see the documentation of the UNIX open()
843 	 * syscall)
844 	 */
845 	NONBLOCK = 2,
846 	/**
847 	 * indicates that the io channel is readable.
848 	 * This flag cannot be changed.
849 	 */
850 	IS_READABLE = 4,
851 	/**
852 	 * indicates that the io channel is writable.
853 	 * This flag cannot be changed.
854 	 */
855 	IS_WRITABLE = 8,
856 	/**
857 	 * a misspelled version of @G_IO_FLAG_IS_WRITABLE
858 	 * that existed before the spelling was fixed in GLib 2.30. It is kept
859 	 * here for compatibility reasons. Deprecated since 2.30
860 	 */
861 	IS_WRITEABLE = 8,
862 	/**
863 	 * indicates that the io channel is seekable,
864 	 * i.e. that g_io_channel_seek_position() can be used on it.
865 	 * This flag cannot be changed.
866 	 */
867 	IS_SEEKABLE = 16,
868 	/**
869 	 * the mask that specifies all the valid flags.
870 	 */
871 	MASK = 31,
872 	/**
873 	 * the mask of the flags that are returned from
874 	 * g_io_channel_get_flags()
875 	 */
876 	GET_MASK = 31,
877 	/**
878 	 * the mask of the flags that the user can modify
879 	 * with g_io_channel_set_flags()
880 	 */
881 	SET_MASK = 3,
882 }
883 alias GIOFlags IOFlags;
884 
885 /**
886  * Stati returned by most of the #GIOFuncs functions.
887  */
888 public enum GIOStatus
889 {
890 	/**
891 	 * An error occurred.
892 	 */
893 	ERROR = 0,
894 	/**
895 	 * Success.
896 	 */
897 	NORMAL = 1,
898 	/**
899 	 * End of file.
900 	 */
901 	EOF = 2,
902 	/**
903 	 * Resource temporarily unavailable.
904 	 */
905 	AGAIN = 3,
906 }
907 alias GIOStatus IOStatus;
908 
909 /**
910  * Error codes returned by key file parsing.
911  */
912 public enum GKeyFileError
913 {
914 	/**
915 	 * the text being parsed was in
916 	 * an unknown encoding
917 	 */
918 	UNKNOWN_ENCODING = 0,
919 	/**
920 	 * document was ill-formed
921 	 */
922 	PARSE = 1,
923 	/**
924 	 * the file was not found
925 	 */
926 	NOT_FOUND = 2,
927 	/**
928 	 * a requested key was not found
929 	 */
930 	KEY_NOT_FOUND = 3,
931 	/**
932 	 * a requested group was not found
933 	 */
934 	GROUP_NOT_FOUND = 4,
935 	/**
936 	 * a value could not be parsed
937 	 */
938 	INVALID_VALUE = 5,
939 }
940 alias GKeyFileError KeyFileError;
941 
942 /**
943  * Flags which influence the parsing.
944  */
945 public enum GKeyFileFlags
946 {
947 	/**
948 	 * No flags, default behaviour
949 	 */
950 	NONE = 0,
951 	/**
952 	 * Use this flag if you plan to write the
953 	 * (possibly modified) contents of the key file back to a file;
954 	 * otherwise all comments will be lost when the key file is
955 	 * written back.
956 	 */
957 	KEEP_COMMENTS = 1,
958 	/**
959 	 * Use this flag if you plan to write the
960 	 * (possibly modified) contents of the key file back to a file;
961 	 * otherwise only the translations for the current language will be
962 	 * written back.
963 	 */
964 	KEEP_TRANSLATIONS = 2,
965 }
966 alias GKeyFileFlags KeyFileFlags;
967 
968 /**
969  * Flags specifying the level of log messages.
970  *
971  * It is possible to change how GLib treats messages of the various
972  * levels using g_log_set_handler() and g_log_set_fatal_mask().
973  */
974 public enum GLogLevelFlags
975 {
976 	/**
977 	 * internal flag
978 	 */
979 	FLAG_RECURSION = 1,
980 	/**
981 	 * internal flag
982 	 */
983 	FLAG_FATAL = 2,
984 	/**
985 	 * log level for errors, see g_error().
986 	 * This level is also used for messages produced by g_assert().
987 	 */
988 	LEVEL_ERROR = 4,
989 	/**
990 	 * log level for critical warning messages, see
991 	 * g_critical().
992 	 * This level is also used for messages produced by g_return_if_fail()
993 	 * and g_return_val_if_fail().
994 	 */
995 	LEVEL_CRITICAL = 8,
996 	/**
997 	 * log level for warnings, see g_warning()
998 	 */
999 	LEVEL_WARNING = 16,
1000 	/**
1001 	 * log level for messages, see g_message()
1002 	 */
1003 	LEVEL_MESSAGE = 32,
1004 	/**
1005 	 * log level for informational messages, see g_info()
1006 	 */
1007 	LEVEL_INFO = 64,
1008 	/**
1009 	 * log level for debug messages, see g_debug()
1010 	 */
1011 	LEVEL_DEBUG = 128,
1012 	/**
1013 	 * a mask including all log levels
1014 	 */
1015 	LEVEL_MASK = -4,
1016 }
1017 alias GLogLevelFlags LogLevelFlags;
1018 
1019 /**
1020  * Return values from #GLogWriterFuncs to indicate whether the given log entry
1021  * was successfully handled by the writer, or whether there was an error in
1022  * handling it (and hence a fallback writer should be used).
1023  *
1024  * If a #GLogWriterFunc ignores a log entry, it should return
1025  * %G_LOG_WRITER_HANDLED.
1026  *
1027  * Since: 2.50
1028  */
1029 public enum GLogWriterOutput
1030 {
1031 	/**
1032 	 * Log writer has handled the log entry.
1033 	 */
1034 	HANDLED = 1,
1035 	/**
1036 	 * Log writer could not handle the log entry.
1037 	 */
1038 	UNHANDLED = 0,
1039 }
1040 alias GLogWriterOutput LogWriterOutput;
1041 
1042 /**
1043  * A mixed enumerated type and flags field. You must specify one type
1044  * (string, strdup, boolean, tristate).  Additionally, you may  optionally
1045  * bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL.
1046  *
1047  * It is likely that this enum will be extended in the future to
1048  * support other types.
1049  */
1050 public enum GMarkupCollectType
1051 {
1052 	/**
1053 	 * used to terminate the list of attributes
1054 	 * to collect
1055 	 */
1056 	INVALID = 0,
1057 	/**
1058 	 * collect the string pointer directly from
1059 	 * the attribute_values[] array. Expects a parameter of type (const
1060 	 * char **). If %G_MARKUP_COLLECT_OPTIONAL is specified and the
1061 	 * attribute isn't present then the pointer will be set to %NULL
1062 	 */
1063 	STRING = 1,
1064 	/**
1065 	 * as with %G_MARKUP_COLLECT_STRING, but
1066 	 * expects a parameter of type (char **) and g_strdup()s the
1067 	 * returned pointer. The pointer must be freed with g_free()
1068 	 */
1069 	STRDUP = 2,
1070 	/**
1071 	 * expects a parameter of type (gboolean *)
1072 	 * and parses the attribute value as a boolean. Sets %FALSE if the
1073 	 * attribute isn't present. Valid boolean values consist of
1074 	 * (case-insensitive) "false", "f", "no", "n", "0" and "true", "t",
1075 	 * "yes", "y", "1"
1076 	 */
1077 	BOOLEAN = 3,
1078 	/**
1079 	 * as with %G_MARKUP_COLLECT_BOOLEAN, but
1080 	 * in the case of a missing attribute a value is set that compares
1081 	 * equal to neither %FALSE nor %TRUE G_MARKUP_COLLECT_OPTIONAL is
1082 	 * implied
1083 	 */
1084 	TRISTATE = 4,
1085 	/**
1086 	 * can be bitwise ORed with the other fields.
1087 	 * If present, allows the attribute not to appear. A default value
1088 	 * is set depending on what value type is used
1089 	 */
1090 	OPTIONAL = 65536,
1091 }
1092 alias GMarkupCollectType MarkupCollectType;
1093 
1094 /**
1095  * Error codes returned by markup parsing.
1096  */
1097 public enum GMarkupError
1098 {
1099 	/**
1100 	 * text being parsed was not valid UTF-8
1101 	 */
1102 	BAD_UTF8 = 0,
1103 	/**
1104 	 * document contained nothing, or only whitespace
1105 	 */
1106 	EMPTY = 1,
1107 	/**
1108 	 * document was ill-formed
1109 	 */
1110 	PARSE = 2,
1111 	/**
1112 	 * error should be set by #GMarkupParser
1113 	 * functions; element wasn't known
1114 	 */
1115 	UNKNOWN_ELEMENT = 3,
1116 	/**
1117 	 * error should be set by #GMarkupParser
1118 	 * functions; attribute wasn't known
1119 	 */
1120 	UNKNOWN_ATTRIBUTE = 4,
1121 	/**
1122 	 * error should be set by #GMarkupParser
1123 	 * functions; content was invalid
1124 	 */
1125 	INVALID_CONTENT = 5,
1126 	/**
1127 	 * error should be set by #GMarkupParser
1128 	 * functions; a required attribute was missing
1129 	 */
1130 	MISSING_ATTRIBUTE = 6,
1131 }
1132 alias GMarkupError MarkupError;
1133 
1134 /**
1135  * Flags that affect the behaviour of the parser.
1136  */
1137 public enum GMarkupParseFlags
1138 {
1139 	/**
1140 	 * flag you should not use
1141 	 */
1142 	DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1,
1143 	/**
1144 	 * When this flag is set, CDATA marked
1145 	 * sections are not passed literally to the @passthrough function of
1146 	 * the parser. Instead, the content of the section (without the
1147 	 * `<![CDATA[` and `]]>`) is
1148 	 * passed to the @text function. This flag was added in GLib 2.12
1149 	 */
1150 	TREAT_CDATA_AS_TEXT = 2,
1151 	/**
1152 	 * Normally errors caught by GMarkup
1153 	 * itself have line/column information prefixed to them to let the
1154 	 * caller know the location of the error. When this flag is set the
1155 	 * location information is also prefixed to errors generated by the
1156 	 * #GMarkupParser implementation functions
1157 	 */
1158 	PREFIX_ERROR_POSITION = 4,
1159 	/**
1160 	 * Ignore (don't report) qualified
1161 	 * attributes and tags, along with their contents.  A qualified
1162 	 * attribute or tag is one that contains ':' in its name (ie: is in
1163 	 * another namespace).  Since: 2.40.
1164 	 */
1165 	IGNORE_QUALIFIED = 8,
1166 }
1167 alias GMarkupParseFlags MarkupParseFlags;
1168 
1169 /**
1170  * Defines how a Unicode string is transformed in a canonical
1171  * form, standardizing such issues as whether a character with
1172  * an accent is represented as a base character and combining
1173  * accent or as a single precomposed character. Unicode strings
1174  * should generally be normalized before comparing them.
1175  */
1176 public enum GNormalizeMode
1177 {
1178 	/**
1179 	 * standardize differences that do not affect the
1180 	 * text content, such as the above-mentioned accent representation
1181 	 */
1182 	DEFAULT = 0,
1183 	/**
1184 	 * another name for %G_NORMALIZE_DEFAULT
1185 	 */
1186 	NFD = 0,
1187 	/**
1188 	 * like %G_NORMALIZE_DEFAULT, but with
1189 	 * composed forms rather than a maximally decomposed form
1190 	 */
1191 	DEFAULT_COMPOSE = 1,
1192 	/**
1193 	 * another name for %G_NORMALIZE_DEFAULT_COMPOSE
1194 	 */
1195 	NFC = 1,
1196 	/**
1197 	 * beyond %G_NORMALIZE_DEFAULT also standardize the
1198 	 * "compatibility" characters in Unicode, such as SUPERSCRIPT THREE
1199 	 * to the standard forms (in this case DIGIT THREE). Formatting
1200 	 * information may be lost but for most text operations such
1201 	 * characters should be considered the same
1202 	 */
1203 	ALL = 2,
1204 	/**
1205 	 * another name for %G_NORMALIZE_ALL
1206 	 */
1207 	NFKD = 2,
1208 	/**
1209 	 * like %G_NORMALIZE_ALL, but with composed
1210 	 * forms rather than a maximally decomposed form
1211 	 */
1212 	ALL_COMPOSE = 3,
1213 	/**
1214 	 * another name for %G_NORMALIZE_ALL_COMPOSE
1215 	 */
1216 	NFKC = 3,
1217 }
1218 alias GNormalizeMode NormalizeMode;
1219 
1220 /**
1221  * Error codes returned by functions converting a string to a number.
1222  *
1223  * Since: 2.54
1224  */
1225 public enum GNumberParserError
1226 {
1227 	/**
1228 	 * String was not a valid number.
1229 	 */
1230 	INVALID = 0,
1231 	/**
1232 	 * String was a number, but out of bounds.
1233 	 */
1234 	OUT_OF_BOUNDS = 1,
1235 }
1236 alias GNumberParserError NumberParserError;
1237 
1238 /**
1239  * The possible statuses of a one-time initialization function
1240  * controlled by a #GOnce struct.
1241  *
1242  * Since: 2.4
1243  */
1244 public enum GOnceStatus
1245 {
1246 	/**
1247 	 * the function has not been called yet.
1248 	 */
1249 	NOTCALLED = 0,
1250 	/**
1251 	 * the function call is currently in progress.
1252 	 */
1253 	PROGRESS = 1,
1254 	/**
1255 	 * the function has been called.
1256 	 */
1257 	READY = 2,
1258 }
1259 alias GOnceStatus OnceStatus;
1260 
1261 /**
1262  * The #GOptionArg enum values determine which type of extra argument the
1263  * options expect to find. If an option expects an extra argument, it can
1264  * be specified in several ways; with a short option: `-x arg`, with a long
1265  * option: `--name arg` or combined in a single argument: `--name=arg`.
1266  */
1267 public enum GOptionArg
1268 {
1269 	/**
1270 	 * No extra argument. This is useful for simple flags.
1271 	 */
1272 	NONE = 0,
1273 	/**
1274 	 * The option takes a string argument.
1275 	 */
1276 	STRING = 1,
1277 	/**
1278 	 * The option takes an integer argument.
1279 	 */
1280 	INT = 2,
1281 	/**
1282 	 * The option provides a callback (of type
1283 	 * #GOptionArgFunc) to parse the extra argument.
1284 	 */
1285 	CALLBACK = 3,
1286 	/**
1287 	 * The option takes a filename as argument.
1288 	 */
1289 	FILENAME = 4,
1290 	/**
1291 	 * The option takes a string argument, multiple
1292 	 * uses of the option are collected into an array of strings.
1293 	 */
1294 	STRING_ARRAY = 5,
1295 	/**
1296 	 * The option takes a filename as argument,
1297 	 * multiple uses of the option are collected into an array of strings.
1298 	 */
1299 	FILENAME_ARRAY = 6,
1300 	/**
1301 	 * The option takes a double argument. The argument
1302 	 * can be formatted either for the user's locale or for the "C" locale.
1303 	 * Since 2.12
1304 	 */
1305 	DOUBLE = 7,
1306 	/**
1307 	 * The option takes a 64-bit integer. Like
1308 	 * %G_OPTION_ARG_INT but for larger numbers. The number can be in
1309 	 * decimal base, or in hexadecimal (when prefixed with `0x`, for
1310 	 * example, `0xffffffff`). Since 2.12
1311 	 */
1312 	INT64 = 8,
1313 }
1314 alias GOptionArg OptionArg;
1315 
1316 /**
1317  * Error codes returned by option parsing.
1318  */
1319 public enum GOptionError
1320 {
1321 	/**
1322 	 * An option was not known to the parser.
1323 	 * This error will only be reported, if the parser hasn't been instructed
1324 	 * to ignore unknown options, see g_option_context_set_ignore_unknown_options().
1325 	 */
1326 	UNKNOWN_OPTION = 0,
1327 	/**
1328 	 * A value couldn't be parsed.
1329 	 */
1330 	BAD_VALUE = 1,
1331 	/**
1332 	 * A #GOptionArgFunc callback failed.
1333 	 */
1334 	FAILED = 2,
1335 }
1336 alias GOptionError OptionError;
1337 
1338 /**
1339  * Flags which modify individual options.
1340  */
1341 public enum GOptionFlags
1342 {
1343 	/**
1344 	 * No flags. Since: 2.42.
1345 	 */
1346 	NONE = 0,
1347 	/**
1348 	 * The option doesn't appear in `--help` output.
1349 	 */
1350 	HIDDEN = 1,
1351 	/**
1352 	 * The option appears in the main section of the
1353 	 * `--help` output, even if it is defined in a group.
1354 	 */
1355 	IN_MAIN = 2,
1356 	/**
1357 	 * For options of the %G_OPTION_ARG_NONE kind, this
1358 	 * flag indicates that the sense of the option is reversed.
1359 	 */
1360 	REVERSE = 4,
1361 	/**
1362 	 * For options of the %G_OPTION_ARG_CALLBACK kind,
1363 	 * this flag indicates that the callback does not take any argument
1364 	 * (like a %G_OPTION_ARG_NONE option). Since 2.8
1365 	 */
1366 	NO_ARG = 8,
1367 	/**
1368 	 * For options of the %G_OPTION_ARG_CALLBACK
1369 	 * kind, this flag indicates that the argument should be passed to the
1370 	 * callback in the GLib filename encoding rather than UTF-8. Since 2.8
1371 	 */
1372 	FILENAME = 16,
1373 	/**
1374 	 * For options of the %G_OPTION_ARG_CALLBACK
1375 	 * kind, this flag indicates that the argument supply is optional.
1376 	 * If no argument is given then data of %GOptionParseFunc will be
1377 	 * set to NULL. Since 2.8
1378 	 */
1379 	OPTIONAL_ARG = 32,
1380 	/**
1381 	 * This flag turns off the automatic conflict
1382 	 * resolution which prefixes long option names with `groupname-` if
1383 	 * there is a conflict. This option should only be used in situations
1384 	 * where aliasing is necessary to model some legacy commandline interface.
1385 	 * It is not safe to use this option, unless all option groups are under
1386 	 * your direct control. Since 2.8.
1387 	 */
1388 	NOALIAS = 64,
1389 }
1390 alias GOptionFlags OptionFlags;
1391 
1392 /**
1393  * Flags specifying compile-time options.
1394  *
1395  * Since: 2.14
1396  */
1397 public enum GRegexCompileFlags
1398 {
1399 	/**
1400 	 * Letters in the pattern match both upper- and
1401 	 * lowercase letters. This option can be changed within a pattern
1402 	 * by a "(?i)" option setting.
1403 	 */
1404 	CASELESS = 1,
1405 	/**
1406 	 * By default, GRegex treats the strings as consisting
1407 	 * of a single line of characters (even if it actually contains
1408 	 * newlines). The "start of line" metacharacter ("^") matches only
1409 	 * at the start of the string, while the "end of line" metacharacter
1410 	 * ("$") matches only at the end of the string, or before a terminating
1411 	 * newline (unless #G_REGEX_DOLLAR_ENDONLY is set). When
1412 	 * #G_REGEX_MULTILINE is set, the "start of line" and "end of line"
1413 	 * constructs match immediately following or immediately before any
1414 	 * newline in the string, respectively, as well as at the very start
1415 	 * and end. This can be changed within a pattern by a "(?m)" option
1416 	 * setting.
1417 	 */
1418 	MULTILINE = 2,
1419 	/**
1420 	 * A dot metacharacter (".") in the pattern matches all
1421 	 * characters, including newlines. Without it, newlines are excluded.
1422 	 * This option can be changed within a pattern by a ("?s") option setting.
1423 	 */
1424 	DOTALL = 4,
1425 	/**
1426 	 * Whitespace data characters in the pattern are
1427 	 * totally ignored except when escaped or inside a character class.
1428 	 * Whitespace does not include the VT character (code 11). In addition,
1429 	 * characters between an unescaped "#" outside a character class and
1430 	 * the next newline character, inclusive, are also ignored. This can
1431 	 * be changed within a pattern by a "(?x)" option setting.
1432 	 */
1433 	EXTENDED = 8,
1434 	/**
1435 	 * The pattern is forced to be "anchored", that is,
1436 	 * it is constrained to match only at the first matching point in the
1437 	 * string that is being searched. This effect can also be achieved by
1438 	 * appropriate constructs in the pattern itself such as the "^"
1439 	 * metacharacter.
1440 	 */
1441 	ANCHORED = 16,
1442 	/**
1443 	 * A dollar metacharacter ("$") in the pattern
1444 	 * matches only at the end of the string. Without this option, a
1445 	 * dollar also matches immediately before the final character if
1446 	 * it is a newline (but not before any other newlines). This option
1447 	 * is ignored if #G_REGEX_MULTILINE is set.
1448 	 */
1449 	DOLLAR_ENDONLY = 32,
1450 	/**
1451 	 * Inverts the "greediness" of the quantifiers so that
1452 	 * they are not greedy by default, but become greedy if followed by "?".
1453 	 * It can also be set by a "(?U)" option setting within the pattern.
1454 	 */
1455 	UNGREEDY = 512,
1456 	/**
1457 	 * Usually strings must be valid UTF-8 strings, using this
1458 	 * flag they are considered as a raw sequence of bytes.
1459 	 */
1460 	RAW = 2048,
1461 	/**
1462 	 * Disables the use of numbered capturing
1463 	 * parentheses in the pattern. Any opening parenthesis that is not
1464 	 * followed by "?" behaves as if it were followed by "?:" but named
1465 	 * parentheses can still be used for capturing (and they acquire numbers
1466 	 * in the usual way).
1467 	 */
1468 	NO_AUTO_CAPTURE = 4096,
1469 	/**
1470 	 * Optimize the regular expression. If the pattern will
1471 	 * be used many times, then it may be worth the effort to optimize it
1472 	 * to improve the speed of matches.
1473 	 */
1474 	OPTIMIZE = 8192,
1475 	/**
1476 	 * Limits an unanchored pattern to match before (or at) the
1477 	 * first newline. Since: 2.34
1478 	 */
1479 	FIRSTLINE = 262144,
1480 	/**
1481 	 * Names used to identify capturing subpatterns need not
1482 	 * be unique. This can be helpful for certain types of pattern when it
1483 	 * is known that only one instance of the named subpattern can ever be
1484 	 * matched.
1485 	 */
1486 	DUPNAMES = 524288,
1487 	/**
1488 	 * Usually any newline character or character sequence is
1489 	 * recognized. If this option is set, the only recognized newline character
1490 	 * is '\r'.
1491 	 */
1492 	NEWLINE_CR = 1048576,
1493 	/**
1494 	 * Usually any newline character or character sequence is
1495 	 * recognized. If this option is set, the only recognized newline character
1496 	 * is '\n'.
1497 	 */
1498 	NEWLINE_LF = 2097152,
1499 	/**
1500 	 * Usually any newline character or character sequence is
1501 	 * recognized. If this option is set, the only recognized newline character
1502 	 * sequence is '\r\n'.
1503 	 */
1504 	NEWLINE_CRLF = 3145728,
1505 	/**
1506 	 * Usually any newline character or character sequence
1507 	 * is recognized. If this option is set, the only recognized newline character
1508 	 * sequences are '\r', '\n', and '\r\n'. Since: 2.34
1509 	 */
1510 	NEWLINE_ANYCRLF = 5242880,
1511 	/**
1512 	 * Usually any newline character or character sequence
1513 	 * is recognised. If this option is set, then "\R" only recognizes the newline
1514 	 * characters '\r', '\n' and '\r\n'. Since: 2.34
1515 	 */
1516 	BSR_ANYCRLF = 8388608,
1517 	/**
1518 	 * Changes behaviour so that it is compatible with
1519 	 * JavaScript rather than PCRE. Since: 2.34
1520 	 */
1521 	JAVASCRIPT_COMPAT = 33554432,
1522 }
1523 alias GRegexCompileFlags RegexCompileFlags;
1524 
1525 /**
1526  * Error codes returned by regular expressions functions.
1527  *
1528  * Since: 2.14
1529  */
1530 public enum GRegexError
1531 {
1532 	/**
1533 	 * Compilation of the regular expression failed.
1534 	 */
1535 	COMPILE = 0,
1536 	/**
1537 	 * Optimization of the regular expression failed.
1538 	 */
1539 	OPTIMIZE = 1,
1540 	/**
1541 	 * Replacement failed due to an ill-formed replacement
1542 	 * string.
1543 	 */
1544 	REPLACE = 2,
1545 	/**
1546 	 * The match process failed.
1547 	 */
1548 	MATCH = 3,
1549 	/**
1550 	 * Internal error of the regular expression engine.
1551 	 * Since 2.16
1552 	 */
1553 	INTERNAL = 4,
1554 	/**
1555 	 * "\\" at end of pattern. Since 2.16
1556 	 */
1557 	STRAY_BACKSLASH = 101,
1558 	/**
1559 	 * "\\c" at end of pattern. Since 2.16
1560 	 */
1561 	MISSING_CONTROL_CHAR = 102,
1562 	/**
1563 	 * Unrecognized character follows "\\".
1564 	 * Since 2.16
1565 	 */
1566 	UNRECOGNIZED_ESCAPE = 103,
1567 	/**
1568 	 * Numbers out of order in "{}"
1569 	 * quantifier. Since 2.16
1570 	 */
1571 	QUANTIFIERS_OUT_OF_ORDER = 104,
1572 	/**
1573 	 * Number too big in "{}" quantifier.
1574 	 * Since 2.16
1575 	 */
1576 	QUANTIFIER_TOO_BIG = 105,
1577 	/**
1578 	 * Missing terminating "]" for
1579 	 * character class. Since 2.16
1580 	 */
1581 	UNTERMINATED_CHARACTER_CLASS = 106,
1582 	/**
1583 	 * Invalid escape sequence
1584 	 * in character class. Since 2.16
1585 	 */
1586 	INVALID_ESCAPE_IN_CHARACTER_CLASS = 107,
1587 	/**
1588 	 * Range out of order in character class.
1589 	 * Since 2.16
1590 	 */
1591 	RANGE_OUT_OF_ORDER = 108,
1592 	/**
1593 	 * Nothing to repeat. Since 2.16
1594 	 */
1595 	NOTHING_TO_REPEAT = 109,
1596 	/**
1597 	 * Unrecognized character after "(?",
1598 	 * "(?<" or "(?P". Since 2.16
1599 	 */
1600 	UNRECOGNIZED_CHARACTER = 112,
1601 	/**
1602 	 * POSIX named classes are
1603 	 * supported only within a class. Since 2.16
1604 	 */
1605 	POSIX_NAMED_CLASS_OUTSIDE_CLASS = 113,
1606 	/**
1607 	 * Missing terminating ")" or ")"
1608 	 * without opening "(". Since 2.16
1609 	 */
1610 	UNMATCHED_PARENTHESIS = 114,
1611 	/**
1612 	 * Reference to non-existent
1613 	 * subpattern. Since 2.16
1614 	 */
1615 	INEXISTENT_SUBPATTERN_REFERENCE = 115,
1616 	/**
1617 	 * Missing terminating ")" after comment.
1618 	 * Since 2.16
1619 	 */
1620 	UNTERMINATED_COMMENT = 118,
1621 	/**
1622 	 * Regular expression too large.
1623 	 * Since 2.16
1624 	 */
1625 	EXPRESSION_TOO_LARGE = 120,
1626 	/**
1627 	 * Failed to get memory. Since 2.16
1628 	 */
1629 	MEMORY_ERROR = 121,
1630 	/**
1631 	 * Lookbehind assertion is not
1632 	 * fixed length. Since 2.16
1633 	 */
1634 	VARIABLE_LENGTH_LOOKBEHIND = 125,
1635 	/**
1636 	 * Malformed number or name after "(?(".
1637 	 * Since 2.16
1638 	 */
1639 	MALFORMED_CONDITION = 126,
1640 	/**
1641 	 * Conditional group contains
1642 	 * more than two branches. Since 2.16
1643 	 */
1644 	TOO_MANY_CONDITIONAL_BRANCHES = 127,
1645 	/**
1646 	 * Assertion expected after "(?(".
1647 	 * Since 2.16
1648 	 */
1649 	ASSERTION_EXPECTED = 128,
1650 	/**
1651 	 * Unknown POSIX class name.
1652 	 * Since 2.16
1653 	 */
1654 	UNKNOWN_POSIX_CLASS_NAME = 130,
1655 	/**
1656 	 * POSIX collating
1657 	 * elements are not supported. Since 2.16
1658 	 */
1659 	POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED = 131,
1660 	/**
1661 	 * Character value in "\\x{...}" sequence
1662 	 * is too large. Since 2.16
1663 	 */
1664 	HEX_CODE_TOO_LARGE = 134,
1665 	/**
1666 	 * Invalid condition "(?(0)". Since 2.16
1667 	 */
1668 	INVALID_CONDITION = 135,
1669 	/**
1670 	 * \\C not allowed in
1671 	 * lookbehind assertion. Since 2.16
1672 	 */
1673 	SINGLE_BYTE_MATCH_IN_LOOKBEHIND = 136,
1674 	/**
1675 	 * Recursive call could loop indefinitely.
1676 	 * Since 2.16
1677 	 */
1678 	INFINITE_LOOP = 140,
1679 	/**
1680 	 * Missing terminator
1681 	 * in subpattern name. Since 2.16
1682 	 */
1683 	MISSING_SUBPATTERN_NAME_TERMINATOR = 142,
1684 	/**
1685 	 * Two named subpatterns have
1686 	 * the same name. Since 2.16
1687 	 */
1688 	DUPLICATE_SUBPATTERN_NAME = 143,
1689 	/**
1690 	 * Malformed "\\P" or "\\p" sequence.
1691 	 * Since 2.16
1692 	 */
1693 	MALFORMED_PROPERTY = 146,
1694 	/**
1695 	 * Unknown property name after "\\P" or
1696 	 * "\\p". Since 2.16
1697 	 */
1698 	UNKNOWN_PROPERTY = 147,
1699 	/**
1700 	 * Subpattern name is too long
1701 	 * (maximum 32 characters). Since 2.16
1702 	 */
1703 	SUBPATTERN_NAME_TOO_LONG = 148,
1704 	/**
1705 	 * Too many named subpatterns (maximum
1706 	 * 10,000). Since 2.16
1707 	 */
1708 	TOO_MANY_SUBPATTERNS = 149,
1709 	/**
1710 	 * Octal value is greater than "\\377".
1711 	 * Since 2.16
1712 	 */
1713 	INVALID_OCTAL_VALUE = 151,
1714 	/**
1715 	 * "DEFINE" group contains more
1716 	 * than one branch. Since 2.16
1717 	 */
1718 	TOO_MANY_BRANCHES_IN_DEFINE = 154,
1719 	/**
1720 	 * Repeating a "DEFINE" group is not allowed.
1721 	 * This error is never raised. Since: 2.16 Deprecated: 2.34
1722 	 */
1723 	DEFINE_REPETION = 155,
1724 	/**
1725 	 * Inconsistent newline options.
1726 	 * Since 2.16
1727 	 */
1728 	INCONSISTENT_NEWLINE_OPTIONS = 156,
1729 	/**
1730 	 * "\\g" is not followed by a braced,
1731 	 * angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16
1732 	 */
1733 	MISSING_BACK_REFERENCE = 157,
1734 	/**
1735 	 * relative reference must not be zero. Since: 2.34
1736 	 */
1737 	INVALID_RELATIVE_REFERENCE = 158,
1738 	/**
1739 	 * the backtracing
1740 	 * control verb used does not allow an argument. Since: 2.34
1741 	 */
1742 	BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN = 159,
1743 	/**
1744 	 * unknown backtracing
1745 	 * control verb. Since: 2.34
1746 	 */
1747 	UNKNOWN_BACKTRACKING_CONTROL_VERB = 160,
1748 	/**
1749 	 * number is too big in escape sequence. Since: 2.34
1750 	 */
1751 	NUMBER_TOO_BIG = 161,
1752 	/**
1753 	 * Missing subpattern name. Since: 2.34
1754 	 */
1755 	MISSING_SUBPATTERN_NAME = 162,
1756 	/**
1757 	 * Missing digit. Since 2.34
1758 	 */
1759 	MISSING_DIGIT = 163,
1760 	/**
1761 	 * In JavaScript compatibility mode,
1762 	 * "[" is an invalid data character. Since: 2.34
1763 	 */
1764 	INVALID_DATA_CHARACTER = 164,
1765 	/**
1766 	 * different names for subpatterns of the
1767 	 * same number are not allowed. Since: 2.34
1768 	 */
1769 	EXTRA_SUBPATTERN_NAME = 165,
1770 	/**
1771 	 * the backtracing control
1772 	 * verb requires an argument. Since: 2.34
1773 	 */
1774 	BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED = 166,
1775 	/**
1776 	 * "\\c" must be followed by an ASCII
1777 	 * character. Since: 2.34
1778 	 */
1779 	INVALID_CONTROL_CHAR = 168,
1780 	/**
1781 	 * "\\k" is not followed by a braced, angle-bracketed, or
1782 	 * quoted name. Since: 2.34
1783 	 */
1784 	MISSING_NAME = 169,
1785 	/**
1786 	 * "\\N" is not supported in a class. Since: 2.34
1787 	 */
1788 	NOT_SUPPORTED_IN_CLASS = 171,
1789 	/**
1790 	 * too many forward references. Since: 2.34
1791 	 */
1792 	TOO_MANY_FORWARD_REFERENCES = 172,
1793 	/**
1794 	 * the name is too long in "(*MARK)", "(*PRUNE)",
1795 	 * "(*SKIP)", or "(*THEN)". Since: 2.34
1796 	 */
1797 	NAME_TOO_LONG = 175,
1798 	/**
1799 	 * the character value in the \\u sequence is
1800 	 * too large. Since: 2.34
1801 	 */
1802 	CHARACTER_VALUE_TOO_LARGE = 176,
1803 }
1804 alias GRegexError RegexError;
1805 
1806 /**
1807  * Flags specifying match-time options.
1808  *
1809  * Since: 2.14
1810  */
1811 public enum GRegexMatchFlags
1812 {
1813 	/**
1814 	 * The pattern is forced to be "anchored", that is,
1815 	 * it is constrained to match only at the first matching point in the
1816 	 * string that is being searched. This effect can also be achieved by
1817 	 * appropriate constructs in the pattern itself such as the "^"
1818 	 * metacharacter.
1819 	 */
1820 	ANCHORED = 16,
1821 	/**
1822 	 * Specifies that first character of the string is
1823 	 * not the beginning of a line, so the circumflex metacharacter should
1824 	 * not match before it. Setting this without #G_REGEX_MULTILINE (at
1825 	 * compile time) causes circumflex never to match. This option affects
1826 	 * only the behaviour of the circumflex metacharacter, it does not
1827 	 * affect "\A".
1828 	 */
1829 	NOTBOL = 128,
1830 	/**
1831 	 * Specifies that the end of the subject string is
1832 	 * not the end of a line, so the dollar metacharacter should not match
1833 	 * it nor (except in multiline mode) a newline immediately before it.
1834 	 * Setting this without #G_REGEX_MULTILINE (at compile time) causes
1835 	 * dollar never to match. This option affects only the behaviour of
1836 	 * the dollar metacharacter, it does not affect "\Z" or "\z".
1837 	 */
1838 	NOTEOL = 256,
1839 	/**
1840 	 * An empty string is not considered to be a valid
1841 	 * match if this option is set. If there are alternatives in the pattern,
1842 	 * they are tried. If all the alternatives match the empty string, the
1843 	 * entire match fails. For example, if the pattern "a?b?" is applied to
1844 	 * a string not beginning with "a" or "b", it matches the empty string
1845 	 * at the start of the string. With this flag set, this match is not
1846 	 * valid, so GRegex searches further into the string for occurrences
1847 	 * of "a" or "b".
1848 	 */
1849 	NOTEMPTY = 1024,
1850 	/**
1851 	 * Turns on the partial matching feature, for more
1852 	 * documentation on partial matching see g_match_info_is_partial_match().
1853 	 */
1854 	PARTIAL = 32768,
1855 	/**
1856 	 * Overrides the newline definition set when
1857 	 * creating a new #GRegex, setting the '\r' character as line terminator.
1858 	 */
1859 	NEWLINE_CR = 1048576,
1860 	/**
1861 	 * Overrides the newline definition set when
1862 	 * creating a new #GRegex, setting the '\n' character as line terminator.
1863 	 */
1864 	NEWLINE_LF = 2097152,
1865 	/**
1866 	 * Overrides the newline definition set when
1867 	 * creating a new #GRegex, setting the '\r\n' characters sequence as line terminator.
1868 	 */
1869 	NEWLINE_CRLF = 3145728,
1870 	/**
1871 	 * Overrides the newline definition set when
1872 	 * creating a new #GRegex, any Unicode newline sequence
1873 	 * is recognised as a newline. These are '\r', '\n' and '\rn', and the
1874 	 * single characters U+000B LINE TABULATION, U+000C FORM FEED (FF),
1875 	 * U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and
1876 	 * U+2029 PARAGRAPH SEPARATOR.
1877 	 */
1878 	NEWLINE_ANY = 4194304,
1879 	/**
1880 	 * Overrides the newline definition set when
1881 	 * creating a new #GRegex; any '\r', '\n', or '\r\n' character sequence
1882 	 * is recognized as a newline. Since: 2.34
1883 	 */
1884 	NEWLINE_ANYCRLF = 5242880,
1885 	/**
1886 	 * Overrides the newline definition for "\R" set when
1887 	 * creating a new #GRegex; only '\r', '\n', or '\r\n' character sequences
1888 	 * are recognized as a newline by "\R". Since: 2.34
1889 	 */
1890 	BSR_ANYCRLF = 8388608,
1891 	/**
1892 	 * Overrides the newline definition for "\R" set when
1893 	 * creating a new #GRegex; any Unicode newline character or character sequence
1894 	 * are recognized as a newline by "\R". These are '\r', '\n' and '\rn', and the
1895 	 * single characters U+000B LINE TABULATION, U+000C FORM FEED (FF),
1896 	 * U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and
1897 	 * U+2029 PARAGRAPH SEPARATOR. Since: 2.34
1898 	 */
1899 	BSR_ANY = 16777216,
1900 	/**
1901 	 * An alias for #G_REGEX_MATCH_PARTIAL. Since: 2.34
1902 	 */
1903 	PARTIAL_SOFT = 32768,
1904 	/**
1905 	 * Turns on the partial matching feature. In contrast to
1906 	 * to #G_REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match
1907 	 * is found, without continuing to search for a possible complete match. See
1908 	 * g_match_info_is_partial_match() for more information. Since: 2.34
1909 	 */
1910 	PARTIAL_HARD = 134217728,
1911 	/**
1912 	 * Like #G_REGEX_MATCH_NOTEMPTY, but only applied to
1913 	 * the start of the matched string. For anchored
1914 	 * patterns this can only happen for pattern containing "\K". Since: 2.34
1915 	 */
1916 	NOTEMPTY_ATSTART = 268435456,
1917 }
1918 alias GRegexMatchFlags RegexMatchFlags;
1919 
1920 /**
1921  * An enumeration specifying the base position for a
1922  * g_io_channel_seek_position() operation.
1923  */
1924 public enum GSeekType
1925 {
1926 	/**
1927 	 * the current position in the file.
1928 	 */
1929 	CUR = 0,
1930 	/**
1931 	 * the start of the file.
1932 	 */
1933 	SET = 1,
1934 	/**
1935 	 * the end of the file.
1936 	 */
1937 	END = 2,
1938 }
1939 alias GSeekType SeekType;
1940 
1941 /**
1942  * Error codes returned by shell functions.
1943  */
1944 public enum GShellError
1945 {
1946 	/**
1947 	 * Mismatched or otherwise mangled quoting.
1948 	 */
1949 	BAD_QUOTING = 0,
1950 	/**
1951 	 * String to be parsed was empty.
1952 	 */
1953 	EMPTY_STRING = 1,
1954 	/**
1955 	 * Some other error.
1956 	 */
1957 	FAILED = 2,
1958 }
1959 alias GShellError ShellError;
1960 
1961 public enum GSliceConfig
1962 {
1963 	ALWAYS_MALLOC = 1,
1964 	BYPASS_MAGAZINES = 2,
1965 	WORKING_SET_MSECS = 3,
1966 	COLOR_INCREMENT = 4,
1967 	CHUNK_SIZES = 5,
1968 	CONTENTION_COUNTER = 6,
1969 }
1970 alias GSliceConfig SliceConfig;
1971 
1972 /**
1973  * Error codes returned by spawning processes.
1974  */
1975 public enum GSpawnError
1976 {
1977 	/**
1978 	 * Fork failed due to lack of memory.
1979 	 */
1980 	FORK = 0,
1981 	/**
1982 	 * Read or select on pipes failed.
1983 	 */
1984 	READ = 1,
1985 	/**
1986 	 * Changing to working directory failed.
1987 	 */
1988 	CHDIR = 2,
1989 	/**
1990 	 * execv() returned `EACCES`
1991 	 */
1992 	ACCES = 3,
1993 	/**
1994 	 * execv() returned `EPERM`
1995 	 */
1996 	PERM = 4,
1997 	/**
1998 	 * execv() returned `E2BIG`
1999 	 */
2000 	TOO_BIG = 5,
2001 	/**
2002 	 * execv() returned `ENOEXEC`
2003 	 */
2004 	NOEXEC = 6,
2005 	/**
2006 	 * execv() returned `ENAMETOOLONG`
2007 	 */
2008 	NAMETOOLONG = 7,
2009 	/**
2010 	 * execv() returned `ENOENT`
2011 	 */
2012 	NOENT = 8,
2013 	/**
2014 	 * execv() returned `ENOMEM`
2015 	 */
2016 	NOMEM = 9,
2017 	/**
2018 	 * execv() returned `ENOTDIR`
2019 	 */
2020 	NOTDIR = 10,
2021 	/**
2022 	 * execv() returned `ELOOP`
2023 	 */
2024 	LOOP = 11,
2025 	/**
2026 	 * execv() returned `ETXTBUSY`
2027 	 */
2028 	TXTBUSY = 12,
2029 	/**
2030 	 * execv() returned `EIO`
2031 	 */
2032 	IO = 13,
2033 	/**
2034 	 * execv() returned `ENFILE`
2035 	 */
2036 	NFILE = 14,
2037 	/**
2038 	 * execv() returned `EMFILE`
2039 	 */
2040 	MFILE = 15,
2041 	/**
2042 	 * execv() returned `EINVAL`
2043 	 */
2044 	INVAL = 16,
2045 	/**
2046 	 * execv() returned `EISDIR`
2047 	 */
2048 	ISDIR = 17,
2049 	/**
2050 	 * execv() returned `ELIBBAD`
2051 	 */
2052 	LIBBAD = 18,
2053 	/**
2054 	 * Some other fatal failure,
2055 	 * `error->message` should explain.
2056 	 */
2057 	FAILED = 19,
2058 }
2059 alias GSpawnError SpawnError;
2060 
2061 /**
2062  * Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().
2063  */
2064 public enum GSpawnFlags
2065 {
2066 	/**
2067 	 * no flags, default behaviour
2068 	 */
2069 	DEFAULT = 0,
2070 	/**
2071 	 * the parent's open file descriptors will
2072 	 * be inherited by the child; otherwise all descriptors except stdin,
2073 	 * stdout and stderr will be closed before calling exec() in the child.
2074 	 */
2075 	LEAVE_DESCRIPTORS_OPEN = 1,
2076 	/**
2077 	 * the child will not be automatically reaped;
2078 	 * you must use g_child_watch_add() yourself (or call waitpid() or handle
2079 	 * `SIGCHLD` yourself), or the child will become a zombie.
2080 	 */
2081 	DO_NOT_REAP_CHILD = 2,
2082 	/**
2083 	 * `argv[0]` need not be an absolute path, it will be
2084 	 * looked for in the user's `PATH`.
2085 	 */
2086 	SEARCH_PATH = 4,
2087 	/**
2088 	 * the child's standard output will be discarded,
2089 	 * instead of going to the same location as the parent's standard output.
2090 	 */
2091 	STDOUT_TO_DEV_NULL = 8,
2092 	/**
2093 	 * the child's standard error will be discarded.
2094 	 */
2095 	STDERR_TO_DEV_NULL = 16,
2096 	/**
2097 	 * the child will inherit the parent's standard
2098 	 * input (by default, the child's standard input is attached to `/dev/null`).
2099 	 */
2100 	CHILD_INHERITS_STDIN = 32,
2101 	/**
2102 	 * the first element of `argv` is the file to
2103 	 * execute, while the remaining elements are the actual argument vector
2104 	 * to pass to the file. Normally g_spawn_async_with_pipes() uses `argv[0]`
2105 	 * as the file to execute, and passes all of `argv` to the child.
2106 	 */
2107 	FILE_AND_ARGV_ZERO = 64,
2108 	/**
2109 	 * if `argv[0]` is not an abolute path,
2110 	 * it will be looked for in the `PATH` from the passed child environment.
2111 	 * Since: 2.34
2112 	 */
2113 	SEARCH_PATH_FROM_ENVP = 128,
2114 	/**
2115 	 * create all pipes with the `O_CLOEXEC` flag set.
2116 	 * Since: 2.40
2117 	 */
2118 	CLOEXEC_PIPES = 256,
2119 }
2120 alias GSpawnFlags SpawnFlags;
2121 
2122 /**
2123  * The type of file to return the filename for, when used with
2124  * g_test_build_filename().
2125  *
2126  * These two options correspond rather directly to the 'dist' and
2127  * 'built' terminology that automake uses and are explicitly used to
2128  * distinguish between the 'srcdir' and 'builddir' being separate.  All
2129  * files in your project should either be dist (in the
2130  * `EXTRA_DIST` or `dist_schema_DATA`
2131  * sense, in which case they will always be in the srcdir) or built (in
2132  * the `BUILT_SOURCES` sense, in which case they will
2133  * always be in the builddir).
2134  *
2135  * Note: as a general rule of automake, files that are generated only as
2136  * part of the build-from-git process (but then are distributed with the
2137  * tarball) always go in srcdir (even if doing a srcdir != builddir
2138  * build from git) and are considered as distributed files.
2139  *
2140  * Since: 2.38
2141  */
2142 public enum GTestFileType
2143 {
2144 	/**
2145 	 * a file that was included in the distribution tarball
2146 	 */
2147 	DIST = 0,
2148 	/**
2149 	 * a file that was built on the compiling machine
2150 	 */
2151 	BUILT = 1,
2152 }
2153 alias GTestFileType TestFileType;
2154 
2155 public enum GTestLogType
2156 {
2157 	NONE = 0,
2158 	ERROR = 1,
2159 	START_BINARY = 2,
2160 	LIST_CASE = 3,
2161 	SKIP_CASE = 4,
2162 	START_CASE = 5,
2163 	STOP_CASE = 6,
2164 	MIN_RESULT = 7,
2165 	MAX_RESULT = 8,
2166 	MESSAGE = 9,
2167 	START_SUITE = 10,
2168 	STOP_SUITE = 11,
2169 }
2170 alias GTestLogType TestLogType;
2171 
2172 public enum GTestResult
2173 {
2174 	SUCCESS = 0,
2175 	SKIPPED = 1,
2176 	FAILURE = 2,
2177 	INCOMPLETE = 3,
2178 }
2179 alias GTestResult TestResult;
2180 
2181 /**
2182  * Flags to pass to g_test_trap_subprocess() to control input and output.
2183  *
2184  * Note that in contrast with g_test_trap_fork(), the default is to
2185  * not show stdout and stderr.
2186  */
2187 public enum GTestSubprocessFlags
2188 {
2189 	/**
2190 	 * If this flag is given, the child
2191 	 * process will inherit the parent's stdin. Otherwise, the child's
2192 	 * stdin is redirected to `/dev/null`.
2193 	 */
2194 	STDIN = 1,
2195 	/**
2196 	 * If this flag is given, the child
2197 	 * process will inherit the parent's stdout. Otherwise, the child's
2198 	 * stdout will not be visible, but it will be captured to allow
2199 	 * later tests with g_test_trap_assert_stdout().
2200 	 */
2201 	STDOUT = 2,
2202 	/**
2203 	 * If this flag is given, the child
2204 	 * process will inherit the parent's stderr. Otherwise, the child's
2205 	 * stderr will not be visible, but it will be captured to allow
2206 	 * later tests with g_test_trap_assert_stderr().
2207 	 */
2208 	STDERR = 4,
2209 }
2210 alias GTestSubprocessFlags TestSubprocessFlags;
2211 
2212 /**
2213  * Test traps are guards around forked tests.
2214  * These flags determine what traps to set.
2215  *
2216  * Deprecated: #GTestTrapFlags is used only with g_test_trap_fork(),
2217  * which is deprecated. g_test_trap_subprocess() uses
2218  * #GTestSubprocessFlags.
2219  */
2220 public enum GTestTrapFlags
2221 {
2222 	/**
2223 	 * Redirect stdout of the test child to
2224 	 * `/dev/null` so it cannot be observed on the console during test
2225 	 * runs. The actual output is still captured though to allow later
2226 	 * tests with g_test_trap_assert_stdout().
2227 	 */
2228 	SILENCE_STDOUT = 128,
2229 	/**
2230 	 * Redirect stderr of the test child to
2231 	 * `/dev/null` so it cannot be observed on the console during test
2232 	 * runs. The actual output is still captured though to allow later
2233 	 * tests with g_test_trap_assert_stderr().
2234 	 */
2235 	SILENCE_STDERR = 256,
2236 	/**
2237 	 * If this flag is given, stdin of the
2238 	 * child process is shared with stdin of its parent process.
2239 	 * It is redirected to `/dev/null` otherwise.
2240 	 */
2241 	INHERIT_STDIN = 512,
2242 }
2243 alias GTestTrapFlags TestTrapFlags;
2244 
2245 /**
2246  * Possible errors of thread related functions.
2247  */
2248 public enum GThreadError
2249 {
2250 	/**
2251 	 * a thread couldn't be created due to resource
2252 	 * shortage. Try again later.
2253 	 */
2254 	THREAD_ERROR_AGAIN = 0,
2255 }
2256 alias GThreadError ThreadError;
2257 
2258 /**
2259  * Disambiguates a given time in two ways.
2260  *
2261  * First, specifies if the given time is in universal or local time.
2262  *
2263  * Second, if the time is in local time, specifies if it is local
2264  * standard time or local daylight time.  This is important for the case
2265  * where the same local time occurs twice (during daylight savings time
2266  * transitions, for example).
2267  */
2268 public enum GTimeType
2269 {
2270 	/**
2271 	 * the time is in local standard time
2272 	 */
2273 	STANDARD = 0,
2274 	/**
2275 	 * the time is in local daylight time
2276 	 */
2277 	DAYLIGHT = 1,
2278 	/**
2279 	 * the time is in UTC
2280 	 */
2281 	UNIVERSAL = 2,
2282 }
2283 alias GTimeType TimeType;
2284 
2285 /**
2286  * The possible types of token returned from each
2287  * g_scanner_get_next_token() call.
2288  */
2289 public enum GTokenType
2290 {
2291 	/**
2292 	 * the end of the file
2293 	 */
2294 	EOF = 0,
2295 	/**
2296 	 * a '(' character
2297 	 */
2298 	LEFT_PAREN = 40,
2299 	/**
2300 	 * a ')' character
2301 	 */
2302 	RIGHT_PAREN = 41,
2303 	/**
2304 	 * a '{' character
2305 	 */
2306 	LEFT_CURLY = 123,
2307 	/**
2308 	 * a '}' character
2309 	 */
2310 	RIGHT_CURLY = 125,
2311 	/**
2312 	 * a '[' character
2313 	 */
2314 	LEFT_BRACE = 91,
2315 	/**
2316 	 * a ']' character
2317 	 */
2318 	RIGHT_BRACE = 93,
2319 	/**
2320 	 * a '=' character
2321 	 */
2322 	EQUAL_SIGN = 61,
2323 	/**
2324 	 * a ',' character
2325 	 */
2326 	COMMA = 44,
2327 	/**
2328 	 * not a token
2329 	 */
2330 	NONE = 256,
2331 	/**
2332 	 * an error occurred
2333 	 */
2334 	ERROR = 257,
2335 	/**
2336 	 * a character
2337 	 */
2338 	CHAR = 258,
2339 	/**
2340 	 * a binary integer
2341 	 */
2342 	BINARY = 259,
2343 	/**
2344 	 * an octal integer
2345 	 */
2346 	OCTAL = 260,
2347 	/**
2348 	 * an integer
2349 	 */
2350 	INT = 261,
2351 	/**
2352 	 * a hex integer
2353 	 */
2354 	HEX = 262,
2355 	/**
2356 	 * a floating point number
2357 	 */
2358 	FLOAT = 263,
2359 	/**
2360 	 * a string
2361 	 */
2362 	STRING = 264,
2363 	/**
2364 	 * a symbol
2365 	 */
2366 	SYMBOL = 265,
2367 	/**
2368 	 * an identifier
2369 	 */
2370 	IDENTIFIER = 266,
2371 	/**
2372 	 * a null identifier
2373 	 */
2374 	IDENTIFIER_NULL = 267,
2375 	/**
2376 	 * one line comment
2377 	 */
2378 	COMMENT_SINGLE = 268,
2379 	/**
2380 	 * multi line comment
2381 	 */
2382 	COMMENT_MULTI = 269,
2383 }
2384 alias GTokenType TokenType;
2385 
2386 /**
2387  * Specifies which nodes are visited during several of the tree
2388  * functions, including g_node_traverse() and g_node_find().
2389  */
2390 public enum GTraverseFlags
2391 {
2392 	/**
2393 	 * only leaf nodes should be visited. This name has
2394 	 * been introduced in 2.6, for older version use
2395 	 * %G_TRAVERSE_LEAFS.
2396 	 */
2397 	LEAVES = 1,
2398 	/**
2399 	 * only non-leaf nodes should be visited. This
2400 	 * name has been introduced in 2.6, for older
2401 	 * version use %G_TRAVERSE_NON_LEAFS.
2402 	 */
2403 	NON_LEAVES = 2,
2404 	/**
2405 	 * all nodes should be visited.
2406 	 */
2407 	ALL = 3,
2408 	/**
2409 	 * a mask of all traverse flags.
2410 	 */
2411 	MASK = 3,
2412 	/**
2413 	 * identical to %G_TRAVERSE_LEAVES.
2414 	 */
2415 	LEAFS = 1,
2416 	/**
2417 	 * identical to %G_TRAVERSE_NON_LEAVES.
2418 	 */
2419 	NON_LEAFS = 2,
2420 }
2421 alias GTraverseFlags TraverseFlags;
2422 
2423 /**
2424  * Specifies the type of traveral performed by g_tree_traverse(),
2425  * g_node_traverse() and g_node_find(). The different orders are
2426  * illustrated here:
2427  * - In order: A, B, C, D, E, F, G, H, I
2428  * ![](Sorted_binary_tree_inorder.svg)
2429  * - Pre order: F, B, A, D, C, E, G, I, H
2430  * ![](Sorted_binary_tree_preorder.svg)
2431  * - Post order: A, C, E, D, B, H, I, G, F
2432  * ![](Sorted_binary_tree_postorder.svg)
2433  * - Level order: F, B, G, A, D, I, C, E, H
2434  * ![](Sorted_binary_tree_breadth-first_traversal.svg)
2435  */
2436 public enum GTraverseType
2437 {
2438 	/**
2439 	 * vists a node's left child first, then the node itself,
2440 	 * then its right child. This is the one to use if you
2441 	 * want the output sorted according to the compare
2442 	 * function.
2443 	 */
2444 	IN_ORDER = 0,
2445 	/**
2446 	 * visits a node, then its children.
2447 	 */
2448 	PRE_ORDER = 1,
2449 	/**
2450 	 * visits the node's children, then the node itself.
2451 	 */
2452 	POST_ORDER = 2,
2453 	/**
2454 	 * is not implemented for
2455 	 * [balanced binary trees][glib-Balanced-Binary-Trees].
2456 	 * For [n-ary trees][glib-N-ary-Trees], it
2457 	 * vists the root node first, then its children, then
2458 	 * its grandchildren, and so on. Note that this is less
2459 	 * efficient than the other orders.
2460 	 */
2461 	LEVEL_ORDER = 3,
2462 }
2463 alias GTraverseType TraverseType;
2464 
2465 /**
2466  * These are the possible line break classifications.
2467  *
2468  * Since new unicode versions may add new types here, applications should be ready
2469  * to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN.
2470  *
2471  * See [Unicode Line Breaking Algorithm](http://www.unicode.org/unicode/reports/tr14/).
2472  */
2473 public enum GUnicodeBreakType
2474 {
2475 	/**
2476 	 * Mandatory Break (BK)
2477 	 */
2478 	MANDATORY = 0,
2479 	/**
2480 	 * Carriage Return (CR)
2481 	 */
2482 	CARRIAGE_RETURN = 1,
2483 	/**
2484 	 * Line Feed (LF)
2485 	 */
2486 	LINE_FEED = 2,
2487 	/**
2488 	 * Attached Characters and Combining Marks (CM)
2489 	 */
2490 	COMBINING_MARK = 3,
2491 	/**
2492 	 * Surrogates (SG)
2493 	 */
2494 	SURROGATE = 4,
2495 	/**
2496 	 * Zero Width Space (ZW)
2497 	 */
2498 	ZERO_WIDTH_SPACE = 5,
2499 	/**
2500 	 * Inseparable (IN)
2501 	 */
2502 	INSEPARABLE = 6,
2503 	/**
2504 	 * Non-breaking ("Glue") (GL)
2505 	 */
2506 	NON_BREAKING_GLUE = 7,
2507 	/**
2508 	 * Contingent Break Opportunity (CB)
2509 	 */
2510 	CONTINGENT = 8,
2511 	/**
2512 	 * Space (SP)
2513 	 */
2514 	SPACE = 9,
2515 	/**
2516 	 * Break Opportunity After (BA)
2517 	 */
2518 	AFTER = 10,
2519 	/**
2520 	 * Break Opportunity Before (BB)
2521 	 */
2522 	BEFORE = 11,
2523 	/**
2524 	 * Break Opportunity Before and After (B2)
2525 	 */
2526 	BEFORE_AND_AFTER = 12,
2527 	/**
2528 	 * Hyphen (HY)
2529 	 */
2530 	HYPHEN = 13,
2531 	/**
2532 	 * Nonstarter (NS)
2533 	 */
2534 	NON_STARTER = 14,
2535 	/**
2536 	 * Opening Punctuation (OP)
2537 	 */
2538 	OPEN_PUNCTUATION = 15,
2539 	/**
2540 	 * Closing Punctuation (CL)
2541 	 */
2542 	CLOSE_PUNCTUATION = 16,
2543 	/**
2544 	 * Ambiguous Quotation (QU)
2545 	 */
2546 	QUOTATION = 17,
2547 	/**
2548 	 * Exclamation/Interrogation (EX)
2549 	 */
2550 	EXCLAMATION = 18,
2551 	/**
2552 	 * Ideographic (ID)
2553 	 */
2554 	IDEOGRAPHIC = 19,
2555 	/**
2556 	 * Numeric (NU)
2557 	 */
2558 	NUMERIC = 20,
2559 	/**
2560 	 * Infix Separator (Numeric) (IS)
2561 	 */
2562 	INFIX_SEPARATOR = 21,
2563 	/**
2564 	 * Symbols Allowing Break After (SY)
2565 	 */
2566 	SYMBOL = 22,
2567 	/**
2568 	 * Ordinary Alphabetic and Symbol Characters (AL)
2569 	 */
2570 	ALPHABETIC = 23,
2571 	/**
2572 	 * Prefix (Numeric) (PR)
2573 	 */
2574 	PREFIX = 24,
2575 	/**
2576 	 * Postfix (Numeric) (PO)
2577 	 */
2578 	POSTFIX = 25,
2579 	/**
2580 	 * Complex Content Dependent (South East Asian) (SA)
2581 	 */
2582 	COMPLEX_CONTEXT = 26,
2583 	/**
2584 	 * Ambiguous (Alphabetic or Ideographic) (AI)
2585 	 */
2586 	AMBIGUOUS = 27,
2587 	/**
2588 	 * Unknown (XX)
2589 	 */
2590 	UNKNOWN = 28,
2591 	/**
2592 	 * Next Line (NL)
2593 	 */
2594 	NEXT_LINE = 29,
2595 	/**
2596 	 * Word Joiner (WJ)
2597 	 */
2598 	WORD_JOINER = 30,
2599 	/**
2600 	 * Hangul L Jamo (JL)
2601 	 */
2602 	HANGUL_L_JAMO = 31,
2603 	/**
2604 	 * Hangul V Jamo (JV)
2605 	 */
2606 	HANGUL_V_JAMO = 32,
2607 	/**
2608 	 * Hangul T Jamo (JT)
2609 	 */
2610 	HANGUL_T_JAMO = 33,
2611 	/**
2612 	 * Hangul LV Syllable (H2)
2613 	 */
2614 	HANGUL_LV_SYLLABLE = 34,
2615 	/**
2616 	 * Hangul LVT Syllable (H3)
2617 	 */
2618 	HANGUL_LVT_SYLLABLE = 35,
2619 	/**
2620 	 * Closing Parenthesis (CP). Since 2.28
2621 	 */
2622 	CLOSE_PARANTHESIS = 36,
2623 	/**
2624 	 * Conditional Japanese Starter (CJ). Since: 2.32
2625 	 */
2626 	CONDITIONAL_JAPANESE_STARTER = 37,
2627 	/**
2628 	 * Hebrew Letter (HL). Since: 2.32
2629 	 */
2630 	HEBREW_LETTER = 38,
2631 	/**
2632 	 * Regional Indicator (RI). Since: 2.36
2633 	 */
2634 	REGIONAL_INDICATOR = 39,
2635 	/**
2636 	 * Emoji Base (EB). Since: 2.50
2637 	 */
2638 	EMOJI_BASE = 40,
2639 	/**
2640 	 * Emoji Modifier (EM). Since: 2.50
2641 	 */
2642 	EMOJI_MODIFIER = 41,
2643 	/**
2644 	 * Zero Width Joiner (ZWJ). Since: 2.50
2645 	 */
2646 	ZERO_WIDTH_JOINER = 42,
2647 }
2648 alias GUnicodeBreakType UnicodeBreakType;
2649 
2650 /**
2651  * The #GUnicodeScript enumeration identifies different writing
2652  * systems. The values correspond to the names as defined in the
2653  * Unicode standard. The enumeration has been added in GLib 2.14,
2654  * and is interchangeable with #PangoScript.
2655  *
2656  * Note that new types may be added in the future. Applications
2657  * should be ready to handle unknown values.
2658  * See [Unicode Standard Annex #24: Script names](http://www.unicode.org/reports/tr24/).
2659  */
2660 public enum GUnicodeScript
2661 {
2662 	/**
2663 	 * a value never returned from g_unichar_get_script()
2664 	 */
2665 	INVALID_CODE = -1,
2666 	/**
2667 	 * a character used by multiple different scripts
2668 	 */
2669 	COMMON = 0,
2670 	/**
2671 	 * a mark glyph that takes its script from the
2672 	 * base glyph to which it is attached
2673 	 */
2674 	INHERITED = 1,
2675 	/**
2676 	 * Arabic
2677 	 */
2678 	ARABIC = 2,
2679 	/**
2680 	 * Armenian
2681 	 */
2682 	ARMENIAN = 3,
2683 	/**
2684 	 * Bengali
2685 	 */
2686 	BENGALI = 4,
2687 	/**
2688 	 * Bopomofo
2689 	 */
2690 	BOPOMOFO = 5,
2691 	/**
2692 	 * Cherokee
2693 	 */
2694 	CHEROKEE = 6,
2695 	/**
2696 	 * Coptic
2697 	 */
2698 	COPTIC = 7,
2699 	/**
2700 	 * Cyrillic
2701 	 */
2702 	CYRILLIC = 8,
2703 	/**
2704 	 * Deseret
2705 	 */
2706 	DESERET = 9,
2707 	/**
2708 	 * Devanagari
2709 	 */
2710 	DEVANAGARI = 10,
2711 	/**
2712 	 * Ethiopic
2713 	 */
2714 	ETHIOPIC = 11,
2715 	/**
2716 	 * Georgian
2717 	 */
2718 	GEORGIAN = 12,
2719 	/**
2720 	 * Gothic
2721 	 */
2722 	GOTHIC = 13,
2723 	/**
2724 	 * Greek
2725 	 */
2726 	GREEK = 14,
2727 	/**
2728 	 * Gujarati
2729 	 */
2730 	GUJARATI = 15,
2731 	/**
2732 	 * Gurmukhi
2733 	 */
2734 	GURMUKHI = 16,
2735 	/**
2736 	 * Han
2737 	 */
2738 	HAN = 17,
2739 	/**
2740 	 * Hangul
2741 	 */
2742 	HANGUL = 18,
2743 	/**
2744 	 * Hebrew
2745 	 */
2746 	HEBREW = 19,
2747 	/**
2748 	 * Hiragana
2749 	 */
2750 	HIRAGANA = 20,
2751 	/**
2752 	 * Kannada
2753 	 */
2754 	KANNADA = 21,
2755 	/**
2756 	 * Katakana
2757 	 */
2758 	KATAKANA = 22,
2759 	/**
2760 	 * Khmer
2761 	 */
2762 	KHMER = 23,
2763 	/**
2764 	 * Lao
2765 	 */
2766 	LAO = 24,
2767 	/**
2768 	 * Latin
2769 	 */
2770 	LATIN = 25,
2771 	/**
2772 	 * Malayalam
2773 	 */
2774 	MALAYALAM = 26,
2775 	/**
2776 	 * Mongolian
2777 	 */
2778 	MONGOLIAN = 27,
2779 	/**
2780 	 * Myanmar
2781 	 */
2782 	MYANMAR = 28,
2783 	/**
2784 	 * Ogham
2785 	 */
2786 	OGHAM = 29,
2787 	/**
2788 	 * Old Italic
2789 	 */
2790 	OLD_ITALIC = 30,
2791 	/**
2792 	 * Oriya
2793 	 */
2794 	ORIYA = 31,
2795 	/**
2796 	 * Runic
2797 	 */
2798 	RUNIC = 32,
2799 	/**
2800 	 * Sinhala
2801 	 */
2802 	SINHALA = 33,
2803 	/**
2804 	 * Syriac
2805 	 */
2806 	SYRIAC = 34,
2807 	/**
2808 	 * Tamil
2809 	 */
2810 	TAMIL = 35,
2811 	/**
2812 	 * Telugu
2813 	 */
2814 	TELUGU = 36,
2815 	/**
2816 	 * Thaana
2817 	 */
2818 	THAANA = 37,
2819 	/**
2820 	 * Thai
2821 	 */
2822 	THAI = 38,
2823 	/**
2824 	 * Tibetan
2825 	 */
2826 	TIBETAN = 39,
2827 	/**
2828 	 * Canadian Aboriginal
2829 	 */
2830 	CANADIAN_ABORIGINAL = 40,
2831 	/**
2832 	 * Yi
2833 	 */
2834 	YI = 41,
2835 	/**
2836 	 * Tagalog
2837 	 */
2838 	TAGALOG = 42,
2839 	/**
2840 	 * Hanunoo
2841 	 */
2842 	HANUNOO = 43,
2843 	/**
2844 	 * Buhid
2845 	 */
2846 	BUHID = 44,
2847 	/**
2848 	 * Tagbanwa
2849 	 */
2850 	TAGBANWA = 45,
2851 	/**
2852 	 * Braille
2853 	 */
2854 	BRAILLE = 46,
2855 	/**
2856 	 * Cypriot
2857 	 */
2858 	CYPRIOT = 47,
2859 	/**
2860 	 * Limbu
2861 	 */
2862 	LIMBU = 48,
2863 	/**
2864 	 * Osmanya
2865 	 */
2866 	OSMANYA = 49,
2867 	/**
2868 	 * Shavian
2869 	 */
2870 	SHAVIAN = 50,
2871 	/**
2872 	 * Linear B
2873 	 */
2874 	LINEAR_B = 51,
2875 	/**
2876 	 * Tai Le
2877 	 */
2878 	TAI_LE = 52,
2879 	/**
2880 	 * Ugaritic
2881 	 */
2882 	UGARITIC = 53,
2883 	/**
2884 	 * New Tai Lue
2885 	 */
2886 	NEW_TAI_LUE = 54,
2887 	/**
2888 	 * Buginese
2889 	 */
2890 	BUGINESE = 55,
2891 	/**
2892 	 * Glagolitic
2893 	 */
2894 	GLAGOLITIC = 56,
2895 	/**
2896 	 * Tifinagh
2897 	 */
2898 	TIFINAGH = 57,
2899 	/**
2900 	 * Syloti Nagri
2901 	 */
2902 	SYLOTI_NAGRI = 58,
2903 	/**
2904 	 * Old Persian
2905 	 */
2906 	OLD_PERSIAN = 59,
2907 	/**
2908 	 * Kharoshthi
2909 	 */
2910 	KHAROSHTHI = 60,
2911 	/**
2912 	 * an unassigned code point
2913 	 */
2914 	UNKNOWN = 61,
2915 	/**
2916 	 * Balinese
2917 	 */
2918 	BALINESE = 62,
2919 	/**
2920 	 * Cuneiform
2921 	 */
2922 	CUNEIFORM = 63,
2923 	/**
2924 	 * Phoenician
2925 	 */
2926 	PHOENICIAN = 64,
2927 	/**
2928 	 * Phags-pa
2929 	 */
2930 	PHAGS_PA = 65,
2931 	/**
2932 	 * N'Ko
2933 	 */
2934 	NKO = 66,
2935 	/**
2936 	 * Kayah Li. Since 2.16.3
2937 	 */
2938 	KAYAH_LI = 67,
2939 	/**
2940 	 * Lepcha. Since 2.16.3
2941 	 */
2942 	LEPCHA = 68,
2943 	/**
2944 	 * Rejang. Since 2.16.3
2945 	 */
2946 	REJANG = 69,
2947 	/**
2948 	 * Sundanese. Since 2.16.3
2949 	 */
2950 	SUNDANESE = 70,
2951 	/**
2952 	 * Saurashtra. Since 2.16.3
2953 	 */
2954 	SAURASHTRA = 71,
2955 	/**
2956 	 * Cham. Since 2.16.3
2957 	 */
2958 	CHAM = 72,
2959 	/**
2960 	 * Ol Chiki. Since 2.16.3
2961 	 */
2962 	OL_CHIKI = 73,
2963 	/**
2964 	 * Vai. Since 2.16.3
2965 	 */
2966 	VAI = 74,
2967 	/**
2968 	 * Carian. Since 2.16.3
2969 	 */
2970 	CARIAN = 75,
2971 	/**
2972 	 * Lycian. Since 2.16.3
2973 	 */
2974 	LYCIAN = 76,
2975 	/**
2976 	 * Lydian. Since 2.16.3
2977 	 */
2978 	LYDIAN = 77,
2979 	/**
2980 	 * Avestan. Since 2.26
2981 	 */
2982 	AVESTAN = 78,
2983 	/**
2984 	 * Bamum. Since 2.26
2985 	 */
2986 	BAMUM = 79,
2987 	/**
2988 	 * Egyptian Hieroglpyhs. Since 2.26
2989 	 */
2990 	EGYPTIAN_HIEROGLYPHS = 80,
2991 	/**
2992 	 * Imperial Aramaic. Since 2.26
2993 	 */
2994 	IMPERIAL_ARAMAIC = 81,
2995 	/**
2996 	 * Inscriptional Pahlavi. Since 2.26
2997 	 */
2998 	INSCRIPTIONAL_PAHLAVI = 82,
2999 	/**
3000 	 * Inscriptional Parthian. Since 2.26
3001 	 */
3002 	INSCRIPTIONAL_PARTHIAN = 83,
3003 	/**
3004 	 * Javanese. Since 2.26
3005 	 */
3006 	JAVANESE = 84,
3007 	/**
3008 	 * Kaithi. Since 2.26
3009 	 */
3010 	KAITHI = 85,
3011 	/**
3012 	 * Lisu. Since 2.26
3013 	 */
3014 	LISU = 86,
3015 	/**
3016 	 * Meetei Mayek. Since 2.26
3017 	 */
3018 	MEETEI_MAYEK = 87,
3019 	/**
3020 	 * Old South Arabian. Since 2.26
3021 	 */
3022 	OLD_SOUTH_ARABIAN = 88,
3023 	/**
3024 	 * Old Turkic. Since 2.28
3025 	 */
3026 	OLD_TURKIC = 89,
3027 	/**
3028 	 * Samaritan. Since 2.26
3029 	 */
3030 	SAMARITAN = 90,
3031 	/**
3032 	 * Tai Tham. Since 2.26
3033 	 */
3034 	TAI_THAM = 91,
3035 	/**
3036 	 * Tai Viet. Since 2.26
3037 	 */
3038 	TAI_VIET = 92,
3039 	/**
3040 	 * Batak. Since 2.28
3041 	 */
3042 	BATAK = 93,
3043 	/**
3044 	 * Brahmi. Since 2.28
3045 	 */
3046 	BRAHMI = 94,
3047 	/**
3048 	 * Mandaic. Since 2.28
3049 	 */
3050 	MANDAIC = 95,
3051 	/**
3052 	 * Chakma. Since: 2.32
3053 	 */
3054 	CHAKMA = 96,
3055 	/**
3056 	 * Meroitic Cursive. Since: 2.32
3057 	 */
3058 	MEROITIC_CURSIVE = 97,
3059 	/**
3060 	 * Meroitic Hieroglyphs. Since: 2.32
3061 	 */
3062 	MEROITIC_HIEROGLYPHS = 98,
3063 	/**
3064 	 * Miao. Since: 2.32
3065 	 */
3066 	MIAO = 99,
3067 	/**
3068 	 * Sharada. Since: 2.32
3069 	 */
3070 	SHARADA = 100,
3071 	/**
3072 	 * Sora Sompeng. Since: 2.32
3073 	 */
3074 	SORA_SOMPENG = 101,
3075 	/**
3076 	 * Takri. Since: 2.32
3077 	 */
3078 	TAKRI = 102,
3079 	/**
3080 	 * Bassa. Since: 2.42
3081 	 */
3082 	BASSA_VAH = 103,
3083 	/**
3084 	 * Caucasian Albanian. Since: 2.42
3085 	 */
3086 	CAUCASIAN_ALBANIAN = 104,
3087 	/**
3088 	 * Duployan. Since: 2.42
3089 	 */
3090 	DUPLOYAN = 105,
3091 	/**
3092 	 * Elbasan. Since: 2.42
3093 	 */
3094 	ELBASAN = 106,
3095 	/**
3096 	 * Grantha. Since: 2.42
3097 	 */
3098 	GRANTHA = 107,
3099 	/**
3100 	 * Kjohki. Since: 2.42
3101 	 */
3102 	KHOJKI = 108,
3103 	/**
3104 	 * Khudawadi, Sindhi. Since: 2.42
3105 	 */
3106 	KHUDAWADI = 109,
3107 	/**
3108 	 * Linear A. Since: 2.42
3109 	 */
3110 	LINEAR_A = 110,
3111 	/**
3112 	 * Mahajani. Since: 2.42
3113 	 */
3114 	MAHAJANI = 111,
3115 	/**
3116 	 * Manichaean. Since: 2.42
3117 	 */
3118 	MANICHAEAN = 112,
3119 	/**
3120 	 * Mende Kikakui. Since: 2.42
3121 	 */
3122 	MENDE_KIKAKUI = 113,
3123 	/**
3124 	 * Modi. Since: 2.42
3125 	 */
3126 	MODI = 114,
3127 	/**
3128 	 * Mro. Since: 2.42
3129 	 */
3130 	MRO = 115,
3131 	/**
3132 	 * Nabataean. Since: 2.42
3133 	 */
3134 	NABATAEAN = 116,
3135 	/**
3136 	 * Old North Arabian. Since: 2.42
3137 	 */
3138 	OLD_NORTH_ARABIAN = 117,
3139 	/**
3140 	 * Old Permic. Since: 2.42
3141 	 */
3142 	OLD_PERMIC = 118,
3143 	/**
3144 	 * Pahawh Hmong. Since: 2.42
3145 	 */
3146 	PAHAWH_HMONG = 119,
3147 	/**
3148 	 * Palmyrene. Since: 2.42
3149 	 */
3150 	PALMYRENE = 120,
3151 	/**
3152 	 * Pau Cin Hau. Since: 2.42
3153 	 */
3154 	PAU_CIN_HAU = 121,
3155 	/**
3156 	 * Psalter Pahlavi. Since: 2.42
3157 	 */
3158 	PSALTER_PAHLAVI = 122,
3159 	/**
3160 	 * Siddham. Since: 2.42
3161 	 */
3162 	SIDDHAM = 123,
3163 	/**
3164 	 * Tirhuta. Since: 2.42
3165 	 */
3166 	TIRHUTA = 124,
3167 	/**
3168 	 * Warang Citi. Since: 2.42
3169 	 */
3170 	WARANG_CITI = 125,
3171 	/**
3172 	 * Ahom. Since: 2.48
3173 	 */
3174 	AHOM = 126,
3175 	/**
3176 	 * Anatolian Hieroglyphs. Since: 2.48
3177 	 */
3178 	ANATOLIAN_HIEROGLYPHS = 127,
3179 	/**
3180 	 * Hatran. Since: 2.48
3181 	 */
3182 	HATRAN = 128,
3183 	/**
3184 	 * Multani. Since: 2.48
3185 	 */
3186 	MULTANI = 129,
3187 	/**
3188 	 * Old Hungarian. Since: 2.48
3189 	 */
3190 	OLD_HUNGARIAN = 130,
3191 	/**
3192 	 * Signwriting. Since: 2.48
3193 	 */
3194 	SIGNWRITING = 131,
3195 	/**
3196 	 * Adlam. Since: 2.50
3197 	 */
3198 	ADLAM = 132,
3199 	/**
3200 	 * Bhaiksuki. Since: 2.50
3201 	 */
3202 	BHAIKSUKI = 133,
3203 	/**
3204 	 * Marchen. Since: 2.50
3205 	 */
3206 	MARCHEN = 134,
3207 	/**
3208 	 * Newa. Since: 2.50
3209 	 */
3210 	NEWA = 135,
3211 	/**
3212 	 * Osage. Since: 2.50
3213 	 */
3214 	OSAGE = 136,
3215 	/**
3216 	 * Tangut. Since: 2.50
3217 	 */
3218 	TANGUT = 137,
3219 	/**
3220 	 * Masaram Gondi. Since: 2.54
3221 	 */
3222 	MASARAM_GONDI = 138,
3223 	/**
3224 	 * Nushu. Since: 2.54
3225 	 */
3226 	NUSHU = 139,
3227 	/**
3228 	 * Soyombo. Since: 2.54
3229 	 */
3230 	SOYOMBO = 140,
3231 	/**
3232 	 * Zanabazar Square. Since: 2.54
3233 	 */
3234 	ZANABAZAR_SQUARE = 141,
3235 }
3236 alias GUnicodeScript UnicodeScript;
3237 
3238 /**
3239  * These are the possible character classifications from the
3240  * Unicode specification.
3241  * See [Unicode Character Database](http://www.unicode.org/reports/tr44/#General_Category_Values).
3242  */
3243 public enum GUnicodeType
3244 {
3245 	/**
3246 	 * General category "Other, Control" (Cc)
3247 	 */
3248 	CONTROL = 0,
3249 	/**
3250 	 * General category "Other, Format" (Cf)
3251 	 */
3252 	FORMAT = 1,
3253 	/**
3254 	 * General category "Other, Not Assigned" (Cn)
3255 	 */
3256 	UNASSIGNED = 2,
3257 	/**
3258 	 * General category "Other, Private Use" (Co)
3259 	 */
3260 	PRIVATE_USE = 3,
3261 	/**
3262 	 * General category "Other, Surrogate" (Cs)
3263 	 */
3264 	SURROGATE = 4,
3265 	/**
3266 	 * General category "Letter, Lowercase" (Ll)
3267 	 */
3268 	LOWERCASE_LETTER = 5,
3269 	/**
3270 	 * General category "Letter, Modifier" (Lm)
3271 	 */
3272 	MODIFIER_LETTER = 6,
3273 	/**
3274 	 * General category "Letter, Other" (Lo)
3275 	 */
3276 	OTHER_LETTER = 7,
3277 	/**
3278 	 * General category "Letter, Titlecase" (Lt)
3279 	 */
3280 	TITLECASE_LETTER = 8,
3281 	/**
3282 	 * General category "Letter, Uppercase" (Lu)
3283 	 */
3284 	UPPERCASE_LETTER = 9,
3285 	/**
3286 	 * General category "Mark, Spacing" (Mc)
3287 	 */
3288 	SPACING_MARK = 10,
3289 	/**
3290 	 * General category "Mark, Enclosing" (Me)
3291 	 */
3292 	ENCLOSING_MARK = 11,
3293 	/**
3294 	 * General category "Mark, Nonspacing" (Mn)
3295 	 */
3296 	NON_SPACING_MARK = 12,
3297 	/**
3298 	 * General category "Number, Decimal Digit" (Nd)
3299 	 */
3300 	DECIMAL_NUMBER = 13,
3301 	/**
3302 	 * General category "Number, Letter" (Nl)
3303 	 */
3304 	LETTER_NUMBER = 14,
3305 	/**
3306 	 * General category "Number, Other" (No)
3307 	 */
3308 	OTHER_NUMBER = 15,
3309 	/**
3310 	 * General category "Punctuation, Connector" (Pc)
3311 	 */
3312 	CONNECT_PUNCTUATION = 16,
3313 	/**
3314 	 * General category "Punctuation, Dash" (Pd)
3315 	 */
3316 	DASH_PUNCTUATION = 17,
3317 	/**
3318 	 * General category "Punctuation, Close" (Pe)
3319 	 */
3320 	CLOSE_PUNCTUATION = 18,
3321 	/**
3322 	 * General category "Punctuation, Final quote" (Pf)
3323 	 */
3324 	FINAL_PUNCTUATION = 19,
3325 	/**
3326 	 * General category "Punctuation, Initial quote" (Pi)
3327 	 */
3328 	INITIAL_PUNCTUATION = 20,
3329 	/**
3330 	 * General category "Punctuation, Other" (Po)
3331 	 */
3332 	OTHER_PUNCTUATION = 21,
3333 	/**
3334 	 * General category "Punctuation, Open" (Ps)
3335 	 */
3336 	OPEN_PUNCTUATION = 22,
3337 	/**
3338 	 * General category "Symbol, Currency" (Sc)
3339 	 */
3340 	CURRENCY_SYMBOL = 23,
3341 	/**
3342 	 * General category "Symbol, Modifier" (Sk)
3343 	 */
3344 	MODIFIER_SYMBOL = 24,
3345 	/**
3346 	 * General category "Symbol, Math" (Sm)
3347 	 */
3348 	MATH_SYMBOL = 25,
3349 	/**
3350 	 * General category "Symbol, Other" (So)
3351 	 */
3352 	OTHER_SYMBOL = 26,
3353 	/**
3354 	 * General category "Separator, Line" (Zl)
3355 	 */
3356 	LINE_SEPARATOR = 27,
3357 	/**
3358 	 * General category "Separator, Paragraph" (Zp)
3359 	 */
3360 	PARAGRAPH_SEPARATOR = 28,
3361 	/**
3362 	 * General category "Separator, Space" (Zs)
3363 	 */
3364 	SPACE_SEPARATOR = 29,
3365 }
3366 alias GUnicodeType UnicodeType;
3367 
3368 /**
3369  * These are logical ids for special directories which are defined
3370  * depending on the platform used. You should use g_get_user_special_dir()
3371  * to retrieve the full path associated to the logical id.
3372  *
3373  * The #GUserDirectory enumeration can be extended at later date. Not
3374  * every platform has a directory for every logical id in this
3375  * enumeration.
3376  *
3377  * Since: 2.14
3378  */
3379 public enum GUserDirectory
3380 {
3381 	/**
3382 	 * the user's Desktop directory
3383 	 */
3384 	DIRECTORY_DESKTOP = 0,
3385 	/**
3386 	 * the user's Documents directory
3387 	 */
3388 	DIRECTORY_DOCUMENTS = 1,
3389 	/**
3390 	 * the user's Downloads directory
3391 	 */
3392 	DIRECTORY_DOWNLOAD = 2,
3393 	/**
3394 	 * the user's Music directory
3395 	 */
3396 	DIRECTORY_MUSIC = 3,
3397 	/**
3398 	 * the user's Pictures directory
3399 	 */
3400 	DIRECTORY_PICTURES = 4,
3401 	/**
3402 	 * the user's shared directory
3403 	 */
3404 	DIRECTORY_PUBLIC_SHARE = 5,
3405 	/**
3406 	 * the user's Templates directory
3407 	 */
3408 	DIRECTORY_TEMPLATES = 6,
3409 	/**
3410 	 * the user's Movies directory
3411 	 */
3412 	DIRECTORY_VIDEOS = 7,
3413 	/**
3414 	 * the number of enum values
3415 	 */
3416 	N_DIRECTORIES = 8,
3417 }
3418 alias GUserDirectory UserDirectory;
3419 
3420 /**
3421  * The range of possible top-level types of #GVariant instances.
3422  *
3423  * Since: 2.24
3424  */
3425 public enum GVariantClass
3426 {
3427 	/**
3428 	 * The #GVariant is a boolean.
3429 	 */
3430 	BOOLEAN = 98,
3431 	/**
3432 	 * The #GVariant is a byte.
3433 	 */
3434 	BYTE = 121,
3435 	/**
3436 	 * The #GVariant is a signed 16 bit integer.
3437 	 */
3438 	INT16 = 110,
3439 	/**
3440 	 * The #GVariant is an unsigned 16 bit integer.
3441 	 */
3442 	UINT16 = 113,
3443 	/**
3444 	 * The #GVariant is a signed 32 bit integer.
3445 	 */
3446 	INT32 = 105,
3447 	/**
3448 	 * The #GVariant is an unsigned 32 bit integer.
3449 	 */
3450 	UINT32 = 117,
3451 	/**
3452 	 * The #GVariant is a signed 64 bit integer.
3453 	 */
3454 	INT64 = 120,
3455 	/**
3456 	 * The #GVariant is an unsigned 64 bit integer.
3457 	 */
3458 	UINT64 = 116,
3459 	/**
3460 	 * The #GVariant is a file handle index.
3461 	 */
3462 	HANDLE = 104,
3463 	/**
3464 	 * The #GVariant is a double precision floating
3465 	 * point value.
3466 	 */
3467 	DOUBLE = 100,
3468 	/**
3469 	 * The #GVariant is a normal string.
3470 	 */
3471 	STRING = 115,
3472 	/**
3473 	 * The #GVariant is a D-Bus object path
3474 	 * string.
3475 	 */
3476 	OBJECT_PATH = 111,
3477 	/**
3478 	 * The #GVariant is a D-Bus signature string.
3479 	 */
3480 	SIGNATURE = 103,
3481 	/**
3482 	 * The #GVariant is a variant.
3483 	 */
3484 	VARIANT = 118,
3485 	/**
3486 	 * The #GVariant is a maybe-typed value.
3487 	 */
3488 	MAYBE = 109,
3489 	/**
3490 	 * The #GVariant is an array.
3491 	 */
3492 	ARRAY = 97,
3493 	/**
3494 	 * The #GVariant is a tuple.
3495 	 */
3496 	TUPLE = 40,
3497 	/**
3498 	 * The #GVariant is a dictionary entry.
3499 	 */
3500 	DICT_ENTRY = 123,
3501 }
3502 alias GVariantClass VariantClass;
3503 
3504 /**
3505  * Error codes returned by parsing text-format GVariants.
3506  */
3507 public enum GVariantParseError
3508 {
3509 	/**
3510 	 * generic error (unused)
3511 	 */
3512 	FAILED = 0,
3513 	/**
3514 	 * a non-basic #GVariantType was given where a basic type was expected
3515 	 */
3516 	BASIC_TYPE_EXPECTED = 1,
3517 	/**
3518 	 * cannot infer the #GVariantType
3519 	 */
3520 	CANNOT_INFER_TYPE = 2,
3521 	/**
3522 	 * an indefinite #GVariantType was given where a definite type was expected
3523 	 */
3524 	DEFINITE_TYPE_EXPECTED = 3,
3525 	/**
3526 	 * extra data after parsing finished
3527 	 */
3528 	INPUT_NOT_AT_END = 4,
3529 	/**
3530 	 * invalid character in number or unicode escape
3531 	 */
3532 	INVALID_CHARACTER = 5,
3533 	/**
3534 	 * not a valid #GVariant format string
3535 	 */
3536 	INVALID_FORMAT_STRING = 6,
3537 	/**
3538 	 * not a valid object path
3539 	 */
3540 	INVALID_OBJECT_PATH = 7,
3541 	/**
3542 	 * not a valid type signature
3543 	 */
3544 	INVALID_SIGNATURE = 8,
3545 	/**
3546 	 * not a valid #GVariant type string
3547 	 */
3548 	INVALID_TYPE_STRING = 9,
3549 	/**
3550 	 * could not find a common type for array entries
3551 	 */
3552 	NO_COMMON_TYPE = 10,
3553 	/**
3554 	 * the numerical value is out of range of the given type
3555 	 */
3556 	NUMBER_OUT_OF_RANGE = 11,
3557 	/**
3558 	 * the numerical value is out of range for any type
3559 	 */
3560 	NUMBER_TOO_BIG = 12,
3561 	/**
3562 	 * cannot parse as variant of the specified type
3563 	 */
3564 	TYPE_ERROR = 13,
3565 	/**
3566 	 * an unexpected token was encountered
3567 	 */
3568 	UNEXPECTED_TOKEN = 14,
3569 	/**
3570 	 * an unknown keyword was encountered
3571 	 */
3572 	UNKNOWN_KEYWORD = 15,
3573 	/**
3574 	 * unterminated string constant
3575 	 */
3576 	UNTERMINATED_STRING_CONSTANT = 16,
3577 	/**
3578 	 * no value given
3579 	 */
3580 	VALUE_EXPECTED = 17,
3581 }
3582 alias GVariantParseError VariantParseError;
3583 
3584 /**
3585  * Flags passed to g_module_open().
3586  * Note that these flags are not supported on all platforms.
3587  */
3588 public enum GModuleFlags
3589 {
3590 	/**
3591 	 * specifies that symbols are only resolved when
3592 	 * needed. The default action is to bind all symbols when the module
3593 	 * is loaded.
3594 	 */
3595 	LAZY = 1,
3596 	/**
3597 	 * specifies that symbols in the module should
3598 	 * not be added to the global name space. The default action on most
3599 	 * platforms is to place symbols in the module in the global name space,
3600 	 * which may cause conflicts with existing symbols.
3601 	 */
3602 	LOCAL = 2,
3603 	/**
3604 	 * mask for all flags.
3605 	 */
3606 	MASK = 3,
3607 }
3608 alias GModuleFlags ModuleFlags;
3609 
3610 /**
3611  * Contains the public fields of a GArray.
3612  */
3613 struct GArray
3614 {
3615 	/**
3616 	 * a pointer to the element data. The data may be moved as
3617 	 * elements are added to the #GArray.
3618 	 */
3619 	char* data;
3620 	/**
3621 	 * the number of elements in the #GArray not including the
3622 	 * possible terminating zero element.
3623 	 */
3624 	uint len;
3625 }
3626 
3627 struct GAsyncQueue;
3628 
3629 struct GBookmarkFile;
3630 
3631 /**
3632  * Contains the public fields of a GByteArray.
3633  */
3634 struct GByteArray
3635 {
3636 	/**
3637 	 * a pointer to the element data. The data may be moved as
3638 	 * elements are added to the #GByteArray
3639 	 */
3640 	ubyte* data;
3641 	/**
3642 	 * the number of elements in the #GByteArray
3643 	 */
3644 	uint len;
3645 }
3646 
3647 struct GBytes;
3648 
3649 struct GChecksum;
3650 
3651 struct GCond
3652 {
3653 	void* p;
3654 	uint[2] i;
3655 }
3656 
3657 /**
3658  * The #GData struct is an opaque data structure to represent a
3659  * [Keyed Data List][glib-Keyed-Data-Lists]. It should only be
3660  * accessed via the following functions.
3661  */
3662 struct GData;
3663 
3664 struct GDate
3665 {
3666 	import std.bitmanip: bitfields;
3667 	mixin(bitfields!(
3668 		uint, "julianDays", 32,
3669 		uint, "julian", 1,
3670 		uint, "dmy", 1,
3671 		uint, "day", 6,
3672 		uint, "month", 4,
3673 		uint, "year", 16,
3674 		uint, "", 4
3675 	));
3676 }
3677 
3678 struct GDateTime;
3679 
3680 /**
3681  * Associates a string with a bit flag.
3682  * Used in g_parse_debug_string().
3683  */
3684 struct GDebugKey
3685 {
3686 	/**
3687 	 * the string
3688 	 */
3689 	const(char)* key;
3690 	/**
3691 	 * the flag
3692 	 */
3693 	uint value;
3694 }
3695 
3696 struct GDir;
3697 
3698 /**
3699  * The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign,
3700  * mantissa and exponent of IEEE floats and doubles. These unions are defined
3701  * as appropriate for a given platform. IEEE floats and doubles are supported
3702  * (used for storage) by at least Intel, PPC and Sparc.
3703  */
3704 struct GDoubleIEEE754
3705 {
3706 	union
3707 	{
3708 		/**
3709 		 * the double value
3710 		 */
3711 		double vDouble;
3712 		struct Mpn
3713 		{
3714 			import std.bitmanip: bitfields;
3715 			mixin(bitfields!(
3716 				uint, "mantissaLow", 32,
3717 				uint, "mantissaHigh", 20,
3718 				uint, "biasedExponent", 11,
3719 				uint, "sign", 1
3720 			));
3721 		}
3722 		Mpn mpn;
3723 	}
3724 }
3725 
3726 struct GError
3727 {
3728 	/**
3729 	 * error domain, e.g. #G_FILE_ERROR
3730 	 */
3731 	GQuark domain;
3732 	/**
3733 	 * error code, e.g. %G_FILE_ERROR_NOENT
3734 	 */
3735 	int code;
3736 	/**
3737 	 * human-readable informative error message
3738 	 */
3739 	char* message;
3740 }
3741 
3742 /**
3743  * The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign,
3744  * mantissa and exponent of IEEE floats and doubles. These unions are defined
3745  * as appropriate for a given platform. IEEE floats and doubles are supported
3746  * (used for storage) by at least Intel, PPC and Sparc.
3747  */
3748 struct GFloatIEEE754
3749 {
3750 	union
3751 	{
3752 		/**
3753 		 * the double value
3754 		 */
3755 		float vFloat;
3756 		struct Mpn
3757 		{
3758 			import std.bitmanip: bitfields;
3759 			mixin(bitfields!(
3760 				uint, "mantissa", 23,
3761 				uint, "biasedExponent", 8,
3762 				uint, "sign", 1
3763 			));
3764 		}
3765 		Mpn mpn;
3766 	}
3767 }
3768 
3769 /**
3770  * The #GHashTable struct is an opaque data structure to represent a
3771  * [Hash Table][glib-Hash-Tables]. It should only be accessed via the
3772  * following functions.
3773  */
3774 struct GHashTable;
3775 
3776 struct GHashTableIter
3777 {
3778 	void* dummy1;
3779 	void* dummy2;
3780 	void* dummy3;
3781 	int dummy4;
3782 	bool dummy5;
3783 	void* dummy6;
3784 }
3785 
3786 struct GHmac;
3787 
3788 struct GHook
3789 {
3790 	/**
3791 	 * data which is passed to func when this hook is invoked
3792 	 */
3793 	void* data;
3794 	/**
3795 	 * pointer to the next hook in the list
3796 	 */
3797 	GHook* next;
3798 	/**
3799 	 * pointer to the previous hook in the list
3800 	 */
3801 	GHook* prev;
3802 	/**
3803 	 * the reference count of this hook
3804 	 */
3805 	uint refCount;
3806 	/**
3807 	 * the id of this hook, which is unique within its list
3808 	 */
3809 	gulong hookId;
3810 	/**
3811 	 * flags which are set for this hook. See #GHookFlagMask for
3812 	 * predefined flags
3813 	 */
3814 	uint flags;
3815 	/**
3816 	 * the function to call when this hook is invoked. The possible
3817 	 * signatures for this function are #GHookFunc and #GHookCheckFunc
3818 	 */
3819 	void* func;
3820 	/**
3821 	 * the default @finalize_hook function of a #GHookList calls
3822 	 * this member of the hook that is being finalized
3823 	 */
3824 	GDestroyNotify destroy;
3825 }
3826 
3827 struct GHookList
3828 {
3829 	/**
3830 	 * the next free #GHook id
3831 	 */
3832 	gulong seqId;
3833 	import std.bitmanip: bitfields;
3834 	mixin(bitfields!(
3835 		uint, "hookSize", 16,
3836 		uint, "isSetup", 1,
3837 		uint, "", 15
3838 	));
3839 	/**
3840 	 * the first #GHook element in the list
3841 	 */
3842 	GHook* hooks;
3843 	/**
3844 	 * unused
3845 	 */
3846 	void* dummy3;
3847 	/**
3848 	 * the function to call to finalize a #GHook element.
3849 	 * The default behaviour is to call the hooks @destroy function
3850 	 */
3851 	GHookFinalizeFunc finalizeHook;
3852 	/**
3853 	 * unused
3854 	 */
3855 	void*[2] dummy;
3856 }
3857 
3858 struct GIOChannel
3859 {
3860 	int refCount;
3861 	GIOFuncs* funcs;
3862 	char* encoding;
3863 	GIConv readCd;
3864 	GIConv writeCd;
3865 	char* lineTerm;
3866 	uint lineTermLen;
3867 	size_t bufSize;
3868 	GString* readBuf;
3869 	GString* encodedReadBuf;
3870 	GString* writeBuf;
3871 	char[6] partialWriteBuf;
3872 	import std.bitmanip: bitfields;
3873 	mixin(bitfields!(
3874 		uint, "useBuffer", 1,
3875 		uint, "doEncode", 1,
3876 		uint, "closeOnUnref", 1,
3877 		uint, "isReadable", 1,
3878 		uint, "isWriteable", 1,
3879 		uint, "isSeekable", 1,
3880 		uint, "", 26
3881 	));
3882 	void* reserved1;
3883 	void* reserved2;
3884 }
3885 
3886 /**
3887  * A table of functions used to handle different types of #GIOChannel
3888  * in a generic way.
3889  */
3890 struct GIOFuncs
3891 {
3892 	/** */
3893 	extern(C) GIOStatus function(GIOChannel* channel, char* buf, size_t count, size_t* bytesRead, GError** err) ioRead;
3894 	/** */
3895 	extern(C) GIOStatus function(GIOChannel* channel, const(char)* buf, size_t count, size_t* bytesWritten, GError** err) ioWrite;
3896 	/** */
3897 	extern(C) GIOStatus function(GIOChannel* channel, long offset, GSeekType type, GError** err) ioSeek;
3898 	/** */
3899 	extern(C) GIOStatus function(GIOChannel* channel, GError** err) ioClose;
3900 	/** */
3901 	extern(C) GSource* function(GIOChannel* channel, GIOCondition condition) ioCreateWatch;
3902 	/** */
3903 	extern(C) void function(GIOChannel* channel) ioFree;
3904 	/** */
3905 	extern(C) GIOStatus function(GIOChannel* channel, GIOFlags flags, GError** err) ioSetFlags;
3906 	/** */
3907 	extern(C) GIOFlags function(GIOChannel* channel) ioGetFlags;
3908 }
3909 
3910 struct GKeyFile;
3911 
3912 /**
3913  * The #GList struct is used for each element in a doubly-linked list.
3914  */
3915 struct GList
3916 {
3917 	/**
3918 	 * holds the element's data, which can be a pointer to any kind
3919 	 * of data, or any integer value using the
3920 	 * [Type Conversion Macros][glib-Type-Conversion-Macros]
3921 	 */
3922 	void* data;
3923 	/**
3924 	 * contains the link to the next element in the list
3925 	 */
3926 	GList* next;
3927 	/**
3928 	 * contains the link to the previous element in the list
3929 	 */
3930 	GList* prev;
3931 }
3932 
3933 /**
3934  * Structure representing a single field in a structured log entry. See
3935  * g_log_structured() for details.
3936  *
3937  * Log fields may contain arbitrary values, including binary with embedded nul
3938  * bytes. If the field contains a string, the string must be UTF-8 encoded and
3939  * have a trailing nul byte. Otherwise, @length must be set to a non-negative
3940  * value.
3941  *
3942  * Since: 2.50
3943  */
3944 struct GLogField
3945 {
3946 	/**
3947 	 * field name (UTF-8 string)
3948 	 */
3949 	const(char)* key;
3950 	/**
3951 	 * field value (arbitrary bytes)
3952 	 */
3953 	void* value;
3954 	/**
3955 	 * length of @value, in bytes, or -1 if it is nul-terminated
3956 	 */
3957 	ptrdiff_t length;
3958 }
3959 
3960 struct GMainContext;
3961 
3962 struct GMainLoop;
3963 
3964 struct GMappedFile;
3965 
3966 struct GMarkupParseContext;
3967 
3968 /**
3969  * Any of the fields in #GMarkupParser can be %NULL, in which case they
3970  * will be ignored. Except for the @error function, any of these callbacks
3971  * can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT,
3972  * %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT
3973  * errors are intended to be set from these callbacks. If you set an error
3974  * from a callback, g_markup_parse_context_parse() will report that error
3975  * back to its caller.
3976  */
3977 struct GMarkupParser
3978 {
3979 	/** */
3980 	extern(C) void function(GMarkupParseContext* context, const(char)* elementName, char** attributeNames, char** attributeValues, void* userData, GError** err) startElement;
3981 	/** */
3982 	extern(C) void function(GMarkupParseContext* context, const(char)* elementName, void* userData, GError** err) endElement;
3983 	/** */
3984 	extern(C) void function(GMarkupParseContext* context, const(char)* text, size_t textLen, void* userData, GError** err) text;
3985 	/** */
3986 	extern(C) void function(GMarkupParseContext* context, const(char)* passthroughText, size_t textLen, void* userData, GError** err) passthrough;
3987 	/** */
3988 	extern(C) void function(GMarkupParseContext* context, GError* error, void* userData) error;
3989 }
3990 
3991 struct GMatchInfo;
3992 
3993 /**
3994  * A set of functions used to perform memory allocation. The same #GMemVTable must
3995  * be used for all allocations in the same program; a call to g_mem_set_vtable(),
3996  * if it exists, should be prior to any use of GLib.
3997  *
3998  * This functions related to this has been deprecated in 2.46, and no longer work.
3999  */
4000 struct GMemVTable
4001 {
4002 	/** */
4003 	extern(C) void* function(size_t nBytes) malloc;
4004 	/** */
4005 	extern(C) void* function(void* mem, size_t nBytes) realloc;
4006 	/** */
4007 	extern(C) void function(void* mem) free;
4008 	/** */
4009 	extern(C) void* function(size_t nBlocks, size_t nBlockBytes) calloc;
4010 	/** */
4011 	extern(C) void* function(size_t nBytes) tryMalloc;
4012 	/** */
4013 	extern(C) void* function(void* mem, size_t nBytes) tryRealloc;
4014 }
4015 
4016 struct GMutex
4017 {
4018 	union
4019 	{
4020 		void* p;
4021 		uint[2] i;
4022 	}
4023 }
4024 
4025 struct GNode
4026 {
4027 	/**
4028 	 * contains the actual data of the node.
4029 	 */
4030 	void* data;
4031 	/**
4032 	 * points to the node's next sibling (a sibling is another
4033 	 * #GNode with the same parent).
4034 	 */
4035 	GNode* next;
4036 	/**
4037 	 * points to the node's previous sibling.
4038 	 */
4039 	GNode* prev;
4040 	/**
4041 	 * points to the parent of the #GNode, or is %NULL if the
4042 	 * #GNode is the root of the tree.
4043 	 */
4044 	GNode* parent;
4045 	/**
4046 	 * points to the first child of the #GNode.  The other
4047 	 * children are accessed by using the @next pointer of each
4048 	 * child.
4049 	 */
4050 	GNode* children;
4051 }
4052 
4053 struct GOnce
4054 {
4055 	/**
4056 	 * the status of the #GOnce
4057 	 */
4058 	GOnceStatus status;
4059 	/**
4060 	 * the value returned by the call to the function, if @status
4061 	 * is %G_ONCE_STATUS_READY
4062 	 */
4063 	void* retval;
4064 }
4065 
4066 struct GOptionContext;
4067 
4068 /**
4069  * A GOptionEntry struct defines a single option. To have an effect, they
4070  * must be added to a #GOptionGroup with g_option_context_add_main_entries()
4071  * or g_option_group_add_entries().
4072  */
4073 struct GOptionEntry
4074 {
4075 	/**
4076 	 * The long name of an option can be used to specify it
4077 	 * in a commandline as `--long_name`. Every option must have a
4078 	 * long name. To resolve conflicts if multiple option groups contain
4079 	 * the same long name, it is also possible to specify the option as
4080 	 * `--groupname-long_name`.
4081 	 */
4082 	const(char)* longName;
4083 	/**
4084 	 * If an option has a short name, it can be specified
4085 	 * `-short_name` in a commandline. @short_name must be  a printable
4086 	 * ASCII character different from '-', or zero if the option has no
4087 	 * short name.
4088 	 */
4089 	char shortName;
4090 	/**
4091 	 * Flags from #GOptionFlags
4092 	 */
4093 	int flags;
4094 	/**
4095 	 * The type of the option, as a #GOptionArg
4096 	 */
4097 	GOptionArg arg;
4098 	/**
4099 	 * If the @arg type is %G_OPTION_ARG_CALLBACK, then @arg_data
4100 	 * must point to a #GOptionArgFunc callback function, which will be
4101 	 * called to handle the extra argument. Otherwise, @arg_data is a
4102 	 * pointer to a location to store the value, the required type of
4103 	 * the location depends on the @arg type:
4104 	 * - %G_OPTION_ARG_NONE: %gboolean
4105 	 * - %G_OPTION_ARG_STRING: %gchar*
4106 	 * - %G_OPTION_ARG_INT: %gint
4107 	 * - %G_OPTION_ARG_FILENAME: %gchar*
4108 	 * - %G_OPTION_ARG_STRING_ARRAY: %gchar**
4109 	 * - %G_OPTION_ARG_FILENAME_ARRAY: %gchar**
4110 	 * - %G_OPTION_ARG_DOUBLE: %gdouble
4111 	 * If @arg type is %G_OPTION_ARG_STRING or %G_OPTION_ARG_FILENAME,
4112 	 * the location will contain a newly allocated string if the option
4113 	 * was given. That string needs to be freed by the callee using g_free().
4114 	 * Likewise if @arg type is %G_OPTION_ARG_STRING_ARRAY or
4115 	 * %G_OPTION_ARG_FILENAME_ARRAY, the data should be freed using g_strfreev().
4116 	 */
4117 	void* argData;
4118 	/**
4119 	 * the description for the option in `--help`
4120 	 * output. The @description is translated using the @translate_func
4121 	 * of the group, see g_option_group_set_translation_domain().
4122 	 */
4123 	const(char)* description;
4124 	/**
4125 	 * The placeholder to use for the extra argument parsed
4126 	 * by the option in `--help` output. The @arg_description is translated
4127 	 * using the @translate_func of the group, see
4128 	 * g_option_group_set_translation_domain().
4129 	 */
4130 	const(char)* argDescription;
4131 }
4132 
4133 struct GOptionGroup;
4134 
4135 struct GPatternSpec;
4136 
4137 /**
4138  * Represents a file descriptor, which events to poll for, and which events
4139  * occurred.
4140  */
4141 struct GPollFD
4142 {
4143 	/**
4144 	 * the file descriptor to poll (or a HANDLE on Win32)
4145 	 */
4146 	int fd;
4147 	/**
4148 	 * a bitwise combination from #GIOCondition, specifying which
4149 	 * events should be polled for. Typically for reading from a file
4150 	 * descriptor you would use %G_IO_IN | %G_IO_HUP | %G_IO_ERR, and
4151 	 * for writing you would use %G_IO_OUT | %G_IO_ERR.
4152 	 */
4153 	ushort events;
4154 	/**
4155 	 * a bitwise combination of flags from #GIOCondition, returned
4156 	 * from the poll() function to indicate which events occurred.
4157 	 */
4158 	ushort revents;
4159 }
4160 
4161 struct GPrivate
4162 {
4163 	void* p;
4164 	GDestroyNotify notify;
4165 	void*[2] future;
4166 }
4167 
4168 /**
4169  * Contains the public fields of a pointer array.
4170  */
4171 struct GPtrArray
4172 {
4173 	/**
4174 	 * points to the array of pointers, which may be moved when the
4175 	 * array grows
4176 	 */
4177 	void** pdata;
4178 	/**
4179 	 * number of pointers in the array
4180 	 */
4181 	uint len;
4182 }
4183 
4184 struct GQueue
4185 {
4186 	/**
4187 	 * a pointer to the first element of the queue
4188 	 */
4189 	GList* head;
4190 	/**
4191 	 * a pointer to the last element of the queue
4192 	 */
4193 	GList* tail;
4194 	/**
4195 	 * the number of elements in the queue
4196 	 */
4197 	uint length;
4198 }
4199 
4200 struct GRWLock
4201 {
4202 	void* p;
4203 	uint[2] i;
4204 }
4205 
4206 struct GRand;
4207 
4208 struct GRecMutex
4209 {
4210 	void* p;
4211 	uint[2] i;
4212 }
4213 
4214 struct GRegex;
4215 
4216 /**
4217  * The #GSList struct is used for each element in the singly-linked
4218  * list.
4219  */
4220 struct GSList
4221 {
4222 	/**
4223 	 * holds the element's data, which can be a pointer to any kind
4224 	 * of data, or any integer value using the
4225 	 * [Type Conversion Macros][glib-Type-Conversion-Macros]
4226 	 */
4227 	void* data;
4228 	/**
4229 	 * contains the link to the next element in the list.
4230 	 */
4231 	GSList* next;
4232 }
4233 
4234 struct GScanner
4235 {
4236 	/**
4237 	 * unused
4238 	 */
4239 	void* userData;
4240 	/**
4241 	 * unused
4242 	 */
4243 	uint maxParseErrors;
4244 	/**
4245 	 * g_scanner_error() increments this field
4246 	 */
4247 	uint parseErrors;
4248 	/**
4249 	 * name of input stream, featured by the default message handler
4250 	 */
4251 	const(char)* inputName;
4252 	/**
4253 	 * quarked data
4254 	 */
4255 	GData* qdata;
4256 	/**
4257 	 * link into the scanner configuration
4258 	 */
4259 	GScannerConfig* config;
4260 	/**
4261 	 * token parsed by the last g_scanner_get_next_token()
4262 	 */
4263 	GTokenType token;
4264 	/**
4265 	 * value of the last token from g_scanner_get_next_token()
4266 	 */
4267 	GTokenValue value;
4268 	/**
4269 	 * line number of the last token from g_scanner_get_next_token()
4270 	 */
4271 	uint line;
4272 	/**
4273 	 * char number of the last token from g_scanner_get_next_token()
4274 	 */
4275 	uint position;
4276 	/**
4277 	 * token parsed by the last g_scanner_peek_next_token()
4278 	 */
4279 	GTokenType nextToken;
4280 	/**
4281 	 * value of the last token from g_scanner_peek_next_token()
4282 	 */
4283 	GTokenValue nextValue;
4284 	/**
4285 	 * line number of the last token from g_scanner_peek_next_token()
4286 	 */
4287 	uint nextLine;
4288 	/**
4289 	 * char number of the last token from g_scanner_peek_next_token()
4290 	 */
4291 	uint nextPosition;
4292 	GHashTable* symbolTable;
4293 	int inputFd;
4294 	const(char)* text;
4295 	const(char)* textEnd;
4296 	char* buffer;
4297 	uint scopeId;
4298 	/**
4299 	 * handler function for _warn and _error
4300 	 */
4301 	GScannerMsgFunc msgHandler;
4302 }
4303 
4304 /**
4305  * Specifies the #GScanner parser configuration. Most settings can
4306  * be changed during the parsing phase and will affect the lexical
4307  * parsing of the next unpeeked token.
4308  */
4309 struct GScannerConfig
4310 {
4311 	/**
4312 	 * specifies which characters should be skipped
4313 	 * by the scanner (the default is the whitespace characters: space,
4314 	 * tab, carriage-return and line-feed).
4315 	 */
4316 	char* csetSkipCharacters;
4317 	/**
4318 	 * specifies the characters which can start
4319 	 * identifiers (the default is #G_CSET_a_2_z, "_", and #G_CSET_A_2_Z).
4320 	 */
4321 	char* csetIdentifierFirst;
4322 	/**
4323 	 * specifies the characters which can be used
4324 	 * in identifiers, after the first character (the default is
4325 	 * #G_CSET_a_2_z, "_0123456789", #G_CSET_A_2_Z, #G_CSET_LATINS,
4326 	 * #G_CSET_LATINC).
4327 	 */
4328 	char* csetIdentifierNth;
4329 	/**
4330 	 * specifies the characters at the start and
4331 	 * end of single-line comments. The default is "#\n" which means
4332 	 * that single-line comments start with a '#' and continue until
4333 	 * a '\n' (end of line).
4334 	 */
4335 	char* cpairCommentSingle;
4336 	import std.bitmanip: bitfields;
4337 	mixin(bitfields!(
4338 		uint, "caseSensitive", 1,
4339 		uint, "skipCommentMulti", 1,
4340 		uint, "skipCommentSingle", 1,
4341 		uint, "scanCommentMulti", 1,
4342 		uint, "scanIdentifier", 1,
4343 		uint, "scanIdentifier1char", 1,
4344 		uint, "scanIdentifierNULL", 1,
4345 		uint, "scanSymbols", 1,
4346 		uint, "scanBinary", 1,
4347 		uint, "scanOctal", 1,
4348 		uint, "scanFloat", 1,
4349 		uint, "scanHex", 1,
4350 		uint, "scanHexDollar", 1,
4351 		uint, "scanStringSq", 1,
4352 		uint, "scanStringDq", 1,
4353 		uint, "numbers2Int", 1,
4354 		uint, "int2Float", 1,
4355 		uint, "identifier2String", 1,
4356 		uint, "char2Token", 1,
4357 		uint, "symbol2Token", 1,
4358 		uint, "scope0Fallback", 1,
4359 		uint, "storeInt64", 1,
4360 		uint, "", 10
4361 	));
4362 	uint paddingDummy;
4363 }
4364 
4365 struct GSequence;
4366 
4367 struct GSequenceIter;
4368 
4369 struct GSource
4370 {
4371 	void* callbackData;
4372 	GSourceCallbackFuncs* callbackFuncs;
4373 	GSourceFuncs* sourceFuncs;
4374 	uint refCount;
4375 	GMainContext* context;
4376 	int priority;
4377 	uint flags;
4378 	uint sourceId;
4379 	GSList* pollFds;
4380 	GSource* prev;
4381 	GSource* next;
4382 	char* name;
4383 	GSourcePrivate* priv;
4384 }
4385 
4386 /**
4387  * The `GSourceCallbackFuncs` struct contains
4388  * functions for managing callback objects.
4389  */
4390 struct GSourceCallbackFuncs
4391 {
4392 	/** */
4393 	extern(C) void function(void* cbData) doref;
4394 	/** */
4395 	extern(C) void function(void* cbData) unref;
4396 	/** */
4397 	extern(C) void function(void* cbData, GSource* source, GSourceFunc* func, void** data) get;
4398 }
4399 
4400 /**
4401  * The `GSourceFuncs` struct contains a table of
4402  * functions used to handle event sources in a generic manner.
4403  *
4404  * For idle sources, the prepare and check functions always return %TRUE
4405  * to indicate that the source is always ready to be processed. The prepare
4406  * function also returns a timeout value of 0 to ensure that the poll() call
4407  * doesn't block (since that would be time wasted which could have been spent
4408  * running the idle function).
4409  *
4410  * For timeout sources, the prepare and check functions both return %TRUE
4411  * if the timeout interval has expired. The prepare function also returns
4412  * a timeout value to ensure that the poll() call doesn't block too long
4413  * and miss the next timeout.
4414  *
4415  * For file descriptor sources, the prepare function typically returns %FALSE,
4416  * since it must wait until poll() has been called before it knows whether
4417  * any events need to be processed. It sets the returned timeout to -1 to
4418  * indicate that it doesn't mind how long the poll() call blocks. In the
4419  * check function, it tests the results of the poll() call to see if the
4420  * required condition has been met, and returns %TRUE if so.
4421  */
4422 struct GSourceFuncs
4423 {
4424 	/** */
4425 	extern(C) int function(GSource* source, int* timeout) prepare;
4426 	/** */
4427 	extern(C) int function(GSource* source) check;
4428 	/** */
4429 	extern(C) int function(GSource* source, GSourceFunc callback, void* userData) dispatch;
4430 	/** */
4431 	extern(C) void function(GSource* source) finalize;
4432 	GSourceFunc closureCallback;
4433 	GSourceDummyMarshal closureMarshal;
4434 }
4435 
4436 struct GSourcePrivate;
4437 
4438 /**
4439  * A type corresponding to the appropriate struct type for the stat()
4440  * system call, depending on the platform and/or compiler being used.
4441  *
4442  * See g_stat() for more information.
4443  */
4444 struct GStatBuf;
4445 
4446 struct GString
4447 {
4448 	/**
4449 	 * points to the character data. It may move as text is added.
4450 	 * The @str field is null-terminated and so
4451 	 * can be used as an ordinary C string.
4452 	 */
4453 	char* str;
4454 	/**
4455 	 * contains the length of the string, not including the
4456 	 * terminating nul byte.
4457 	 */
4458 	size_t len;
4459 	/**
4460 	 * the number of bytes that can be stored in the
4461 	 * string before it needs to be reallocated. May be larger than @len.
4462 	 */
4463 	size_t allocatedLen;
4464 }
4465 
4466 struct GStringChunk;
4467 
4468 /**
4469  * An opaque structure representing a test case.
4470  */
4471 struct GTestCase;
4472 
4473 struct GTestConfig
4474 {
4475 	bool testInitialized;
4476 	bool testQuick;
4477 	bool testPerf;
4478 	bool testVerbose;
4479 	bool testQuiet;
4480 	bool testUndefined;
4481 }
4482 
4483 struct GTestLogBuffer
4484 {
4485 	GString* data;
4486 	GSList* msgs;
4487 }
4488 
4489 struct GTestLogMsg
4490 {
4491 	GTestLogType logType;
4492 	uint nStrings;
4493 	char** strings;
4494 	uint nNums;
4495 	long* nums;
4496 }
4497 
4498 struct GTestSuite;
4499 
4500 struct GThread;
4501 
4502 struct GThreadPool
4503 {
4504 	/**
4505 	 * the function to execute in the threads of this pool
4506 	 */
4507 	GFunc func;
4508 	/**
4509 	 * the user data for the threads of this pool
4510 	 */
4511 	void* userData;
4512 	/**
4513 	 * are all threads exclusive to this pool
4514 	 */
4515 	bool exclusive;
4516 }
4517 
4518 struct GTimeVal
4519 {
4520 	/**
4521 	 * seconds
4522 	 */
4523 	glong tvSec;
4524 	/**
4525 	 * microseconds
4526 	 */
4527 	glong tvUsec;
4528 }
4529 
4530 struct GTimeZone;
4531 
4532 struct GTimer;
4533 
4534 /**
4535  * A union holding the value of the token.
4536  */
4537 struct GTokenValue
4538 {
4539 	union
4540 	{
4541 		/**
4542 		 * token symbol value
4543 		 */
4544 		void* vSymbol;
4545 		/**
4546 		 * token identifier value
4547 		 */
4548 		char* vIdentifier;
4549 		/**
4550 		 * token binary integer value
4551 		 */
4552 		gulong vBinary;
4553 		/**
4554 		 * octal integer value
4555 		 */
4556 		gulong vOctal;
4557 		/**
4558 		 * integer value
4559 		 */
4560 		gulong vInt;
4561 		/**
4562 		 * 64-bit integer value
4563 		 */
4564 		ulong vInt64;
4565 		/**
4566 		 * floating point value
4567 		 */
4568 		double vFloat;
4569 		/**
4570 		 * hex integer value
4571 		 */
4572 		gulong vHex;
4573 		/**
4574 		 * string value
4575 		 */
4576 		char* vString;
4577 		/**
4578 		 * comment value
4579 		 */
4580 		char* vComment;
4581 		/**
4582 		 * character value
4583 		 */
4584 		char vChar;
4585 		/**
4586 		 * error value
4587 		 */
4588 		uint vError;
4589 	}
4590 }
4591 
4592 /**
4593  * Each piece of memory that is pushed onto the stack
4594  * is cast to a GTrashStack*.
4595  *
4596  * Deprecated: #GTrashStack is deprecated without replacement
4597  */
4598 struct GTrashStack
4599 {
4600 	/**
4601 	 * pointer to the previous element of the stack,
4602 	 * gets stored in the first `sizeof (gpointer)`
4603 	 * bytes of the element
4604 	 */
4605 	GTrashStack* next;
4606 }
4607 
4608 struct GTree;
4609 
4610 struct GVariant;
4611 
4612 struct GVariantBuilder
4613 {
4614 	union U
4615 	{
4616 		struct S
4617 		{
4618 			size_t partialMagic;
4619 			GVariantType* type;
4620 			size_t[14] y;
4621 		}
4622 		S s;
4623 		size_t[16] x;
4624 	}
4625 	U u;
4626 }
4627 
4628 struct GVariantDict
4629 {
4630 	union U
4631 	{
4632 		struct S
4633 		{
4634 			GVariant* asv;
4635 			size_t partialMagic;
4636 			size_t[14] y;
4637 		}
4638 		S s;
4639 		size_t[16] x;
4640 	}
4641 	U u;
4642 }
4643 
4644 struct GVariantIter
4645 {
4646 	size_t[16] x;
4647 }
4648 
4649 struct GVariantType;
4650 
4651 struct GModule;
4652 
4653 /**
4654  * Prototype of a #GChildWatchSource callback, called when a child
4655  * process has exited.  To interpret @status, see the documentation
4656  * for g_spawn_check_exit_status().
4657  *
4658  * Params:
4659  *     pid = the process id of the child process
4660  *     status = Status information about the child process, encoded
4661  *         in a platform-specific manner
4662  *     userData = user data passed to g_child_watch_add()
4663  */
4664 public alias extern(C) void function(GPid pid, int status, void* userData) GChildWatchFunc;
4665 
4666 /**
4667  * Specifies the type of function passed to g_clear_handle_id().
4668  * The implementation is expected to free the resource identified
4669  * by @handle_id; for instance, if @handle_id is a #GSource ID,
4670  * g_source_remove() can be used.
4671  *
4672  * Params:
4673  *     handleId = the handle ID to clear
4674  *
4675  * Since: 2.56
4676  */
4677 public alias extern(C) void function(uint handleId) GClearHandleFunc;
4678 
4679 /**
4680  * Specifies the type of a comparison function used to compare two
4681  * values.  The function should return a negative integer if the first
4682  * value comes before the second, 0 if they are equal, or a positive
4683  * integer if the first value comes after the second.
4684  *
4685  * Params:
4686  *     a = a value
4687  *     b = a value to compare with
4688  *     userData = user data
4689  *
4690  * Returns: negative value if @a < @b; zero if @a = @b; positive
4691  *     value if @a > @b
4692  */
4693 public alias extern(C) int function(void* a, void* b, void* userData) GCompareDataFunc;
4694 
4695 /**
4696  * Specifies the type of a comparison function used to compare two
4697  * values.  The function should return a negative integer if the first
4698  * value comes before the second, 0 if they are equal, or a positive
4699  * integer if the first value comes after the second.
4700  *
4701  * Params:
4702  *     a = a value
4703  *     b = a value to compare with
4704  *
4705  * Returns: negative value if @a < @b; zero if @a = @b; positive
4706  *     value if @a > @b
4707  */
4708 public alias extern(C) int function(void* a, void* b) GCompareFunc;
4709 
4710 /**
4711  * A function of this signature is used to copy the node data
4712  * when doing a deep-copy of a tree.
4713  *
4714  * Params:
4715  *     src = A pointer to the data which should be copied
4716  *     data = Additional data
4717  *
4718  * Returns: A pointer to the copy
4719  *
4720  * Since: 2.4
4721  */
4722 public alias extern(C) void* function(void* src, void* data) GCopyFunc;
4723 
4724 /**
4725  * Specifies the type of function passed to g_dataset_foreach(). It is
4726  * called with each #GQuark id and associated data element, together
4727  * with the @user_data parameter supplied to g_dataset_foreach().
4728  *
4729  * Params:
4730  *     keyId = the #GQuark id to identifying the data element.
4731  *     data = the data element.
4732  *     userData = user data passed to g_dataset_foreach().
4733  */
4734 public alias extern(C) void function(GQuark keyId, void* data, void* userData) GDataForeachFunc;
4735 
4736 /**
4737  * Specifies the type of function which is called when a data element
4738  * is destroyed. It is passed the pointer to the data element and
4739  * should free any memory and resources allocated for it.
4740  *
4741  * Params:
4742  *     data = the data element.
4743  */
4744 public alias extern(C) void function(void* data) GDestroyNotify;
4745 
4746 /**
4747  * The type of functions that are used to 'duplicate' an object.
4748  * What this means depends on the context, it could just be
4749  * incrementing the reference count, if @data is a ref-counted
4750  * object.
4751  *
4752  * Params:
4753  *     data = the data to duplicate
4754  *     userData = user data that was specified in
4755  *         g_datalist_id_dup_data()
4756  *
4757  * Returns: a duplicate of data
4758  */
4759 public alias extern(C) void* function(void* data, void* userData) GDuplicateFunc;
4760 
4761 /**
4762  * Specifies the type of a function used to test two values for
4763  * equality. The function should return %TRUE if both values are equal
4764  * and %FALSE otherwise.
4765  *
4766  * Params:
4767  *     a = a value
4768  *     b = a value to compare with
4769  *
4770  * Returns: %TRUE if @a = @b; %FALSE otherwise
4771  */
4772 public alias extern(C) int function(void* a, void* b) GEqualFunc;
4773 
4774 /**
4775  * Declares a type of function which takes an arbitrary
4776  * data pointer argument and has no return value. It is
4777  * not currently used in GLib or GTK+.
4778  *
4779  * Params:
4780  *     data = a data pointer
4781  */
4782 public alias extern(C) void function(void* data) GFreeFunc;
4783 
4784 /**
4785  * Specifies the type of functions passed to g_list_foreach() and
4786  * g_slist_foreach().
4787  *
4788  * Params:
4789  *     data = the element's data
4790  *     userData = user data passed to g_list_foreach() or g_slist_foreach()
4791  */
4792 public alias extern(C) void function(void* data, void* userData) GFunc;
4793 
4794 /**
4795  * Specifies the type of the function passed to g_hash_table_foreach().
4796  * It is called with each key/value pair, together with the @user_data
4797  * parameter which is passed to g_hash_table_foreach().
4798  *
4799  * Params:
4800  *     key = a key
4801  *     value = the value corresponding to the key
4802  *     userData = user data passed to g_hash_table_foreach()
4803  */
4804 public alias extern(C) void function(void* key, void* value, void* userData) GHFunc;
4805 
4806 /**
4807  * Specifies the type of the function passed to
4808  * g_hash_table_foreach_remove(). It is called with each key/value
4809  * pair, together with the @user_data parameter passed to
4810  * g_hash_table_foreach_remove(). It should return %TRUE if the
4811  * key/value pair should be removed from the #GHashTable.
4812  *
4813  * Params:
4814  *     key = a key
4815  *     value = the value associated with the key
4816  *     userData = user data passed to g_hash_table_remove()
4817  *
4818  * Returns: %TRUE if the key/value pair should be removed from the
4819  *     #GHashTable
4820  */
4821 public alias extern(C) int function(void* key, void* value, void* userData) GHRFunc;
4822 
4823 /**
4824  * Specifies the type of the hash function which is passed to
4825  * g_hash_table_new() when a #GHashTable is created.
4826  *
4827  * The function is passed a key and should return a #guint hash value.
4828  * The functions g_direct_hash(), g_int_hash() and g_str_hash() provide
4829  * hash functions which can be used when the key is a #gpointer, #gint*,
4830  * and #gchar* respectively.
4831  *
4832  * g_direct_hash() is also the appropriate hash function for keys
4833  * of the form `GINT_TO_POINTER (n)` (or similar macros).
4834  *
4835  * A good hash functions should produce
4836  * hash values that are evenly distributed over a fairly large range.
4837  * The modulus is taken with the hash table size (a prime number) to
4838  * find the 'bucket' to place each key into. The function should also
4839  * be very fast, since it is called for each key lookup.
4840  *
4841  * Note that the hash functions provided by GLib have these qualities,
4842  * but are not particularly robust against manufactured keys that
4843  * cause hash collisions. Therefore, you should consider choosing
4844  * a more secure hash function when using a GHashTable with keys
4845  * that originate in untrusted data (such as HTTP requests).
4846  * Using g_str_hash() in that situation might make your application
4847  * vulerable to
4848  * [Algorithmic Complexity Attacks](https://lwn.net/Articles/474912/).
4849  *
4850  * The key to choosing a good hash is unpredictability.  Even
4851  * cryptographic hashes are very easy to find collisions for when the
4852  * remainder is taken modulo a somewhat predictable prime number.  There
4853  * must be an element of randomness that an attacker is unable to guess.
4854  *
4855  * Params:
4856  *     key = a key
4857  *
4858  * Returns: the hash value corresponding to the key
4859  */
4860 public alias extern(C) uint function(void* key) GHashFunc;
4861 
4862 /**
4863  * Defines the type of a hook function that can be invoked
4864  * by g_hook_list_invoke_check().
4865  *
4866  * Params:
4867  *     data = the data field of the #GHook is passed to the hook function here
4868  *
4869  * Returns: %FALSE if the #GHook should be destroyed
4870  */
4871 public alias extern(C) int function(void* data) GHookCheckFunc;
4872 
4873 /**
4874  * Defines the type of function used by g_hook_list_marshal_check().
4875  *
4876  * Params:
4877  *     hook = a #GHook
4878  *     marshalData = user data
4879  *
4880  * Returns: %FALSE if @hook should be destroyed
4881  */
4882 public alias extern(C) int function(GHook* hook, void* marshalData) GHookCheckMarshaller;
4883 
4884 /**
4885  * Defines the type of function used to compare #GHook elements in
4886  * g_hook_insert_sorted().
4887  *
4888  * Params:
4889  *     newHook = the #GHook being inserted
4890  *     sibling = the #GHook to compare with @new_hook
4891  *
4892  * Returns: a value <= 0 if @new_hook should be before @sibling
4893  */
4894 public alias extern(C) int function(GHook* newHook, GHook* sibling) GHookCompareFunc;
4895 
4896 /**
4897  * Defines the type of function to be called when a hook in a
4898  * list of hooks gets finalized.
4899  *
4900  * Params:
4901  *     hookList = a #GHookList
4902  *     hook = the hook in @hook_list that gets finalized
4903  */
4904 public alias extern(C) void function(GHookList* hookList, GHook* hook) GHookFinalizeFunc;
4905 
4906 /**
4907  * Defines the type of the function passed to g_hook_find().
4908  *
4909  * Params:
4910  *     hook = a #GHook
4911  *     data = user data passed to g_hook_find_func()
4912  *
4913  * Returns: %TRUE if the required #GHook has been found
4914  */
4915 public alias extern(C) int function(GHook* hook, void* data) GHookFindFunc;
4916 
4917 /**
4918  * Defines the type of a hook function that can be invoked
4919  * by g_hook_list_invoke().
4920  *
4921  * Params:
4922  *     data = the data field of the #GHook is passed to the hook function here
4923  */
4924 public alias extern(C) void function(void* data) GHookFunc;
4925 
4926 /**
4927  * Defines the type of function used by g_hook_list_marshal().
4928  *
4929  * Params:
4930  *     hook = a #GHook
4931  *     marshalData = user data
4932  */
4933 public alias extern(C) void function(GHook* hook, void* marshalData) GHookMarshaller;
4934 
4935 /**
4936  * Specifies the type of function passed to g_io_add_watch() or
4937  * g_io_add_watch_full(), which is called when the requested condition
4938  * on a #GIOChannel is satisfied.
4939  *
4940  * Params:
4941  *     source = the #GIOChannel event source
4942  *     condition = the condition which has been satisfied
4943  *     data = user data set in g_io_add_watch() or g_io_add_watch_full()
4944  *
4945  * Returns: the function should return %FALSE if the event source
4946  *     should be removed
4947  */
4948 public alias extern(C) int function(GIOChannel* source, GIOCondition condition, void* data) GIOFunc;
4949 
4950 /**
4951  * Specifies the prototype of log handler functions.
4952  *
4953  * The default log handler, g_log_default_handler(), automatically appends a
4954  * new-line character to @message when printing it. It is advised that any
4955  * custom log handler functions behave similarly, so that logging calls in user
4956  * code do not need modifying to add a new-line character to the message if the
4957  * log handler is changed.
4958  *
4959  * This is not used if structured logging is enabled; see
4960  * [Using Structured Logging][using-structured-logging].
4961  *
4962  * Params:
4963  *     logDomain = the log domain of the message
4964  *     logLevel = the log level of the message (including the
4965  *         fatal and recursion flags)
4966  *     message = the message to process
4967  *     userData = user data, set in g_log_set_handler()
4968  */
4969 public alias extern(C) void function(const(char)* logDomain, GLogLevelFlags logLevel, const(char)* message, void* userData) GLogFunc;
4970 
4971 /**
4972  * Writer function for log entries. A log entry is a collection of one or more
4973  * #GLogFields, using the standard [field names from journal
4974  * specification](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html).
4975  * See g_log_structured() for more information.
4976  *
4977  * Writer functions must ignore fields which they do not recognise, unless they
4978  * can write arbitrary binary output, as field values may be arbitrary binary.
4979  *
4980  * @log_level is guaranteed to be included in @fields as the `PRIORITY` field,
4981  * but is provided separately for convenience of deciding whether or where to
4982  * output the log entry.
4983  *
4984  * Writer functions should return %G_LOG_WRITER_HANDLED if they handled the log
4985  * message successfully or if they deliberately ignored it. If there was an
4986  * error handling the message (for example, if the writer function is meant to
4987  * send messages to a remote logging server and there is a network error), it
4988  * should return %G_LOG_WRITER_UNHANDLED. This allows writer functions to be
4989  * chained and fall back to simpler handlers in case of failure.
4990  *
4991  * Params:
4992  *     logLevel = log level of the message
4993  *     fields = fields forming the message
4994  *     nFields = number of @fields
4995  *     userData = user data passed to g_log_set_writer_func()
4996  *
4997  * Returns: %G_LOG_WRITER_HANDLED if the log entry was handled successfully;
4998  *     %G_LOG_WRITER_UNHANDLED otherwise
4999  *
5000  * Since: 2.50
5001  */
5002 public alias extern(C) GLogWriterOutput function(GLogLevelFlags logLevel, GLogField* fields, size_t nFields, void* userData) GLogWriterFunc;
5003 
5004 /**
5005  * Specifies the type of function passed to g_node_children_foreach().
5006  * The function is called with each child node, together with the user
5007  * data passed to g_node_children_foreach().
5008  *
5009  * Params:
5010  *     node = a #GNode.
5011  *     data = user data passed to g_node_children_foreach().
5012  */
5013 public alias extern(C) void function(GNode* node, void* data) GNodeForeachFunc;
5014 
5015 /**
5016  * Specifies the type of function passed to g_node_traverse(). The
5017  * function is called with each of the nodes visited, together with the
5018  * user data passed to g_node_traverse(). If the function returns
5019  * %TRUE, then the traversal is stopped.
5020  *
5021  * Params:
5022  *     node = a #GNode.
5023  *     data = user data passed to g_node_traverse().
5024  *
5025  * Returns: %TRUE to stop the traversal.
5026  */
5027 public alias extern(C) int function(GNode* node, void* data) GNodeTraverseFunc;
5028 
5029 /**
5030  * The type of function to be passed as callback for %G_OPTION_ARG_CALLBACK
5031  * options.
5032  *
5033  * Params:
5034  *     optionName = The name of the option being parsed. This will be either a
5035  *         single dash followed by a single letter (for a short name) or two dashes
5036  *         followed by a long option name.
5037  *     value = The value to be parsed.
5038  *     data = User data added to the #GOptionGroup containing the option when it
5039  *         was created with g_option_group_new()
5040  *
5041  * Returns: %TRUE if the option was successfully parsed, %FALSE if an error
5042  *     occurred, in which case @error should be set with g_set_error()
5043  *
5044  * Throws: GException on failure.
5045  */
5046 public alias extern(C) int function(const(char)* optionName, const(char)* value, void* data, GError** err) GOptionArgFunc;
5047 
5048 /**
5049  * The type of function to be used as callback when a parse error occurs.
5050  *
5051  * Params:
5052  *     context = The active #GOptionContext
5053  *     group = The group to which the function belongs
5054  *     data = User data added to the #GOptionGroup containing the option when it
5055  *         was created with g_option_group_new()
5056  *
5057  * Throws: GException on failure.
5058  */
5059 public alias extern(C) void function(GOptionContext* context, GOptionGroup* group, void* data, GError** err) GOptionErrorFunc;
5060 
5061 /**
5062  * The type of function that can be called before and after parsing.
5063  *
5064  * Params:
5065  *     context = The active #GOptionContext
5066  *     group = The group to which the function belongs
5067  *     data = User data added to the #GOptionGroup containing the option when it
5068  *         was created with g_option_group_new()
5069  *
5070  * Returns: %TRUE if the function completed successfully, %FALSE if an error
5071  *     occurred, in which case @error should be set with g_set_error()
5072  *
5073  * Throws: GException on failure.
5074  */
5075 public alias extern(C) int function(GOptionContext* context, GOptionGroup* group, void* data, GError** err) GOptionParseFunc;
5076 
5077 /**
5078  * Specifies the type of function passed to g_main_context_set_poll_func().
5079  * The semantics of the function should match those of the poll() system call.
5080  *
5081  * Params:
5082  *     ufds = an array of #GPollFD elements
5083  *     nfsd = the number of elements in @ufds
5084  *     timeout = the maximum time to wait for an event of the file descriptors.
5085  *         A negative value indicates an infinite timeout.
5086  *
5087  * Returns: the number of #GPollFD elements which have events or errors
5088  *     reported, or -1 if an error occurred.
5089  */
5090 public alias extern(C) int function(GPollFD* ufds, uint nfsd, int timeout) GPollFunc;
5091 
5092 /**
5093  * Specifies the type of the print handler functions.
5094  * These are called with the complete formatted string to output.
5095  *
5096  * Params:
5097  *     str = the message to output
5098  */
5099 public alias extern(C) void function(const(char)* str) GPrintFunc;
5100 
5101 /**
5102  * Specifies the type of the function passed to g_regex_replace_eval().
5103  * It is called for each occurrence of the pattern in the string passed
5104  * to g_regex_replace_eval(), and it should append the replacement to
5105  * @result.
5106  *
5107  * Params:
5108  *     matchInfo = the #GMatchInfo generated by the match.
5109  *         Use g_match_info_get_regex() and g_match_info_get_string() if you
5110  *         need the #GRegex or the matched string.
5111  *     result = a #GString containing the new string
5112  *     userData = user data passed to g_regex_replace_eval()
5113  *
5114  * Returns: %FALSE to continue the replacement process, %TRUE to stop it
5115  *
5116  * Since: 2.14
5117  */
5118 public alias extern(C) int function(GMatchInfo* matchInfo, GString* result, void* userData) GRegexEvalCallback;
5119 
5120 /**
5121  * Specifies the type of the message handler function.
5122  *
5123  * Params:
5124  *     scanner = a #GScanner
5125  *     message = the message
5126  *     error = %TRUE if the message signals an error,
5127  *         %FALSE if it signals a warning.
5128  */
5129 public alias extern(C) void function(GScanner* scanner, char* message, int error) GScannerMsgFunc;
5130 
5131 /**
5132  * A #GSequenceIterCompareFunc is a function used to compare iterators.
5133  * It must return zero if the iterators compare equal, a negative value
5134  * if @a comes before @b, and a positive value if @b comes before @a.
5135  *
5136  * Params:
5137  *     a = a #GSequenceIter
5138  *     b = a #GSequenceIter
5139  *     data = user data
5140  *
5141  * Returns: zero if the iterators are equal, a negative value if @a
5142  *     comes before @b, and a positive value if @b comes before @a.
5143  */
5144 public alias extern(C) int function(GSequenceIter* a, GSequenceIter* b, void* data) GSequenceIterCompareFunc;
5145 
5146 /**
5147  * This is just a placeholder for #GClosureMarshal,
5148  * which cannot be used here for dependency reasons.
5149  */
5150 public alias extern(C) void function() GSourceDummyMarshal;
5151 
5152 /**
5153  * Specifies the type of function passed to g_timeout_add(),
5154  * g_timeout_add_full(), g_idle_add(), and g_idle_add_full().
5155  *
5156  * Params:
5157  *     userData = data passed to the function, set when the source was
5158  *         created with one of the above functions
5159  *
5160  * Returns: %FALSE if the source should be removed. #G_SOURCE_CONTINUE and
5161  *     #G_SOURCE_REMOVE are more memorable names for the return value.
5162  */
5163 public alias extern(C) int function(void* userData) GSourceFunc;
5164 
5165 /**
5166  * Specifies the type of the setup function passed to g_spawn_async(),
5167  * g_spawn_sync() and g_spawn_async_with_pipes(), which can, in very
5168  * limited ways, be used to affect the child's execution.
5169  *
5170  * On POSIX platforms, the function is called in the child after GLib
5171  * has performed all the setup it plans to perform, but before calling
5172  * exec(). Actions taken in this function will only affect the child,
5173  * not the parent.
5174  *
5175  * On Windows, the function is called in the parent. Its usefulness on
5176  * Windows is thus questionable. In many cases executing the child setup
5177  * function in the parent can have ill effects, and you should be very
5178  * careful when porting software to Windows that uses child setup
5179  * functions.
5180  *
5181  * However, even on POSIX, you are extremely limited in what you can
5182  * safely do from a #GSpawnChildSetupFunc, because any mutexes that were
5183  * held by other threads in the parent process at the time of the fork()
5184  * will still be locked in the child process, and they will never be
5185  * unlocked (since the threads that held them don't exist in the child).
5186  * POSIX allows only async-signal-safe functions (see signal(7)) to be
5187  * called in the child between fork() and exec(), which drastically limits
5188  * the usefulness of child setup functions.
5189  *
5190  * In particular, it is not safe to call any function which may
5191  * call malloc(), which includes POSIX functions such as setenv().
5192  * If you need to set up the child environment differently from
5193  * the parent, you should use g_get_environ(), g_environ_setenv(),
5194  * and g_environ_unsetenv(), and then pass the complete environment
5195  * list to the `g_spawn...` function.
5196  *
5197  * Params:
5198  *     userData = user data to pass to the function.
5199  */
5200 public alias extern(C) void function(void* userData) GSpawnChildSetupFunc;
5201 
5202 /**
5203  * The type used for test case functions that take an extra pointer
5204  * argument.
5205  *
5206  * Params:
5207  *     userData = the data provided when registering the test
5208  *
5209  * Since: 2.28
5210  */
5211 public alias extern(C) void function(void* userData) GTestDataFunc;
5212 
5213 /**
5214  * The type used for functions that operate on test fixtures.  This is
5215  * used for the fixture setup and teardown functions as well as for the
5216  * testcases themselves.
5217  *
5218  * @user_data is a pointer to the data that was given when registering
5219  * the test case.
5220  *
5221  * @fixture will be a pointer to the area of memory allocated by the
5222  * test framework, of the size requested.  If the requested size was
5223  * zero then @fixture will be equal to @user_data.
5224  *
5225  * Params:
5226  *     fixture = the test fixture
5227  *     userData = the data provided when registering the test
5228  *
5229  * Since: 2.28
5230  */
5231 public alias extern(C) void function(void* fixture, void* userData) GTestFixtureFunc;
5232 
5233 /**
5234  * The type used for test case functions.
5235  *
5236  * Since: 2.28
5237  */
5238 public alias extern(C) void function() GTestFunc;
5239 
5240 /**
5241  * Specifies the prototype of fatal log handler functions.
5242  *
5243  * Params:
5244  *     logDomain = the log domain of the message
5245  *     logLevel = the log level of the message (including the fatal and recursion flags)
5246  *     message = the message to process
5247  *     userData = user data, set in g_test_log_set_fatal_handler()
5248  *
5249  * Returns: %TRUE if the program should abort, %FALSE otherwise
5250  *
5251  * Since: 2.22
5252  */
5253 public alias extern(C) int function(const(char)* logDomain, GLogLevelFlags logLevel, const(char)* message, void* userData) GTestLogFatalFunc;
5254 
5255 /**
5256  * Specifies the type of the @func functions passed to g_thread_new()
5257  * or g_thread_try_new().
5258  *
5259  * Params:
5260  *     data = data passed to the thread
5261  *
5262  * Returns: the return value of the thread
5263  */
5264 public alias extern(C) void* function(void* data) GThreadFunc;
5265 
5266 /**
5267  * The type of functions which are used to translate user-visible
5268  * strings, for <option>--help</option> output.
5269  *
5270  * Params:
5271  *     str = the untranslated string
5272  *     data = user data specified when installing the function, e.g.
5273  *         in g_option_group_set_translate_func()
5274  *
5275  * Returns: a translation of the string for the current locale.
5276  *     The returned string is owned by GLib and must not be freed.
5277  */
5278 public alias extern(C) const(char)* function(const(char)* str, void* data) GTranslateFunc;
5279 
5280 /**
5281  * Specifies the type of function passed to g_tree_traverse(). It is
5282  * passed the key and value of each node, together with the @user_data
5283  * parameter passed to g_tree_traverse(). If the function returns
5284  * %TRUE, the traversal is stopped.
5285  *
5286  * Params:
5287  *     key = a key of a #GTree node
5288  *     value = the value corresponding to the key
5289  *     data = user data passed to g_tree_traverse()
5290  *
5291  * Returns: %TRUE to stop the traversal
5292  */
5293 public alias extern(C) int function(void* key, void* value, void* data) GTraverseFunc;
5294 
5295 /**
5296  * The type of functions to be called when a UNIX fd watch source
5297  * triggers.
5298  *
5299  * Params:
5300  *     fd = the fd that triggered the event
5301  *     condition = the IO conditions reported on @fd
5302  *     userData = user data passed to g_unix_fd_add()
5303  *
5304  * Returns: %FALSE if the source should be removed
5305  */
5306 public alias extern(C) int function(int fd, GIOCondition condition, void* userData) GUnixFDSourceFunc;
5307 
5308 /**
5309  * Declares a type of function which takes no arguments
5310  * and has no return value. It is used to specify the type
5311  * function passed to g_atexit().
5312  */
5313 public alias extern(C) void function() GVoidFunc;
5314 
5315 /**
5316  * Specifies the type of the module initialization function.
5317  * If a module contains a function named g_module_check_init() it is called
5318  * automatically when the module is loaded. It is passed the #GModule structure
5319  * and should return %NULL on success or a string describing the initialization
5320  * error.
5321  *
5322  * Params:
5323  *     modul = the #GModule corresponding to the module which has just been loaded
5324  *
5325  * Returns: %NULL on success, or a string describing the initialization error
5326  */
5327 public alias extern(C) const(char)* function(GModule* modul) GModuleCheckInit;
5328 
5329 /**
5330  * Specifies the type of the module function called when it is unloaded.
5331  * If a module contains a function named g_module_unload() it is called
5332  * automatically when the module is unloaded.
5333  * It is passed the #GModule structure.
5334  *
5335  * Params:
5336  *     modul = the #GModule about to be unloaded
5337  */
5338 public alias extern(C) void function(GModule* modul) GModuleUnload;
5339 
5340 enum ANALYZER_ANALYZING = 1;
5341 alias G_ANALYZER_ANALYZING = ANALYZER_ANALYZING;
5342 
5343 /**
5344  * A good size for a buffer to be passed into g_ascii_dtostr().
5345  * It is guaranteed to be enough for all output of that function
5346  * on systems with 64bit IEEE-compatible doubles.
5347  *
5348  * The typical usage would be something like:
5349  * |[<!-- language="C" -->
5350  * char buf[G_ASCII_DTOSTR_BUF_SIZE];
5351  *
5352  * fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value));
5353  * ]|
5354  */
5355 enum ASCII_DTOSTR_BUF_SIZE = 39;
5356 alias G_ASCII_DTOSTR_BUF_SIZE = ASCII_DTOSTR_BUF_SIZE;
5357 
5358 /**
5359  * Specifies one of the possible types of byte order.
5360  * See #G_BYTE_ORDER.
5361  */
5362 enum BIG_ENDIAN = 4321;
5363 alias G_BIG_ENDIAN = BIG_ENDIAN;
5364 
5365 /**
5366  * The set of uppercase ASCII alphabet characters.
5367  * Used for specifying valid identifier characters
5368  * in #GScannerConfig.
5369  */
5370 enum CSET_A_2_Z = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
5371 alias G_CSET_A_2_Z = CSET_A_2_Z;
5372 
5373 /**
5374  * The set of ASCII digits.
5375  * Used for specifying valid identifier characters
5376  * in #GScannerConfig.
5377  */
5378 enum CSET_DIGITS = "0123456789";
5379 alias G_CSET_DIGITS = CSET_DIGITS;
5380 
5381 /**
5382  * The set of lowercase ASCII alphabet characters.
5383  * Used for specifying valid identifier characters
5384  * in #GScannerConfig.
5385  */
5386 enum CSET_a_2_z = "abcdefghijklmnopqrstuvwxyz";
5387 alias G_CSET_a_2_z = CSET_a_2_z;
5388 
5389 /**
5390  * A bitmask that restricts the possible flags passed to
5391  * g_datalist_set_flags(). Passing a flags value where
5392  * flags & ~G_DATALIST_FLAGS_MASK != 0 is an error.
5393  */
5394 enum DATALIST_FLAGS_MASK = 3;
5395 alias G_DATALIST_FLAGS_MASK = DATALIST_FLAGS_MASK;
5396 
5397 /**
5398  * Represents an invalid #GDateDay.
5399  */
5400 enum DATE_BAD_DAY = 0;
5401 alias G_DATE_BAD_DAY = DATE_BAD_DAY;
5402 
5403 /**
5404  * Represents an invalid Julian day number.
5405  */
5406 enum DATE_BAD_JULIAN = 0;
5407 alias G_DATE_BAD_JULIAN = DATE_BAD_JULIAN;
5408 
5409 /**
5410  * Represents an invalid year.
5411  */
5412 enum DATE_BAD_YEAR = 0;
5413 alias G_DATE_BAD_YEAR = DATE_BAD_YEAR;
5414 
5415 /**
5416  * This is the platform dependent conversion specifier for scanning and
5417  * printing values of type #gint16. It is a string literal, but doesn't
5418  * include the percent-sign, such that you can add precision and length
5419  * modifiers between percent-sign and conversion specifier.
5420  *
5421  * |[<!-- language="C" -->
5422  * gint16 in;
5423  * gint32 out;
5424  * sscanf ("42", "%" G_GINT16_FORMAT, &in)
5425  * out = in * 1000;
5426  * g_print ("%" G_GINT32_FORMAT, out);
5427  * ]|
5428  */
5429 enum GINT16_FORMAT = "hi";
5430 alias G_GINT16_FORMAT = GINT16_FORMAT;
5431 
5432 /**
5433  * The platform dependent length modifier for conversion specifiers
5434  * for scanning and printing values of type #gint16 or #guint16. It
5435  * is a string literal, but doesn't include the percent-sign, such
5436  * that you can add precision and length modifiers between percent-sign
5437  * and conversion specifier and append a conversion specifier.
5438  *
5439  * The following example prints "0x7b";
5440  * |[<!-- language="C" -->
5441  * gint16 value = 123;
5442  * g_print ("%#" G_GINT16_MODIFIER "x", value);
5443  * ]|
5444  */
5445 enum GINT16_MODIFIER = "h";
5446 alias G_GINT16_MODIFIER = GINT16_MODIFIER;
5447 
5448 /**
5449  * This is the platform dependent conversion specifier for scanning
5450  * and printing values of type #gint32. See also #G_GINT16_FORMAT.
5451  */
5452 enum GINT32_FORMAT = "i";
5453 alias G_GINT32_FORMAT = GINT32_FORMAT;
5454 
5455 /**
5456  * The platform dependent length modifier for conversion specifiers
5457  * for scanning and printing values of type #gint32 or #guint32. It
5458  * is a string literal. See also #G_GINT16_MODIFIER.
5459  */
5460 enum GINT32_MODIFIER = "";
5461 alias G_GINT32_MODIFIER = GINT32_MODIFIER;
5462 
5463 /**
5464  * This is the platform dependent conversion specifier for scanning
5465  * and printing values of type #gint64. See also #G_GINT16_FORMAT.
5466  *
5467  * Some platforms do not support scanning and printing 64-bit integers,
5468  * even though the types are supported. On such platforms %G_GINT64_FORMAT
5469  * is not defined. Note that scanf() may not support 64-bit integers, even
5470  * if %G_GINT64_FORMAT is defined. Due to its weak error handling, scanf()
5471  * is not recommended for parsing anyway; consider using g_ascii_strtoull()
5472  * instead.
5473  */
5474 enum GINT64_FORMAT = "li";
5475 alias G_GINT64_FORMAT = GINT64_FORMAT;
5476 
5477 /**
5478  * The platform dependent length modifier for conversion specifiers
5479  * for scanning and printing values of type #gint64 or #guint64.
5480  * It is a string literal.
5481  *
5482  * Some platforms do not support printing 64-bit integers, even
5483  * though the types are supported. On such platforms %G_GINT64_MODIFIER
5484  * is not defined.
5485  */
5486 enum GINT64_MODIFIER = "l";
5487 alias G_GINT64_MODIFIER = GINT64_MODIFIER;
5488 
5489 /**
5490  * This is the platform dependent conversion specifier for scanning
5491  * and printing values of type #gintptr.
5492  */
5493 enum GINTPTR_FORMAT = "li";
5494 alias G_GINTPTR_FORMAT = GINTPTR_FORMAT;
5495 
5496 /**
5497  * The platform dependent length modifier for conversion specifiers
5498  * for scanning and printing values of type #gintptr or #guintptr.
5499  * It is a string literal.
5500  */
5501 enum GINTPTR_MODIFIER = "l";
5502 alias G_GINTPTR_MODIFIER = GINTPTR_MODIFIER;
5503 
5504 /**
5505  * Expands to "" on all modern compilers, and to  __FUNCTION__ on gcc
5506  * version 2.x. Don't use it.
5507  *
5508  * Deprecated: Use G_STRFUNC() instead
5509  */
5510 enum GNUC_FUNCTION = "";
5511 alias G_GNUC_FUNCTION = GNUC_FUNCTION;
5512 
5513 /**
5514  * Expands to "" on all modern compilers, and to __PRETTY_FUNCTION__
5515  * on gcc version 2.x. Don't use it.
5516  *
5517  * Deprecated: Use G_STRFUNC() instead
5518  */
5519 enum GNUC_PRETTY_FUNCTION = "";
5520 alias G_GNUC_PRETTY_FUNCTION = GNUC_PRETTY_FUNCTION;
5521 
5522 /**
5523  * This is the platform dependent conversion specifier for scanning
5524  * and printing values of type #gsize. See also #G_GINT16_FORMAT.
5525  */
5526 enum GSIZE_FORMAT = "lu";
5527 alias G_GSIZE_FORMAT = GSIZE_FORMAT;
5528 
5529 /**
5530  * The platform dependent length modifier for conversion specifiers
5531  * for scanning and printing values of type #gsize. It
5532  * is a string literal.
5533  */
5534 enum GSIZE_MODIFIER = "l";
5535 alias G_GSIZE_MODIFIER = GSIZE_MODIFIER;
5536 
5537 /**
5538  * This is the platform dependent conversion specifier for scanning
5539  * and printing values of type #gssize. See also #G_GINT16_FORMAT.
5540  */
5541 enum GSSIZE_FORMAT = "li";
5542 alias G_GSSIZE_FORMAT = GSSIZE_FORMAT;
5543 
5544 /**
5545  * The platform dependent length modifier for conversion specifiers
5546  * for scanning and printing values of type #gssize. It
5547  * is a string literal.
5548  */
5549 enum GSSIZE_MODIFIER = "l";
5550 alias G_GSSIZE_MODIFIER = GSSIZE_MODIFIER;
5551 
5552 /**
5553  * This is the platform dependent conversion specifier for scanning
5554  * and printing values of type #guint16. See also #G_GINT16_FORMAT
5555  */
5556 enum GUINT16_FORMAT = "hu";
5557 alias G_GUINT16_FORMAT = GUINT16_FORMAT;
5558 
5559 /**
5560  * This is the platform dependent conversion specifier for scanning
5561  * and printing values of type #guint32. See also #G_GINT16_FORMAT.
5562  */
5563 enum GUINT32_FORMAT = "u";
5564 alias G_GUINT32_FORMAT = GUINT32_FORMAT;
5565 
5566 /**
5567  * This is the platform dependent conversion specifier for scanning
5568  * and printing values of type #guint64. See also #G_GINT16_FORMAT.
5569  *
5570  * Some platforms do not support scanning and printing 64-bit integers,
5571  * even though the types are supported. On such platforms %G_GUINT64_FORMAT
5572  * is not defined.  Note that scanf() may not support 64-bit integers, even
5573  * if %G_GINT64_FORMAT is defined. Due to its weak error handling, scanf()
5574  * is not recommended for parsing anyway; consider using g_ascii_strtoull()
5575  * instead.
5576  */
5577 enum GUINT64_FORMAT = "lu";
5578 alias G_GUINT64_FORMAT = GUINT64_FORMAT;
5579 
5580 /**
5581  * This is the platform dependent conversion specifier
5582  * for scanning and printing values of type #guintptr.
5583  */
5584 enum GUINTPTR_FORMAT = "lu";
5585 alias G_GUINTPTR_FORMAT = GUINTPTR_FORMAT;
5586 
5587 enum HAVE_GINT64 = 1;
5588 alias G_HAVE_GINT64 = HAVE_GINT64;
5589 
5590 enum HAVE_GNUC_VARARGS = 1;
5591 alias G_HAVE_GNUC_VARARGS = HAVE_GNUC_VARARGS;
5592 
5593 /**
5594  * Defined to 1 if gcc-style visibility handling is supported.
5595  */
5596 enum HAVE_GNUC_VISIBILITY = 1;
5597 alias G_HAVE_GNUC_VISIBILITY = HAVE_GNUC_VISIBILITY;
5598 
5599 enum HAVE_GROWING_STACK = 0;
5600 alias G_HAVE_GROWING_STACK = HAVE_GROWING_STACK;
5601 
5602 enum HAVE_ISO_VARARGS = 1;
5603 alias G_HAVE_ISO_VARARGS = HAVE_ISO_VARARGS;
5604 
5605 /**
5606  * The position of the first bit which is not reserved for internal
5607  * use be the #GHook implementation, i.e.
5608  * `1 << G_HOOK_FLAG_USER_SHIFT` is the first
5609  * bit which can be used for application-defined flags.
5610  */
5611 enum HOOK_FLAG_USER_SHIFT = 4;
5612 alias G_HOOK_FLAG_USER_SHIFT = HOOK_FLAG_USER_SHIFT;
5613 
5614 /**
5615  * The bias by which exponents in double-precision floats are offset.
5616  */
5617 enum IEEE754_DOUBLE_BIAS = 1023;
5618 alias G_IEEE754_DOUBLE_BIAS = IEEE754_DOUBLE_BIAS;
5619 
5620 /**
5621  * The bias by which exponents in single-precision floats are offset.
5622  */
5623 enum IEEE754_FLOAT_BIAS = 127;
5624 alias G_IEEE754_FLOAT_BIAS = IEEE754_FLOAT_BIAS;
5625 
5626 /**
5627  * The name of the main group of a desktop entry file, as defined in the
5628  * [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec).
5629  * Consult the specification for more
5630  * details about the meanings of the keys below.
5631  */
5632 enum KEY_FILE_DESKTOP_GROUP = "Desktop Entry";
5633 alias G_KEY_FILE_DESKTOP_GROUP = KEY_FILE_DESKTOP_GROUP;
5634 
5635 /**
5636  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string list
5637  * giving the available application actions.
5638  */
5639 enum KEY_FILE_DESKTOP_KEY_ACTIONS = "Actions";
5640 alias G_KEY_FILE_DESKTOP_KEY_ACTIONS = KEY_FILE_DESKTOP_KEY_ACTIONS;
5641 
5642 /**
5643  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list
5644  * of strings giving the categories in which the desktop entry
5645  * should be shown in a menu.
5646  */
5647 enum KEY_FILE_DESKTOP_KEY_CATEGORIES = "Categories";
5648 alias G_KEY_FILE_DESKTOP_KEY_CATEGORIES = KEY_FILE_DESKTOP_KEY_CATEGORIES;
5649 
5650 /**
5651  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
5652  * string giving the tooltip for the desktop entry.
5653  */
5654 enum KEY_FILE_DESKTOP_KEY_COMMENT = "Comment";
5655 alias G_KEY_FILE_DESKTOP_KEY_COMMENT = KEY_FILE_DESKTOP_KEY_COMMENT;
5656 
5657 /**
5658  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean set to true
5659  * if the application is D-Bus activatable.
5660  */
5661 enum KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE = "DBusActivatable";
5662 alias G_KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE = KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE;
5663 
5664 /**
5665  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string
5666  * giving the command line to execute. It is only valid for desktop
5667  * entries with the `Application` type.
5668  */
5669 enum KEY_FILE_DESKTOP_KEY_EXEC = "Exec";
5670 alias G_KEY_FILE_DESKTOP_KEY_EXEC = KEY_FILE_DESKTOP_KEY_EXEC;
5671 
5672 /**
5673  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
5674  * string giving the generic name of the desktop entry.
5675  */
5676 enum KEY_FILE_DESKTOP_KEY_GENERIC_NAME = "GenericName";
5677 alias G_KEY_FILE_DESKTOP_KEY_GENERIC_NAME = KEY_FILE_DESKTOP_KEY_GENERIC_NAME;
5678 
5679 /**
5680  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
5681  * stating whether the desktop entry has been deleted by the user.
5682  */
5683 enum KEY_FILE_DESKTOP_KEY_HIDDEN = "Hidden";
5684 alias G_KEY_FILE_DESKTOP_KEY_HIDDEN = KEY_FILE_DESKTOP_KEY_HIDDEN;
5685 
5686 /**
5687  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
5688  * string giving the name of the icon to be displayed for the desktop
5689  * entry.
5690  */
5691 enum KEY_FILE_DESKTOP_KEY_ICON = "Icon";
5692 alias G_KEY_FILE_DESKTOP_KEY_ICON = KEY_FILE_DESKTOP_KEY_ICON;
5693 
5694 /**
5695  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list
5696  * of strings giving the MIME types supported by this desktop entry.
5697  */
5698 enum KEY_FILE_DESKTOP_KEY_MIME_TYPE = "MimeType";
5699 alias G_KEY_FILE_DESKTOP_KEY_MIME_TYPE = KEY_FILE_DESKTOP_KEY_MIME_TYPE;
5700 
5701 /**
5702  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
5703  * string giving the specific name of the desktop entry.
5704  */
5705 enum KEY_FILE_DESKTOP_KEY_NAME = "Name";
5706 alias G_KEY_FILE_DESKTOP_KEY_NAME = KEY_FILE_DESKTOP_KEY_NAME;
5707 
5708 /**
5709  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list of
5710  * strings identifying the environments that should not display the
5711  * desktop entry.
5712  */
5713 enum KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN = "NotShowIn";
5714 alias G_KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN = KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN;
5715 
5716 /**
5717  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
5718  * stating whether the desktop entry should be shown in menus.
5719  */
5720 enum KEY_FILE_DESKTOP_KEY_NO_DISPLAY = "NoDisplay";
5721 alias G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY = KEY_FILE_DESKTOP_KEY_NO_DISPLAY;
5722 
5723 /**
5724  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a list of
5725  * strings identifying the environments that should display the
5726  * desktop entry.
5727  */
5728 enum KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN = "OnlyShowIn";
5729 alias G_KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN = KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN;
5730 
5731 /**
5732  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string
5733  * containing the working directory to run the program in. It is only
5734  * valid for desktop entries with the `Application` type.
5735  */
5736 enum KEY_FILE_DESKTOP_KEY_PATH = "Path";
5737 alias G_KEY_FILE_DESKTOP_KEY_PATH = KEY_FILE_DESKTOP_KEY_PATH;
5738 
5739 /**
5740  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
5741  * stating whether the application supports the
5742  * [Startup Notification Protocol Specification](http://www.freedesktop.org/Standards/startup-notification-spec).
5743  */
5744 enum KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY = "StartupNotify";
5745 alias G_KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY = KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY;
5746 
5747 /**
5748  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is string
5749  * identifying the WM class or name hint of a window that the application
5750  * will create, which can be used to emulate Startup Notification with
5751  * older applications.
5752  */
5753 enum KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS = "StartupWMClass";
5754 alias G_KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS = KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS;
5755 
5756 /**
5757  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
5758  * stating whether the program should be run in a terminal window.
5759  * It is only valid for desktop entries with the
5760  * `Application` type.
5761  */
5762 enum KEY_FILE_DESKTOP_KEY_TERMINAL = "Terminal";
5763 alias G_KEY_FILE_DESKTOP_KEY_TERMINAL = KEY_FILE_DESKTOP_KEY_TERMINAL;
5764 
5765 /**
5766  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string
5767  * giving the file name of a binary on disk used to determine if the
5768  * program is actually installed. It is only valid for desktop entries
5769  * with the `Application` type.
5770  */
5771 enum KEY_FILE_DESKTOP_KEY_TRY_EXEC = "TryExec";
5772 alias G_KEY_FILE_DESKTOP_KEY_TRY_EXEC = KEY_FILE_DESKTOP_KEY_TRY_EXEC;
5773 
5774 /**
5775  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string
5776  * giving the type of the desktop entry. Usually
5777  * #G_KEY_FILE_DESKTOP_TYPE_APPLICATION,
5778  * #G_KEY_FILE_DESKTOP_TYPE_LINK, or
5779  * #G_KEY_FILE_DESKTOP_TYPE_DIRECTORY.
5780  */
5781 enum KEY_FILE_DESKTOP_KEY_TYPE = "Type";
5782 alias G_KEY_FILE_DESKTOP_KEY_TYPE = KEY_FILE_DESKTOP_KEY_TYPE;
5783 
5784 /**
5785  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string
5786  * giving the URL to access. It is only valid for desktop entries
5787  * with the `Link` type.
5788  */
5789 enum KEY_FILE_DESKTOP_KEY_URL = "URL";
5790 alias G_KEY_FILE_DESKTOP_KEY_URL = KEY_FILE_DESKTOP_KEY_URL;
5791 
5792 /**
5793  * A key under #G_KEY_FILE_DESKTOP_GROUP, whose value is a string
5794  * giving the version of the Desktop Entry Specification used for
5795  * the desktop entry file.
5796  */
5797 enum KEY_FILE_DESKTOP_KEY_VERSION = "Version";
5798 alias G_KEY_FILE_DESKTOP_KEY_VERSION = KEY_FILE_DESKTOP_KEY_VERSION;
5799 
5800 /**
5801  * The value of the #G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop
5802  * entries representing applications.
5803  */
5804 enum KEY_FILE_DESKTOP_TYPE_APPLICATION = "Application";
5805 alias G_KEY_FILE_DESKTOP_TYPE_APPLICATION = KEY_FILE_DESKTOP_TYPE_APPLICATION;
5806 
5807 /**
5808  * The value of the #G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop
5809  * entries representing directories.
5810  */
5811 enum KEY_FILE_DESKTOP_TYPE_DIRECTORY = "Directory";
5812 alias G_KEY_FILE_DESKTOP_TYPE_DIRECTORY = KEY_FILE_DESKTOP_TYPE_DIRECTORY;
5813 
5814 /**
5815  * The value of the #G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop
5816  * entries representing links to documents.
5817  */
5818 enum KEY_FILE_DESKTOP_TYPE_LINK = "Link";
5819 alias G_KEY_FILE_DESKTOP_TYPE_LINK = KEY_FILE_DESKTOP_TYPE_LINK;
5820 
5821 /**
5822  * Specifies one of the possible types of byte order.
5823  * See #G_BYTE_ORDER.
5824  */
5825 enum LITTLE_ENDIAN = 1234;
5826 alias G_LITTLE_ENDIAN = LITTLE_ENDIAN;
5827 
5828 /**
5829  * Defines the log domain. See [Log Domains](#log-domains).
5830  *
5831  * Libraries should define this so that any messages
5832  * which they log can be differentiated from messages from other
5833  * libraries and application code. But be careful not to define
5834  * it in any public header files.
5835  *
5836  * Log domains must be unique, and it is recommended that they are the
5837  * application or library name, optionally followed by a hyphen and a sub-domain
5838  * name. For example, `bloatpad` or `bloatpad-io`.
5839  *
5840  * If undefined, it defaults to the default %NULL (or `""`) log domain; this is
5841  * not advisable, as it cannot be filtered against using the `G_MESSAGES_DEBUG`
5842  * environment variable.
5843  *
5844  * For example, GTK+ uses this in its `Makefile.am`:
5845  * |[
5846  * AM_CPPFLAGS = -DG_LOG_DOMAIN=\"Gtk\"
5847  * ]|
5848  *
5849  * Applications can choose to leave it as the default %NULL (or `""`)
5850  * domain. However, defining the domain offers the same advantages as
5851  * above.
5852  */
5853 enum LOG_DOMAIN = 0;
5854 alias G_LOG_DOMAIN = LOG_DOMAIN;
5855 
5856 /**
5857  * GLib log levels that are considered fatal by default.
5858  *
5859  * This is not used if structured logging is enabled; see
5860  * [Using Structured Logging][using-structured-logging].
5861  */
5862 enum LOG_FATAL_MASK = 5;
5863 alias G_LOG_FATAL_MASK = LOG_FATAL_MASK;
5864 
5865 /**
5866  * Log levels below 1<<G_LOG_LEVEL_USER_SHIFT are used by GLib.
5867  * Higher bits can be used for user-defined log levels.
5868  */
5869 enum LOG_LEVEL_USER_SHIFT = 8;
5870 alias G_LOG_LEVEL_USER_SHIFT = LOG_LEVEL_USER_SHIFT;
5871 
5872 /**
5873  * The major version number of the GLib library.
5874  *
5875  * Like #glib_major_version, but from the headers used at
5876  * application compile time, rather than from the library
5877  * linked against at application run time.
5878  */
5879 enum MAJOR_VERSION = 2;
5880 alias GLIB_MAJOR_VERSION = MAJOR_VERSION;
5881 
5882 /**
5883  * The maximum value which can be held in a #gint16.
5884  */
5885 enum MAXINT16 = 32767;
5886 alias G_MAXINT16 = MAXINT16;
5887 
5888 /**
5889  * The maximum value which can be held in a #gint32.
5890  */
5891 enum MAXINT32 = 2147483647;
5892 alias G_MAXINT32 = MAXINT32;
5893 
5894 /**
5895  * The maximum value which can be held in a #gint64.
5896  */
5897 enum MAXINT64 = 9223372036854775807UL;
5898 alias G_MAXINT64 = MAXINT64;
5899 
5900 /**
5901  * The maximum value which can be held in a #gint8.
5902  */
5903 enum MAXINT8 = 127;
5904 alias G_MAXINT8 = MAXINT8;
5905 
5906 /**
5907  * The maximum value which can be held in a #guint16.
5908  */
5909 enum MAXUINT16 = 65535;
5910 alias G_MAXUINT16 = MAXUINT16;
5911 
5912 /**
5913  * The maximum value which can be held in a #guint32.
5914  */
5915 enum MAXUINT32 = 4294967295;
5916 alias G_MAXUINT32 = MAXUINT32;
5917 
5918 /**
5919  * The maximum value which can be held in a #guint64.
5920  */
5921 enum MAXUINT64 = 18446744073709551615UL;
5922 alias G_MAXUINT64 = MAXUINT64;
5923 
5924 /**
5925  * The maximum value which can be held in a #guint8.
5926  */
5927 enum MAXUINT8 = 255;
5928 alias G_MAXUINT8 = MAXUINT8;
5929 
5930 /**
5931  * The micro version number of the GLib library.
5932  *
5933  * Like #gtk_micro_version, but from the headers used at
5934  * application compile time, rather than from the library
5935  * linked against at application run time.
5936  */
5937 enum MICRO_VERSION = 1;
5938 alias GLIB_MICRO_VERSION = MICRO_VERSION;
5939 
5940 /**
5941  * The minimum value which can be held in a #gint16.
5942  */
5943 enum MININT16 = -32768;
5944 alias G_MININT16 = MININT16;
5945 
5946 /**
5947  * The minimum value which can be held in a #gint32.
5948  */
5949 enum MININT32 = -2147483648;
5950 alias G_MININT32 = MININT32;
5951 
5952 /**
5953  * The minimum value which can be held in a #gint64.
5954  */
5955 enum MININT64 = -9223372036854775808UL;
5956 alias G_MININT64 = MININT64;
5957 
5958 /**
5959  * The minimum value which can be held in a #gint8.
5960  */
5961 enum MININT8 = -128;
5962 alias G_MININT8 = MININT8;
5963 
5964 /**
5965  * The minor version number of the GLib library.
5966  *
5967  * Like #gtk_minor_version, but from the headers used at
5968  * application compile time, rather than from the library
5969  * linked against at application run time.
5970  */
5971 enum MINOR_VERSION = 56;
5972 alias GLIB_MINOR_VERSION = MINOR_VERSION;
5973 
5974 enum MODULE_SUFFIX = "so";
5975 alias G_MODULE_SUFFIX = MODULE_SUFFIX;
5976 
5977 /**
5978  * If a long option in the main group has this name, it is not treated as a
5979  * regular option. Instead it collects all non-option arguments which would
5980  * otherwise be left in `argv`. The option must be of type
5981  * %G_OPTION_ARG_CALLBACK, %G_OPTION_ARG_STRING_ARRAY
5982  * or %G_OPTION_ARG_FILENAME_ARRAY.
5983  *
5984  *
5985  * Using #G_OPTION_REMAINING instead of simply scanning `argv`
5986  * for leftover arguments has the advantage that GOption takes care of
5987  * necessary encoding conversions for strings or filenames.
5988  */
5989 enum OPTION_REMAINING = "";
5990 alias G_OPTION_REMAINING = OPTION_REMAINING;
5991 
5992 /**
5993  * Specifies one of the possible types of byte order
5994  * (currently unused). See #G_BYTE_ORDER.
5995  */
5996 enum PDP_ENDIAN = 3412;
5997 alias G_PDP_ENDIAN = PDP_ENDIAN;
5998 
5999 /**
6000  * A format specifier that can be used in printf()-style format strings
6001  * when printing a #GPid.
6002  */
6003 enum PID_FORMAT = "i";
6004 alias G_PID_FORMAT = PID_FORMAT;
6005 
6006 /**
6007  * A format specifier that can be used in printf()-style format strings
6008  * when printing the @fd member of a #GPollFD.
6009  */
6010 enum POLLFD_FORMAT = "%d";
6011 alias G_POLLFD_FORMAT = POLLFD_FORMAT;
6012 
6013 /**
6014  * Use this for default priority event sources.
6015  *
6016  * In GLib this priority is used when adding timeout functions
6017  * with g_timeout_add(). In GDK this priority is used for events
6018  * from the X server.
6019  */
6020 enum PRIORITY_DEFAULT = 0;
6021 alias G_PRIORITY_DEFAULT = PRIORITY_DEFAULT;
6022 
6023 /**
6024  * Use this for default priority idle functions.
6025  *
6026  * In GLib this priority is used when adding idle functions with
6027  * g_idle_add().
6028  */
6029 enum PRIORITY_DEFAULT_IDLE = 200;
6030 alias G_PRIORITY_DEFAULT_IDLE = PRIORITY_DEFAULT_IDLE;
6031 
6032 /**
6033  * Use this for high priority event sources.
6034  *
6035  * It is not used within GLib or GTK+.
6036  */
6037 enum PRIORITY_HIGH = -100;
6038 alias G_PRIORITY_HIGH = PRIORITY_HIGH;
6039 
6040 /**
6041  * Use this for high priority idle functions.
6042  *
6043  * GTK+ uses #G_PRIORITY_HIGH_IDLE + 10 for resizing operations,
6044  * and #G_PRIORITY_HIGH_IDLE + 20 for redrawing operations. (This is
6045  * done to ensure that any pending resizes are processed before any
6046  * pending redraws, so that widgets are not redrawn twice unnecessarily.)
6047  */
6048 enum PRIORITY_HIGH_IDLE = 100;
6049 alias G_PRIORITY_HIGH_IDLE = PRIORITY_HIGH_IDLE;
6050 
6051 /**
6052  * Use this for very low priority background tasks.
6053  *
6054  * It is not used within GLib or GTK+.
6055  */
6056 enum PRIORITY_LOW = 300;
6057 alias G_PRIORITY_LOW = PRIORITY_LOW;
6058 
6059 enum SIZEOF_LONG = 8;
6060 alias GLIB_SIZEOF_LONG = SIZEOF_LONG;
6061 
6062 enum SIZEOF_SIZE_T = 8;
6063 alias GLIB_SIZEOF_SIZE_T = SIZEOF_SIZE_T;
6064 
6065 enum SIZEOF_SSIZE_T = 8;
6066 alias GLIB_SIZEOF_SSIZE_T = SIZEOF_SSIZE_T;
6067 
6068 enum SIZEOF_VOID_P = 8;
6069 alias GLIB_SIZEOF_VOID_P = SIZEOF_VOID_P;
6070 
6071 /**
6072  * Use this macro as the return value of a #GSourceFunc to leave
6073  * the #GSource in the main loop.
6074  */
6075 enum SOURCE_CONTINUE = true;
6076 alias G_SOURCE_CONTINUE = SOURCE_CONTINUE;
6077 
6078 /**
6079  * Use this macro as the return value of a #GSourceFunc to remove
6080  * the #GSource from the main loop.
6081  */
6082 enum SOURCE_REMOVE = false;
6083 alias G_SOURCE_REMOVE = SOURCE_REMOVE;
6084 
6085 /**
6086  * The standard delimiters, used in g_strdelimit().
6087  */
6088 enum STR_DELIMITERS = "_-|> <.";
6089 alias G_STR_DELIMITERS = STR_DELIMITERS;
6090 
6091 enum SYSDEF_AF_INET = 2;
6092 alias GLIB_SYSDEF_AF_INET = SYSDEF_AF_INET;
6093 
6094 enum SYSDEF_AF_INET6 = 10;
6095 alias GLIB_SYSDEF_AF_INET6 = SYSDEF_AF_INET6;
6096 
6097 enum SYSDEF_AF_UNIX = 1;
6098 alias GLIB_SYSDEF_AF_UNIX = SYSDEF_AF_UNIX;
6099 
6100 enum SYSDEF_MSG_DONTROUTE = 4;
6101 alias GLIB_SYSDEF_MSG_DONTROUTE = SYSDEF_MSG_DONTROUTE;
6102 
6103 enum SYSDEF_MSG_OOB = 1;
6104 alias GLIB_SYSDEF_MSG_OOB = SYSDEF_MSG_OOB;
6105 
6106 enum SYSDEF_MSG_PEEK = 2;
6107 alias GLIB_SYSDEF_MSG_PEEK = SYSDEF_MSG_PEEK;
6108 
6109 /**
6110  * Evaluates to a time span of one day.
6111  */
6112 enum TIME_SPAN_DAY = 86400000000UL;
6113 alias G_TIME_SPAN_DAY = TIME_SPAN_DAY;
6114 
6115 /**
6116  * Evaluates to a time span of one hour.
6117  */
6118 enum TIME_SPAN_HOUR = 3600000000UL;
6119 alias G_TIME_SPAN_HOUR = TIME_SPAN_HOUR;
6120 
6121 /**
6122  * Evaluates to a time span of one millisecond.
6123  */
6124 enum TIME_SPAN_MILLISECOND = 1000UL;
6125 alias G_TIME_SPAN_MILLISECOND = TIME_SPAN_MILLISECOND;
6126 
6127 /**
6128  * Evaluates to a time span of one minute.
6129  */
6130 enum TIME_SPAN_MINUTE = 60000000UL;
6131 alias G_TIME_SPAN_MINUTE = TIME_SPAN_MINUTE;
6132 
6133 /**
6134  * Evaluates to a time span of one second.
6135  */
6136 enum TIME_SPAN_SECOND = 1000000UL;
6137 alias G_TIME_SPAN_SECOND = TIME_SPAN_SECOND;
6138 
6139 /**
6140  * The maximum length (in codepoints) of a compatibility or canonical
6141  * decomposition of a single Unicode character.
6142  *
6143  * This is as defined by Unicode 6.1.
6144  */
6145 enum UNICHAR_MAX_DECOMPOSITION_LENGTH = 18;
6146 alias G_UNICHAR_MAX_DECOMPOSITION_LENGTH = UNICHAR_MAX_DECOMPOSITION_LENGTH;
6147 
6148 /**
6149  * Generic delimiters characters as defined in RFC 3986. Includes ":/?#[]@".
6150  */
6151 enum URI_RESERVED_CHARS_GENERIC_DELIMITERS = ":/?#[]@";
6152 alias G_URI_RESERVED_CHARS_GENERIC_DELIMITERS = URI_RESERVED_CHARS_GENERIC_DELIMITERS;
6153 
6154 /**
6155  * Subcomponent delimiter characters as defined in RFC 3986. Includes "!$&'()*+,;=".
6156  */
6157 enum URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS = "!$&'()*+,;=";
6158 alias G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS = URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS;
6159 
6160 /**
6161  * Number of microseconds in one second (1 million).
6162  * This macro is provided for code readability.
6163  */
6164 enum USEC_PER_SEC = 1000000;
6165 alias G_USEC_PER_SEC = USEC_PER_SEC;
6166 
6167 enum VA_COPY_AS_ARRAY = 1;
6168 alias G_VA_COPY_AS_ARRAY = VA_COPY_AS_ARRAY;
6169 
6170 enum WIN32_MSG_HANDLE = 19981206;
6171 alias G_WIN32_MSG_HANDLE = WIN32_MSG_HANDLE;