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 module gtkc.glibtypes;
25 
26 /* The GLib Basic Types */
27 public alias int gint;
28 public alias uint guint;
29 public alias int gboolean;
30 public alias void* gpointer;
31 public alias void* gconstpointer;
32 public alias char gchar;
33 public alias char guchar;
34 public alias short gshort;
35 public alias ushort gushort;
36 public alias byte gint8;
37 public alias ubyte guint8;
38 public alias short gint16;
39 public alias ushort guint16;
40 public alias int gint32;
41 public alias long gint64;
42 public alias uint guint32;
43 public alias ulong guint64;
44 public alias float gfloat;
45 public alias double gdouble;
46 public alias size_t gsize;
47 public alias ptrdiff_t gssize;
48 public alias long goffset;
49 public alias void* va_list;
50 public alias dchar unichar;
51 public alias wchar unichar2;
52 public alias uint time_t;
53 public alias uint XID;
54 public alias uint uid_t;
55 
56 
57 version(Tango)
58 {
59 	//avoid some conflicts with other string aliases.
60 	static if( !is(string) )
61 	alias char[] string;
62 }
63 
64 version( Windows )
65 {
66 	alias int glong;
67 	alias uint gulong;
68 }
69 else version( X86_64 )
70 {
71 	alias long glong;
72 	alias ulong gulong;
73 }
74 else
75 {
76 	alias int glong;
77 	alias uint gulong;
78 }
79 
80 version(D_Version2)
81 {
82 	mixin("enum _shared = \"shared \";");
83 	mixin("enum gshared = \"__gshared \";");
84 }
85 else
86 {
87 	const char[] _shared = "";
88 	const char[] gshared = "";
89 }
90 
91 version (Windows)
92 {
93 	version(Tango)
94 	{
95 		private import tango.stdc.stdio;
96 		
97 		//Phobos defines this function in std.c.stdio
98 		extern (C) FILE*  fdopen(int, char*);
99 	}
100 	version(D_Version2) version(CRuntime_Microsoft)
101 	{
102 		private import core.stdc.stdio;
103 		
104 		extern (C) FILE*  fdopen(int, char*);
105 	}
106 }
107 
108 const uint G_MAXUINT = 4294967295;
109 
110 
111 /**
112  * typedef int GPid;
113  * A type which is used to hold a process identification.
114  * On UNIX, processes are identified by a process id (an integer),
115  * while Windows uses process handles (which are pointers).
116  */
117 public alias int GPid;
118 
119 /**
120  * typedef guint32 gunichar;
121  * A type which can hold any UTF-32 or UCS-4 character code, also known
122  * as a Unicode code point.
123  * If you want to produce the UTF-8 representation of a gunichar,
124  * use g_ucs4_to_utf8(). See also g_utf8_to_ucs4() for the reverse process.
125  * To print/scan values of this type as integer, use
126  * G_GINT32_MODIFIER and/or G_GUINT32_FORMAT.
127  * The notation to express a Unicode code point in running text is as a
128  * hexadecimal number with four to six digits and uppercase letters, prefixed
129  * by the string "U+". Leading zeros are omitted, unless the code point would
130  * have fewer than four hexadecimal digits.
131  * For example, "U+0041 LATIN CAPITAL LETTER A".
132  * To print a code point in the U+-notation, use the format string
133  * "U+04"G_GINT32_FORMAT"X".
134  * To scan, use the format string "U+06"G_GINT32_FORMAT"X".
135  * $(DDOC_COMMENT example)
136  */
137 public alias uint gunichar;
138 
139 /**
140  * typedef guint16 gunichar2;
141  * A type which can hold any UTF-16 code
142  * point[3].
143  * To print/scan values of this type to/from text you need to convert
144  * to/from UTF-8, using g_utf16_to_utf8()/g_utf8_to_utf16().
145  * To print/scan values of this type as integer, use
146  * G_GINT16_MODIFIER and/or G_GUINT16_FORMAT.
147  */
148 public alias ushort gunichar2;
149 
150 /**
151  * typedef gint32 GTime;
152  * Simply a replacement for time_t. It has been deprected
153  * since it is not equivalent to time_t
154  * on 64-bit platforms with a 64-bit time_t.
155  * Unrelated to GTimer.
156  * Note that GTime is defined to always be a 32bit integer,
157  * unlike time_t which may be 64bit on some systems.
158  * Therefore, GTime will overflow in the year 2038, and
159  * you cannot use the address of a GTime variable as argument
160  * to the UNIX time() function. Instead, do the following:
161  * $(DDOC_COMMENT example)
162  */
163 public alias int GTime;
164 
165 /**
166  * typedef guint8 GDateDay; /+* day of the month +/
167  * Integer representing a day of the month; between 1 and
168  * 31. G_DATE_BAD_DAY represents an invalid day of the month.
169  */
170 public alias ubyte GDateDay;
171 
172 /**
173  * typedef guint16 GDateYear;
174  * Integer representing a year; G_DATE_BAD_YEAR is the invalid
175  * value. The year must be 1 or higher; negative (BC) years are not
176  * allowed. The year is represented with four digits.
177  */
178 public alias ushort GDateYear;
179 
180 /**
181  * typedef gint64 GTimeSpan;
182  * A value representing an interval of time, in microseconds.
183  * Since 2.26
184  */
185 public alias long GTimeSpan;
186 
187 /**
188  * typedef guint32 GQuark;
189  * A GQuark is a non-zero integer which uniquely identifies a
190  * particular string. A GQuark value of zero is associated to NULL.
191  */
192 public alias uint GQuark;
193 
194 enum GPriority
195 {
196 	HIGH = -100,
197 	DEFAULT = 0,
198 	HIGH_IDLE = 100,
199 	DEFAULT_IDLE = 200,
200 	LOW = 300
201 }
202 
203 /**
204  * Flags passed to g_module_open(). Note that these flags are
205  * not supported on all platforms.
206  * G_MODULE_BIND_LAZY
207  * specifies that symbols are only resolved when needed.
208  *  The default action is to bind all symbols when the module is loaded.
209  * G_MODULE_BIND_LOCAL
210  * specifies that symbols in the module should
211  *  not be added to the global name space. The default action on most
212  *  platforms is to place symbols in the module in the global name space,
213  *  which may cause conflicts with existing symbols.
214  * G_MODULE_BIND_MASK
215  * mask for all flags.
216  */
217 public enum GModuleFlags
218 {
219 	BIND_LAZY = 1 << 0,
220 	BIND_LOCAL = 1 << 1,
221 	BIND_MASK = 0x03
222 }
223 alias GModuleFlags ModuleFlags;
224 
225 /**
226  * An enumeration specifying the base position for a
227  * g_io_channel_seek_position() operation.
228  * G_SEEK_CUR
229  * the current position in the file.
230  * G_SEEK_SET
231  * the start of the file.
232  * G_SEEK_END
233  * the end of the file.
234  */
235 public enum GSeekType
236 {
237 	CUR,
238 	SET,
239 	END
240 }
241 alias GSeekType SeekType;
242 
243 /**
244  * Stati returned by most of the GIOFuncs functions.
245  * G_IO_STATUS_ERROR
246  * An error occurred.
247  * G_IO_STATUS_NORMAL
248  * Success.
249  * G_IO_STATUS_EOF
250  * End of file.
251  * G_IO_STATUS_AGAIN
252  * Resource temporarily unavailable.
253  */
254 public enum GIOStatus
255 {
256 	ERROR,
257 	NORMAL,
258 	EOF,
259 	AGAIN
260 }
261 alias GIOStatus IOStatus;
262 
263 /**
264  * Error codes returned by GIOChannel operations.
265  * G_IO_CHANNEL_ERROR_FBIG
266  * File too large.
267  * G_IO_CHANNEL_ERROR_INVAL
268  * Invalid argument.
269  * G_IO_CHANNEL_ERROR_IO
270  * IO error.
271  * G_IO_CHANNEL_ERROR_ISDIR
272  * File is a directory.
273  * G_IO_CHANNEL_ERROR_NOSPC
274  * No space left on device.
275  * G_IO_CHANNEL_ERROR_NXIO
276  * No such device or address.
277  * G_IO_CHANNEL_ERROR_OVERFLOW
278  * Value too large for defined datatype.
279  * G_IO_CHANNEL_ERROR_PIPE
280  * Broken pipe.
281  * G_IO_CHANNEL_ERROR_FAILED
282  * Some other error.
283  */
284 public enum GIOChannelError
285 {
286 	/+* Derived from errno +/
287 	FBIG,
288 	INVAL,
289 	IO,
290 	ISDIR,
291 	NOSPC,
292 	NXIO,
293 	OVERFLOW,
294 	PIPE,
295 	/+* Other +/
296 	FAILED
297 }
298 alias GIOChannelError IOChannelError;
299 
300 /**
301  * A bitwise combination representing a condition to watch for on an
302  * event source.
303  * G_IO_IN
304  * There is data to read.
305  * G_IO_OUT
306  * Data can be written (without blocking).
307  * G_IO_PRI
308  * There is urgent data to read.
309  * G_IO_ERR
310  * Error condition.
311  * G_IO_HUP
312  * Hung up (the connection has been broken, usually for
313  *  pipes and sockets).
314  * G_IO_NVAL
315  * Invalid request. The file descriptor is not open.
316  */
317 public enum GIOCondition
318 {
319 	IN = 1,
320 	OUT = 4,
321 	PRI = 2,
322 	ERR = 8,
323 	HUP = 16,
324 	NVAL = 32
325 }
326 alias GIOCondition IOCondition;
327 
328 /**
329  * Specifies properties of a GIOChannel. Some of the flags can only be
330  * read with g_io_channel_get_flags(), but not changed with
331  * g_io_channel_set_flags().
332  * G_IO_FLAG_APPEND
333  * turns on append mode, corresponds to O_APPEND
334  *  (see the documentation of the UNIX open()
335  *  syscall).
336  * G_IO_FLAG_NONBLOCK
337  * turns on nonblocking mode, corresponds to
338  *  O_NONBLOCK/O_NDELAY (see the documentation of
339  *  the UNIX open() syscall).
340  * G_IO_FLAG_IS_READABLE
341  * indicates that the io channel is readable.
342  *  This flag can not be changed.
343  * G_IO_FLAG_IS_WRITEABLE
344  * indicates that the io channel is writable.
345  *  This flag can not be changed.
346  * G_IO_FLAG_IS_SEEKABLE
347  * indicates that the io channel is seekable,
348  *  i.e. that g_io_channel_seek_position() can
349  *  be used on it. This flag can not be changed.
350  * G_IO_FLAG_MASK
351  * the mask that specifies all the valid flags.
352  * G_IO_FLAG_GET_MASK
353  * the mask of the flags that are returned from
354  *  g_io_channel_get_flags().
355  * G_IO_FLAG_SET_MASK
356  * the mask of the flags that the user can modify
357  *  with g_io_channel_set_flags().
358  */
359 public enum GIOFlags
360 {
361 	APPEND = 1 << 0,
362 	NONBLOCK = 1 << 1,
363 	IS_READABLE = 1 << 2, /+* Read only flag +/
364 	IS_WRITEABLE = 1 << 3, /+* Read only flag +/
365 	IS_SEEKABLE = 1 << 4, /+* Read only flag +/
366 	MASK = (1 << 5) - 1,
367 	GET_MASK = MASK,
368 	SET_MASK = APPEND | NONBLOCK
369 }
370 alias GIOFlags IOFlags;
371 
372 /**
373  * GIOError is only used by the deprecated functions
374  * g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().
375  * G_IO_ERROR_NONE
376  * no error
377  * G_IO_ERROR_AGAIN
378  * an EAGAIN error occurred
379  * G_IO_ERROR_INVAL
380  * an EINVAL error occurred
381  * G_IO_ERROR_UNKNOWN
382  * another error occurred
383  */
384 public enum GIOError
385 {
386 	NONE,
387 	AGAIN,
388 	INVAL,
389 	UNKNOWN
390 }
391 alias GIOError IOError;
392 
393 /**
394  * Flags specifying the level of log messages. It is possible to change
395  * how GLib treats messages of the various levels using g_log_set_handler()
396  * and g_log_set_fatal_mask().
397  * G_LOG_FLAG_RECURSION
398  * internal flag
399  * G_LOG_FLAG_FATAL
400  * internal flag
401  * G_LOG_LEVEL_ERROR
402  * log level for errors, see g_error().
403  *  This level is also used for messages produced by g_assert().
404  * G_LOG_LEVEL_CRITICAL
405  * log level for critical messages, see g_critical().
406  *  This level is also used for messages produced by g_return_if_fail() and
407  *  g_return_val_if_fail().
408  * G_LOG_LEVEL_WARNING
409  * log level for warnings, see g_warning()
410  * G_LOG_LEVEL_MESSAGE
411  * log level for messages, see g_message()
412  * G_LOG_LEVEL_INFO
413  * log level for informational messages
414  * G_LOG_LEVEL_DEBUG
415  * log level for debug messages, see g_debug()
416  * G_LOG_LEVEL_MASK
417  * a mask including all log levels.
418  */
419 public enum GLogLevelFlags
420 {
421 	/+* log flags +/
422 	FLAG_RECURSION = 1 << 0,
423 	FLAG_FATAL = 1 << 1,
424 	/+* GLib log levels +/
425 	LEVEL_ERROR = 1 << 2, /+* always fatal +/
426 	LEVEL_CRITICAL = 1 << 3,
427 	LEVEL_WARNING = 1 << 4,
428 	LEVEL_MESSAGE = 1 << 5,
429 	LEVEL_INFO = 1 << 6,
430 	LEVEL_DEBUG = 1 << 7,
431 	LEVEL_MASK = ~(FLAG_RECURSION | FLAG_FATAL)
432 }
433 alias GLogLevelFlags LogLevelFlags;
434 
435 /**
436  * Error codes returned by character set conversion routines.
437  * G_CONVERT_ERROR_NO_CONVERSION
438  * Conversion between the requested character
439  *  sets is not supported.
440  * G_CONVERT_ERROR_ILLEGAL_SEQUENCE
441  * Invalid byte sequence in conversion input.
442  * G_CONVERT_ERROR_FAILED
443  * Conversion failed for some reason.
444  * G_CONVERT_ERROR_PARTIAL_INPUT
445  * Partial character sequence at end of input.
446  * G_CONVERT_ERROR_BAD_URI
447  * URI is invalid.
448  * G_CONVERT_ERROR_NOT_ABSOLUTE_PATH
449  * Pathname is not an absolute path.
450  */
451 public enum GConvertError
452 {
453 	NO_CONVERSION,
454 	ILLEGAL_SEQUENCE,
455 	FAILED,
456 	PARTIAL_INPUT,
457 	BAD_URI,
458 	NOT_ABSOLUTE_PATH
459 }
460 alias GConvertError ConvertError;
461 
462 /**
463  * These are the possible character classifications from the
464  * Unicode specification.
465  * See http://www.unicode.org/Public/UNIDATA/UnicodeData.html.
466  * G_UNICODE_CONTROL
467  * General category "Other, Control" (Cc)
468  * G_UNICODE_FORMAT
469  * General category "Other, Format" (Cf)
470  * G_UNICODE_UNASSIGNED
471  * General category "Other, Not Assigned" (Cn)
472  * G_UNICODE_PRIVATE_USE
473  * General category "Other, Private Use" (Co)
474  * G_UNICODE_SURROGATE
475  * General category "Other, Surrogate" (Cs)
476  * G_UNICODE_LOWERCASE_LETTER
477  * General category "Letter, Lowercase" (Ll)
478  * G_UNICODE_MODIFIER_LETTER
479  * General category "Letter, Modifier" (Lm)
480  * G_UNICODE_OTHER_LETTER
481  * General category "Letter, Other" (Lo)
482  * G_UNICODE_TITLECASE_LETTER
483  * General category "Letter, Titlecase" (Lt)
484  * G_UNICODE_UPPERCASE_LETTER
485  * General category "Letter, Uppercase" (Lu)
486  * G_UNICODE_COMBINING_MARK
487  * General category "Mark, Spacing Combining" (Mc)
488  * G_UNICODE_ENCLOSING_MARK
489  * General category "Mark, Enclosing" (Me)
490  * G_UNICODE_NON_SPACING_MARK
491  * General category "Mark, Nonspacing" (Mn)
492  * G_UNICODE_DECIMAL_NUMBER
493  * General category "Number, Decimal Digit" (Nd)
494  * G_UNICODE_LETTER_NUMBER
495  * General category "Number, Letter" (Nl)
496  * G_UNICODE_OTHER_NUMBER
497  * General category "Number, Other" (No)
498  * G_UNICODE_CONNECT_PUNCTUATION
499  * General category "Punctuation, Connector" (Pc)
500  * G_UNICODE_DASH_PUNCTUATION
501  * General category "Punctuation, Dash" (Pd)
502  * G_UNICODE_CLOSE_PUNCTUATION
503  * General category "Punctuation, Close" (Pe)
504  * G_UNICODE_FINAL_PUNCTUATION
505  * General category "Punctuation, Final quote" (Pf)
506  * G_UNICODE_INITIAL_PUNCTUATION
507  * General category "Punctuation, Initial quote" (Pi)
508  * G_UNICODE_OTHER_PUNCTUATION
509  * General category "Punctuation, Other" (Po)
510  * G_UNICODE_OPEN_PUNCTUATION
511  * General category "Punctuation, Open" (Ps)
512  * G_UNICODE_CURRENCY_SYMBOL
513  * General category "Symbol, Currency" (Sc)
514  * G_UNICODE_MODIFIER_SYMBOL
515  * General category "Symbol, Modifier" (Sk)
516  * G_UNICODE_MATH_SYMBOL
517  * General category "Symbol, Math" (Sm)
518  * G_UNICODE_OTHER_SYMBOL
519  * General category "Symbol, Other" (So)
520  * G_UNICODE_LINE_SEPARATOR
521  * General category "Separator, Line" (Zl)
522  * G_UNICODE_PARAGRAPH_SEPARATOR
523  * General category "Separator, Paragraph" (Zp)
524  * G_UNICODE_SPACE_SEPARATOR
525  * General category "Separator, Space" (Zs)
526  */
527 public enum GUnicodeType
528 {
529 	CONTROL,
530 	FORMAT,
531 	UNASSIGNED,
532 	PRIVATE_USE,
533 	SURROGATE,
534 	LOWERCASE_LETTER,
535 	MODIFIER_LETTER,
536 	OTHER_LETTER,
537 	TITLECASE_LETTER,
538 	UPPERCASE_LETTER,
539 	COMBINING_MARK,
540 	ENCLOSING_MARK,
541 	NON_SPACING_MARK,
542 	DECIMAL_NUMBER,
543 	LETTER_NUMBER,
544 	OTHER_NUMBER,
545 	CONNECT_PUNCTUATION,
546 	DASH_PUNCTUATION,
547 	CLOSE_PUNCTUATION,
548 	FINAL_PUNCTUATION,
549 	INITIAL_PUNCTUATION,
550 	OTHER_PUNCTUATION,
551 	OPEN_PUNCTUATION,
552 	CURRENCY_SYMBOL,
553 	MODIFIER_SYMBOL,
554 	MATH_SYMBOL,
555 	OTHER_SYMBOL,
556 	LINE_SEPARATOR,
557 	PARAGRAPH_SEPARATOR,
558 	SPACE_SEPARATOR
559 }
560 alias GUnicodeType UnicodeType;
561 
562 /**
563  * These are the possible line break classifications.
564  * The five Hangul types were added in Unicode 4.1, so, has been
565  * introduced in GLib 2.10. Note that new types may be added in the future.
566  * Applications should be ready to handle unknown values.
567  * They may be regarded as G_UNICODE_BREAK_UNKNOWN.
568  * See http://www.unicode.org/unicode/reports/tr14/.
569  * G_UNICODE_BREAK_MANDATORY
570  * Mandatory Break (BK)
571  * G_UNICODE_BREAK_CARRIAGE_RETURN
572  * Carriage Return (CR)
573  * G_UNICODE_BREAK_LINE_FEED
574  * Line Feed (LF)
575  * G_UNICODE_BREAK_COMBINING_MARK
576  * Attached Characters and Combining Marks (CM)
577  * G_UNICODE_BREAK_SURROGATE
578  * Surrogates (SG)
579  * G_UNICODE_BREAK_ZERO_WIDTH_SPACE
580  * Zero Width Space (ZW)
581  * G_UNICODE_BREAK_INSEPARABLE
582  * Inseparable (IN)
583  * G_UNICODE_BREAK_NON_BREAKING_GLUE
584  * Non-breaking ("Glue") (GL)
585  * G_UNICODE_BREAK_CONTINGENT
586  * Contingent Break Opportunity (CB)
587  * G_UNICODE_BREAK_SPACE
588  * Space (SP)
589  * G_UNICODE_BREAK_AFTER
590  * Break Opportunity After (BA)
591  * G_UNICODE_BREAK_BEFORE
592  * Break Opportunity Before (BB)
593  * G_UNICODE_BREAK_BEFORE_AND_AFTER
594  * Break Opportunity Before and After (B2)
595  * G_UNICODE_BREAK_HYPHEN
596  * Hyphen (HY)
597  * G_UNICODE_BREAK_NON_STARTER
598  * Nonstarter (NS)
599  * G_UNICODE_BREAK_OPEN_PUNCTUATION
600  * Opening Punctuation (OP)
601  * G_UNICODE_BREAK_CLOSE_PUNCTUATION
602  * Closing Punctuation (CL)
603  * G_UNICODE_BREAK_QUOTATION
604  * Ambiguous Quotation (QU)
605  * G_UNICODE_BREAK_EXCLAMATION
606  * Exclamation/Interrogation (EX)
607  * G_UNICODE_BREAK_IDEOGRAPHIC
608  * Ideographic (ID)
609  * G_UNICODE_BREAK_NUMERIC
610  * Numeric (NU)
611  * G_UNICODE_BREAK_INFIX_SEPARATOR
612  * Infix Separator (Numeric) (IS)
613  * G_UNICODE_BREAK_SYMBOL
614  * Symbols Allowing Break After (SY)
615  * G_UNICODE_BREAK_ALPHABETIC
616  * Ordinary Alphabetic and Symbol Characters (AL)
617  * G_UNICODE_BREAK_PREFIX
618  * Prefix (Numeric) (PR)
619  * G_UNICODE_BREAK_POSTFIX
620  * Postfix (Numeric) (PO)
621  * G_UNICODE_BREAK_COMPLEX_CONTEXT
622  * Complex Content Dependent (South East Asian) (SA)
623  * G_UNICODE_BREAK_AMBIGUOUS
624  * Ambiguous (Alphabetic or Ideographic) (AI)
625  * G_UNICODE_BREAK_UNKNOWN
626  * Unknown (XX)
627  * G_UNICODE_BREAK_NEXT_LINE
628  * Next Line (NL)
629  * G_UNICODE_BREAK_WORD_JOINER
630  * Word Joiner (WJ)
631  * G_UNICODE_BREAK_HANGUL_L_JAMO
632  * Hangul L Jamo (JL)
633  * G_UNICODE_BREAK_HANGUL_V_JAMO
634  * Hangul V Jamo (JV)
635  * G_UNICODE_BREAK_HANGUL_T_JAMO
636  * Hangul T Jamo (JT)
637  * G_UNICODE_BREAK_HANGUL_LV_SYLLABLE
638  * Hangul LV Syllable (H2)
639  * G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE
640  * Hangul LVT Syllable (H3)
641  * G_UNICODE_BREAK_CLOSE_PARANTHESIS
642  * Closing Parenthesis (CP). Since 2.28
643  */
644 public enum GUnicodeBreakType
645 {
646 	MANDATORY,
647 	CARRIAGE_RETURN,
648 	LINE_FEED,
649 	COMBINING_MARK,
650 	SURROGATE,
651 	ZERO_WIDTH_SPACE,
652 	INSEPARABLE,
653 	NON_BREAKING_GLUE,
654 	CONTINGENT,
655 	SPACE,
656 	AFTER,
657 	BEFORE,
658 	BEFORE_AND_AFTER,
659 	HYPHEN,
660 	NON_STARTER,
661 	OPEN_PUNCTUATION,
662 	CLOSE_PUNCTUATION,
663 	QUOTATION,
664 	EXCLAMATION,
665 	IDEOGRAPHIC,
666 	NUMERIC,
667 	INFIX_SEPARATOR,
668 	SYMBOL,
669 	ALPHABETIC,
670 	PREFIX,
671 	POSTFIX,
672 	COMPLEX_CONTEXT,
673 	AMBIGUOUS,
674 	UNKNOWN,
675 	NEXT_LINE,
676 	WORD_JOINER,
677 	HANGUL_L_JAMO,
678 	HANGUL_V_JAMO,
679 	HANGUL_T_JAMO,
680 	HANGUL_LV_SYLLABLE,
681 	HANGUL_LVT_SYLLABLE,
682 	CLOSE_PARANTHESIS
683 }
684 alias GUnicodeBreakType UnicodeBreakType;
685 
686 /**
687  * The GUnicodeScript enumeration identifies different writing
688  * systems. The values correspond to the names as defined in the
689  * Unicode standard. The enumeration has been added in GLib 2.14,
690  * and is interchangeable with PangoScript.
691  * Note that new types may be added in the future. Applications
692  * should be ready to handle unknown values.
693  * See Unicode Standard Annex
694  * #24: Script names.
695  * G_UNICODE_SCRIPT_INVALID_CODE
696  * a value never returned from g_unichar_get_script()
697  * G_UNICODE_SCRIPT_COMMON
698  *  a character used by multiple different scripts
699  * G_UNICODE_SCRIPT_INHERITED
700  *  a mark glyph that takes its script from the
701  *  base glyph to which it is attached
702  * G_UNICODE_SCRIPT_ARABIC
703  *  Arabic
704  * G_UNICODE_SCRIPT_ARMENIAN
705  *  Armenian
706  * G_UNICODE_SCRIPT_BENGALI
707  *  Bengali
708  * G_UNICODE_SCRIPT_BOPOMOFO
709  *  Bopomofo
710  * G_UNICODE_SCRIPT_CHEROKEE
711  *  Cherokee
712  * G_UNICODE_SCRIPT_COPTIC
713  *  Coptic
714  * G_UNICODE_SCRIPT_CYRILLIC
715  *  Cyrillic
716  * G_UNICODE_SCRIPT_DESERET
717  *  Deseret
718  * G_UNICODE_SCRIPT_DEVANAGARI
719  * Devanagari
720  * G_UNICODE_SCRIPT_ETHIOPIC
721  *  Ethiopic
722  * G_UNICODE_SCRIPT_GEORGIAN
723  *  Georgian
724  * G_UNICODE_SCRIPT_GOTHIC
725  *  Gothic
726  * G_UNICODE_SCRIPT_GREEK
727  *  Greek
728  * G_UNICODE_SCRIPT_GUJARATI
729  *  Gujarati
730  * G_UNICODE_SCRIPT_GURMUKHI
731  *  Gurmukhi
732  * G_UNICODE_SCRIPT_HAN
733  *  Han
734  * G_UNICODE_SCRIPT_HANGUL
735  *  Hangul
736  * G_UNICODE_SCRIPT_HEBREW
737  *  Hebrew
738  * G_UNICODE_SCRIPT_HIRAGANA
739  *  Hiragana
740  * G_UNICODE_SCRIPT_KANNADA
741  *  Kannada
742  * G_UNICODE_SCRIPT_KATAKANA
743  *  Katakana
744  * G_UNICODE_SCRIPT_KHMER
745  *  Khmer
746  * G_UNICODE_SCRIPT_LAO
747  *  Lao
748  * G_UNICODE_SCRIPT_LATIN
749  *  Latin
750  * G_UNICODE_SCRIPT_MALAYALAM
751  *  Malayalam
752  * G_UNICODE_SCRIPT_MONGOLIAN
753  *  Mongolian
754  * G_UNICODE_SCRIPT_MYANMAR
755  *  Myanmar
756  * G_UNICODE_SCRIPT_OGHAM
757  *  Ogham
758  * G_UNICODE_SCRIPT_OLD_ITALIC
759  * Old Italic
760  * G_UNICODE_SCRIPT_ORIYA
761  *  Oriya
762  * G_UNICODE_SCRIPT_RUNIC
763  *  Runic
764  * G_UNICODE_SCRIPT_SINHALA
765  *  Sinhala
766  * G_UNICODE_SCRIPT_SYRIAC
767  *  Syriac
768  * G_UNICODE_SCRIPT_TAMIL
769  *  Tamil
770  * G_UNICODE_SCRIPT_TELUGU
771  *  Telugu
772  * G_UNICODE_SCRIPT_THAANA
773  *  Thaana
774  * G_UNICODE_SCRIPT_THAI
775  *  Thai
776  * G_UNICODE_SCRIPT_TIBETAN
777  *  Tibetan
778  * G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL
779  *  Canadian Aboriginal
780  * G_UNICODE_SCRIPT_YI
781  *  Yi
782  * G_UNICODE_SCRIPT_TAGALOG
783  *  Tagalog
784  * G_UNICODE_SCRIPT_HANUNOO
785  *  Hanunoo
786  * G_UNICODE_SCRIPT_BUHID
787  *  Buhid
788  * G_UNICODE_SCRIPT_TAGBANWA
789  *  Tagbanwa
790  * G_UNICODE_SCRIPT_BRAILLE
791  *  Braille
792  * G_UNICODE_SCRIPT_CYPRIOT
793  *  Cypriot
794  * G_UNICODE_SCRIPT_LIMBU
795  *  Limbu
796  * G_UNICODE_SCRIPT_OSMANYA
797  *  Osmanya
798  * G_UNICODE_SCRIPT_SHAVIAN
799  *  Shavian
800  * G_UNICODE_SCRIPT_LINEAR_B
801  *  Linear B
802  * G_UNICODE_SCRIPT_TAI_LE
803  *  Tai Le
804  * G_UNICODE_SCRIPT_UGARITIC
805  *  Ugaritic
806  * G_UNICODE_SCRIPT_NEW_TAI_LUE
807  * New Tai Lue
808  * G_UNICODE_SCRIPT_BUGINESE
809  *  Buginese
810  * G_UNICODE_SCRIPT_GLAGOLITIC
811  * Glagolitic
812  * G_UNICODE_SCRIPT_TIFINAGH
813  *  Tifinagh
814  * G_UNICODE_SCRIPT_SYLOTI_NAGRI
815  * Syloti Nagri
816  * G_UNICODE_SCRIPT_OLD_PERSIAN
817  * Old Persian
818  * G_UNICODE_SCRIPT_KHAROSHTHI
819  * Kharoshthi
820  * G_UNICODE_SCRIPT_UNKNOWN
821  *  an unassigned code point
822  * G_UNICODE_SCRIPT_BALINESE
823  *  Balinese
824  * G_UNICODE_SCRIPT_CUNEIFORM
825  *  Cuneiform
826  * G_UNICODE_SCRIPT_PHOENICIAN
827  * Phoenician
828  * G_UNICODE_SCRIPT_PHAGS_PA
829  *  Phags-pa
830  * G_UNICODE_SCRIPT_NKO
831  *  N'Ko
832  * G_UNICODE_SCRIPT_KAYAH_LI
833  *  Kayah Li. Since 2.16.3
834  * G_UNICODE_SCRIPT_LEPCHA
835  *  Lepcha. Since 2.16.3
836  * G_UNICODE_SCRIPT_REJANG
837  *  Rejang. Since 2.16.3
838  * G_UNICODE_SCRIPT_SUNDANESE
839  *  Sundanese. Since 2.16.3
840  * G_UNICODE_SCRIPT_SAURASHTRA
841  * Saurashtra. Since 2.16.3
842  * G_UNICODE_SCRIPT_CHAM
843  *  Cham. Since 2.16.3
844  * G_UNICODE_SCRIPT_OL_CHIKI
845  *  Ol Chiki. Since 2.16.3
846  * G_UNICODE_SCRIPT_VAI
847  *  Vai. Since 2.16.3
848  * G_UNICODE_SCRIPT_CARIAN
849  *  Carian. Since 2.16.3
850  * G_UNICODE_SCRIPT_LYCIAN
851  *  Lycian. Since 2.16.3
852  * G_UNICODE_SCRIPT_LYDIAN
853  *  Lydian. Since 2.16.3
854  * G_UNICODE_SCRIPT_AVESTAN
855  *  Avestan. Since 2.26
856  * G_UNICODE_SCRIPT_BAMUM
857  *  Bamum. Since 2.26
858  * G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS
859  *  Egyptian Hieroglpyhs. Since 2.26
860  * G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC
861  *  Imperial Aramaic. Since 2.26
862  * G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI
863  *  Inscriptional Pahlavi. Since 2.26
864  * G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN
865  * Inscriptional Parthian. Since 2.26
866  * G_UNICODE_SCRIPT_JAVANESE
867  *  Javanese. Since 2.26
868  * G_UNICODE_SCRIPT_KAITHI
869  *  Kaithi. Since 2.26
870  * G_UNICODE_SCRIPT_LISU
871  *  Lisu. Since 2.26
872  * G_UNICODE_SCRIPT_MEETEI_MAYEK
873  *  Meetei Mayek. Since 2.26
874  * G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN
875  *  Old South Arabian. Since 2.26
876  * G_UNICODE_SCRIPT_OLD_TURKIC
877  *  Old Turkic. Since 2.28
878  * G_UNICODE_SCRIPT_SAMARITAN
879  *  Samaritan. Since 2.26
880  * G_UNICODE_SCRIPT_TAI_THAM
881  *  Tai Tham. Since 2.26
882  * G_UNICODE_SCRIPT_TAI_VIET
883  *  Tai Viet. Since 2.26
884  * G_UNICODE_SCRIPT_BATAK
885  *  Batak. Since 2.28
886  * G_UNICODE_SCRIPT_BRAHMI
887  *  Brahmi. Since 2.28
888  * G_UNICODE_SCRIPT_MANDAIC
889  *  Mandaic. Since 2.28
890  */
891 public enum GUnicodeScript
892 {
893 	INVALID_CODE = -1,
894 	COMMON = 0, /+* Zyyy +/
895 	INHERITED, /+* Qaai +/
896 	ARABIC, /+* Arab +/
897 	ARMENIAN, /+* Armn +/
898 	BENGALI, /+* Beng +/
899 	BOPOMOFO, /+* Bopo +/
900 	CHEROKEE, /+* Cher +/
901 	COPTIC, /+* Qaac +/
902 	CYRILLIC, /+* Cyrl (Cyrs) +/
903 	DESERET, /+* Dsrt +/
904 	DEVANAGARI, /+* Deva +/
905 	ETHIOPIC, /+* Ethi +/
906 	GEORGIAN, /+* Geor (Geon, Geoa) +/
907 	GOTHIC, /+* Goth +/
908 	GREEK, /+* Grek +/
909 	GUJARATI, /+* Gujr +/
910 	GURMUKHI, /+* Guru +/
911 	HAN, /+* Hani +/
912 	HANGUL, /+* Hang +/
913 	HEBREW, /+* Hebr +/
914 	HIRAGANA, /+* Hira +/
915 	KANNADA, /+* Knda +/
916 	KATAKANA, /+* Kana +/
917 	KHMER, /+* Khmr +/
918 	LAO, /+* Laoo +/
919 	LATIN, /+* Latn (Latf, Latg) +/
920 	MALAYALAM, /+* Mlym +/
921 	MONGOLIAN, /+* Mong +/
922 	MYANMAR, /+* Mymr +/
923 	OGHAM, /+* Ogam +/
924 	OLD_ITALIC, /+* Ital +/
925 	ORIYA, /+* Orya +/
926 	RUNIC, /+* Runr +/
927 	SINHALA, /+* Sinh +/
928 	SYRIAC, /+* Syrc (Syrj, Syrn, Syre) +/
929 	TAMIL, /+* Taml +/
930 	TELUGU, /+* Telu +/
931 	THAANA, /+* Thaa +/
932 	THAI, /+* Thai +/
933 	TIBETAN, /+* Tibt +/
934 	CANADIAN_ABORIGINAL, /+* Cans +/
935 	YI, /+* Yiii +/
936 	TAGALOG, /+* Tglg +/
937 	HANUNOO, /+* Hano +/
938 	BUHID, /+* Buhd +/
939 	TAGBANWA, /+* Tagb +/
940 	/+* Unicode-4.0 additions +/
941 	BRAILLE, /+* Brai +/
942 	CYPRIOT, /+* Cprt +/
943 	LIMBU, /+* Limb +/
944 	OSMANYA, /+* Osma +/
945 	SHAVIAN, /+* Shaw +/
946 	LINEAR_B, /+* Linb +/
947 	TAI_LE, /+* Tale +/
948 	UGARITIC, /+* Ugar +/
949 	/+* Unicode-4.1 additions +/
950 	NEW_TAI_LUE, /+* Talu +/
951 	BUGINESE, /+* Bugi +/
952 	GLAGOLITIC, /+* Glag +/
953 	TIFINAGH, /+* Tfng +/
954 	SYLOTI_NAGRI, /+* Sylo +/
955 	OLD_PERSIAN, /+* Xpeo +/
956 	KHAROSHTHI, /+* Khar +/
957 	/+* Unicode-5.0 additions +/
958 	UNKNOWN, /+* Zzzz +/
959 	BALINESE, /+* Bali +/
960 	CUNEIFORM, /+* Xsux +/
961 	PHOENICIAN, /+* Phnx +/
962 	PHAGS_PA, /+* Phag +/
963 	NKO, /+* Nkoo +/
964 	/+* Unicode-5.1 additions +/
965 	KAYAH_LI, /+* Kali +/
966 	LEPCHA, /+* Lepc +/
967 	REJANG, /+* Rjng +/
968 	SUNDANESE, /+* Sund +/
969 	SAURASHTRA, /+* Saur +/
970 	CHAM, /+* Cham +/
971 	OL_CHIKI, /+* Olck +/
972 	VAI, /+* Vaii +/
973 	CARIAN, /+* Cari +/
974 	LYCIAN, /+* Lyci +/
975 	LYDIAN, /+* Lydi +/
976 	/+* Unicode-5.2 additions +/
977 	AVESTAN, /+* Avst +/
978 	BAMUM, /+* Bamu +/
979 	EGYPTIAN_HIEROGLYPHS, /+* Egyp +/
980 	IMPERIAL_ARAMAIC, /+* Armi +/
981 	INSCRIPTIONAL_PAHLAVI, /+* Phli +/
982 	INSCRIPTIONAL_PARTHIAN, /+* Prti +/
983 	JAVANESE, /+* Java +/
984 	KAITHI, /+* Kthi +/
985 	LISU, /+* Lisu +/
986 	MEETEI_MAYEK, /+* Mtei +/
987 	OLD_SOUTH_ARABIAN, /+* Sarb +/
988 	OLD_TURKIC, /+* Orkh +/
989 	SAMARITAN, /+* Samr +/
990 	TAI_THAM, /+* Lana +/
991 	TAI_VIET, /+* Tavt +/
992 	/+* Unicode-6.0 additions +/
993 	BATAK, /+* Batk +/
994 	BRAHMI, /+* Brah +/
995 	MANDAIC /+* Mand +/
996 }
997 alias GUnicodeScript UnicodeScript;
998 
999 /**
1000  * Defines how a Unicode string is transformed in a canonical
1001  * form, standardizing such issues as whether a character with an accent is
1002  * represented as a base character and combining accent or as a single precomposed
1003  * character. Unicode strings should generally be normalized before comparing them.
1004  * G_NORMALIZE_DEFAULT
1005  * standardize differences that do not affect the
1006  *  text content, such as the above-mentioned accent representation.
1007  * G_NORMALIZE_NFD
1008  * another name for G_NORMALIZE_DEFAULT.
1009  * G_NORMALIZE_DEFAULT_COMPOSE
1010  * like G_NORMALIZE_DEFAULT, but with composed
1011  *  forms rather than a maximally decomposed form.
1012  * G_NORMALIZE_NFC
1013  * another name for G_NORMALIZE_DEFAULT_COMPOSE.
1014  * G_NORMALIZE_ALL
1015  * beyond G_NORMALIZE_DEFAULT also standardize the
1016  *  "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the
1017  *  standard forms (in this case DIGIT THREE). Formatting information may be
1018  *  lost but for most text operations such characters should be considered the
1019  *  same.
1020  * G_NORMALIZE_NFKD
1021  * another name for G_NORMALIZE_ALL.
1022  * G_NORMALIZE_ALL_COMPOSE
1023  * like G_NORMALIZE_ALL, but with composed
1024  *  forms rather than a maximally decomposed form.
1025  * G_NORMALIZE_NFKC
1026  * another name for G_NORMALIZE_ALL_COMPOSE.
1027  */
1028 public enum GNormalizeMode
1029 {
1030 	DEFAULT,
1031 	NFD = DEFAULT,
1032 	DEFAULT_COMPOSE,
1033 	NFC = DEFAULT_COMPOSE,
1034 	ALL,
1035 	NFKD = ALL,
1036 	ALL_COMPOSE,
1037 	NFKC = ALL_COMPOSE
1038 }
1039 alias GNormalizeMode NormalizeMode;
1040 
1041 /**
1042  * The hashing algorithm to be used by GChecksum when performing the
1043  * digest of some data.
1044  * Note that the GChecksumType enumeration may be extended at a later
1045  * date to include new hashing algorithm types.
1046  * G_CHECKSUM_MD5
1047  * Use the MD5 hashing algorithm
1048  * G_CHECKSUM_SHA1
1049  * Use the SHA-1 hashing algorithm
1050  * G_CHECKSUM_SHA256
1051  * Use the SHA-256 hashing algorithm
1052  * Since 2.16
1053  */
1054 public enum GChecksumType
1055 {
1056 	MD5,
1057 	SHA1,
1058 	SHA256
1059 }
1060 alias GChecksumType ChecksumType;
1061 
1062 /**
1063  * This enumeration isn't used in the API, but may be useful if you need
1064  * to mark a number as a day, month, or year.
1065  * G_DATE_DAY
1066  * a day
1067  * G_DATE_MONTH
1068  * a month
1069  * G_DATE_YEAR
1070  * a year
1071  */
1072 public enum GDateDMY
1073 {
1074 	DAY = 0,
1075 	MONTH = 1,
1076 	YEAR = 2
1077 }
1078 alias GDateDMY DateDMY;
1079 
1080 /**
1081  * Enumeration representing a month; values are G_DATE_JANUARY,
1082  * G_DATE_FEBRUARY, etc. G_DATE_BAD_MONTH is the invalid value.
1083  * G_DATE_BAD_MONTH
1084  * invalid value
1085  * G_DATE_JANUARY
1086  * January
1087  * G_DATE_FEBRUARY
1088  * February
1089  * G_DATE_MARCH
1090  * March
1091  * G_DATE_APRIL
1092  * April
1093  * G_DATE_MAY
1094  * May
1095  * G_DATE_JUNE
1096  * June
1097  * G_DATE_JULY
1098  * July
1099  * G_DATE_AUGUST
1100  * August
1101  * G_DATE_SEPTEMBER
1102  * September
1103  * G_DATE_OCTOBER
1104  * October
1105  * G_DATE_NOVEMBER
1106  * November
1107  * G_DATE_DECEMBER
1108  * December
1109  */
1110 public enum GDateMonth
1111 {
1112 	BAD_MONTH = 0,
1113 	JANUARY = 1,
1114 	FEBRUARY = 2,
1115 	MARCH = 3,
1116 	APRIL = 4,
1117 	MAY = 5,
1118 	JUNE = 6,
1119 	JULY = 7,
1120 	AUGUST = 8,
1121 	SEPTEMBER = 9,
1122 	OCTOBER = 10,
1123 	NOVEMBER = 11,
1124 	DECEMBER = 12
1125 }
1126 alias GDateMonth DateMonth;
1127 
1128 /**
1129  * Enumeration representing a day of the week; G_DATE_MONDAY,
1130  * G_DATE_TUESDAY, etc. G_DATE_BAD_WEEKDAY is an invalid weekday.
1131  * G_DATE_BAD_WEEKDAY
1132  * invalid value
1133  * G_DATE_MONDAY
1134  * Monday
1135  * G_DATE_TUESDAY
1136  * Tuesday
1137  * G_DATE_WEDNESDAY
1138  * Wednesday
1139  * G_DATE_THURSDAY
1140  * Thursday
1141  * G_DATE_FRIDAY
1142  * Friday
1143  * G_DATE_SATURDAY
1144  * Saturday
1145  * G_DATE_SUNDAY
1146  * Sunday
1147  */
1148 public enum GDateWeekday
1149 {
1150 	BAD_WEEKDAY = 0,
1151 	MONDAY = 1,
1152 	TUESDAY = 2,
1153 	WEDNESDAY = 3,
1154 	THURSDAY = 4,
1155 	FRIDAY = 5,
1156 	SATURDAY = 6,
1157 	SUNDAY = 7
1158 }
1159 alias GDateWeekday DateWeekday;
1160 
1161 /**
1162  * Disambiguates a given time in two ways.
1163  * First, specifies if the given time is in universal or local time.
1164  * Second, if the time is in local time, specifies if it is local
1165  * standard time or local daylight time. This is important for the case
1166  * where the same local time occurs twice (during daylight savings time
1167  * transitions, for example).
1168  * G_TIME_TYPE_STANDARD
1169  * the time is in local standard time
1170  * G_TIME_TYPE_DAYLIGHT
1171  * the time is in local daylight time
1172  * G_TIME_TYPE_UNIVERSAL
1173  * the time is in UTC
1174  */
1175 public enum GTimeType
1176 {
1177 	TYPE_STANDARD,
1178 	TYPE_DAYLIGHT,
1179 	TYPE_UNIVERSAL
1180 }
1181 alias GTimeType TimeType;
1182 
1183 /**
1184  * These are logical ids for special directories which are defined
1185  * depending on the platform used. You should use g_get_user_special_dir()
1186  * to retrieve the full path associated to the logical id.
1187  * The GUserDirectory enumeration can be extended at later date. Not
1188  * every platform has a directory for every logical id in this
1189  * enumeration.
1190  * G_USER_DIRECTORY_DESKTOP
1191  * the user's Desktop directory
1192  * G_USER_DIRECTORY_DOCUMENTS
1193  * the user's Documents directory
1194  * G_USER_DIRECTORY_DOWNLOAD
1195  * the user's Downloads directory
1196  * G_USER_DIRECTORY_MUSIC
1197  * the user's Music directory
1198  * G_USER_DIRECTORY_PICTURES
1199  * the user's Pictures directory
1200  * G_USER_DIRECTORY_PUBLIC_SHARE
1201  * the user's shared directory
1202  * G_USER_DIRECTORY_TEMPLATES
1203  * the user's Templates directory
1204  * G_USER_DIRECTORY_VIDEOS
1205  * the user's Movies directory
1206  * G_USER_N_DIRECTORIES
1207  * the number of enum values
1208  * Since 2.14
1209  */
1210 public enum GUserDirectory
1211 {
1212 	DESKTOP,
1213 	DOCUMENTS,
1214 	DOWNLOAD,
1215 	MUSIC,
1216 	PICTURES,
1217 	PUBLIC_SHARE,
1218 	TEMPLATES,
1219 	VIDEOS,
1220 	G_USER_N_DIRECTORIES
1221 }
1222 alias GUserDirectory UserDirectory;
1223 
1224 /**
1225  * The possible types of token returned from each g_scanner_get_next_token() call.
1226  * G_TOKEN_EOF
1227  * the end of the file.
1228  * G_TOKEN_LEFT_PAREN
1229  * a '(' character.
1230  * G_TOKEN_LEFT_CURLY
1231  * a '{' character.
1232  * G_TOKEN_RIGHT_CURLY
1233  * a '}' character.
1234  */
1235 public enum GTokenType
1236 {
1237 	EOF = 0,
1238 	LEFT_PAREN = '(',
1239 	RIGHT_PAREN = ')',
1240 	LEFT_CURLY = '{',
1241 	RIGHT_CURLY = '}',
1242 	LEFT_BRACE = '[',
1243 	RIGHT_BRACE = ']',
1244 	EQUAL_SIGN = '=',
1245 	COMMA = ',',
1246 	NONE = 256,
1247 	ERROR,
1248 	CHAR,
1249 	BINARY,
1250 	OCTAL,
1251 	INT,
1252 	HEX,
1253 	FLOAT,
1254 	STRING,
1255 	SYMBOL,
1256 	IDENTIFIER,
1257 	IDENTIFIER_NULL,
1258 	COMMENT_SINGLE,
1259 	COMMENT_MULTI,
1260 	LAST
1261 }
1262 alias GTokenType TokenType;
1263 
1264 /**
1265  * The possible errors, used in the v_error field
1266  * of GTokenValue, when the token is a G_TOKEN_ERROR.
1267  * G_ERR_UNKNOWN
1268  * unknown error.
1269  * G_ERR_UNEXP_EOF
1270  * unexpected end of file.
1271  * G_ERR_UNEXP_EOF_IN_STRING
1272  * unterminated string constant.
1273  * G_ERR_UNEXP_EOF_IN_COMMENT
1274  * unterminated comment.
1275  * G_ERR_NON_DIGIT_IN_CONST
1276  * non-digit character in a number.
1277  * G_ERR_DIGIT_RADIX
1278  * digit beyond radix in a number.
1279  * G_ERR_FLOAT_RADIX
1280  * non-decimal floating point number.
1281  * G_ERR_FLOAT_MALFORMED
1282  * malformed floating point number.
1283  */
1284 public enum GErrorType
1285 {
1286 	UNKNOWN,
1287 	UNEXP_EOF,
1288 	UNEXP_EOF_IN_STRING,
1289 	UNEXP_EOF_IN_COMMENT,
1290 	NON_DIGIT_IN_CONST,
1291 	DIGIT_RADIX,
1292 	FLOAT_RADIX,
1293 	FLOAT_MALFORMED
1294 }
1295 alias GErrorType ErrorType;
1296 
1297 /**
1298  * Error codes returned by spawning processes.
1299  * G_SPAWN_ERROR_FORK
1300  * Fork failed due to lack of memory.
1301  * G_SPAWN_ERROR_READ
1302  * Read or select on pipes failed.
1303  * G_SPAWN_ERROR_CHDIR
1304  * Changing to working directory failed.
1305  * G_SPAWN_ERROR_ACCES
1306  * execv() returned EACCES.
1307  * G_SPAWN_ERROR_PERM
1308  * execv() returned EPERM.
1309  * G_SPAWN_ERROR_2BIG
1310  * execv() returned E2BIG.
1311  * G_SPAWN_ERROR_NOEXEC
1312  * execv() returned ENOEXEC.
1313  * G_SPAWN_ERROR_NAMETOOLONG
1314  * execv() returned ENAMETOOLONG.
1315  * G_SPAWN_ERROR_NOENT
1316  * execv() returned ENOENT.
1317  * G_SPAWN_ERROR_NOMEM
1318  * execv() returned ENOMEM.
1319  * G_SPAWN_ERROR_NOTDIR
1320  * execv() returned ENOTDIR.
1321  * G_SPAWN_ERROR_LOOP
1322  * execv() returned ELOOP.
1323  * G_SPAWN_ERROR_TXTBUSY
1324  * execv() returned ETXTBUSY.
1325  * G_SPAWN_ERROR_IO
1326  * execv() returned EIO.
1327  * G_SPAWN_ERROR_NFILE
1328  * execv() returned ENFILE.
1329  * G_SPAWN_ERROR_MFILE
1330  * execv() returned EMFILE.
1331  * G_SPAWN_ERROR_INVAL
1332  * execv() returned EINVAL.
1333  * G_SPAWN_ERROR_ISDIR
1334  * execv() returned EISDIR.
1335  * G_SPAWN_ERROR_LIBBAD
1336  * execv() returned ELIBBAD.
1337  * G_SPAWN_ERROR_FAILED
1338  * Some other fatal failure, error->message should explain.
1339  */
1340 public enum GSpawnError
1341 {
1342 	FORK, /+* fork failed due to lack of memory +/
1343 	READ, /+* read or select on pipes failed +/
1344 	CHDIR, /+* changing to working dir failed +/
1345 	ACCES, /+* execv() returned EACCES +/
1346 	PERM, /+* execv() returned EPERM +/
1347 	TOO_BIG, /+* execv() returned E2BIG +/
1348 	NOEXEC, /+* execv() returned ENOEXEC +/
1349 	NAMETOOLONG, /+* "" "" ENAMETOOLONG +/
1350 	NOENT, /+* "" "" ENOENT +/
1351 	NOMEM, /+* "" "" ENOMEM +/
1352 	NOTDIR, /+* "" "" ENOTDIR +/
1353 	LOOP, /+* "" "" ELOOP +/
1354 	TXTBUSY, /+* "" "" ETXTBUSY +/
1355 	IO, /+* "" "" EIO +/
1356 	NFILE, /+* "" "" ENFILE +/
1357 	MFILE, /+* "" "" EMFLE +/
1358 	INVAL, /+* "" "" EINVAL +/
1359 	ISDIR, /+* "" "" EISDIR +/
1360 	LIBBAD, /+* "" "" ELIBBAD +/
1361 	FAILED /+* other fatal failure, error->message
1362 	 * should explain
1363 	+/
1364 }
1365 alias GSpawnError SpawnError;
1366 
1367 /**
1368  * Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().
1369  * G_SPAWN_LEAVE_DESCRIPTORS_OPEN
1370  * the parent's open file descriptors will be
1371  *  inherited by the child; otherwise all descriptors except stdin/stdout/stderr
1372  *  will be closed before calling exec() in the child.
1373  * G_SPAWN_DO_NOT_REAP_CHILD
1374  * the child will not be automatically reaped; you
1375  *  must use g_child_watch_add() yourself (or call waitpid()
1376  *  or handle SIGCHLD yourself), or the child will become a zombie.
1377  * G_SPAWN_SEARCH_PATH
1378  * argv[0] need not be an absolute path,
1379  *  it will be looked for in the user's PATH.
1380  * G_SPAWN_STDOUT_TO_DEV_NULL
1381  * the child's standard output will be discarded,
1382  *  instead of going to the same location as the parent's standard output.
1383  * G_SPAWN_STDERR_TO_DEV_NULL
1384  * the child's standard error will be discarded.
1385  * G_SPAWN_CHILD_INHERITS_STDIN
1386  * the child will inherit the parent's standard
1387  *  input (by default, the child's standard input is attached to
1388  *  /dev/null).
1389  * G_SPAWN_FILE_AND_ARGV_ZERO
1390  * the first element of argv is
1391  *  the file to execute, while the remaining elements are the actual argument
1392  *  vector to pass to the file. Normally g_spawn_async_with_pipes() uses
1393  *  argv[0] as the file to execute, and passes all of
1394  *  argv to the child.
1395  */
1396 public enum GSpawnFlags
1397 {
1398 	LEAVE_DESCRIPTORS_OPEN = 1 << 0,
1399 	DO_NOT_REAP_CHILD = 1 << 1,
1400 	/+* look for argv[0] inn the path i.e. use execvp() +/
1401 	SEARCH_PATH = 1 << 2,
1402 	/+* Dump output to /dev/null +/
1403 	STDOUT_TO_DEV_NULL = 1 << 3,
1404 	STDERR_TO_DEV_NULL = 1 << 4,
1405 	CHILD_INHERITS_STDIN = 1 << 5,
1406 	FILE_AND_ARGV_ZERO = 1 << 6
1407 }
1408 alias GSpawnFlags SpawnFlags;
1409 
1410 /**
1411  * Values corresponding to errno codes returned from file operations
1412  * on UNIX. Unlike errno codes, GFileError values are available on
1413  * all systems, even Windows. The exact meaning of each code depends on what
1414  * sort of file operation you were performing; the UNIX documentation
1415  * gives more details. The following error code descriptions come
1416  * from the GNU C Library manual, and are under the copyright
1417  * of that manual.
1418  * It's not very portable to make detailed assumptions about exactly
1419  * which errors will be returned from a given operation. Some errors
1420  * don't occur on some systems, etc., sometimes there are subtle
1421  * differences in when a system will report a given error, etc.
1422  * G_FILE_ERROR_EXIST
1423  * Operation not permitted; only the owner of the
1424  *  file (or other resource) or processes with special privileges can
1425  *  perform the operation.
1426  * G_FILE_ERROR_ISDIR
1427  * File is a directory; you cannot open a directory
1428  *  for writing, or create or remove hard links to it.
1429  * G_FILE_ERROR_ACCES
1430  * Permission denied; the file permissions do not
1431  *  allow the attempted operation.
1432  * G_FILE_ERROR_NAMETOOLONG
1433  * Filename too long.
1434  * G_FILE_ERROR_NOENT
1435  * No such file or directory. This is a "file
1436  *  doesn't exist" error for ordinary files that are referenced in
1437  *  contexts where they are expected to already exist.
1438  * G_FILE_ERROR_NOTDIR
1439  * A file that isn't a directory was specified when
1440  *  a directory is required.
1441  * G_FILE_ERROR_NXIO
1442  * No such device or address. The system tried to
1443  *  use the device represented by a file you specified, and it
1444  *  couldn't find the device. This can mean that the device file was
1445  *  installed incorrectly, or that the physical device is missing or
1446  *  not correctly attached to the computer.
1447  * G_FILE_ERROR_NODEV
1448  * This file is of a type that doesn't support
1449  *  mapping.
1450  * G_FILE_ERROR_ROFS
1451  * The directory containing the new link can't be
1452  *  modified because it's on a read-only file system.
1453  * G_FILE_ERROR_TXTBSY
1454  * Text file busy.
1455  * G_FILE_ERROR_FAULT
1456  * You passed in a pointer to bad memory.
1457  *  (GLib won't reliably return this, don't pass in pointers to bad
1458  *  memory.)
1459  * G_FILE_ERROR_LOOP
1460  * Too many levels of symbolic links were encountered
1461  *  in looking up a file name. This often indicates a cycle of symbolic
1462  *  links.
1463  * G_FILE_ERROR_NOSPC
1464  * No space left on device; write operation on a
1465  *  file failed because the disk is full.
1466  * G_FILE_ERROR_NOMEM
1467  * No memory available. The system cannot allocate
1468  *  more virtual memory because its capacity is full.
1469  * G_FILE_ERROR_MFILE
1470  * The current process has too many files open and
1471  *  can't open any more. Duplicate descriptors do count toward this
1472  *  limit.
1473  * G_FILE_ERROR_NFILE
1474  * There are too many distinct file openings in the
1475  *  entire system.
1476  * G_FILE_ERROR_BADF
1477  * Bad file descriptor; for example, I/O on a
1478  *  descriptor that has been closed or reading from a descriptor open
1479  *  only for writing (or vice versa).
1480  * G_FILE_ERROR_INVAL
1481  * Invalid argument. This is used to indicate
1482  *  various kinds of problems with passing the wrong argument to a
1483  *  library function.
1484  * G_FILE_ERROR_PIPE
1485  * Broken pipe; there is no process reading from the
1486  *  other end of a pipe. Every library function that returns this
1487  *  error code also generates a `SIGPIPE' signal; this signal
1488  *  terminates the program if not handled or blocked. Thus, your
1489  *  program will never actually see this code unless it has handled or
1490  *  blocked `SIGPIPE'.
1491  * G_FILE_ERROR_AGAIN
1492  * Resource temporarily unavailable; the call might
1493  *  work if you try again later.
1494  * G_FILE_ERROR_INTR
1495  * Interrupted function call; an asynchronous signal
1496  *  occurred and prevented completion of the call. When this
1497  *  happens, you should try the call again.
1498  * G_FILE_ERROR_IO
1499  * Input/output error; usually used for physical read
1500  *  or write errors. i.e. the disk or other physical device hardware
1501  *  is returning errors.
1502  * G_FILE_ERROR_PERM
1503  * Operation not permitted; only the owner of the
1504  *  file (or other resource) or processes with special privileges can
1505  *  perform the operation.
1506  * G_FILE_ERROR_NOSYS
1507  * Function not implemented; this indicates that the
1508  *  system is missing some functionality.
1509  * G_FILE_ERROR_FAILED
1510  * Does not correspond to a UNIX error code; this
1511  *  is the standard "failed for unspecified reason" error code present in
1512  *  all GError error code enumerations. Returned if no specific
1513  *  code applies.
1514  */
1515 public enum GFileError
1516 {
1517 	EXIST,
1518 	ISDIR,
1519 	ACCES,
1520 	NAMETOOLONG,
1521 	NOENT,
1522 	NOTDIR,
1523 	NXIO,
1524 	NODEV,
1525 	ROFS,
1526 	TXTBSY,
1527 	FAULT,
1528 	LOOP,
1529 	NOSPC,
1530 	NOMEM,
1531 	MFILE,
1532 	NFILE,
1533 	BADF,
1534 	INVAL,
1535 	PIPE,
1536 	AGAIN,
1537 	INTR,
1538 	IO,
1539 	PERM,
1540 	NOSYS,
1541 	FAILED
1542 }
1543 alias GFileError FileError;
1544 
1545 /**
1546  * A test to perform on a file using g_file_test().
1547  * G_FILE_TEST_IS_REGULAR
1548  * TRUE if the file is a regular file (not a directory).
1549  *  Note that this test will also return TRUE if the tested file is a symlink
1550  *  to a regular file.
1551  * G_FILE_TEST_IS_SYMLINK
1552  * TRUE if the file is a symlink.
1553  * G_FILE_TEST_IS_DIR
1554  * TRUE if the file is a directory.
1555  * G_FILE_TEST_IS_EXECUTABLE
1556  * TRUE if the file is executable.
1557  * G_FILE_TEST_EXISTS
1558  * TRUE if the file exists.
1559  *  It may or may not be a regular file.
1560  */
1561 public enum GFileTest
1562 {
1563 	IS_REGULAR = 1 << 0,
1564 	IS_SYMLINK = 1 << 1,
1565 	IS_DIR = 1 << 2,
1566 	IS_EXECUTABLE = 1 << 3,
1567 	EXISTS = 1 << 4
1568 }
1569 alias GFileTest FileTest;
1570 
1571 /**
1572  * Error codes returned by shell functions.
1573  * G_SHELL_ERROR_BAD_QUOTING
1574  * Mismatched or otherwise mangled quoting.
1575  * G_SHELL_ERROR_EMPTY_STRING
1576  * String to be parsed was empty.
1577  * G_SHELL_ERROR_FAILED
1578  * Some other error.
1579  */
1580 public enum GShellError
1581 {
1582 	/+* mismatched or otherwise mangled quoting +/
1583 	BAD_QUOTING,
1584 	/+* string to be parsed was empty +/
1585 	EMPTY_STRING,
1586 	FAILED
1587 }
1588 alias GShellError ShellError;
1589 
1590 /**
1591  * Error codes returned by option parsing.
1592  * G_OPTION_ERROR_UNKNOWN_OPTION
1593  * An option was not known to the parser.
1594  *  This error will only be reported, if the parser hasn't been instructed
1595  *  to ignore unknown options, see g_option_context_set_ignore_unknown_options().
1596  * G_OPTION_ERROR_BAD_VALUE
1597  * A value couldn't be parsed.
1598  * G_OPTION_ERROR_FAILED
1599  * A GOptionArgFunc callback failed.
1600  */
1601 public enum GOptionError
1602 {
1603 	UNKNOWN_OPTION,
1604 	BAD_VALUE,
1605 	FAILED
1606 }
1607 alias GOptionError OptionError;
1608 
1609 /**
1610  * The GOptionArg enum values determine which type of extra argument the
1611  * options expect to find. If an option expects an extra argument, it
1612  * can be specified in several ways; with a short option:
1613  * -x arg, with a long option: --name arg
1614  * or combined in a single argument: --name=arg.
1615  * G_OPTION_ARG_NONE
1616  * No extra argument. This is useful for simple flags.
1617  * G_OPTION_ARG_STRING
1618  * The option takes a string argument.
1619  * G_OPTION_ARG_INT
1620  * The option takes an integer argument.
1621  * G_OPTION_ARG_CALLBACK
1622  * The option provides a callback to parse the
1623  *  extra argument.
1624  * G_OPTION_ARG_FILENAME
1625  * The option takes a filename as argument.
1626  * G_OPTION_ARG_STRING_ARRAY
1627  * The option takes a string argument, multiple
1628  *  uses of the option are collected into an array of strings.
1629  * G_OPTION_ARG_FILENAME_ARRAY
1630  * The option takes a filename as argument,
1631  *  multiple uses of the option are collected into an array of strings.
1632  * G_OPTION_ARG_DOUBLE
1633  * The option takes a double argument. The argument
1634  *  can be formatted either for the user's locale or for the "C" locale. Since 2.12
1635  * G_OPTION_ARG_INT64
1636  * The option takes a 64-bit integer. Like G_OPTION_ARG_INT
1637  *  but for larger numbers. The number can be in decimal base, or in hexadecimal
1638  *  (when prefixed with 0x, for example, 0xffffffff).
1639  *  Since 2.12
1640  */
1641 public enum GOptionArg
1642 {
1643 	NONE,
1644 	STRING,
1645 	INT,
1646 	CALLBACK,
1647 	FILENAME,
1648 	STRING_ARRAY,
1649 	FILENAME_ARRAY,
1650 	DOUBLE,
1651 	INT64
1652 }
1653 alias GOptionArg OptionArg;
1654 
1655 /**
1656  * Flags which modify individual options.
1657  * G_OPTION_FLAG_HIDDEN
1658  * The option doesn't appear in --help
1659  *  output.
1660  * G_OPTION_FLAG_IN_MAIN
1661  * The option appears in the main section of the
1662  *  --help output, even if it is defined in a group.
1663  * G_OPTION_FLAG_REVERSE
1664  * For options of the G_OPTION_ARG_NONE kind, this flag
1665  *  indicates that the sense of the option is reversed.
1666  * G_OPTION_FLAG_NO_ARG
1667  * For options of the G_OPTION_ARG_CALLBACK kind,
1668  *  this flag indicates that the callback does not take any argument
1669  *  (like a G_OPTION_ARG_NONE option). Since 2.8
1670  * G_OPTION_FLAG_FILENAME
1671  * For options of the G_OPTION_ARG_CALLBACK
1672  *  kind, this flag indicates that the argument should be passed to the
1673  *  callback in the GLib filename encoding rather than UTF-8. Since 2.8
1674  * G_OPTION_FLAG_OPTIONAL_ARG
1675  * For options of the G_OPTION_ARG_CALLBACK
1676  *  kind, this flag indicates that the argument supply is optional. If no argument
1677  *  is given then data of GOptionParseFunc will be set to NULL. Since 2.8
1678  * G_OPTION_FLAG_NOALIAS
1679  * This flag turns off the automatic conflict resolution
1680  *  which prefixes long option names with groupname- if
1681  *  there is a conflict. This option should only be used in situations where
1682  *  aliasing is necessary to model some legacy commandline interface. It is
1683  *  not safe to use this option, unless all option groups are under your
1684  *  direct control. Since 2.8.
1685  */
1686 public enum GOptionFlags
1687 {
1688 	HIDDEN = 1 << 0,
1689 	IN_MAIN = 1 << 1,
1690 	REVERSE = 1 << 2,
1691 	NO_ARG = 1 << 3,
1692 	FILENAME = 1 << 4,
1693 	OPTIONAL_ARG = 1 << 5,
1694 	NOALIAS = 1 << 6
1695 }
1696 alias GOptionFlags OptionFlags;
1697 
1698 /**
1699  * Error codes returned by regular expressions functions.
1700  * G_REGEX_ERROR_COMPILE
1701  * Compilation of the regular expression failed.
1702  * G_REGEX_ERROR_OPTIMIZE
1703  * Optimization of the regular expression failed.
1704  * G_REGEX_ERROR_REPLACE
1705  * Replacement failed due to an ill-formed replacement
1706  *  string.
1707  * G_REGEX_ERROR_MATCH
1708  * The match process failed.
1709  * G_REGEX_ERROR_INTERNAL
1710  * Internal error of the regular expression engine.
1711  *  Since 2.16
1712  * G_REGEX_ERROR_STRAY_BACKSLASH
1713  * "\\" at end of pattern. Since 2.16
1714  * G_REGEX_ERROR_MISSING_CONTROL_CHAR
1715  * "\\c" at end of pattern. Since 2.16
1716  * G_REGEX_ERROR_UNRECOGNIZED_ESCAPE
1717  * Unrecognized character follows "\\".
1718  *  Since 2.16
1719  * G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER
1720  * Numbers out of order in "{}"
1721  *  quantifier. Since 2.16
1722  * G_REGEX_ERROR_QUANTIFIER_TOO_BIG
1723  * Number too big in "{}" quantifier.
1724  *  Since 2.16
1725  * G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS
1726  * Missing terminating "]" for
1727  *  character class. Since 2.16
1728  * G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS
1729  * Invalid escape sequence
1730  *  in character class. Since 2.16
1731  * G_REGEX_ERROR_RANGE_OUT_OF_ORDER
1732  * Range out of order in character class.
1733  *  Since 2.16
1734  * G_REGEX_ERROR_NOTHING_TO_REPEAT
1735  * Nothing to repeat. Since 2.16
1736  * G_REGEX_ERROR_UNRECOGNIZED_CHARACTER
1737  * Unrecognized character after "(?",
1738  *  "(?<" or "(?P". Since 2.16
1739  * G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS
1740  * POSIX named classes are
1741  *  supported only within a class. Since 2.16
1742  * G_REGEX_ERROR_UNMATCHED_PARENTHESIS
1743  * Missing terminating ")" or ")"
1744  *  without opening "(". Since 2.16
1745  * G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE
1746  * Reference to non-existent
1747  *  subpattern. Since 2.16
1748  * G_REGEX_ERROR_UNTERMINATED_COMMENT
1749  * Missing terminating ")" after comment.
1750  *  Since 2.16
1751  * G_REGEX_ERROR_EXPRESSION_TOO_LARGE
1752  * Regular expression too large.
1753  *  Since 2.16
1754  * G_REGEX_ERROR_MEMORY_ERROR
1755  * Failed to get memory. Since 2.16
1756  * G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND
1757  * Lookbehind assertion is not
1758  *  fixed length. Since 2.16
1759  * G_REGEX_ERROR_MALFORMED_CONDITION
1760  * Malformed number or name after "(?(".
1761  *  Since 2.16
1762  * G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES
1763  * Conditional group contains
1764  *  more than two branches. Since 2.16
1765  * G_REGEX_ERROR_ASSERTION_EXPECTED
1766  * Assertion expected after "(?(".
1767  *  Since 2.16
1768  * G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME
1769  * Unknown POSIX class name.
1770  *  Since 2.16
1771  * G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED
1772  * POSIX collating
1773  *  elements are not supported. Since 2.16
1774  * G_REGEX_ERROR_HEX_CODE_TOO_LARGE
1775  * Character value in "\\x{...}" sequence
1776  *  is too large. Since 2.16
1777  * G_REGEX_ERROR_INVALID_CONDITION
1778  * Invalid condition "(?(0)". Since 2.16
1779  * G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND
1780  * \\C not allowed in
1781  *  lookbehind assertion. Since 2.16
1782  * G_REGEX_ERROR_INFINITE_LOOP
1783  * Recursive call could loop indefinitely.
1784  *  Since 2.16
1785  * G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR
1786  * Missing terminator
1787  *  in subpattern name. Since 2.16
1788  * G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME
1789  * Two named subpatterns have
1790  *  the same name. Since 2.16
1791  * G_REGEX_ERROR_MALFORMED_PROPERTY
1792  * Malformed "\\P" or "\\p" sequence.
1793  *  Since 2.16
1794  * G_REGEX_ERROR_UNKNOWN_PROPERTY
1795  * Unknown property name after "\\P" or
1796  *  "\\p". Since 2.16
1797  * G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG
1798  * Subpattern name is too long
1799  *  (maximum 32 characters). Since 2.16
1800  * G_REGEX_ERROR_TOO_MANY_SUBPATTERNS
1801  * Too many named subpatterns (maximum
1802  *  10,000). Since 2.16
1803  * G_REGEX_ERROR_INVALID_OCTAL_VALUE
1804  * Octal value is greater than "\\377".
1805  *  Since 2.16
1806  * G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE
1807  * "DEFINE" group contains more
1808  *  than one branch. Since 2.16
1809  * G_REGEX_ERROR_DEFINE_REPETION
1810  * Repeating a "DEFINE" group is not allowed.
1811  *  Since 2.16
1812  * G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS
1813  * Inconsistent newline options.
1814  *  Since 2.16
1815  * G_REGEX_ERROR_MISSING_BACK_REFERENCE
1816  * "\\g" is not followed by a braced
1817  *  name or an optionally braced non-zero number. Since 2.16
1818  * Since 2.14
1819  */
1820 public enum GRegexError
1821 {
1822 	COMPILE,
1823 	OPTIMIZE,
1824 	REPLACE,
1825 	MATCH,
1826 	INTERNAL,
1827 	/+* These are the error codes from PCRE + 100 +/
1828 	STRAY_BACKSLASH = 101,
1829 	MISSING_CONTROL_CHAR = 102,
1830 	UNRECOGNIZED_ESCAPE = 103,
1831 	QUANTIFIERS_OUT_OF_ORDER = 104,
1832 	QUANTIFIER_TOO_BIG = 105,
1833 	UNTERMINATED_CHARACTER_CLASS = 106,
1834 	INVALID_ESCAPE_IN_CHARACTER_CLASS = 107,
1835 	RANGE_OUT_OF_ORDER = 108,
1836 	NOTHING_TO_REPEAT = 109,
1837 	UNRECOGNIZED_CHARACTER = 112,
1838 	POSIX_NAMED_CLASS_OUTSIDE_CLASS = 113,
1839 	UNMATCHED_PARENTHESIS = 114,
1840 	INEXISTENT_SUBPATTERN_REFERENCE = 115,
1841 	UNTERMINATED_COMMENT = 118,
1842 	EXPRESSION_TOO_LARGE = 120,
1843 	MEMORY_ERROR = 121,
1844 	VARIABLE_LENGTH_LOOKBEHIND = 125,
1845 	MALFORMED_CONDITION = 126,
1846 	TOO_MANY_CONDITIONAL_BRANCHES = 127,
1847 	ASSERTION_EXPECTED = 128,
1848 	UNKNOWN_POSIX_CLASS_NAME = 130,
1849 	POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED = 131,
1850 	HEX_CODE_TOO_LARGE = 134,
1851 	INVALID_CONDITION = 135,
1852 	SINGLE_BYTE_MATCH_IN_LOOKBEHIND = 136,
1853 	INFINITE_LOOP = 140,
1854 	MISSING_SUBPATTERN_NAME_TERMINATOR = 142,
1855 	DUPLICATE_SUBPATTERN_NAME = 143,
1856 	MALFORMED_PROPERTY = 146,
1857 	UNKNOWN_PROPERTY = 147,
1858 	SUBPATTERN_NAME_TOO_LONG = 148,
1859 	TOO_MANY_SUBPATTERNS = 149,
1860 	INVALID_OCTAL_VALUE = 151,
1861 	TOO_MANY_BRANCHES_IN_DEFINE = 154,
1862 	DEFINE_REPETION = 155,
1863 	INCONSISTENT_NEWLINE_OPTIONS = 156,
1864 	MISSING_BACK_REFERENCE = 157
1865 }
1866 alias GRegexError RegexError;
1867 
1868 /**
1869  * Flags specifying compile-time options.
1870  * G_REGEX_CASELESS
1871  * Letters in the pattern match both upper- and
1872  *  lowercase letters. This option can be changed within a pattern
1873  *  by a "(?i)" option setting.
1874  * G_REGEX_MULTILINE
1875  * By default, GRegex treats the strings as consisting
1876  *  of a single line of characters (even if it actually contains
1877  *  newlines). The "start of line" metacharacter ("^") matches only
1878  *  at the start of the string, while the "end of line" metacharacter
1879  *  ("$") matches only at the end of the string, or before a terminating
1880  *  newline (unless G_REGEX_DOLLAR_ENDONLY is set). When
1881  *  G_REGEX_MULTILINE is set, the "start of line" and "end of line"
1882  *  constructs match immediately following or immediately before any
1883  *  newline in the string, respectively, as well as at the very start
1884  *  and end. This can be changed within a pattern by a "(?m)" option
1885  *  setting.
1886  * G_REGEX_DOTALL
1887  * A dot metacharater (".") in the pattern matches all
1888  *  characters, including newlines. Without it, newlines are excluded.
1889  *  This option can be changed within a pattern by a ("?s") option setting.
1890  * G_REGEX_EXTENDED
1891  * Whitespace data characters in the pattern are
1892  *  totally ignored except when escaped or inside a character class.
1893  *  Whitespace does not include the VT character (code 11). In addition,
1894  *  characters between an unescaped "#" outside a character class and
1895  *  the next newline character, inclusive, are also ignored. This can
1896  *  be changed within a pattern by a "(?x)" option setting.
1897  * G_REGEX_ANCHORED
1898  * The pattern is forced to be "anchored", that is,
1899  *  it is constrained to match only at the first matching point in the
1900  *  string that is being searched. This effect can also be achieved by
1901  *  appropriate constructs in the pattern itself such as the "^"
1902  *  metacharater.
1903  * G_REGEX_DOLLAR_ENDONLY
1904  * A dollar metacharacter ("$") in the pattern
1905  *  matches only at the end of the string. Without this option, a
1906  *  dollar also matches immediately before the final character if
1907  *  it is a newline (but not before any other newlines). This option
1908  *  is ignored if G_REGEX_MULTILINE is set.
1909  * G_REGEX_UNGREEDY
1910  * Inverts the "greediness" of the quantifiers so that
1911  *  they are not greedy by default, but become greedy if followed by "?".
1912  *  It can also be set by a "(?U)" option setting within the pattern.
1913  * G_REGEX_RAW
1914  * Usually strings must be valid UTF-8 strings, using this
1915  *  flag they are considered as a raw sequence of bytes.
1916  * G_REGEX_NO_AUTO_CAPTURE
1917  * Disables the use of numbered capturing
1918  *  parentheses in the pattern. Any opening parenthesis that is not
1919  *  followed by "?" behaves as if it were followed by "?:" but named
1920  *  parentheses can still be used for capturing (and they acquire numbers
1921  *  in the usual way).
1922  * G_REGEX_OPTIMIZE
1923  * Optimize the regular expression. If the pattern will
1924  *  be used many times, then it may be worth the effort to optimize it
1925  *  to improve the speed of matches.
1926  * G_REGEX_DUPNAMES
1927  * Names used to identify capturing subpatterns need not
1928  *  be unique. This can be helpful for certain types of pattern when it
1929  *  is known that only one instance of the named subpattern can ever be
1930  *  matched.
1931  * G_REGEX_NEWLINE_CR
1932  * Usually any newline character is recognized, if this
1933  *  option is set, the only recognized newline character is '\r'.
1934  * G_REGEX_NEWLINE_LF
1935  * Usually any newline character is recognized, if this
1936  *  option is set, the only recognized newline character is '\n'.
1937  * G_REGEX_NEWLINE_CRLF
1938  * Usually any newline character is recognized, if this
1939  *  option is set, the only recognized newline character sequence is '\r\n'.
1940  * Since 2.14
1941  */
1942 public enum GRegexCompileFlags
1943 {
1944 	CASELESS = 1 << 0,
1945 	MULTILINE = 1 << 1,
1946 	DOTALL = 1 << 2,
1947 	EXTENDED = 1 << 3,
1948 	ANCHORED = 1 << 4,
1949 	DOLLAR_ENDONLY = 1 << 5,
1950 	UNGREEDY = 1 << 9,
1951 	RAW = 1 << 11,
1952 	NO_AUTO_CAPTURE = 1 << 12,
1953 	OPTIMIZE = 1 << 13,
1954 	DUPNAMES = 1 << 19,
1955 	NEWLINE_CR = 1 << 20,
1956 	NEWLINE_LF = 1 << 21,
1957 	NEWLINE_CRLF = NEWLINE_CR | NEWLINE_LF
1958 }
1959 alias GRegexCompileFlags RegexCompileFlags;
1960 
1961 /**
1962  * Flags specifying match-time options.
1963  * G_REGEX_MATCH_ANCHORED
1964  * The pattern is forced to be "anchored", that is,
1965  *  it is constrained to match only at the first matching point in the
1966  *  string that is being searched. This effect can also be achieved by
1967  *  appropriate constructs in the pattern itself such as the "^"
1968  *  metacharater.
1969  * G_REGEX_MATCH_NOTBOL
1970  * Specifies that first character of the string is
1971  *  not the beginning of a line, so the circumflex metacharacter should
1972  *  not match before it. Setting this without G_REGEX_MULTILINE (at
1973  *  compile time) causes circumflex never to match. This option affects
1974  *  only the behaviour of the circumflex metacharacter, it does not
1975  *  affect "\A".
1976  * G_REGEX_MATCH_NOTEOL
1977  * Specifies that the end of the subject string is
1978  *  not the end of a line, so the dollar metacharacter should not match
1979  *  it nor (except in multiline mode) a newline immediately before it.
1980  *  Setting this without G_REGEX_MULTILINE (at compile time) causes
1981  *  dollar never to match. This option affects only the behaviour of
1982  *  the dollar metacharacter, it does not affect "\Z" or "\z".
1983  * G_REGEX_MATCH_NOTEMPTY
1984  * An empty string is not considered to be a valid
1985  *  match if this option is set. If there are alternatives in the pattern,
1986  *  they are tried. If all the alternatives match the empty string, the
1987  *  entire match fails. For example, if the pattern "a?b?" is applied to
1988  *  a string not beginning with "a" or "b", it matches the empty string
1989  *  at the start of the string. With this flag set, this match is not
1990  *  valid, so GRegex searches further into the string for occurrences
1991  *  of "a" or "b".
1992  * G_REGEX_MATCH_PARTIAL
1993  * Turns on the partial matching feature, for more
1994  *  documentation on partial matching see g_match_info_is_partial_match().
1995  * G_REGEX_MATCH_NEWLINE_CR
1996  * Overrides the newline definition set when
1997  *  creating a new GRegex, setting the '\r' character as line terminator.
1998  * G_REGEX_MATCH_NEWLINE_LF
1999  * Overrides the newline definition set when
2000  *  creating a new GRegex, setting the '\n' character as line terminator.
2001  * G_REGEX_MATCH_NEWLINE_CRLF
2002  * Overrides the newline definition set when
2003  *  creating a new GRegex, setting the '\r\n' characters as line terminator.
2004  * G_REGEX_MATCH_NEWLINE_ANY
2005  * Overrides the newline definition set when
2006  *  creating a new GRegex, any newline character or character sequence
2007  *  is recognized.
2008  * Since 2.14
2009  */
2010 public enum GRegexMatchFlags
2011 {
2012 	ANCHORED = 1 << 4,
2013 	NOTBOL = 1 << 7,
2014 	NOTEOL = 1 << 8,
2015 	NOTEMPTY = 1 << 10,
2016 	PARTIAL = 1 << 15,
2017 	NEWLINE_CR = 1 << 20,
2018 	NEWLINE_LF = 1 << 21,
2019 	NEWLINE_CRLF = NEWLINE_CR | NEWLINE_LF,
2020 	NEWLINE_ANY = 1 << 22
2021 }
2022 alias GRegexMatchFlags RegexMatchFlags;
2023 
2024 /**
2025  * Error codes returned by markup parsing.
2026  * G_MARKUP_ERROR_BAD_UTF8
2027  * text being parsed was not valid UTF-8
2028  * G_MARKUP_ERROR_EMPTY
2029  * document contained nothing, or only whitespace
2030  * G_MARKUP_ERROR_PARSE
2031  * document was ill-formed
2032  * G_MARKUP_ERROR_UNKNOWN_ELEMENT
2033  * error should be set by GMarkupParser
2034  *  functions; element wasn't known
2035  * G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE
2036  * error should be set by GMarkupParser
2037  *  functions; attribute wasn't known
2038  * G_MARKUP_ERROR_INVALID_CONTENT
2039  * error should be set by GMarkupParser
2040  *  functions; content was invalid
2041  * G_MARKUP_ERROR_MISSING_ATTRIBUTE
2042  * error should be set by GMarkupParser
2043  *  functions; a required attribute was missing
2044  */
2045 public enum GMarkupError
2046 {
2047 	BAD_UTF8,
2048 	EMPTY,
2049 	PARSE,
2050 	/+* The following are primarily intended for specific GMarkupParser
2051 	 * implementations to set.
2052 	+/
2053 	UNKNOWN_ELEMENT,
2054 	UNKNOWN_ATTRIBUTE,
2055 	INVALID_CONTENT,
2056 	MISSING_ATTRIBUTE
2057 }
2058 alias GMarkupError MarkupError;
2059 
2060 /**
2061  * Flags that affect the behaviour of the parser.
2062  * G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG
2063  * flag you should not use
2064  * G_MARKUP_TREAT_CDATA_AS_TEXT
2065  * When this flag is set, CDATA marked
2066  *  sections are not passed literally to the passthrough function of
2067  *  the parser. Instead, the content of the section (without the
2068  *  <![CDATA[ and ]]>) is
2069  *  passed to the text function. This flag was added in GLib 2.12
2070  * G_MARKUP_PREFIX_ERROR_POSITION
2071  * Normally errors caught by GMarkup
2072  *  itself have line/column information prefixed to them to let the
2073  *  caller know the location of the error. When this flag is set the
2074  *  location information is also prefixed to errors generated by the
2075  *  GMarkupParser implementation functions
2076  */
2077 public enum GMarkupParseFlags
2078 {
2079 	DO_NOT_USE_THIS_UNSUPPORTED_FLAG = 1 << 0,
2080 	TREAT_CDATA_AS_TEXT = 1 << 1,
2081 	PREFIX_ERROR_POSITION = 1 << 2
2082 }
2083 alias GMarkupParseFlags MarkupParseFlags;
2084 
2085 /**
2086  * A mixed enumerated type and flags field. You must specify one type
2087  * (string, strdup, boolean, tristate). Additionally, you may optionally
2088  * bitwise OR the type with the flag G_MARKUP_COLLECT_OPTIONAL.
2089  * It is likely that this enum will be extended in the future to
2090  * support other types.
2091  * G_MARKUP_COLLECT_INVALID
2092  * used to terminate the list of attributes
2093  *  to collect
2094  * G_MARKUP_COLLECT_STRING
2095  * collect the string pointer directly from
2096  *  the attribute_values[] array. Expects a parameter of type (const
2097  *  char **). If G_MARKUP_COLLECT_OPTIONAL is specified and the
2098  *  attribute isn't present then the pointer will be set to NULL
2099  * G_MARKUP_COLLECT_STRDUP
2100  * as with G_MARKUP_COLLECT_STRING, but
2101  *  expects a parameter of type (char **) and g_strdup()s the
2102  *  returned pointer. The pointer must be freed with g_free()
2103  * G_MARKUP_COLLECT_BOOLEAN
2104  * expects a parameter of type (gboolean *)
2105  *  and parses the attribute value as a boolean. Sets FALSE if the
2106  *  attribute isn't present. Valid boolean values consist of
2107  *  (case-insensitive) "false", "f", "no", "n", "0" and "true", "t",
2108  *  "yes", "y", "1"
2109  * G_MARKUP_COLLECT_TRISTATE
2110  * as with G_MARKUP_COLLECT_BOOLEAN, but
2111  *  in the case of a missing attribute a value is set that compares
2112  *  equal to neither FALSE nor TRUE G_MARKUP_COLLECT_OPTIONAL is
2113  *  implied
2114  * G_MARKUP_COLLECT_OPTIONAL
2115  * can be bitwise ORed with the other fields.
2116  *  If present, allows the attribute not to appear. A default value
2117  *  is set depending on what value type is used
2118  */
2119 public enum GMarkupCollectType
2120 {
2121 	INVALID,
2122 	STRING,
2123 	STRDUP,
2124 	BOOLEAN,
2125 	TRISTATE,
2126 	OPTIONAL = (1 << 16)
2127 }
2128 alias GMarkupCollectType MarkupCollectType;
2129 
2130 /**
2131  * Error codes returned by key file parsing.
2132  * G_KEY_FILE_ERROR_UNKNOWN_ENCODING
2133  * the text being parsed was in an unknown encoding
2134  * G_KEY_FILE_ERROR_PARSE
2135  * document was ill-formed
2136  * G_KEY_FILE_ERROR_NOT_FOUND
2137  * the file was not found
2138  * G_KEY_FILE_ERROR_KEY_NOT_FOUND
2139  * a requested key was not found
2140  * G_KEY_FILE_ERROR_GROUP_NOT_FOUND
2141  * a requested group was not found
2142  * G_KEY_FILE_ERROR_INVALID_VALUE
2143  * a value could not be parsed
2144  */
2145 public enum GKeyFileError
2146 {
2147 	UNKNOWN_ENCODING,
2148 	PARSE,
2149 	NOT_FOUND,
2150 	KEY_NOT_FOUND,
2151 	GROUP_NOT_FOUND,
2152 	INVALID_VALUE
2153 }
2154 alias GKeyFileError KeyFileError;
2155 
2156 /**
2157  * Flags which influence the parsing.
2158  * G_KEY_FILE_NONE
2159  * No flags, default behaviour
2160  * G_KEY_FILE_KEEP_COMMENTS
2161  * Use this flag if you plan to write the (possibly modified)
2162  *  contents of the key file back to a file; otherwise all comments will be lost when
2163  *  the key file is written back.
2164  * G_KEY_FILE_KEEP_TRANSLATIONS
2165  * Use this flag if you plan to write the (possibly modified)
2166  *  contents of the key file back to a file; otherwise only the translations for the current
2167  *  language will be written back.
2168  */
2169 public enum GKeyFileFlags
2170 {
2171 	NONE = 0,
2172 	KEEP_COMMENTS = 1 << 0,
2173 	KEEP_TRANSLATIONS = 1 << 1
2174 }
2175 alias GKeyFileFlags KeyFileFlags;
2176 
2177 /**
2178  * Error codes returned by bookmark file parsing.
2179  * G_BOOKMARK_FILE_ERROR_INVALID_URI
2180  * URI was ill-formed
2181  * G_BOOKMARK_FILE_ERROR_INVALID_VALUE
2182  * a requested field was not found
2183  * G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED
2184  * a requested application did
2185  *  not register a bookmark
2186  * G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND
2187  * a requested URI was not found
2188  * G_BOOKMARK_FILE_ERROR_READ
2189  * document was ill formed
2190  * G_BOOKMARK_FILE_ERROR_UNKNOWN_ENCODING
2191  * the text being parsed was
2192  *  in an unknown encoding
2193  * G_BOOKMARK_FILE_ERROR_WRITE
2194  * an error occurred while writing
2195  * G_BOOKMARK_FILE_ERROR_FILE_NOT_FOUND
2196  * requested file was not found
2197  */
2198 public enum GBookmarkFileError
2199 {
2200 	INVALID_URI,
2201 	INVALID_VALUE,
2202 	APP_NOT_REGISTERED,
2203 	URI_NOT_FOUND,
2204 	READ,
2205 	UNKNOWN_ENCODING,
2206 	WRITE,
2207 	FILE_NOT_FOUND
2208 }
2209 alias GBookmarkFileError BookmarkFileError;
2210 
2211 /**
2212  * Specifies the type of traveral performed by g_tree_traverse(),
2213  * g_node_traverse() and g_node_find().
2214  * G_IN_ORDER
2215  * vists a node's left child first, then the node itself,
2216  *  then its right child. This is the one to use if you
2217  *  want the output sorted according to the compare
2218  *  function.
2219  * G_PRE_ORDER
2220  * visits a node, then its children.
2221  * G_POST_ORDER
2222  * visits the node's children, then the node itself.
2223  * G_LEVEL_ORDER
2224  * is not implemented for Balanced Binary
2225  *  Trees. For N-ary Trees, it
2226  *  vists the root node first, then its children, then
2227  *  its grandchildren, and so on. Note that this is less
2228  *  efficient than the other orders.
2229  */
2230 public enum GTraverseType
2231 {
2232 	IN_ORDER,
2233 	PRE_ORDER,
2234 	POST_ORDER,
2235 	LEVEL_ORDER
2236 }
2237 alias GTraverseType TraverseType;
2238 
2239 /**
2240  * Specifies which nodes are visited during several of the tree
2241  * functions, including g_node_traverse() and g_node_find().
2242  * G_TRAVERSE_LEAVES
2243  * only leaf nodes should be visited. This name has
2244  *  been introduced in 2.6, for older version use
2245  *  G_TRAVERSE_LEAFS.
2246  * G_TRAVERSE_NON_LEAVES
2247  * only non-leaf nodes should be visited. This
2248  *  name has been introduced in 2.6, for older
2249  *  version use G_TRAVERSE_NON_LEAFS.
2250  * G_TRAVERSE_ALL
2251  * all nodes should be visited.
2252  * G_TRAVERSE_MASK
2253  * a mask of all traverse flags.
2254  * G_TRAVERSE_LEAFS
2255  * identical to G_TRAVERSE_LEAVES.
2256  * G_TRAVERSE_NON_LEAFS
2257  * identical to G_TRAVERSE_NON_LEAVES.
2258  */
2259 public enum GTraverseFlags
2260 {
2261 	LEAVES = 1 << 0,
2262 	NON_LEAVES = 1 << 1,
2263 	ALL = LEAVES | NON_LEAVES,
2264 	MASK = 0x03,
2265 	LEAFS = LEAVES,
2266 	NON_LEAFS = NON_LEAVES
2267 }
2268 alias GTraverseFlags TraverseFlags;
2269 
2270 /**
2271  * The range of possible top-level types of GVariant instances.
2272  * G_VARIANT_CLASS_BOOLEAN
2273  * The GVariant is a boolean.
2274  * G_VARIANT_CLASS_BYTE
2275  * The GVariant is a byte.
2276  * G_VARIANT_CLASS_INT16
2277  * The GVariant is a signed 16 bit integer.
2278  * G_VARIANT_CLASS_UINT16
2279  * The GVariant is an unsigned 16 bit integer.
2280  * G_VARIANT_CLASS_INT32
2281  * The GVariant is a signed 32 bit integer.
2282  * G_VARIANT_CLASS_UINT32
2283  * The GVariant is an unsigned 32 bit integer.
2284  * G_VARIANT_CLASS_INT64
2285  * The GVariant is a signed 64 bit integer.
2286  * G_VARIANT_CLASS_UINT64
2287  * The GVariant is an unsigned 64 bit integer.
2288  * G_VARIANT_CLASS_HANDLE
2289  * The GVariant is a file handle index.
2290  * G_VARIANT_CLASS_DOUBLE
2291  * The GVariant is a double precision floating
2292  *  point value.
2293  * G_VARIANT_CLASS_STRING
2294  * The GVariant is a normal string.
2295  * G_VARIANT_CLASS_OBJECT_PATH
2296  * The GVariant is a D-Bus object path
2297  *  string.
2298  * G_VARIANT_CLASS_SIGNATURE
2299  * The GVariant is a D-Bus signature string.
2300  * G_VARIANT_CLASS_VARIANT
2301  * The GVariant is a variant.
2302  * G_VARIANT_CLASS_MAYBE
2303  * The GVariant is a maybe-typed value.
2304  * G_VARIANT_CLASS_ARRAY
2305  * The GVariant is an array.
2306  * G_VARIANT_CLASS_TUPLE
2307  * The GVariant is a tuple.
2308  * G_VARIANT_CLASS_DICT_ENTRY
2309  * The GVariant is a dictionary entry.
2310  * Since 2.24
2311  */
2312 public enum GVariantClass
2313 {
2314 	BOOLEAN = 'b',
2315 	BYTE = 'y',
2316 	INT16 = 'n',
2317 	UINT16 = 'q',
2318 	INT32 = 'i',
2319 	UINT32 = 'u',
2320 	INT64 = 'x',
2321 	UINT64 = 't',
2322 	HANDLE = 'h',
2323 	DOUBLE = 'd',
2324 	STRING = 's',
2325 	OBJECT_PATH = 'o',
2326 	SIGNATURE = 'g',
2327 	VARIANT = 'v',
2328 	MAYBE = 'm',
2329 	ARRAY = 'a',
2330 	TUPLE = '(',
2331 	DICT_ENTRY = '{'
2332 }
2333 alias GVariantClass VariantClass;
2334 
2335 /**
2336  * Error codes returned by parsing text-format GVariants.
2337  * G_VARIANT_PARSE_ERROR_FAILED
2338  * generic error (unused)
2339  * G_VARIANT_PARSE_ERROR_BASIC_TYPE_EXPECTED
2340  * a non-basic GVariantType was given where a basic type was expected
2341  * G_VARIANT_PARSE_ERROR_CANNOT_INFER_TYPE
2342  * cannot infer the GVariantType
2343  * G_VARIANT_PARSE_ERROR_DEFINITE_TYPE_EXPECTED
2344  * an indefinite GVariantType was given where a definite type was expected
2345  * G_VARIANT_PARSE_ERROR_INPUT_NOT_AT_END
2346  * extra data after parsing finished
2347  * G_VARIANT_PARSE_ERROR_INVALID_CHARACTER
2348  * invalid character in number or unicode escape
2349  * G_VARIANT_PARSE_ERROR_INVALID_FORMAT_STRING
2350  * not a valid GVariant format string
2351  * G_VARIANT_PARSE_ERROR_INVALID_OBJECT_PATH
2352  * not a valid object path
2353  * G_VARIANT_PARSE_ERROR_INVALID_SIGNATURE
2354  * not a valid type signature
2355  * G_VARIANT_PARSE_ERROR_INVALID_TYPE_STRING
2356  * not a valid GVariant type string
2357  * G_VARIANT_PARSE_ERROR_NO_COMMON_TYPE
2358  * could not find a common type for array entries
2359  * G_VARIANT_PARSE_ERROR_NUMBER_OUT_OF_RANGE
2360  * the numerical value is out of range of the given type
2361  * G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG
2362  * the numerical value is out of range for any type
2363  * G_VARIANT_PARSE_ERROR_TYPE_ERROR
2364  * cannot parse as variant of the specified type
2365  * G_VARIANT_PARSE_ERROR_UNEXPECTED_TOKEN
2366  * an unexpected token was encountered
2367  * G_VARIANT_PARSE_ERROR_UNKNOWN_KEYWORD
2368  * an unknown keyword was encountered
2369  * G_VARIANT_PARSE_ERROR_UNTERMINATED_STRING_CONSTANT
2370  * unterminated string constant
2371  * G_VARIANT_PARSE_ERROR_VALUE_EXPECTED
2372  * no value given
2373  */
2374 public enum GVariantParseError
2375 {
2376 	FAILED,
2377 	BASIC_TYPE_EXPECTED,
2378 	CANNOT_INFER_TYPE,
2379 	DEFINITE_TYPE_EXPECTED,
2380 	INPUT_NOT_AT_END,
2381 	INVALID_CHARACTER,
2382 	INVALID_FORMAT_STRING,
2383 	INVALID_OBJECT_PATH,
2384 	INVALID_SIGNATURE,
2385 	INVALID_TYPE_STRING,
2386 	NO_COMMON_TYPE,
2387 	NUMBER_OUT_OF_RANGE,
2388 	NUMBER_TOO_BIG,
2389 	TYPE_ERROR,
2390 	UNEXPECTED_TOKEN,
2391 	UNKNOWN_KEYWORD,
2392 	UNTERMINATED_STRING_CONSTANT,
2393 	VALUE_EXPECTED
2394 }
2395 alias GVariantParseError VariantParseError;
2396 
2397 public struct GSocketControlMessageClass{}
2398 public struct GInetSocketAddressClass{}
2399 
2400 /**
2401  * Main Gtk struct.
2402  * The GMainLoop struct is an opaque data type
2403  * representing the main event loop of a GLib or GTK+ application.
2404  */
2405 public struct GMainLoop{}
2406 
2407 
2408 /**
2409  * The GMainContext struct is an opaque data
2410  * type representing a set of sources to be handled in a main loop.
2411  */
2412 public struct GMainContext{}
2413 
2414 
2415 /**
2416  * gint64 fd;
2417  * gint fd;
2418  * gushort events;
2419  * a bitwise combination from GIOCondition, specifying which
2420  * events should be polled for. Typically for reading from a file
2421  * descriptor you would use G_IO_IN | G_IO_HUP | G_IO_ERR, and
2422  * for writing you would use G_IO_OUT | G_IO_ERR.
2423  * gushort revents;
2424  * a bitwise combination of flags from GIOCondition, returned
2425  * from the poll() function to indicate which events occurred.
2426  */
2427 public struct GPollFD
2428 {
2429 	version(Win64)
2430 	{
2431 		long fd;
2432 	}
2433 	else
2434 	{
2435 		int fd;
2436 	}
2437 	ushort events;
2438 	ushort revents;
2439 }
2440 
2441 
2442 /**
2443  * The GSource struct is an opaque data type
2444  * representing an event source.
2445  */
2446 public struct GSource{}
2447 
2448 
2449 /**
2450  * The GSourceFuncs struct contains a table of
2451  * functions used to handle event sources in a generic manner.
2452  * For idle sources, the prepare and check functions always return TRUE
2453  * to indicate that the source is always ready to be processed. The prepare
2454  * function also returns a timeout value of 0 to ensure that the poll() call
2455  * doesn't block (since that would be time wasted which could have been spent
2456  * running the idle function).
2457  * For timeout sources, the prepare and check functions both return TRUE
2458  * if the timeout interval has expired. The prepare function also returns
2459  * a timeout value to ensure that the poll() call doesn't block too long
2460  * and miss the next timeout.
2461  * For file descriptor sources, the prepare function typically returns FALSE,
2462  * since it must wait until poll() has been called before it knows whether
2463  * any events need to be processed. It sets the returned timeout to -1 to
2464  * indicate that it doesn't mind how long the poll() call blocks. In the
2465  * check function, it tests the results of the poll() call to see if the
2466  * required condition has been met, and returns TRUE if so.
2467  * prepare ()
2468  * Called before all the file descriptors are polled. If the
2469  * source can determine that it is ready here (without waiting for the
2470  * results of the poll() call) it should return TRUE. It can also return
2471  * a timeout_ value which should be the maximum timeout (in milliseconds)
2472  * which should be passed to the poll() call. The actual timeout used will
2473  * be -1 if all sources returned -1, or it will be the minimum of all the
2474  * timeout_ values returned which were >= 0.
2475  * check ()
2476  * Called after all the file descriptors are polled. The source
2477  * should return TRUE if it is ready to be dispatched. Note that some
2478  * time may have passed since the previous prepare function was called,
2479  * so the source should be checked again here.
2480  * dispatch ()
2481  * Called to dispatch the event source, after it has returned
2482  * TRUE in either its prepare or its check function. The dispatch
2483  * function is passed in a callback function and data. The callback
2484  * function may be NULL if the source was never connected to a callback
2485  * using g_source_set_callback(). The dispatch function should call the
2486  * callback function with user_data and whatever additional parameters
2487  * are needed for this type of event source.
2488  * finalize ()
2489  * Called when the source is finalized.
2490  * GSourceFunc closure_callback;
2491  * GSourceDummyMarshal closure_marshal;
2492  */
2493 public struct GSourceFuncs
2494 {
2495 	extern(C) int function(GSource* source, int* timeout) prepare;
2496 	extern(C) int function(GSource* source) check;
2497 	extern(C) int function(GSource* source, GSourceFunc callback, void* userData) dispatch;
2498 	extern(C) void function(GSource* source) finalize; /+* Can be NULL +/
2499 	/+* For use by sourceSetClosure +/
2500 	GSourceFunc closureCallback;
2501 	GSourceDummyMarshal closureMarshal; /+* Really is of type GClosureMarshal +/
2502 }
2503 
2504 
2505 /**
2506  * The GSourceCallbackFuncs struct contains
2507  * functions for managing callback objects.
2508  * ref ()
2509  * Called when a reference is added to the callback object
2510  * unref ()
2511  * Called when a reference to the callback object is dropped
2512  * get ()
2513  * Called to extract the callback function and data from the
2514  * callback object.
2515  */
2516 public struct GSourceCallbackFuncs
2517 {
2518 	extern(C) void function(void* cbData) doref;
2519 	extern(C) void function(void* cbData) unref;
2520 	extern(C) void function(void* cbData, GSource* source, GSourceFunc* func, void** data) get;
2521 }
2522 
2523 
2524 /**
2525  * Main Gtk struct.
2526  * The GThreadPool struct represents a thread pool. It has three
2527  * public read-only members, but the underlying struct is bigger, so
2528  * you must not copy this struct.
2529  * GFunc func;
2530  * the function to execute in the threads of this pool
2531  * gpointer user_data;
2532  * the user data for the threads of this pool
2533  * gboolean exclusive;
2534  * are all threads exclusive to this pool
2535  */
2536 public struct GThreadPool
2537 {
2538 	GFunc func;
2539 	void* userData;
2540 	int exclusive;
2541 }
2542 
2543 
2544 /**
2545  * Main Gtk struct.
2546  * The GAsyncQueue struct is an opaque data structure, which represents
2547  * an asynchronous queue. It should only be accessed through the
2548  * g_async_queue_* functions.
2549  */
2550 public struct GAsyncQueue{}
2551 
2552 
2553 /**
2554  * Main Gtk struct.
2555  * The GModule struct is an opaque data structure to represent a
2556  * Dynamically-Loaded Module.
2557  * It should only be accessed via the following functions.
2558  */
2559 public struct GModule{}
2560 
2561 
2562 /**
2563  * A set of functions used to perform memory allocation. The same GMemVTable must
2564  * be used for all allocations in the same program; a call to g_mem_set_vtable(),
2565  * if it exists, should be prior to any use of GLib.
2566  * malloc ()
2567  * function to use for allocating memory.
2568  * realloc ()
2569  * function to use for reallocating memory.
2570  * free ()
2571  * function to use to free memory.
2572  * calloc ()
2573  * function to use for allocating zero-filled memory.
2574  * try_malloc ()
2575  * function to use for allocating memory without a default error handler.
2576  * try_realloc ()
2577  * function to use for reallocating memory without a default error handler.
2578  */
2579 public struct GMemVTable
2580 {
2581 	extern(C) void* function(gsize nBytes) malloc;
2582 	extern(C) void* function(void* mem, gsize nBytes) realloc;
2583 	extern(C) void function(void* mem) free;
2584 	/+* optional; set to NULL if not used ! +/
2585 	extern(C) void* function(gsize nBlocks, gsize nBlockBytes) calloc;
2586 	extern(C) void* function(gsize nBytes) tryMalloc;
2587 	extern(C) void* function(void* mem, gsize nBytes) tryRealloc;
2588 }
2589 
2590 
2591 /**
2592  * Main Gtk struct.
2593  * A data structure representing an IO Channel. The fields should be
2594  * considered private and should only be accessed with the following
2595  * functions.
2596  */
2597 public struct GIOChannel{}
2598 
2599 
2600 /**
2601  * A table of functions used to handle different types of GIOChannel
2602  * in a generic way.
2603  * io_read ()
2604  * reads raw bytes from the channel. This is called from
2605  * various functions such as g_io_channel_read_chars() to
2606  * read raw bytes from the channel. Encoding and buffering
2607  * issues are dealt with at a higher level.
2608  * io_write ()
2609  * writes raw bytes to the channel. This is called from
2610  * various functions such as g_io_channel_write_chars() to
2611  * write raw bytes to the channel. Encoding and buffering
2612  * issues are dealt with at a higher level.
2613  * io_seek ()
2614  * (optional) seeks the channel. This is called from
2615  * g_io_channel_seek() on channels that support it.
2616  * io_close ()
2617  * closes the channel. This is called from
2618  * g_io_channel_close() after flushing the buffers.
2619  * io_create_watch ()
2620  * creates a watch on the channel. This call
2621  * corresponds directly to g_io_create_watch().
2622  * io_free ()
2623  * called from g_io_channel_unref() when the channel needs to
2624  * be freed. This function must free the memory associated
2625  * with the channel, including freeing the GIOChannel
2626  * structure itself. The channel buffers have been flushed
2627  * and possibly io_close has been called by the time this
2628  * function is called.
2629  * io_set_flags ()
2630  * sets the GIOFlags on the channel. This is called
2631  * from g_io_channel_set_flags() with all flags except
2632  * for G_IO_FLAG_APPEND and G_IO_FLAG_NONBLOCK masked
2633  * out.
2634  * io_get_flags ()
2635  * gets the GIOFlags for the channel. This function
2636  * need only return the G_IO_FLAG_APPEND and
2637  * G_IO_FLAG_NONBLOCK flags; g_io_channel_get_flags()
2638  * automatically adds the others as appropriate.
2639  */
2640 public struct GIOFuncs
2641 {
2642 	extern(C) GIOStatus function(GIOChannel* channel, char* buf, gsize count, gsize* bytesRead, GError** err) ioRead;
2643 	extern(C) GIOStatus function(GIOChannel* channel, char* buf, gsize count, gsize* bytesWritten, GError** err) ioWrite;
2644 	extern(C) GIOStatus function(GIOChannel* channel, long offset, GSeekType type, GError** err) ioSeek;
2645 	extern(C) GIOStatus function(GIOChannel* channel, GError** err) ioClose;
2646 	extern(C) GSource* function(GIOChannel* channel, GIOCondition condition) ioCreateWatch;
2647 	extern(C) void function(GIOChannel* channel) ioFree;
2648 	extern(C) GIOStatus function(GIOChannel* channel, GIOFlags flags, GError** err) ioSetFlags;
2649 	extern(C) GIOFlags function(GIOChannel* channel) ioGetFlags;
2650 }
2651 
2652 
2653 /**
2654  * Main Gtk struct.
2655  * The GError structure contains
2656  * information about an error that has occurred.
2657  * GQuark domain;
2658  * error domain, e.g. G_FILE_ERROR.
2659  * gint code;
2660  * error code, e.g. G_FILE_ERROR_NOENT.
2661  * gchar *message;
2662  * human-readable informative error message.
2663  */
2664 public struct GError
2665 {
2666 	GQuark domain;
2667 	int code;
2668 	char *message;
2669 }
2670 
2671 
2672 public struct GIConv{}
2673 
2674 
2675 /**
2676  * Main Gtk struct.
2677  * An opaque structure representing a checksumming operation.
2678  * To create a new GChecksum, use g_checksum_new(). To free
2679  * a GChecksum, use g_checksum_free().
2680  * Since 2.16
2681  */
2682 public struct GChecksum{}
2683 
2684 
2685 /**
2686  * Main Gtk struct.
2687  * Represents a precise time, with seconds and microseconds.
2688  * Similar to the struct timeval returned by
2689  * the gettimeofday() UNIX call.
2690  * GLib is attempting to unify around the use of 64bit integers to
2691  * represent microsecond-precision time. As such, this type will be
2692  * removed from a future version of GLib.
2693  * glong tv_sec;
2694  * seconds
2695  * glong tv_usec;
2696  * microseconds
2697  */
2698 public struct GTimeVal
2699 {
2700 	glong tvSec;
2701 	glong tvUsec;
2702 }
2703 
2704 
2705 /**
2706  * Represents a day between January 1, Year 1 and a few thousand years in
2707  * the future. None of its members should be accessed directly. If the
2708  * GDate is obtained from g_date_new(), it will
2709  * be safe to mutate but invalid and thus not safe for calendrical computations.
2710  * If it's declared on the stack, it will contain garbage so must be
2711  * initialized with g_date_clear(). g_date_clear() makes the date invalid
2712  * but sane. An invalid date doesn't represent a day, it's "empty." A
2713  * date becomes valid after you set it to a Julian day or you set a day,
2714  * month, and year.
2715  * guint julian_days : 32;
2716  * the Julian representation of the date
2717  * guint julian : 1;
2718  * this bit is set if julian_days is valid
2719  * guint dmy : 1;
2720  * this is set if day, month and year are valid
2721  * guint day : 6;
2722  * the day of the day-month-year representation of the date, as
2723  * a number between 1 and 31
2724  * guint month : 4;
2725  * the day of the day-month-year representation of the date, as
2726  * a number between 1 and 12
2727  * guint year : 16;
2728  * the day of the day-month-year representation of the date
2729  */
2730 public struct GDate
2731 {
2732 	uint bitfield0;
2733 	//uint julianDays : 32;
2734 	/+* julian days representation - we use a
2735 	 * bitfield hoping that 64 bit platforms
2736 	 * will pack this whole struct inn one big
2737 	 * int
2738 	+/
2739 	uint bitfield1;
2740 	//uint julian : 1; /+* julian is valid +/
2741 	//uint dmy : 1; /+* dmy is valid +/
2742 	/+* DMY representation +/
2743 	//uint day : 6;
2744 	//uint month : 4;
2745 	//uint year : 16;
2746 }
2747 
2748 
2749 /**
2750  * Main Gtk struct.
2751  * GDateTime is an opaque structure whose members cannot be accessed
2752  * directly.
2753  * Since 2.26
2754  */
2755 public struct GTimeZone{}
2756 
2757 
2758 /**
2759  * Main Gtk struct.
2760  * GDateTime is an opaque structure whose members
2761  * cannot be accessed directly.
2762  * Since 2.26
2763  */
2764 public struct GDateTime{}
2765 
2766 
2767 /**
2768  * Main Gtk struct.
2769  * The GRand struct is an opaque data structure. It should only be
2770  * accessed through the g_rand_* functions.
2771  */
2772 public struct GRand{}
2773 
2774 
2775 /**
2776  * Associates a string with a bit flag.
2777  * Used in g_parse_debug_string().
2778  * const gchar *key;
2779  * the string
2780  * guint value;
2781  * the flag
2782  */
2783 public struct GDebugKey
2784 {
2785 	char *key;
2786 	uint value;
2787 }
2788 
2789 
2790 /**
2791  * Main Gtk struct.
2792  * The data structure representing a lexical scanner.
2793  * You should set input_name after creating
2794  * the scanner, since it is used by the default message handler when
2795  * displaying warnings and errors. If you are scanning a file, the file
2796  * name would be a good choice.
2797  * The user_data and
2798  * max_parse_errors fields are not used.
2799  * If you need to associate extra data with the scanner you can place them here.
2800  * If you want to use your own message handler you can set the
2801  * msg_handler field. The type of the message
2802  * handler function is declared by GScannerMsgFunc.
2803  * gpointer user_data;
2804  * guint max_parse_errors;
2805  * guint parse_errors;
2806  * const gchar *input_name;
2807  * GData *qdata;
2808  * GScannerConfig *config;
2809  * GTokenType token;
2810  * token parsed by the last g_scanner_get_next_token()
2811  * GTokenValue value;
2812  * value of the last token from g_scanner_get_next_token()
2813  * guint line;
2814  * line number of the last token from g_scanner_get_next_token()
2815  * guint position;
2816  * char number of the last token from g_scanner_get_next_token()
2817  * GTokenType next_token;
2818  * token parsed by the last g_scanner_peek_next_token()
2819  * GTokenValue next_value;
2820  * value of the last token from g_scanner_peek_next_token()
2821  * guint next_line;
2822  * line number of the last token from g_scanner_peek_next_token()
2823  * guint next_position;
2824  * char number of the last token from g_scanner_peek_next_token()
2825  * GHashTable *symbol_table;
2826  * gint input_fd;
2827  * const gchar *text;
2828  * const gchar *text_end;
2829  * gchar *buffer;
2830  * guint scope_id;
2831  * GScannerMsgFunc msg_handler;
2832  * function to handle GScanner message output
2833  */
2834 public struct GScanner
2835 {
2836 	/+* unused fields +/
2837 	void* userData;
2838 	uint maxParseErrors;
2839 	/+* error() increments this field +/
2840 	uint parseErrors;
2841 	/+* name of input stream, featured by the defaulx message handler +/
2842 	char *inputName;
2843 	/+* quarked data +/
2844 	GData *qdata;
2845 	/+* link into the scanner configuration +/
2846 	GScannerConfig *config;
2847 	/+* fields filled inn after getNextToken() +/
2848 	GTokenType token;
2849 	GTokenValue value;
2850 	uint line;
2851 	uint position;
2852 	/+* fields filled inn after peekNextToken() +/
2853 	GTokenType nextToken;
2854 	GTokenValue nextValue;
2855 	uint nextLine;
2856 	uint nextPosition;
2857 	/+* to be considered private +/
2858 	GHashTable *symbolTable;
2859 	int inputFd;
2860 	char *text;
2861 	char *textEnd;
2862 	char *buffer;
2863 	uint scopeId;
2864 	/+* handler funct for _Warn and _Error +/
2865 	GScannerMsgFunc msgHandler;
2866 }
2867 
2868 
2869 /**
2870  * Specifies the GScanner parser configuration. Most settings can be changed during
2871  * the parsing phase and will affect the lexical parsing of the next unpeeked token.
2872  * cset_skip_characters specifies which characters
2873  * should be skipped by the scanner (the default is the whitespace characters:
2874  * space, tab, carriage-return and line-feed).
2875  * cset_identifier_first specifies the characters
2876  * which can start identifiers (the default is G_CSET_a_2_z, "_", and
2877  * G_CSET_A_2_Z).
2878  * cset_identifier_nth specifies the characters
2879  * which can be used in identifiers, after the first character (the default
2880  * is G_CSET_a_2_z, "_0123456789", G_CSET_A_2_Z, G_CSET_LATINS,
2881  * G_CSET_LATINC).
2882  * cpair_comment_single specifies the characters
2883  * at the start and end of single-line comments. The default is "#\n" which
2884  * means that single-line comments start with a '#' and continue until a '\n'
2885  * (end of line).
2886  * case_sensitive specifies if symbols are
2887  * case sensitive (the default is FALSE).
2888  * skip_comment_multi specifies if multi-line
2889  * comments are skipped and not returned as tokens (the default is TRUE).
2890  * skip_comment_single specifies if single-line
2891  * comments are skipped and not returned as tokens (the default is TRUE).
2892  * scan_comment_multi specifies if multi-line
2893  * comments are recognized (the default is TRUE).
2894  * scan_identifier specifies if identifiers
2895  * are recognized (the default is TRUE).
2896  * scan_identifier_1char specifies if single-character
2897  * identifiers are recognized (the default is FALSE).
2898  * scan_identifier_NULL specifies if
2899  * NULL is reported as G_TOKEN_IDENTIFIER_NULL.
2900  * (the default is FALSE).
2901  * scan_symbols specifies if symbols are
2902  * recognized (the default is TRUE).
2903  * scan_binary specifies if binary numbers
2904  * are recognized (the default is FALSE).
2905  * scan_octal specifies if octal numbers
2906  * are recognized (the default is TRUE).
2907  * scan_float specifies if floating point numbers
2908  * are recognized (the default is TRUE).
2909  * scan_hex specifies if hexadecimal numbers
2910  * are recognized (the default is TRUE).
2911  * scan_hex_dollar specifies if '$' is recognized
2912  * as a prefix for hexadecimal numbers (the default is FALSE).
2913  * scan_string_sq specifies if strings can be
2914  * enclosed in single quotes (the default is TRUE).
2915  * scan_string_dq specifies if strings can be
2916  * enclosed in double quotes (the default is TRUE).
2917  * numbers_2_int specifies if binary, octal and
2918  * hexadecimal numbers are reported as G_TOKEN_INT (the default is TRUE).
2919  * int_2_float specifies if all numbers are
2920  * reported as G_TOKEN_FLOAT (the default is FALSE).
2921  * identifier_2_string specifies if identifiers
2922  * are reported as strings (the default is FALSE).
2923  * char_2_token specifies if characters
2924  * are reported by setting token = ch or as G_TOKEN_CHAR
2925  * (the default is TRUE).
2926  * symbol_2_token specifies if symbols
2927  * are reported by setting token = v_symbol or as
2928  * G_TOKEN_SYMBOL (the default is FALSE).
2929  * scope_0_fallback specifies if a symbol
2930  * is searched for in the default scope in addition to the current scope
2931  * (the default is FALSE).
2932  */
2933 public struct GScannerConfig
2934 {
2935 	/+* Character sets
2936 	+/
2937 	char *csetSkipCharacters; /+* default: " \t\n" +/
2938 	char *csetIdentifierFirst;
2939 	char *csetIdentifierNth;
2940 	char *cpairCommentSingle; /+* default: "#\n" +/
2941 	/+* Should symbol lookup work case sensitive?
2942 	+/
2943 	uint bitfield0;
2944 	//uint caseSensitive : 1;
2945 	/+* Boolean values to be adjusted "on the fly"
2946 	 * to configure scanning behaviour.
2947 	+/
2948 	//uint skipCommentMulti : 1; /+* C like comment +/
2949 	//uint skipCommentSingle : 1; /+* single line comment +/
2950 	//uint scanCommentMulti : 1; /+* scan multi line comments? +/
2951 	//uint scanIdentifier : 1;
2952 	//uint scanIdentifier1char : 1;
2953 	//uint scanIdentifierNULL : 1;
2954 	//uint scanSymbols : 1;
2955 	//uint scanBinary : 1;
2956 	//uint scanOctal : 1;
2957 	//uint scanFloat : 1;
2958 	//uint scanHex : 1; /+* `0x0ff0' +/
2959 	//uint scanHexDollar : 1; /+* `$0ff0' +/
2960 	//uint scanStringSq : 1; /+* string: 'anything' +/
2961 	//uint scanStringDq : 1; /+* string: "\\-escapes!\n" +/
2962 	//uint numbers2_Int : 1; /+* bin, octal, hex => int +/
2963 	//uint int2_Float : 1; /+* int => G_TOKEN_FLOAT? +/
2964 	//uint identifier2_String : 1;
2965 	//uint char2_Token : 1; /+* return G_TOKEN_CHAR? +/
2966 	//uint symbol2_Token : 1;
2967 	//uint scope0_Fallback : 1; /+* try scope 0 on lookups? +/
2968 	//uint storeInt64 : 1; /+* use value.vInt64 rather than vInt +/
2969 	uint paddingDummy;
2970 }
2971 
2972 
2973 /**
2974  * Main Gtk struct.
2975  * The data structure used for automatic completion.
2976  * GList *items;
2977  * list of target items (strings or data structures).
2978  * GCompletionFunc func;
2979  * function which is called to get the string associated with a
2980  * target item. It is NULL if the target items are strings.
2981  * gchar *prefix;
2982  * the last prefix passed to g_completion_complete() or
2983  * g_completion_complete_utf8().
2984  * GList *cache;
2985  * the list of items which begin with prefix.
2986  * GCompletionStrncmpFunc strncmp_func;
2987  * The function to use when comparing strings. Use
2988  * g_completion_set_compare() to modify this function.
2989  */
2990 public struct GCompletion
2991 {
2992 	GList* items;
2993 	GCompletionFunc func;
2994 	char* prefix;
2995 	GList* cache;
2996 	GCompletionStrncmpFunc strncmpFunc;
2997 }
2998 
2999 
3000 /**
3001  * Main Gtk struct.
3002  * Opaque datatype that records a start time.
3003  */
3004 public struct GTimer{}
3005 
3006 
3007 /**
3008  * An opaque structure representing an opened directory.
3009  */
3010 public struct GDir{}
3011 
3012 
3013 /**
3014  * The GMappedFile represents a file mapping created with
3015  * g_mapped_file_new(). It has only private members and should
3016  * not be accessed directly.
3017  */
3018 public struct GMappedFile{}
3019 
3020 
3021 /**
3022  * A type corresponding to the appropriate struct type for the stat
3023  * system call, depending on the platform and/or compiler being used.
3024  * See g_stat() for more information.
3025  */
3026 public struct GStatBuf{}
3027 
3028 
3029 /**
3030  * Main Gtk struct.
3031  * A GOptionContext struct defines which options
3032  * are accepted by the commandline option parser. The struct has only private
3033  * fields and should not be directly accessed.
3034  */
3035 public struct GOptionContext{}
3036 
3037 
3038 /**
3039  * A GOptionEntry defines a single option.
3040  * To have an effect, they must be added to a GOptionGroup with
3041  * g_option_context_add_main_entries() or g_option_group_add_entries().
3042  * const gchar *long_name;
3043  * The long name of an option can be used to specify it
3044  * in a commandline as --long_name. Every
3045  * option must have a long name. To resolve conflicts if multiple
3046  * option groups contain the same long name, it is also possible to
3047  * specify the option as
3048  * --groupname-long_name.
3049  * gchar short_name;
3050  * If an option has a short name, it can be specified
3051  * -short_name in a commandline. short_name must be
3052  * a printable ASCII character different from '-', or zero if the option has no
3053  * short name.
3054  * gint flags;
3055  * Flags from GOptionFlags.
3056  * GOptionArg arg;
3057  * The type of the option, as a GOptionArg.
3058  * gpointer arg_data;
3059  * If the arg type is G_OPTION_ARG_CALLBACK, then arg_data must
3060  * point to a GOptionArgFunc callback function, which will be called to handle
3061  * the extra argument. Otherwise, arg_data is a pointer to a location to store
3062  * the value, the required type of the location depends on the arg type:
3063  * G_OPTION_ARG_NONE
3064  * gboolean
3065  * G_OPTION_ARG_STRING
3066  * gchar*
3067  * G_OPTION_ARG_INT
3068  * gint
3069  * G_OPTION_ARG_FILENAME
3070  * gchar*
3071  * G_OPTION_ARG_STRING_ARRAY
3072  * gchar**
3073  * G_OPTION_ARG_FILENAME_ARRAY
3074  * gchar**
3075  * G_OPTION_ARG_DOUBLE
3076  * gdouble
3077  * If arg type is G_OPTION_ARG_STRING or G_OPTION_ARG_FILENAME the location
3078  * will contain a newly allocated string if the option was given. That string
3079  * needs to be freed by the callee using g_free(). Likewise if arg type is
3080  * G_OPTION_ARG_STRING_ARRAY or G_OPTION_ARG_FILENAME_ARRAY, the data should
3081  * be freed using g_strfreev().
3082  * const gchar *description;
3083  * the description for the option in --help
3084  * output. The description is translated using the translate_func of the
3085  * group, see g_option_group_set_translation_domain().
3086  * const gchar *arg_description;
3087  * The placeholder to use for the extra argument parsed
3088  * by the option in --help
3089  * output. The arg_description is translated using the translate_func of the
3090  * group, see g_option_group_set_translation_domain().
3091  */
3092 public struct GOptionEntry
3093 {
3094 	char *longName;
3095 	char shortName;
3096 	int flags;
3097 	GOptionArg arg;
3098 	void* argData;
3099 	char *description;
3100 	char *argDescription;
3101 }
3102 
3103 
3104 /**
3105  * A GOptionGroup struct defines the options in a single
3106  * group. The struct has only private fields and should not be directly accessed.
3107  * All options in a group share the same translation function. Libraries which
3108  * need to parse commandline options are expected to provide a function for
3109  * getting a GOptionGroup holding their options, which
3110  * the application can then add to its GOptionContext.
3111  */
3112 public struct GOptionGroup{}
3113 
3114 
3115 /**
3116  * Main Gtk struct.
3117  * A GPatternSpec is the 'compiled' form of a
3118  * pattern. This structure is opaque and its fields cannot be accessed
3119  * directly.
3120  */
3121 public struct GPatternSpec{}
3122 
3123 
3124 /**
3125  * Main Gtk struct.
3126  * A GRegex is the "compiled" form of a regular expression pattern. This
3127  * structure is opaque and its fields cannot be accessed directly.
3128  * Since 2.14
3129  */
3130 public struct GRegex{}
3131 
3132 
3133 /**
3134  * GMatchInfo is used to retrieve information about the regular expression match
3135  * which created it.
3136  * This structure is opaque and its fields cannot be accessed directly.
3137  * Since 2.14
3138  */
3139 public struct GMatchInfo{}
3140 
3141 
3142 /**
3143  * Main Gtk struct.
3144  * A parse context is used to parse a stream of bytes that
3145  * you expect to contain marked-up text.
3146  * See g_markup_parse_context_new(), GMarkupParser, and so
3147  * on for more details.
3148  */
3149 public struct GMarkupParseContext{}
3150 
3151 
3152 /**
3153  * Any of the fields in GMarkupParser can be NULL, in which case they
3154  * will be ignored. Except for the error function, any of these callbacks
3155  * can set an error; in particular the G_MARKUP_ERROR_UNKNOWN_ELEMENT,
3156  * G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and G_MARKUP_ERROR_INVALID_CONTENT
3157  * errors are intended to be set from these callbacks. If you set an error
3158  * from a callback, g_markup_parse_context_parse() will report that error
3159  * back to its caller.
3160  * start_element ()
3161  * Callback to invoke when the opening tag of an element
3162  * is seen.
3163  * end_element ()
3164  * Callback to invoke when the closing tag of an element
3165  * is seen. Note that this is also called for empty tags like
3166  * <empty/>.
3167  * text ()
3168  * Callback to invoke when some text is seen (text is always
3169  * inside an element). Note that the text of an element may be spread
3170  * over multiple calls of this function. If the
3171  * G_MARKUP_TREAT_CDATA_AS_TEXT flag is set, this function is also
3172  * called for the content of CDATA marked sections.
3173  * passthrough ()
3174  * Callback to invoke for comments, processing instructions
3175  * and doctype declarations; if you're re-writing the parsed document,
3176  * write the passthrough text back out in the same position. If the
3177  * G_MARKUP_TREAT_CDATA_AS_TEXT flag is not set, this function is also
3178  * called for CDATA marked sections.
3179  * error ()
3180  * Callback to invoke when an error occurs.
3181  */
3182 public struct GMarkupParser
3183 {
3184 	/+* Called for open tags <foo bar="baz"> +/
3185 	extern(C) void function(GMarkupParseContext* context, char* elementName, char** attributeNames, char** attributeValues, void* userData, GError** error) startElement;
3186 	/+* Called for close tags </foo> +/
3187 	extern(C) void function(GMarkupParseContext* context, char* elementName, void* userData, GError** error) endElement;
3188 	/+* Called for character data +/
3189 	/+* text is not nul-terminated +/
3190 	extern(C) void function(GMarkupParseContext* context, char* text, gsize textLen, void* userData, GError** error) text;
3191 	/+* Called for strings that should be re-saved verbatim inn this same
3192 	 * position, but are not otherwise interpretable. At the moment
3193 	 * this includes comments and processing instructions.
3194 	+/
3195 	/+* text is not nul-terminated. +/
3196 	extern(C) void function(GMarkupParseContext* context, char* passthroughText, gsize textLen, void* userData, GError** error) passthrough;
3197 	/+* Called on error, including one set by other
3198 	 * methods inn the vtable. The GError should not be freed.
3199 	+/
3200 	extern(C) void function(GMarkupParseContext* context, GError* error, void* userData) error;
3201 }
3202 
3203 
3204 /**
3205  * Main Gtk struct.
3206  * The GKeyFile struct contains only private fields
3207  * and should not be used directly.
3208  */
3209 public struct GKeyFile{}
3210 
3211 
3212 /**
3213  * Main Gtk struct.
3214  * The GBookmarkFile struct contains only
3215  * private data and should not be directly accessed.
3216  */
3217 public struct GBookmarkFile{}
3218 
3219 
3220 /**
3221  * Main Gtk struct.
3222  * Warning
3223  * GMemChunk is deprecated and should not be used in newly-written code.
3224  * The GMemChunk struct is an opaque data structure representing a
3225  * memory chunk. It should be accessed only through the use of the
3226  * following functions.
3227  */
3228 public struct GMemChunk{}
3229 
3230 
3231 /**
3232  * Main Gtk struct.
3233  * The GList struct is used for each element in a doubly-linked list.
3234  * gpointer data;
3235  * holds the element's data, which can be a pointer to any kind
3236  * of data, or any integer value using the Type Conversion
3237  * Macros.
3238  * GList *next;
3239  * contains the link to the next element in the list.
3240  * GList *prev;
3241  * contains the link to the previous element in the list.
3242  */
3243 public struct GList
3244 {
3245 	void* data;
3246 	GList *next;
3247 	GList *prev;
3248 }
3249 
3250 
3251 /**
3252  * Main Gtk struct.
3253  * The GSList struct is used for each element in the singly-linked
3254  * list.
3255  * gpointer data;
3256  * holds the element's data, which can be a pointer to any kind
3257  * of data, or any integer value using the Type Conversion
3258  * Macros.
3259  * GSList *next;
3260  * contains the link to the next element in the list.
3261  */
3262 public struct GSList
3263 {
3264 	void* data;
3265 	GSList *next;
3266 }
3267 
3268 
3269 /**
3270  * Main Gtk struct.
3271  * Contains the public fields of a Queue.
3272  * GList *head;
3273  * a pointer to the first element of the queue.
3274  * GList *tail;
3275  * a pointer to the last element of the queue.
3276  * guint length;
3277  * the number of elements in the queue.
3278  */
3279 public struct GQueue
3280 {
3281 	GList *head;
3282 	GList *tail;
3283 	uint length;
3284 }
3285 
3286 
3287 /**
3288  * Main Gtk struct.
3289  * The GSequence struct is an opaque data type representing a
3290  * Sequence data type.
3291  */
3292 public struct GSequence{}
3293 
3294 
3295 /**
3296  * The GSequenceIter struct is an opaque data type representing an
3297  * iterator pointing into a GSequence.
3298  */
3299 public struct GSequenceIter{}
3300 
3301 
3302 /**
3303  * Main Gtk struct.
3304  * Each piece of memory that is pushed onto the stack
3305  * is cast to a GTrashStack*.
3306  * GTrashStack *next;
3307  * pointer to the previous element of the stack,
3308  * gets stored in the first sizeof (gpointer)
3309  * bytes of the element.
3310  */
3311 public struct GTrashStack
3312 {
3313 	GTrashStack *next;
3314 }
3315 
3316 
3317 /**
3318  * Main Gtk struct.
3319  * The GHashTable struct is an opaque data structure to represent a
3320  * Hash Table. It should only be
3321  * accessed via the following functions.
3322  */
3323 public struct GHashTable{}
3324 
3325 
3326 /**
3327  * A GHashTableIter structure represents an iterator that can be used
3328  * to iterate over the elements of a GHashTable. GHashTableIter
3329  * structures are typically allocated on the stack and then initialized
3330  * with g_hash_table_iter_init().
3331  */
3332 public struct GHashTableIter{}
3333 
3334 
3335 /**
3336  * Main Gtk struct.
3337  * The GString struct contains the public fields of a GString.
3338  * gchar *str;
3339  * points to the character data. It may move as text is added.
3340  * The str field is nul-terminated and so
3341  * can be used as an ordinary C string.
3342  * gsize len;
3343  * contains the length of the string, not including the
3344  * terminating nul byte.
3345  * gsize allocated_len;
3346  * the number of bytes that can be stored in the
3347  * string before it needs to be reallocated. May be larger than len.
3348  */
3349 public struct GString
3350 {
3351 	char *str;
3352 	gsize len;
3353 	gsize allocatedLen;
3354 }
3355 
3356 
3357 /**
3358  * Main Gtk struct.
3359  * An opaque data structure representing String Chunks. It should only
3360  * be accessed by using the following functions.
3361  */
3362 public struct GStringChunk{}
3363 
3364 
3365 /**
3366  * Main Gtk struct.
3367  * Contains the public fields of an Array.
3368  * gchar *data;
3369  * a pointer to the element data. The data may be moved as
3370  * elements are added to the GArray.
3371  * guint len;
3372  * the number of elements in the GArray not including the
3373  * possible terminating zero element.
3374  */
3375 public struct GArray
3376 {
3377 	char *data;
3378 	uint len;
3379 }
3380 
3381 
3382 /**
3383  * Main Gtk struct.
3384  * Contains the public fields of a pointer array.
3385  * gpointer *pdata;
3386  * points to the array of pointers, which may be moved when the
3387  * array grows.
3388  * guint len;
3389  * number of pointers in the array.
3390  */
3391 public struct GPtrArray
3392 {
3393 	void* *pdata;
3394 	uint len;
3395 }
3396 
3397 
3398 /**
3399  * Main Gtk struct.
3400  * The GByteArray struct allows access to the
3401  * public fields of a GByteArray.
3402  * guint8 *data;
3403  * a pointer to the element data. The data may be moved as
3404  * elements are added to the GByteArray.
3405  * guint len;
3406  * the number of elements in the GByteArray.
3407  */
3408 public struct GByteArray
3409 {
3410 	ubyte *data;
3411 	uint len;
3412 }
3413 
3414 
3415 /**
3416  * Main Gtk struct.
3417  * The GTree struct is an opaque data
3418  * structure representing a Balanced Binary Tree. It
3419  * should be accessed only by using the following functions.
3420  */
3421 public struct GTree{}
3422 
3423 
3424 /**
3425  * Main Gtk struct.
3426  * The GNode struct represents one node in a
3427  * N-ary Tree. fields
3428  * gpointer data;
3429  * contains the actual data of the node.
3430  * GNode *next;
3431  * points to the node's next sibling (a sibling is another
3432  * GNode with the same parent).
3433  * GNode *prev;
3434  * points to the node's previous sibling.
3435  * GNode *parent;
3436  * points to the parent of the GNode, or is NULL if the
3437  * GNode is the root of the tree.
3438  * GNode *children;
3439  * points to the first child of the GNode. The other
3440  * children are accessed by using the next pointer of each
3441  * child.
3442  */
3443 public struct GNode
3444 {
3445 	void* data;
3446 	GNode *next;
3447 	GNode *prev;
3448 	GNode *parent;
3449 	GNode *children;
3450 }
3451 
3452 
3453 /**
3454  * Main Gtk struct.
3455  * The GData struct is an opaque data structure to represent a Keyed Data List. It should
3456  * only be accessed via the following functions.
3457  */
3458 public struct GData{}
3459 
3460 
3461 /**
3462  * Main Gtk struct.
3463  * The GRelation struct is an opaque data structure to represent a
3464  * Relation. It should
3465  * only be accessed via the following functions.
3466  */
3467 public struct GRelation{}
3468 
3469 
3470 /**
3471  * The GTuples struct is used to return records (or tuples) from the
3472  * GRelation by g_relation_select(). It only contains one public
3473  * member - the number of records that matched. To access the matched
3474  * records, you must use g_tuples_index().
3475  * guint len;
3476  * the number of records that matched.
3477  */
3478 public struct GTuples
3479 {
3480 	uint len;
3481 }
3482 
3483 
3484 /**
3485  * Main Gtk struct.
3486  * The GCache struct is an opaque data structure containing
3487  * information about a GCache. It should only be accessed via the
3488  * following functions.
3489  */
3490 public struct GCache{}
3491 
3492 
3493 /**
3494  * Main Gtk struct.
3495  * Warning
3496  * GAllocator is deprecated and should not be used in newly-written code.
3497  * The GAllocator struct contains private data. and should only be
3498  * accessed using the following functions.
3499  */
3500 public struct GAllocator{}
3501 
3502 
3503 /**
3504  * Main Gtk struct.
3505  * A type in the GVariant type system.
3506  * Two types may not be compared by value; use g_variant_type_equal() or
3507  * g_variant_type_is_subtype_of(). May be copied using
3508  * g_variant_type_copy() and freed using g_variant_type_free().
3509  */
3510 public struct GVariantType{}
3511 
3512 
3513 /**
3514  * Main Gtk struct.
3515  * GVariant is an opaque data structure and can only be accessed
3516  * using the following functions.
3517  * Since 2.24
3518  */
3519 public struct GVariant{}
3520 
3521 
3522 /**
3523  * GVariantIter is an opaque data structure and can only be accessed
3524  * using the following functions.
3525  */
3526 public struct GVariantIter{}
3527 
3528 
3529 /**
3530  * A utility type for constructing container-type GVariant instances.
3531  * This is an opaque structure and may only be accessed using the
3532  * following functions.
3533  * GVariantBuilder is not threadsafe in any way. Do not attempt to
3534  * access it from more than one thread.
3535  */
3536 public struct GVariantBuilder{}
3537 
3538 
3539 /*
3540  * Checks the version of the GLib library.
3541  * Returns TRUE if the version of the GLib header files is the same
3542  * as or newer than the passed-in version.
3543  * $(DDOC_COMMENT example)
3544  * major :
3545  * the major version number.
3546  * minor :
3547  * the minor version number.
3548  * micro :
3549  * the micro version number.
3550  */
3551 // TODO
3552 // #define GLIB_CHECK_VERSION(major,minor,micro)
3553 
3554 /*
3555  * Warning
3556  * g_main_new has been deprecated since version 2.2 and should not be used in newly-written code. Use g_main_loop_new() instead
3557  * Creates a new GMainLoop for th default main context.
3558  * is_running :
3559  * set to TRUE to indicate that the loop is running. This
3560  * is not very important since calling g_main_run() will set this
3561  * to TRUE anyway.
3562  * Returns :
3563  * a new GMainLoop
3564  */
3565 // TODO
3566 // #define g_main_new(is_running)
3567 
3568 /*
3569  * Warning
3570  * g_main_destroy has been deprecated since version 2.2 and should not be used in newly-written code. Use g_main_loop_unref() instead
3571  * Frees the memory allocated for the GMainLoop.
3572  * loop :
3573  * a GMainLoop
3574  */
3575 // TODO
3576 // #define g_main_destroy(loop)
3577 
3578 /*
3579  * Warning
3580  * g_main_run has been deprecated since version 2.2 and should not be used in newly-written code. Use g_main_loop_run() instead
3581  * Runs a main loop until it stops running.
3582  * loop :
3583  * a GMainLoop
3584  */
3585 // TODO
3586 // #define g_main_run(loop)
3587 
3588 /*
3589  * Warning
3590  * g_main_quit has been deprecated since version 2.2 and should not be used in newly-written code. Use g_main_loop_quit() instead
3591  * Stops the GMainLoop.
3592  * If g_main_run() was called to run the GMainLoop, it will now return.
3593  * loop :
3594  * a GMainLoop
3595  */
3596 // TODO
3597 // #define g_main_quit(loop)
3598 
3599 /*
3600  * Warning
3601  * g_main_is_running has been deprecated since version 2.2 and should not be used in newly-written code. Use g_main_loop_is_running() instead
3602  * Checks if the main loop is running.
3603  * loop :
3604  * a GMainLoop
3605  * Returns :
3606  * TRUE if the main loop is running
3607  */
3608 // TODO
3609 // #define g_main_is_running(loop)
3610 
3611 /*
3612  * Warning
3613  * g_main_iteration has been deprecated since version 2.2 and should not be used in newly-written code. Use g_main_context_iteration() instead.
3614  * Runs a single iteration for the default GMainContext.
3615  * may_block :
3616  * set to TRUE if it should block (i.e. wait) until an event
3617  * source becomes ready. It will return after an event source has been
3618  * processed. If set to FALSE it will return immediately if no event
3619  * source is ready to be processed.
3620  * Returns :
3621  * TRUE if more events are pending.
3622  */
3623 // TODO
3624 // #define g_main_iteration(may_block)
3625 
3626 /*
3627  * Warning
3628  * g_main_set_poll_func has been deprecated since version 2.2 and should not be used in newly-written code. Use g_main_context_set_poll_func() again
3629  * Sets the function to use for the handle polling of file descriptors
3630  * for the default main context.
3631  * func :
3632  * the function to call to poll all file descriptors
3633  */
3634 // TODO
3635 // #define g_main_set_poll_func(func)
3636 
3637 /*
3638  * Allocates n_structs elements of type struct_type.
3639  * The returned pointer is cast to a pointer to the given type.
3640  * If n_structs is 0 it returns NULL.
3641  * Care is taken to avoid overflow when calculating the size of the allocated block.
3642  * Since the returned pointer is already casted to the right type,
3643  * it is normally unnecessary to cast it explicitly, and doing
3644  * so might hide memory allocation errors.
3645  * struct_type :
3646  * the type of the elements to allocate
3647  * n_structs :
3648  * the number of elements to allocate
3649  * Returns :
3650  * a pointer to the allocated memory, cast to a pointer to struct_type
3651  */
3652 // TODO
3653 // #define g_new(struct_type, n_structs)
3654 
3655 /*
3656  * Allocates n_structs elements of type struct_type, initialized to 0's.
3657  * The returned pointer is cast to a pointer to the given type.
3658  * If n_structs is 0 it returns NULL.
3659  * Care is taken to avoid overflow when calculating the size of the allocated block.
3660  * Since the returned pointer is already casted to the right type,
3661  * it is normally unnecessary to cast it explicitly, and doing
3662  * so might hide memory allocation errors.
3663  * struct_type :
3664  * the type of the elements to allocate.
3665  * n_structs :
3666  * the number of elements to allocate.
3667  * Returns :
3668  * a pointer to the allocated memory, cast to a pointer to struct_type.
3669  */
3670 // TODO
3671 // #define g_new0(struct_type, n_structs)
3672 
3673 /*
3674  * Reallocates the memory pointed to by mem, so that it now has space for
3675  * n_structs elements of type struct_type. It returns the new address of
3676  * the memory, which may have been moved.
3677  * Care is taken to avoid overflow when calculating the size of the allocated block.
3678  * struct_type :
3679  * the type of the elements to allocate
3680  * mem :
3681  * the currently allocated memory
3682  * n_structs :
3683  * the number of elements to allocate
3684  * Returns :
3685  * a pointer to the new allocated memory, cast to a pointer to struct_type
3686  */
3687 // TODO
3688 // #define g_renew(struct_type, mem, n_structs)
3689 
3690 /*
3691  * Attempts to allocate n_structs elements of type struct_type, and returns
3692  * NULL on failure. Contrast with g_new(), which aborts the program on failure.
3693  * The returned pointer is cast to a pointer to the given type.
3694  * The function returns NULL when n_structs is 0 of if an overflow occurs.
3695  * struct_type :
3696  * the type of the elements to allocate
3697  * n_structs :
3698  * the number of elements to allocate
3699  * Returns :
3700  * a pointer to the allocated memory, cast to a pointer to struct_type
3701  * Since 2.8
3702  */
3703 // TODO
3704 // #define g_try_new(struct_type, n_structs)
3705 
3706 /*
3707  * Attempts to allocate n_structs elements of type struct_type, initialized
3708  * to 0's, and returns NULL on failure. Contrast with g_new0(), which aborts
3709  * the program on failure.
3710  * The returned pointer is cast to a pointer to the given type.
3711  * The function returns NULL when n_structs is 0 of if an overflow occurs.
3712  * struct_type :
3713  * the type of the elements to allocate
3714  * n_structs :
3715  * the number of elements to allocate
3716  * Returns :
3717  * a pointer to the allocated memory, cast to a pointer to struct_type
3718  * Since 2.8
3719  */
3720 // TODO
3721 // #define g_try_new0(struct_type, n_structs)
3722 
3723 /*
3724  * Attempts to reallocate the memory pointed to by mem, so that it now has
3725  * space for n_structs elements of type struct_type, and returns NULL on
3726  * failure. Contrast with g_renew(), which aborts the program on failure.
3727  * It returns the new address of the memory, which may have been moved.
3728  * The function returns NULL if an overflow occurs.
3729  * struct_type :
3730  * the type of the elements to allocate
3731  * mem :
3732  * the currently allocated memory
3733  * n_structs :
3734  * the number of elements to allocate
3735  * Returns :
3736  * a pointer to the new allocated memory, cast to a pointer to struct_type
3737  * Since 2.8
3738  */
3739 // TODO
3740 // #define g_try_renew(struct_type, mem, n_structs)
3741 
3742 /*
3743  * Allocates size bytes on the stack; these bytes will be freed when the current
3744  * stack frame is cleaned up. This macro essentially just wraps the alloca()
3745  * function present on most UNIX variants.
3746  * Thus it provides the same advantages and pitfalls as alloca():
3747  *  + alloca() is very fast, as on most systems it's implemented by just adjusting
3748  *  the stack pointer register.
3749  *  + It doesn't cause any memory fragmentation, within its scope, separate alloca()
3750  *  blocks just build up and are released together at function end.
3751  *  - Allocation sizes have to fit into the current stack frame. For instance in a
3752  *  threaded environment on Linux, the per-thread stack size is limited to 2 Megabytes,
3753  *  so be sparse with alloca() uses.
3754  *  - Allocation failure due to insufficient stack space is not indicated with a NULL
3755  *  return like e.g. with malloc(). Instead, most systems probably handle it the same
3756  *  way as out of stack space situations from infinite function recursion, i.e.
3757  *  with a segmentation fault.
3758  *  - Special care has to be taken when mixing alloca() with GNU C variable sized arrays.
3759  *  Stack space allocated with alloca() in the same scope as a variable sized array
3760  *  will be freed together with the variable sized array upon exit of that scope, and
3761  *  not upon exit of the enclosing function scope.
3762  * size :
3763  * number of bytes to allocate.
3764  * Returns :
3765  * space for size bytes, allocated on the stack
3766  */
3767 // TODO
3768 // #define g_alloca(size)
3769 
3770 /*
3771  * Wraps g_alloca() in a more typesafe manner.
3772  * struct_type :
3773  * Type of memory chunks to be allocated
3774  * n_structs :
3775  * Number of chunks to be allocated
3776  * Returns :
3777  * Pointer to stack space for n_structs chunks of type struct_type
3778  */
3779 // TODO
3780 // #define g_newa(struct_type, n_structs)
3781 
3782 /*
3783  * Copies a block of memory len bytes long, from src to dest.
3784  * The source and destination areas may overlap.
3785  * In order to use this function, you must include
3786  * string.h yourself, because this macro will
3787  * typically simply resolve to memmove() and GLib does not include
3788  * string.h for you.
3789  * dest :
3790  * the destination address to copy the bytes to.
3791  * src :
3792  * the source address to copy the bytes from.
3793  * len :
3794  * the number of bytes to copy.
3795  */
3796 // TODO
3797 // #define g_memmove(dest,src,len)
3798 
3799 /*
3800  * Returns from the current function if the expression is not true.
3801  * If the expression evaluates to FALSE, a critical message is logged and
3802  * the function returns. This can only be used in functions which do not return
3803  * a value.
3804  * expr :
3805  * the expression to check.
3806  */
3807 // TODO
3808 // #define g_return_if_fail(expr)
3809 
3810 /*
3811  * Returns from the current function, returning the value val, if the expression
3812  * is not true.
3813  * If the expression evaluates to FALSE, a critical message is logged and
3814  * val is returned.
3815  * expr :
3816  * the expression to check.
3817  * val :
3818  * the value to return from the current function if the expression is not
3819  * true.
3820  */
3821 // TODO
3822 // #define g_return_val_if_fail(expr,val)
3823 
3824 /*
3825  * Logs a critical message and returns val.
3826  * val :
3827  * the value to return from the current function.
3828  */
3829 // TODO
3830 // #define g_return_val_if_reached(val)
3831 
3832 /*
3833  * Logs a warning if the expression is not true.
3834  * expr :
3835  * the expression to check
3836  * Since 2.16
3837  */
3838 // TODO
3839 // #define g_warn_if_fail(expr)
3840 
3841 /*
3842  * A convenience function/macro to log a normal message.
3843  * ... :
3844  * format string, followed by parameters to insert into the format string (as with printf())
3845  */
3846 // TODO
3847 // #define g_message(...)
3848 
3849 /*
3850  * A convenience function/macro to log a warning message.
3851  * You can make warnings fatal at runtime by setting the G_DEBUG environment
3852  * variable (see Running GLib Applications).
3853  * ... :
3854  * format string, followed by parameters to insert into the format string (as with printf())
3855  */
3856 // TODO
3857 // #define g_warning(...)
3858 
3859 /*
3860  * Logs a "critical warning" (G_LOG_LEVEL_CRITICAL). It's more or less
3861  * application-defined what constitutes a critical vs. a regular
3862  * warning. You could call g_log_set_always_fatal() to make critical
3863  * warnings exit the program, then use g_critical() for fatal errors, for
3864  * example.
3865  * You can also make critical warnings fatal at runtime by setting
3866  * the G_DEBUG environment variable (see
3867  * Running GLib Applications).
3868  * ... :
3869  * format string, followed by parameters to insert into the format string (as with printf())
3870  */
3871 // TODO
3872 // #define g_critical(...)
3873 
3874 /*
3875  * A convenience function/macro to log an error message.
3876  * Error messages are always fatal, resulting in a call to
3877  * abort() to terminate the application.
3878  * This function will result in a core dump; don't use it for errors you
3879  * expect. Using this function indicates a bug in your program, i.e. an
3880  * assertion failure.
3881  * ... :
3882  * format string, followed by parameters to insert into the format string (as with printf())
3883  */
3884 // TODO
3885 // #define g_error(...)
3886 
3887 /*
3888  * A convenience function/macro to log a debug message.
3889  * ... :
3890  * format string, followed by parameters to insert into the format string (as with printf())
3891  * Since 2.6
3892  */
3893 // TODO
3894 // #define g_debug(...)
3895 
3896 /*
3897  * Removes leading and trailing whitespace from a string. See g_strchomp() and
3898  * g_strchug().
3899  * string :
3900  * a string to remove the leading and trailing whitespace from.
3901  */
3902 // TODO
3903 // #define g_strstrip( string )
3904 
3905 /*
3906  * Skips to the next character in a UTF-8 string. The string must be
3907  * valid; this macro is as fast as possible, and has no error-checking.
3908  * You would use this macro to iterate over a string character by
3909  * character. The macro returns the start of the next UTF-8 character.
3910  * Before using this macro, use g_utf8_validate() to validate strings
3911  * that may contain invalid UTF-8.
3912  * p :
3913  * Pointer to the start of a valid UTF-8 character.
3914  */
3915 // TODO
3916 // #define g_utf8_next_char(p)
3917 
3918 /*
3919  * Marks a string for translation, gets replaced with the translated string
3920  * at runtime.
3921  * String :
3922  * the string to be translated
3923  * Since 2.4
3924  */
3925 // TODO
3926 // #define _(String)
3927 
3928 /*
3929  * Like _(), but handles context in message ids. This has the advantage that
3930  * the string can be adorned with a prefix to guarantee uniqueness and provide
3931  * context to the translator.
3932  * One use case given in the gettext manual is GUI translation, where one could
3933  * e.g. disambiguate two "Open" menu entries as "File|Open" and "Printer|Open".
3934  * Another use case is the string "Russian" which may have to be translated
3935  * differently depending on whether it's the name of a character set or a
3936  * language. This could be solved by using "charset|Russian" and
3937  * "language|Russian".
3938  * See the C_() macro for a different way to mark up translatable strings
3939  * with context.
3940  * Note
3941  * If you are using the Q_() macro, you need to make sure that you
3942  * pass --keyword=Q_ to xgettext when extracting messages.
3943  * If you are using GNU gettext >= 0.15, you can also use
3944  * --keyword=Q_:1g to let xgettext split the context
3945  * string off into a msgctxt line in the po file.
3946  * String :
3947  * the string to be translated, with a '|'-separated prefix which
3948  * must not be translated
3949  * Returns :
3950  * the translated message
3951  * Since 2.4
3952  */
3953 // TODO
3954 // #define Q_(String)
3955 
3956 /*
3957  * Uses gettext to get the translation for msgid. msgctxt is
3958  * used as a context. This is mainly useful for short strings which
3959  * may need different translations, depending on the context in which
3960  * they are used.
3961  * $(DDOC_COMMENT example)
3962  * Note
3963  * If you are using the C_() macro, you need to make sure that you
3964  * pass --keyword=C_:1c,2 to xgettext when extracting
3965  * messages. Note that this only works with GNU gettext >= 0.15.
3966  * Context :
3967  * a message context, must be a string literal
3968  * String :
3969  * a message id, must be a string literal
3970  * Returns :
3971  * the translated message
3972  * Since 2.16
3973  */
3974 // TODO
3975 // #define C_(Context,String)
3976 
3977 /*
3978  * Only marks a string for translation.
3979  * This is useful in situations where the translated strings can't
3980  * be directly used, e.g. in string array initializers.
3981  * To get the translated string, call gettext() at runtime.
3982  * $(DDOC_COMMENT example)
3983  * String :
3984  * the string to be translated
3985  * Since 2.4
3986  */
3987 // TODO
3988 // #define N_(String)
3989 
3990 /*
3991  * Only marks a string for translation, with context.
3992  * This is useful in situations where the translated strings can't
3993  * be directly used, e.g. in string array initializers.
3994  * To get the translated string, you should call g_dpgettext2() at runtime.
3995  * $(DDOC_COMMENT example)
3996  * Note
3997  * If you are using the NC_() macro, you need to make sure that you
3998  * pass --keyword=NC_:1c,2 to xgettext when extracting
3999  * messages. Note that this only works with GNU gettext >= 0.15.
4000  * Intltool has support for the NC_() macro since version 0.40.1.
4001  * Context :
4002  * a message context, must be a string literal
4003  * String :
4004  * a message id, must be a string literal
4005  * Since 2.18
4006  */
4007 // TODO
4008 // #define NC_(Context, String)
4009 
4010 /*
4011  * Returns a random gboolean from rand_. This corresponds to a
4012  * unbiased coin toss.
4013  * rand_ :
4014  * a GRand.
4015  * Returns :
4016  * a random gboolean.
4017  */
4018 // TODO
4019 // #define g_rand_boolean(rand_)
4020 
4021 /*
4022  * Warning
4023  * g_scanner_add_symbol has been deprecated since version 2.2 and should not be used in newly-written code. Use g_scanner_scope_add_symbol() instead.
4024  * Adds a symbol to the default scope.
4025  * scanner :
4026  * a GScanner.
4027  * symbol :
4028  * the symbol to add.
4029  * value :
4030  * the value of the symbol.
4031  */
4032 // TODO
4033 // #define g_scanner_add_symbol( scanner, symbol, value )
4034 
4035 /*
4036  * Warning
4037  * g_scanner_remove_symbol has been deprecated since version 2.2 and should not be used in newly-written code. Use g_scanner_scope_remove_symbol() instead.
4038  * Removes a symbol from the default scope.
4039  * scanner :
4040  * a GScanner.
4041  * symbol :
4042  * the symbol to remove.
4043  */
4044 // TODO
4045 // #define g_scanner_remove_symbol( scanner, symbol )
4046 
4047 /*
4048  * Warning
4049  * g_scanner_foreach_symbol has been deprecated since version 2.2 and should not be used in newly-written code. Use g_scanner_scope_foreach_symbol() instead.
4050  * Calls a function for each symbol in the default scope.
4051  * scanner :
4052  * a GScanner.
4053  * func :
4054  * the function to call with each symbol.
4055  * data :
4056  * data to pass to the function.
4057  */
4058 // TODO
4059 // #define g_scanner_foreach_symbol( scanner, func, data )
4060 
4061 /*
4062  * Warning
4063  * g_scanner_freeze_symbol_table has been deprecated since version 2.2 and should not be used in newly-written code. This macro does nothing.
4064  * There is no reason to use this macro, since it does nothing.
4065  * scanner :
4066  * a GScanner.
4067  */
4068 // TODO
4069 // #define g_scanner_freeze_symbol_table(scanner)
4070 
4071 /*
4072  * Warning
4073  * g_scanner_thaw_symbol_table has been deprecated since version 2.2 and should not be used in newly-written code. This macro does nothing.
4074  * There is no reason to use this macro, since it does nothing.
4075  * scanner :
4076  * a GScanner.
4077  */
4078 // TODO
4079 // #define g_scanner_thaw_symbol_table(scanner)
4080 
4081 /*
4082  */
4083 // TODO
4084 // # define G_WIN32_DLLMAIN_FOR_DLL_NAME(static, dll_name) Warning G_WIN32_DLLMAIN_FOR_DLL_NAME is deprecated and should not be used in newly-written code. On Windows, this macro defines a DllMain() function that stores the actual DLL name that the code being compiled will be included in. On non-Windows platforms, expands to nothing. static : empty or "static". dll_name : the name of the (pointer to the) char array where the DLL name will be stored. If this is used, you must also include windows.h. If you need a more complex DLL entry point function, you cannot use this.
4085 
4086 /*
4087  * A convenience macro to allocate a block of memory from the slice allocator.
4088  * It calls g_slice_alloc() with sizeof (type) and casts
4089  * the returned pointer to a pointer of the given type, avoiding a type cast
4090  * in the source code.
4091  * Note that the underlying slice allocation mechanism can
4092  * be changed with the G_SLICE=always-malloc
4093  * environment variable.
4094  * type :
4095  * the type to allocate, typically a structure name
4096  * Returns :
4097  * a pointer to the allocated block, cast to a pointer to type.
4098  * Since 2.10
4099  */
4100 // TODO
4101 // #define g_slice_new(type)
4102 
4103 /*
4104  * A convenience macro to allocate a block of memory from the slice allocator
4105  * and set the memory to 0. It calls g_slice_alloc0() with
4106  * sizeof (type) and casts the returned pointer to a pointer
4107  * of the given type, avoiding a type cast in the source code.
4108  * Note that the underlying slice allocation mechanism can
4109  * be changed with the G_SLICE=always-malloc
4110  * environment variable.
4111  * type :
4112  * the type to allocate, typically a structure name
4113  * Returns :
4114  * a pointer to the allocated block, cast to a pointer to type.
4115  * Since 2.10
4116  */
4117 // TODO
4118 // #define g_slice_new0(type)
4119 
4120 /*
4121  * A convenience macro to duplicate a block of memory using the slice allocator.
4122  * It calls g_slice_copy() with sizeof (type) and casts
4123  * the returned pointer to a pointer of the given type, avoiding a type cast
4124  * in the source code.
4125  * Note that the underlying slice allocation mechanism can
4126  * be changed with the G_SLICE=always-malloc
4127  * environment variable.
4128  * type :
4129  * the type to duplicate, typically a structure name
4130  * mem :
4131  * the memory to copy into the allocated block
4132  * Returns :
4133  * a pointer to the allocated block, cast to a pointer to type.
4134  * Since 2.14
4135  */
4136 // TODO
4137 // #define g_slice_dup(type, mem)
4138 
4139 /*
4140  * A convenience macro to free a block of memory that has been allocated
4141  * from the slice allocator. It calls g_slice_free1() using
4142  * sizeof (type) as the block size.
4143  * Note that the exact release behaviour can be changed with the
4144  * G_DEBUG=gc-friendly environment variable,
4145  * also see G_SLICE for related debugging options.
4146  * type :
4147  * the type of the block to free, typically a structure name
4148  * mem :
4149  * a pointer to the block to free
4150  * Since 2.10
4151  */
4152 // TODO
4153 // #define g_slice_free(type, mem)
4154 
4155 /*
4156  * Frees a linked list of memory blocks of structure type type.
4157  * The memory blocks must be equal-sized, allocated via
4158  * g_slice_alloc() or g_slice_alloc0() and linked together by a
4159  * next pointer (similar to GSList). The name of the
4160  * next field in type is passed as third argument.
4161  * Note that the exact release behaviour can be changed with the
4162  * G_DEBUG=gc-friendly environment variable,
4163  * also see G_SLICE for related debugging options.
4164  * type :
4165  * the type of the mem_chain blocks
4166  * mem_chain :
4167  * a pointer to the first block of the chain
4168  * next :
4169  * the field name of the next pointer in type
4170  * Since 2.10
4171  * [6]
4172  * [Bonwick94] Jeff Bonwick, The slab allocator: An object-caching kernel
4173  * memory allocator. USENIX 1994, and
4174  * [Bonwick01] Bonwick and Jonathan Adams, Magazines and vmem: Extending the
4175  * slab allocator to many cpu's and arbitrary resources. USENIX 2001
4176  */
4177 // TODO
4178 // #define g_slice_free_chain(type, mem_chain, next)
4179 
4180 /*
4181  * Warning
4182  * g_mem_chunk_create has been deprecated since version 2.10 and should not be used in newly-written code. Use the slice
4183  *  allocator instead
4184  * A convenience macro for creating a new GMemChunk. It calls
4185  * g_mem_chunk_new(), using the given type to create the GMemChunk
4186  * name. The atom size is determined using
4187  * sizeof(), and the area size is calculated by
4188  * multiplying the pre_alloc parameter with the atom size.
4189  * type :
4190  * the type of the atoms, typically a structure name.
4191  * pre_alloc :
4192  * the number of atoms to store in each block of memory.
4193  * alloc_type :
4194  * the type of the GMemChunk. G_ALLOC_AND_FREE is used
4195  * if the atoms will be freed individually. G_ALLOC_ONLY
4196  * should be used if atoms will never be freed
4197  * individually. G_ALLOC_ONLY is quicker, since it does
4198  * not need to track free atoms, but it obviously wastes
4199  * memory if you no longer need many of the atoms.
4200  * Returns :
4201  * the new GMemChunk.
4202  */
4203 // TODO
4204 // #define g_mem_chunk_create(type, pre_alloc, alloc_type)
4205 
4206 /*
4207  * Warning
4208  * g_chunk_new has been deprecated since version 2.10 and should not be used in newly-written code. Use g_slice_new() instead
4209  * A convenience macro to allocate an atom of memory from a GMemChunk.
4210  * It calls g_mem_chunk_alloc() and casts the returned atom to a
4211  * pointer to the given type, avoiding a type cast in the source code.
4212  * type :
4213  * the type of the GMemChunk atoms, typically a structure name.
4214  * chunk :
4215  * a GMemChunk.
4216  * Returns :
4217  * a pointer to the allocated atom, cast to a pointer to
4218  * type.
4219  */
4220 // TODO
4221 // #define g_chunk_new(type, chunk)
4222 
4223 /*
4224  * Warning
4225  * g_chunk_new0 has been deprecated since version 2.10 and should not be used in newly-written code. Use g_slice_new0() instead
4226  * A convenience macro to allocate an atom of memory from a GMemChunk.
4227  * It calls g_mem_chunk_alloc0() and casts the returned atom to a
4228  * pointer to the given type, avoiding a type cast in the source code.
4229  * type :
4230  * the type of the GMemChunk atoms, typically a structure name.
4231  * chunk :
4232  * a GMemChunk.
4233  * Returns :
4234  * a pointer to the allocated atom, cast to a pointer to
4235  * type.
4236  */
4237 // TODO
4238 // #define g_chunk_new0(type, chunk)
4239 
4240 /*
4241  * Warning
4242  * g_chunk_free has been deprecated since version 2.10 and should not be used in newly-written code. Use g_slice_free() instead
4243  * A convenience macro to free an atom of memory from a GMemChunk. It
4244  * simply switches the arguments and calls g_mem_chunk_free() It is
4245  * included simply to complement the other convenience macros,
4246  * g_chunk_new() and g_chunk_new0().
4247  * mem :
4248  * a pointer to the atom to be freed.
4249  * mem_chunk :
4250  * a GMemChunk.
4251  */
4252 // TODO
4253 // #define g_chunk_free(mem, mem_chunk)
4254 
4255 /*
4256  * A convenience macro to get the previous element in a GList.
4257  * list :
4258  * an element in a GList.
4259  * Returns :
4260  * the previous element, or NULL if there are no previous
4261  * elements.
4262  */
4263 // TODO
4264 // #define g_list_previous(list)
4265 
4266 /*
4267  * A convenience macro to get the next element in a GList.
4268  * list :
4269  * an element in a GList.
4270  * Returns :
4271  * the next element, or NULL if there are no more elements.
4272  */
4273 // TODO
4274 // #define g_list_next(list)
4275 
4276 /*
4277  * A convenience macro to get the next element in a GSList.
4278  * slist :
4279  * an element in a GSList.
4280  * Returns :
4281  * the next element, or NULL if there are no more elements.
4282  */
4283 // TODO
4284 // #define g_slist_next(slist)
4285 
4286 /*
4287  * Warning
4288  * g_hash_table_freeze is deprecated and should not be used in newly-written code.
4289  * This function is deprecated and will be removed in the next major
4290  * release of GLib. It does nothing.
4291  * hash_table :
4292  * a GHashTable
4293  */
4294 // TODO
4295 // #define g_hash_table_freeze(hash_table)
4296 
4297 /*
4298  * Warning
4299  * g_hash_table_thaw is deprecated and should not be used in newly-written code.
4300  * This function is deprecated and will be removed in the next major
4301  * release of GLib. It does nothing.
4302  * hash_table :
4303  * a GHashTable
4304  */
4305 // TODO
4306 // #define g_hash_table_thaw(hash_table)
4307 
4308 /*
4309  * Adds the value on to the end of the array. The array will grow in
4310  * size automatically if necessary.
4311  * Note
4312  * g_array_append_val() is a macro which uses a reference
4313  * to the value parameter v. This means that you cannot use it with
4314  * literal values such as "27". You must use variables.
4315  * a :
4316  * a GArray.
4317  * v :
4318  * the value to append to the GArray.
4319  * Returns :
4320  * the GArray.
4321  */
4322 // TODO
4323 // #define g_array_append_val(a,v)
4324 
4325 /*
4326  * Adds the value on to the start of the array. The array will grow in
4327  * size automatically if necessary.
4328  * This operation is slower than g_array_append_val() since the
4329  * existing elements in the array have to be moved to make space for
4330  * the new element.
4331  * Note
4332  * g_array_prepend_val() is a macro which uses a reference
4333  * to the value parameter v. This means that you cannot use it with
4334  * literal values such as "27". You must use variables.
4335  * a :
4336  * a GArray.
4337  * v :
4338  * the value to prepend to the GArray.
4339  * Returns :
4340  * the GArray.
4341  */
4342 // TODO
4343 // #define g_array_prepend_val(a,v)
4344 
4345 /*
4346  * Inserts an element into an array at the given index.
4347  * Note
4348  * g_array_insert_val() is a macro which uses a reference
4349  * to the value parameter v. This means that you cannot use it with
4350  * literal values such as "27". You must use variables.
4351  * a :
4352  * a GArray.
4353  * i :
4354  * the index to place the element at.
4355  * v :
4356  * the value to insert into the array.
4357  * Returns :
4358  * the GArray.
4359  */
4360 // TODO
4361 // #define g_array_insert_val(a,i,v)
4362 
4363 /*
4364  * Returns the element of a GArray at the given index. The return
4365  * value is cast to the given type.
4366  * $(DDOC_COMMENT example)
4367  * a :
4368  * a GArray.
4369  * t :
4370  * the type of the elements.
4371  * i :
4372  * the index of the element to return.
4373  * Returns :
4374  * the element of the GArray at the index given by i.
4375  */
4376 // TODO
4377 // #define g_array_index(a,t,i)
4378 
4379 /*
4380  * Returns the pointer at the given index of the pointer array.
4381  * array :
4382  * a GPtrArray.
4383  * index_ :
4384  * the index of the pointer to return.
4385  * Returns :
4386  * the pointer at the given index.
4387  */
4388 // TODO
4389 // #define g_ptr_array_index(array,index_)
4390 
4391 /*
4392  * Inserts a GNode as the last child of the given parent.
4393  * parent :
4394  * the GNode to place the new GNode under
4395  * node :
4396  * the GNode to insert
4397  * Returns :
4398  * the inserted GNode
4399  */
4400 // TODO
4401 // #define g_node_append(parent, node)
4402 
4403 /*
4404  * Inserts a new GNode at the given position.
4405  * parent :
4406  * the GNode to place the new GNode under
4407  * position :
4408  * the position to place the new GNode at. If position is -1,
4409  * the new GNode is inserted as the last child of parent
4410  * data :
4411  * the data for the new GNode
4412  * Returns :
4413  * the new GNode
4414  */
4415 // TODO
4416 // #define g_node_insert_data(parent, position, data)
4417 
4418 /*
4419  * Inserts a new GNode before the given sibling.
4420  * parent :
4421  * the GNode to place the new GNode under
4422  * sibling :
4423  * the sibling GNode to place the new GNode before
4424  * data :
4425  * the data for the new GNode
4426  * Returns :
4427  * the new GNode
4428  */
4429 // TODO
4430 // #define g_node_insert_data_before(parent, sibling, data)
4431 
4432 /*
4433  * Inserts a new GNode as the last child of the given parent.
4434  * parent :
4435  * the GNode to place the new GNode under
4436  * data :
4437  * the data for the new GNode
4438  * Returns :
4439  * the new GNode
4440  */
4441 // TODO
4442 // #define g_node_append_data(parent, data)
4443 
4444 /*
4445  * Inserts a new GNode as the first child of the given parent.
4446  * parent :
4447  * the GNode to place the new GNode under
4448  * data :
4449  * the data for the new GNode
4450  * Returns :
4451  * the new GNode
4452  */
4453 // TODO
4454 // #define g_node_prepend_data(parent, data)
4455 
4456 /*
4457  * Gets the first child of a GNode.
4458  * node :
4459  * a GNode
4460  * Returns :
4461  * the first child of node, or NULL if node is NULL
4462  * or has no children
4463  */
4464 // TODO
4465 // #define g_node_first_child(node)
4466 
4467 /*
4468  * Gets the next sibling of a GNode.
4469  * node :
4470  * a GNode
4471  * Returns :
4472  * the next sibling of node, or NULL if node is the last node
4473  * or NULL
4474  */
4475 // TODO
4476 // #define g_node_next_sibling(node)
4477 
4478 /*
4479  * Gets the previous sibling of a GNode.
4480  * node :
4481  * a GNode
4482  * Returns :
4483  * the previous sibling of node, or NULL if node is the first
4484  * node or NULL
4485  */
4486 // TODO
4487 // #define g_node_prev_sibling(node)
4488 
4489 /*
4490  * Returns TRUE if a GNode is a leaf node.
4491  * node :
4492  * a GNode
4493  * Returns :
4494  * TRUE if the GNode is a leaf node
4495  * (i.e. it has no children)
4496  */
4497 // TODO
4498 // #define	 G_NODE_IS_LEAF(node) (((GNode*) (node))->children == NULL)
4499 
4500 /*
4501  * Returns TRUE if a GNode is the root of a tree.
4502  * node :
4503  * a GNode
4504  * Returns :
4505  * TRUE if the GNode is the root of a tree
4506  * (i.e. it has no parent or siblings)
4507  */
4508 // TODO
4509 // #define G_NODE_IS_ROOT(node)
4510 
4511 /*
4512  * Sets the data corresponding to the given GQuark id. Any previous
4513  * data with the same key is removed, and its destroy function is
4514  * called.
4515  * dl :
4516  * a datalist.
4517  * q :
4518  * the GQuark to identify the data element.
4519  * d :
4520  * the data element, or NULL to remove any previous element
4521  * corresponding to q.
4522  */
4523 // TODO
4524 // #define g_datalist_id_set_data(dl, q, d)
4525 
4526 /*
4527  * Removes an element, using its GQuark identifier.
4528  * dl :
4529  * a datalist.
4530  * q :
4531  * the GQuark identifying the data element.
4532  */
4533 // TODO
4534 // #define g_datalist_id_remove_data(dl, q)
4535 
4536 /*
4537  * Sets the data element corresponding to the given string identifier.
4538  * dl :
4539  * a datalist.
4540  * k :
4541  * the string to identify the data element.
4542  * d :
4543  * the data element, or NULL to remove any previous element
4544  * corresponding to k.
4545  */
4546 // TODO
4547 // #define g_datalist_set_data(dl, k, d)
4548 
4549 /*
4550  * Sets the data element corresponding to the given string identifier,
4551  * and the function to be called when the data element is removed.
4552  * dl :
4553  * a datalist.
4554  * k :
4555  * the string to identify the data element.
4556  * d :
4557  * the data element, or NULL to remove any previous element
4558  * corresponding to k.
4559  * f :
4560  * the function to call when the data element is removed. This
4561  * function will be called with the data element and can be used to
4562  * free any memory allocated for it. If d is NULL, then f must
4563  * also be NULL.
4564  */
4565 // TODO
4566 // #define g_datalist_set_data_full(dl, k, d, f)
4567 
4568 /*
4569  * Gets a data element, using its string identifer. This is slower than
4570  * g_datalist_id_get_data() because the string is first converted to a
4571  * GQuark.
4572  * dl :
4573  * a datalist.
4574  * k :
4575  * the string identifying a data element.
4576  * Returns :
4577  * the data element, or NULL if it is not found.
4578  */
4579 // TODO
4580 // #define g_datalist_get_data(dl, k)
4581 
4582 /*
4583  * Removes an element using its string identifier. The data element's
4584  * destroy function is called if it has been set.
4585  * dl :
4586  * a datalist.
4587  * k :
4588  * the string identifying the data element.
4589  */
4590 // TODO
4591 // #define g_datalist_remove_data(dl, k)
4592 
4593 /*
4594  * Removes an element, without calling its destroy notifier.
4595  * dl :
4596  * a datalist.
4597  * k :
4598  * the string identifying the data element.
4599  */
4600 // TODO
4601 // #define g_datalist_remove_no_notify(dl, k)
4602 
4603 /*
4604  * Sets the data element associated with the given GQuark id. Any
4605  * previous data with the same key is removed, and its destroy function
4606  * is called.
4607  * l :
4608  * the location identifying the dataset.
4609  * k :
4610  * the GQuark id to identify the data element.
4611  * d :
4612  * the data element.
4613  */
4614 // TODO
4615 // #define g_dataset_id_set_data(l, k, d)
4616 
4617 /*
4618  * Removes a data element from a dataset. The data element's destroy
4619  * function is called if it has been set.
4620  * l :
4621  * the location identifying the dataset.
4622  * k :
4623  * the GQuark id identifying the data element.
4624  */
4625 // TODO
4626 // #define g_dataset_id_remove_data(l, k)
4627 
4628 /*
4629  * Sets the data corresponding to the given string identifier.
4630  * l :
4631  * the location identifying the dataset.
4632  * k :
4633  * the string to identify the data element.
4634  * d :
4635  * the data element.
4636  */
4637 // TODO
4638 // #define g_dataset_set_data(l, k, d)
4639 
4640 /*
4641  * Sets the data corresponding to the given string identifier, and the
4642  * function to call when the data element is destroyed.
4643  * l :
4644  * the location identifying the dataset.
4645  * k :
4646  * the string to identify the data element.
4647  * d :
4648  * the data element.
4649  * f :
4650  * the function to call when the data element is removed. This
4651  * function will be called with the data element and can be used to
4652  * free any memory allocated for it.
4653  */
4654 // TODO
4655 // #define g_dataset_set_data_full(l, k, d, f)
4656 
4657 /*
4658  * Gets the data element corresponding to a string.
4659  * l :
4660  * the location identifying the dataset.
4661  * k :
4662  * the string identifying the data element.
4663  * Returns :
4664  * the data element corresponding to the string, or NULL if
4665  * it is not found.
4666  */
4667 // TODO
4668 // #define g_dataset_get_data(l, k)
4669 
4670 /*
4671  * Removes a data element corresponding to a string. Its destroy
4672  * function is called if it has been set.
4673  * l :
4674  * the location identifying the dataset.
4675  * k :
4676  * the string identifying the data element.
4677  */
4678 // TODO
4679 // #define g_dataset_remove_data(l, k)
4680 
4681 /*
4682  * Removes an element, without calling its destroy notifier.
4683  * l :
4684  * the location identifying the dataset.
4685  * k :
4686  * the string identifying the data element.
4687  */
4688 // TODO
4689 // #define g_dataset_remove_no_notify(l, k)
4690 
4691 /*
4692  */
4693 // TODO
4694 // # define G_VARIANT_TYPE(type_string) (g_variant_type_checked_ ((type_string))) Converts a string to a const GVariantType. Depending on the current debugging level, this function may perform a runtime check to ensure that string is a valid GVariant type string. It is always a programmer error to use this macro with an invalid type string. Since 2.24 type_string : a well-formed GVariantType type string
4695 
4696 /*
4697  * Specifies the type of function passed to g_main_context_set_poll_func().
4698  * The semantics of the function should match those of the poll() system call.
4699  * ufds :
4700  * an array of GPollFD elements
4701  * nfsd :
4702  * the number of elements in ufds
4703  * timeout_ :
4704  * the maximum time to wait for an event of the file descriptors.
4705  * A negative value indicates an infinite timeout.
4706  * Returns :
4707  * the number of GPollFD elements which have events or errors
4708  * reported, or -1 if an error occurred.
4709  */
4710 // gint (*GPollFunc) (GPollFD *ufds,  guint nfsd,  gint timeout_);
4711 public alias extern(C) int function(GPollFD* ufds, uint nfsd, int timeout) GPollFunc;
4712 
4713 /*
4714  * The type of functions to be called when a child exists.
4715  * pid :
4716  * the process id of the child process
4717  * status :
4718  * Status information about the child process,
4719  * see waitpid(2) for more information about this field
4720  * data :
4721  * user data passed to g_child_watch_add()
4722  */
4723 // void (*GChildWatchFunc) (GPid pid,  gint status,  gpointer data);
4724 public alias extern(C) void function(GPid pid, int status, void* data) GChildWatchFunc;
4725 
4726 /*
4727  * This is just a placeholder for GClosureMarshal, which cannot be used here
4728  * for dependency reasons.
4729  */
4730 // void (*GSourceDummyMarshal) (void);
4731 public alias extern(C) void function() GSourceDummyMarshal;
4732 
4733 /*
4734  * Specifies the type of function passed to g_timeout_add(), g_timeout_add_full(),
4735  * g_idle_add(), and g_idle_add_full().
4736  * data :
4737  * data passed to the function, set when the source was created with one
4738  * of the above functions.
4739  * Returns :
4740  * it should return FALSE if the source should be removed.
4741  */
4742 // gboolean (*GSourceFunc) (gpointer data);
4743 public alias extern(C) int function(void* data) GSourceFunc;
4744 
4745 /*
4746  * Specifies the type of the module initialization function.
4747  * If a module contains a function named g_module_check_init() it is called
4748  * automatically when the module is loaded. It is passed the GModule structure
4749  * and should return NULL on success or a string describing the initialization
4750  * error.
4751  * module :
4752  * the GModule corresponding to the module which has just been loaded.
4753  * Returns :
4754  * NULL on success, or a string describing the initialization error.
4755  */
4756 // const gchar * (*GModuleCheckInit) (GModule *module);
4757 public alias extern(C) char * function(GModule* modul) GModuleCheckInit;
4758 
4759 /*
4760  * Specifies the type of the module function called when it is unloaded.
4761  * If a module contains a function named g_module_unload() it is called
4762  * automatically when the module is unloaded.
4763  * It is passed the GModule structure.
4764  * module :
4765  * the GModule about to be unloaded.
4766  */
4767 // void (*GModuleUnload) (GModule *module);
4768 public alias extern(C) void function(GModule* modul) GModuleUnload;
4769 
4770 /*
4771  * Specifies the type of function passed to g_io_add_watch() or
4772  * g_io_add_watch_full(), which is called when the requested condition
4773  * on a GIOChannel is satisfied.
4774  * source :
4775  * the GIOChannel event source
4776  * condition :
4777  * the condition which has been satisfied
4778  * data :
4779  * user data set in g_io_add_watch() or g_io_add_watch_full()
4780  * Returns :
4781  * the function should return FALSE if the event source
4782  * should be removed
4783  */
4784 // gboolean (*GIOFunc) (GIOChannel *source,  GIOCondition condition,  gpointer data);
4785 public alias extern(C) int function(GIOChannel* source, GIOCondition condition, void* data) GIOFunc;
4786 
4787 /*
4788  * Specifies the type of the print handler functions.
4789  * These are called with the complete formatted string to output.
4790  * string :
4791  * the message to be output.
4792  */
4793 // void (*GPrintFunc) (const gchar *string);
4794 public alias extern(C) void function(char* string) GPrintFunc;
4795 
4796 /*
4797  * Specifies the prototype of log handler functions.
4798  * log_domain :
4799  * the log domain of the message.
4800  * log_level :
4801  * the log level of the message (including the fatal and recursion
4802  * flags).
4803  * message :
4804  * the message to process.
4805  * user_data :
4806  * user data, set in g_log_set_handler().
4807  */
4808 // void (*GLogFunc) (const gchar *log_domain,  GLogLevelFlags log_level,  const gchar *message,  gpointer user_data);
4809 public alias extern(C) void function(char* logDomain, GLogLevelFlags logLevel, char* message, void* userData) GLogFunc;
4810 
4811 /*
4812  * Declares a type of function which takes no arguments and has no return value.
4813  * It is used to specify the type function passed to g_atexit().
4814  */
4815 // void (*GVoidFunc) (void);
4816 public alias extern(C) void function() GVoidFunc;
4817 
4818 /*
4819  * Declares a type of function which takes an arbitrary data pointer argument
4820  * and has no return value. It is not currently used in GLib or GTK+.
4821  * data :
4822  * a data pointer.
4823  */
4824 // void (*GFreeFunc) (gpointer data);
4825 public alias extern(C) void function(void* data) GFreeFunc;
4826 
4827 /*
4828  * Specifies the type of the message handler function.
4829  * scanner :
4830  * a GScanner.
4831  * message :
4832  * the message.
4833  * error :
4834  * TRUE if the message signals an error, FALSE if it
4835  * signals a warning.
4836  */
4837 // void (*GScannerMsgFunc) (GScanner *scanner,  gchar *message,  gboolean error);
4838 public alias extern(C) void function(GScanner* scanner, char* message, int error) GScannerMsgFunc;
4839 
4840 /*
4841  * Specifies the type of the function passed to g_completion_new(). It
4842  * should return the string corresponding to the given target item.
4843  * This is used when you use data structures as GCompletion items.
4844  * Param1 :
4845  * the completion item.
4846  * Returns :
4847  * the string corresponding to the item.
4848  */
4849 // gchar * (*GCompletionFunc) (gpointer Param1);
4850 public alias extern(C) char * function(void* Param1) GCompletionFunc;
4851 
4852 /*
4853  * Specifies the type of the function passed to
4854  * g_completion_set_compare(). This is used when you use strings as
4855  * GCompletion items.
4856  * s1 :
4857  * string to compare with s2.
4858  * s2 :
4859  * string to compare with s1.
4860  * n :
4861  * maximal number of bytes to compare.
4862  * Returns :
4863  * an integer less than, equal to, or greater than zero if
4864  * the first n bytes of s1 is found, respectively, to be
4865  * less than, to match, or to be greater than the first n
4866  * bytes of s2.
4867  */
4868 // gint (*GCompletionStrncmpFunc) (const gchar *s1,  const gchar *s2,  gsize n);
4869 public alias extern(C) int function(char* s1, char* s2, gsize n) GCompletionStrncmpFunc;
4870 
4871 /*
4872  * Specifies the type of the setup function passed to g_spawn_async(),
4873  * g_spawn_sync() and g_spawn_async_with_pipes(). On POSIX platforms it
4874  * is called in the child after GLib has performed all the setup it plans
4875  * to perform but before calling exec(). On POSIX actions taken in this
4876  * function will thus only affect the child, not the parent.
4877  * Note that POSIX allows only async-signal-safe functions (see signal(7))
4878  * to be called in the child between fork() and exec(), which drastically
4879  * limits the usefulness of child setup functions.
4880  * Also note that modifying the environment from the child setup function
4881  * may not have the intended effect, since it will get overridden by
4882  * a non-NULL env argument to the g_spawn... functions.
4883  * On Windows the function is called in the parent. Its usefulness on
4884  * Windows is thus questionable. In many cases executing the child setup
4885  * function in the parent can have ill effects, and you should be very
4886  * careful when porting software to Windows that uses child setup
4887  * functions.
4888  * user_data :
4889  * user data to pass to the function.
4890  */
4891 // void (*GSpawnChildSetupFunc) (gpointer user_data);
4892 public alias extern(C) void function(void* userData) GSpawnChildSetupFunc;
4893 
4894 /*
4895  * The type of function to be passed as callback for G_OPTION_ARG_CALLBACK
4896  * options.
4897  * option_name :
4898  * The name of the option being parsed. This will be either a
4899  * single dash followed by a single letter (for a short name) or two dashes
4900  * followed by a long option name.
4901  * value :
4902  * The value to be parsed.
4903  * data :
4904  * User data added to the GOptionGroup containing the option when it
4905  * was created with g_option_group_new()
4906  * error :
4907  * A return location for errors. The error code G_OPTION_ERROR_FAILED
4908  * is intended to be used for errors in GOptionArgFunc callbacks.
4909  * Returns :
4910  * TRUE if the option was successfully parsed, FALSE if an error
4911  * occurred, in which case error should be set with g_set_error()
4912  */
4913 // gboolean (*GOptionArgFunc) (const gchar *option_name,  const gchar *value,  gpointer data,  GError **error);
4914 public alias extern(C) int function(char* optionName, char* value, void* data, GError** error) GOptionArgFunc;
4915 
4916 /*
4917  * The type of functions which are used to translate user-visible
4918  * strings, for --help output.
4919  * str :
4920  * the untranslated string
4921  * data :
4922  * user data specified when installing the function, e.g.
4923  * in g_option_group_set_translate_func()
4924  * Returns :
4925  * a translation of the string for the current locale.
4926  * The returned string is owned by GLib and must not be freed.
4927  */
4928 // const gchar * (*GTranslateFunc) (const gchar *str,  gpointer data);
4929 public alias extern(C) char * function(char* str, void* data) GTranslateFunc;
4930 
4931 /*
4932  * The type of function that can be called before and after parsing.
4933  * context :
4934  * The active GOptionContext
4935  * group :
4936  * The group to which the function belongs
4937  * data :
4938  * User data added to the GOptionGroup containing the option when it
4939  * was created with g_option_group_new()
4940  * error :
4941  * A return location for error details
4942  * Returns :
4943  * TRUE if the function completed successfully, FALSE if an error
4944  * occurred, in which case error should be set with g_set_error()
4945  */
4946 // gboolean (*GOptionParseFunc) (GOptionContext *context,  GOptionGroup *group,  gpointer data,  GError **error);
4947 public alias extern(C) int function(GOptionContext* context, GOptionGroup* group, void* data, GError** error) GOptionParseFunc;
4948 
4949 /*
4950  * The type of function to be used as callback when a parse error occurs.
4951  * context :
4952  * The active GOptionContext
4953  * group :
4954  * The group to which the function belongs
4955  * data :
4956  * User data added to the GOptionGroup containing the option when it
4957  * was created with g_option_group_new()
4958  * error :
4959  * The GError containing details about the parse error
4960  */
4961 // void (*GOptionErrorFunc) (GOptionContext *context,  GOptionGroup *group,  gpointer data,  GError **error);
4962 public alias extern(C) void function(GOptionContext* context, GOptionGroup* group, void* data, GError** error) GOptionErrorFunc;
4963 
4964 /*
4965  * Specifies the type of the function passed to g_regex_replace_eval().
4966  * It is called for each occurance of the pattern in the string passed
4967  * to g_regex_replace_eval(), and it should append the replacement to
4968  * result.
4969  * match_info :
4970  * the GMatchInfo generated by the match.
4971  * Use g_match_info_get_regex() and g_match_info_get_string() if you
4972  * need the GRegex or the matched string.
4973  * result :
4974  * a GString containing the new string
4975  * user_data :
4976  * user data passed to g_regex_replace_eval()
4977  * Returns :
4978  * FALSE to continue the replacement process, TRUE to stop it
4979  * Since 2.14
4980  */
4981 // gboolean (*GRegexEvalCallback) (const GMatchInfo *match_info,  GString *result,  gpointer user_data);
4982 public alias extern(C) int function(GMatchInfo* matchInfo, GString* result, void* userData) GRegexEvalCallback;
4983 
4984 /*
4985  * Specifies the type of a comparison function used to compare two
4986  * values. The function should return a negative integer if the first
4987  * value comes before the second, 0 if they are equal, or a positive
4988  * integer if the first value comes after the second.
4989  * a :
4990  * a value.
4991  * b :
4992  * a value to compare with.
4993  * Returns :
4994  * negative value if a < b; zero if a = b; positive
4995  * value if a > b.
4996  */
4997 // gint (*GCompareFunc) (gconstpointer a,  gconstpointer b);
4998 public alias extern(C) int function(void* a, void* b) GCompareFunc;
4999 
5000 /*
5001  * Specifies the type of a comparison function used to compare two
5002  * values. The function should return a negative integer if the first
5003  * value comes before the second, 0 if they are equal, or a positive
5004  * integer if the first value comes after the second.
5005  * a :
5006  * a value.
5007  * b :
5008  * a value to compare with.
5009  * user_data :
5010  * user data to pass to comparison function.
5011  * Returns :
5012  * negative value if a < b; zero if a = b; positive
5013  * value if a > b.
5014  */
5015 // gint (*GCompareDataFunc) (gconstpointer a,  gconstpointer b,  gpointer user_data);
5016 public alias extern(C) int function(void* a, void* b, void* userData) GCompareDataFunc;
5017 
5018 /*
5019  * Specifies the type of functions passed to g_list_foreach() and
5020  * g_slist_foreach().
5021  * data :
5022  * the element's data.
5023  * user_data :
5024  * user data passed to g_list_foreach() or
5025  * g_slist_foreach().
5026  */
5027 // void (*GFunc) (gpointer data,  gpointer user_data);
5028 public alias extern(C) void function(void* data, void* userData) GFunc;
5029 
5030 /*
5031  * A GSequenceIterCompareFunc is a function used to compare iterators.
5032  * It must return zero if the iterators compare equal, a negative value
5033  * if a comes before b, and a positive value if b comes before a.
5034  * a :
5035  * a GSequenceIter
5036  * b :
5037  * a GSequenceIter
5038  * data :
5039  * user data
5040  * Returns :
5041  * zero if the iterators are equal, a negative value if a
5042  * comes before b, and a positive value if b comes before
5043  * a.
5044  */
5045 // gint (*GSequenceIterCompareFunc) (GSequenceIter *a,  GSequenceIter *b,  gpointer data);
5046 public alias extern(C) int function(GSequenceIter* a, GSequenceIter* b, void* data) GSequenceIterCompareFunc;
5047 
5048 /*
5049  * Specifies the type of the hash function which is passed to
5050  * g_hash_table_new() when a GHashTable is created.
5051  * The function is passed a key and should return a guint hash value.
5052  * The functions g_direct_hash(), g_int_hash() and g_str_hash() provide
5053  * hash functions which can be used when the key is a gpointer, gint,
5054  * and gchar* respectively.
5055  *  The hash values should be evenly
5056  * distributed over a fairly large range? The modulus is taken with the
5057  * hash table size (a prime number) to find the 'bucket' to place each
5058  * key into. The function should also be very fast, since it is called
5059  * for each key lookup.
5060  * key :
5061  * a key.
5062  * Returns :
5063  * the hash value corresponding to the key.
5064  */
5065 // guint (*GHashFunc) (gconstpointer key);
5066 public alias extern(C) uint function(void* key) GHashFunc;
5067 
5068 /*
5069  * Specifies the type of a function used to test two values for
5070  * equality. The function should return TRUE if both values are equal
5071  * and FALSE otherwise.
5072  * a :
5073  * a value.
5074  * b :
5075  * a value to compare with.
5076  * Returns :
5077  * TRUE if a = b; FALSE otherwise.
5078  */
5079 // gboolean (*GEqualFunc) (gconstpointer a,  gconstpointer b);
5080 public alias extern(C) int function(void* a, void* b) GEqualFunc;
5081 
5082 /*
5083  * Specifies the type of the function passed to g_hash_table_foreach().
5084  * It is called with each key/value pair, together with the user_data
5085  * parameter which is passed to g_hash_table_foreach().
5086  * key :
5087  * a key.
5088  * value :
5089  * the value corresponding to the key.
5090  * user_data :
5091  * user data passed to g_hash_table_foreach().
5092  */
5093 // void (*GHFunc) (gpointer key,  gpointer value,  gpointer user_data);
5094 public alias extern(C) void function(void* key, void* value, void* userData) GHFunc;
5095 
5096 /*
5097  * Specifies the type of the function passed to
5098  * g_hash_table_foreach_remove(). It is called with each key/value
5099  * pair, together with the user_data parameter passed to
5100  * g_hash_table_foreach_remove(). It should return TRUE if the
5101  * key/value pair should be removed from the GHashTable.
5102  * key :
5103  * a key.
5104  * value :
5105  * the value associated with the key.
5106  * user_data :
5107  * user data passed to g_hash_table_remove().
5108  * Returns :
5109  * TRUE if the key/value pair should be removed from the
5110  * GHashTable.
5111  */
5112 // gboolean (*GHRFunc) (gpointer key,  gpointer value,  gpointer user_data);
5113 public alias extern(C) int function(void* key, void* value, void* userData) GHRFunc;
5114 
5115 /*
5116  * Specifies the type of function passed to g_tree_traverse(). It is
5117  * passed the key and value of each node, together with the user_data
5118  * parameter passed to g_tree_traverse(). If the function returns
5119  * TRUE, the traversal is stopped.
5120  * key :
5121  * a key of a GTree node.
5122  * value :
5123  * the value corresponding to the key.
5124  * data :
5125  * user data passed to g_tree_traverse().
5126  * Returns :
5127  * TRUE to stop the traversal.
5128  */
5129 // gboolean (*GTraverseFunc) (gpointer key,  gpointer value,  gpointer data);
5130 public alias extern(C) int function(void* key, void* value, void* data) GTraverseFunc;
5131 
5132 /*
5133  * A function of this signature is used to copy the node data
5134  * when doing a deep-copy of a tree.
5135  * src :
5136  * A pointer to the data which should be copied
5137  * data :
5138  * Additional data
5139  * Returns :
5140  * A pointer to the copy
5141  * Since 2.4
5142  */
5143 // gpointer (*GCopyFunc) (gconstpointer src,  gpointer data);
5144 public alias extern(C) void* function(void* src, void* data) GCopyFunc;
5145 
5146 /*
5147  * Specifies the type of function passed to g_node_traverse(). The
5148  * function is called with each of the nodes visited, together with the
5149  * user data passed to g_node_traverse(). If the function returns
5150  * TRUE, then the traversal is stopped.
5151  * node :
5152  * a GNode.
5153  * data :
5154  * user data passed to g_node_traverse().
5155  * Returns :
5156  * TRUE to stop the traversal.
5157  */
5158 // gboolean (*GNodeTraverseFunc) (GNode *node,  gpointer data);
5159 public alias extern(C) int function(GNode* node, void* data) GNodeTraverseFunc;
5160 
5161 /*
5162  * Specifies the type of function passed to g_node_children_foreach().
5163  * The function is called with each child node, together with the user
5164  * data passed to g_node_children_foreach().
5165  * node :
5166  * a GNode.
5167  * data :
5168  * user data passed to g_node_children_foreach().
5169  */
5170 // void (*GNodeForeachFunc) (GNode *node,  gpointer data);
5171 public alias extern(C) void function(GNode* node, void* data) GNodeForeachFunc;
5172 
5173 /*
5174  * Specifies the type of function which is called when a data element
5175  * is destroyed. It is passed the pointer to the data element and
5176  * should free any memory and resources allocated for it.
5177  * data :
5178  * the data element.
5179  */
5180 // void (*GDestroyNotify) (gpointer data);
5181 public alias extern(C) void function(void* data) GDestroyNotify;
5182 
5183 /*
5184  * Specifies the type of function passed to g_dataset_foreach(). It is
5185  * called with each GQuark id and associated data element, together
5186  * with the user_data parameter supplied to g_dataset_foreach().
5187  * key_id :
5188  * the GQuark id to identifying the data element.
5189  * data :
5190  * the data element.
5191  * user_data :
5192  * user data passed to g_dataset_foreach().
5193  */
5194 // void (*GDataForeachFunc) (GQuark key_id,  gpointer data,  gpointer user_data);
5195 public alias extern(C) void function(GQuark keyId, void* data, void* userData) GDataForeachFunc;
5196 
5197 /*
5198  * Specifies the type of the value_destroy_func and key_destroy_func
5199  * functions passed to g_cache_new(). The functions are passed a
5200  * pointer to the GCache key or GCache value and should free any
5201  * memory and other resources associated with it.
5202  * value :
5203  * the GCache value to destroy.
5204  */
5205 // void (*GCacheDestroyFunc) (gpointer value);
5206 public alias extern(C) void function(void* value) GCacheDestroyFunc;
5207 
5208 /*
5209  * Specifies the type of the key_dup_func function passed to
5210  * g_cache_new(). The function is passed a key
5211  * (not a value as the prototype implies) and
5212  * should return a duplicate of the key.
5213  * value :
5214  * the GCache key to destroy (not a
5215  * GCache value as it seems).
5216  * Returns :
5217  * a copy of the GCache key.
5218  */
5219 // gpointer (*GCacheDupFunc) (gpointer value);
5220 public alias extern(C) void* function(void* value) GCacheDupFunc;
5221 
5222 /*
5223  * Specifies the type of the value_new_func function passed to
5224  * g_cache_new(). It is passed a GCache key and should create the
5225  * value corresponding to the key.
5226  * key :
5227  * a GCache key.
5228  * Returns :
5229  * a new GCache value corresponding to the key.
5230  */
5231 // gpointer (*GCacheNewFunc) (gpointer key);
5232 public alias extern(C) void* function(void* key) GCacheNewFunc;
5233 /**
5234  * A union holding the value of the token.
5235  */
5236 public struct GTokenValue
5237 {
5238 	union
5239 	{
5240 		void* vSymbol;
5241 		char *vIdentifier;
5242 		gulong vBinary;
5243 		gulong vOctal;
5244 		gulong vInt;
5245 		ulong vInt64;
5246 		double vFloat;
5247 		gulong vHex;
5248 		char *vString;
5249 		char *vComment;
5250 		char vChar;
5251 		uint vError;
5252 	}
5253 }