1#![crate_name = "glib_2_0_sys"]
4#![crate_type = "lib"]
5#![allow(non_upper_case_globals)] extern crate gtypes;
8extern crate libc;
9
10use gtypes::*;
11
12#[repr(C)]
13pub struct GDate([u32; 2]);
14
15#[repr(C)]
16pub struct GDoubleIEEE754(gdouble);
17
18#[repr(C)]
19pub struct GFloatIEEE754(gfloat);
20
21#[repr(C)]
22pub struct GHookList {
23 pub seq_id: gulong,
24 _hook_size_is_setup: u32,
26 pub hooks: *mut GHook,
27 dummy3: gpointer,
28 pub finalize_hook: Option<GHookFinalizeFunc>,
29 dummy: [gpointer; 2]
30}
31
32#[repr(C)]
33pub struct GIOChannel {
34 ref_count :gint,
35 funcs: *mut GIOFuncs,
36
37 encoding: *mut gchar,
38 read_cd: GIConv,
39 write_cd: GIConv,
40 line_term: *mut gchar,
41 line_term_len: gint,
42
43 buf_size: gsize,
44 read_buf: *mut GString,
45 encoded_read_buf: *mut GString,
46 write_buf: *mut GString,
47
48
49 partial_write_buf: [gchar; 6],
50
51 flags: u16,
54
55 reserved1: gpointer,
56 reserved2: gpointer
57}
58
59#[repr(C)]
62pub enum GIOCondition {
63 In = 1,
64 Out = 4,
65 Pri = 2,
66 Err = 8,
67 Hup = 16,
68 Nval = 32
69}
70pub const G_IO_IN: guint = GIOCondition::In as guint;
71pub const G_IO_OUT: guint = GIOCondition::Out as guint;
72pub const G_IO_PRI: guint = GIOCondition::Pri as guint;
73pub const G_IO_ERR: guint = GIOCondition::Err as guint;
74pub const G_IO_HUP: guint = GIOCondition::Hup as guint;
75pub const G_IO_NVAL: guint = GIOCondition::Nval as guint;
76
77#[cfg(target_pointer_width = "32")]
78#[repr(C)]
79pub struct GMutex([guint; 2]);
80
81#[cfg(target_pointer_width = "64")]
83#[repr(C)]
84pub struct GMutex(gpointer);
85
86#[cfg(unix)]
87pub type GPid = gint;
88
89#[cfg(windows)]
90pub type GPid = *mut libc::c_void;
91
92#[repr(C)]
93pub struct GScannerConfig {
94 pub cset_skip_characters: *mut gchar,
95 pub cset_identifier_first: *mut gchar,
96 pub cset_identifier_nth: *mut gchar,
97 pub cpair_comment_single: *mut gchar,
98
99 flags: u32,
101
102 padding_dummy: guint
103}
104
105#[repr(C)]
106pub struct GTokenValue {
107 v: u64
108}
109
110pub const GLIB_SYSDEF_AF_INET: gint = libc::AF_INET;
111pub const GLIB_SYSDEF_AF_INET6: gint = libc::AF_INET6;
112pub const GLIB_SYSDEF_AF_UNIX: gint = libc::AF_UNIX;
113
114mod consts {
115
116 #[cfg(any(target_os = "linux",
119 target_os = "windows",
120 target_os = "macos",
121 target_os = "freebsd",
122 target_os = "dragonfly",
123 target_os = "openbsd",
124 target_os = "bitrig",
125 target_os = "netbsd",
126 target_os = "android",
127 target_os = "nacl"))]
128 pub mod os {
129
130 use gtypes::*;
131
132 pub const GLIB_SYSDEF_MSG_OOB: gint = 1;
133 pub const GLIB_SYSDEF_MSG_PEEK: gint = 2;
134 pub const GLIB_SYSDEF_MSG_DONTROUTE: gint = 4;
135 }
136
137 #[cfg(all(any(target_arch = "x86",
139 target_arch = "arm",
140 target_arch = "mips",
141 target_arch = "mipsel",
142 target_arch = "powerpc",
143 target_arch = "le32"),
144 not(windows)))]
145 pub mod datamodel {
146 pub const G_GINT16_MODIFIER: &'static [u8] = b"h\0";
147 pub const G_GINT16_FORMAT: &'static [u8] = b"hi\0";
148 pub const G_GUINT16_FORMAT: &'static [u8] = b"hu\0";
149 pub const G_GINT32_MODIFIER: &'static [u8] = b"\0";
150 pub const G_GINT32_FORMAT: &'static [u8] = b"i\0";
151 pub const G_GUINT32_FORMAT: &'static [u8] = b"u\0";
152 pub const G_GINT64_MODIFIER: &'static [u8] = b"ll\0";
153 pub const G_GINT64_FORMAT: &'static [u8] = b"lli\0";
154 pub const G_GUINT64_FORMAT: &'static [u8] = b"llu\0";
155 pub const G_GINTPTR_MODIFIER: &'static [u8] = b"\0";
156 pub const G_GINTPTR_FORMAT: &'static [u8] = b"i\0";
157 pub const G_GUINTPTR_FORMAT: &'static [u8] = b"u\0";
158 pub const G_GSIZE_MODIFIER: &'static [u8] = b"\0";
159 pub const G_GSSIZE_MODIFIER: &'static [u8] = b"\0";
160 pub const G_GSIZE_FORMAT: &'static [u8] = b"u\0";
161 pub const G_GSSIZE_FORMAT: &'static [u8] = b"i\0";
162 }
163
164 #[cfg(all(windows, target_arch = "x86"))]
166 pub mod datamodel {
167 pub const G_GINT16_MODIFIER: &'static [u8] = b"h\0";
168 pub const G_GINT16_FORMAT: &'static [u8] = b"hi\0";
169 pub const G_GUINT16_FORMAT: &'static [u8] = b"hu\0";
170 pub const G_GINT32_MODIFIER: &'static [u8] = b"\0";
171 pub const G_GINT32_FORMAT: &'static [u8] = b"i\0";
172 pub const G_GUINT32_FORMAT: &'static [u8] = b"u\0";
173 pub const G_GINT64_MODIFIER: &'static [u8] = b"I64\0";
174 pub const G_GINT64_FORMAT: &'static [u8] = b"I64i\0";
175 pub const G_GUINT64_FORMAT: &'static [u8] = b"I64u\0";
176 pub const G_GINTPTR_MODIFIER: &'static [u8] = b"\0";
177 pub const G_GINTPTR_FORMAT: &'static [u8] = b"i\0";
178 pub const G_GUINTPTR_FORMAT: &'static [u8] = b"u\0";
179 pub const G_GSIZE_MODIFIER: &'static [u8] = b"\0";
180 pub const G_GSSIZE_MODIFIER: &'static [u8] = b"\0";
181 pub const G_GSIZE_FORMAT: &'static [u8] = b"u\0";
182 pub const G_GSSIZE_FORMAT: &'static [u8] = b"i\0";
183 }
184
185 #[cfg(all(unix,
187 any(target_arch = "x86_64",
188 target_arch = "aarch64")))]
189 pub mod datamodel {
190 pub const G_GINT16_MODIFIER: &'static [u8] = b"h\0";
191 pub const G_GINT16_FORMAT: &'static [u8] = b"hi\0";
192 pub const G_GUINT16_FORMAT: &'static [u8] = b"hu\0";
193 pub const G_GINT32_MODIFIER: &'static [u8] = b"\0";
194 pub const G_GINT32_FORMAT: &'static [u8] = b"i\0";
195 pub const G_GUINT32_FORMAT: &'static [u8] = b"u\0";
196 pub const G_GINT64_MODIFIER: &'static [u8] = b"l\0";
197 pub const G_GINT64_FORMAT: &'static [u8] = b"li\0";
198 pub const G_GUINT64_FORMAT: &'static [u8] = b"lu\0";
199 pub const G_GINTPTR_MODIFIER: &'static [u8] = b"l\0";
200 pub const G_GINTPTR_FORMAT: &'static [u8] = b"li\0";
201 pub const G_GUINTPTR_FORMAT: &'static [u8] = b"lu\0";
202 pub const G_GSIZE_MODIFIER: &'static [u8] = b"l\0";
203 pub const G_GSSIZE_MODIFIER: &'static [u8] = b"l\0";
204 pub const G_GSIZE_FORMAT: &'static [u8] = b"lu\0";
205 pub const G_GSSIZE_FORMAT: &'static [u8] = b"li\0";
206 }
207
208 #[cfg(all(windows, target_arch = "x86_64"))]
210 pub mod datamodel {
211 pub const G_GINT16_MODIFIER: &'static [u8] = b"h\0";
212 pub const G_GINT16_FORMAT: &'static [u8] = b"hi\0";
213 pub const G_GUINT16_FORMAT: &'static [u8] = b"hu\0";
214 pub const G_GINT32_MODIFIER: &'static [u8] = b"\0";
215 pub const G_GINT32_FORMAT: &'static [u8] = b"i\0";
216 pub const G_GUINT32_FORMAT: &'static [u8] = b"u\0";
217 pub const G_GINT64_MODIFIER: &'static [u8] = b"I64\0";
218 pub const G_GINT64_FORMAT: &'static [u8] = b"I64i\0";
219 pub const G_GUINT64_FORMAT: &'static [u8] = b"I64u\0";
220 pub const G_GINTPTR_MODIFIER: &'static [u8] = b"I64\0";
221 pub const G_GINTPTR_FORMAT: &'static [u8] = b"I64i\0";
222 pub const G_GUINTPTR_FORMAT: &'static [u8] = b"I64u\0";
223 pub const G_GSIZE_MODIFIER: &'static [u8] = b"I64\0";
224 pub const G_GSSIZE_MODIFIER: &'static [u8] = b"I64\0";
225 pub const G_GSIZE_FORMAT: &'static [u8] = b"I64u\0";
226 pub const G_GSSIZE_FORMAT: &'static [u8] = b"I64i\0";
227 }
228
229 #[cfg(unix)]
230 pub mod filename {
231 pub const G_DIR_SEPARATOR: u8 = b'/';
232 pub const G_DIR_SEPARATOR_S: &'static [u8] = b"/\0";
233 pub const G_SEARCHPATH_SEPARATOR: u8 = b':';
234 pub const G_SEARCHPATH_SEPARATOR_S: &'static [u8] = b":\0";
235 pub const G_MODULE_SUFFIX: &'static [u8] = b"so\0";
236 }
237
238 #[cfg(windows)]
239 pub mod filename {
240 pub const G_DIR_SEPARATOR: u8 = b'\\';
241 pub const G_DIR_SEPARATOR_S: &'static [u8] = b"\\\0";
242 pub const G_SEARCHPATH_SEPARATOR: u8 = b';';
243 pub const G_SEARCHPATH_SEPARATOR_S: &'static [u8] = b";\0";
244 pub const G_MODULE_SUFFIX: &'static [u8] = b"dll\0";
245 }
246
247 #[cfg(unix)]
248 pub mod pollfd {
249 pub const G_POLLFD_FORMAT: &'static [u8] = b"%d\0";
250 }
251
252 #[cfg(windows)]
253 pub mod pollfd {
254
255 #[cfg(target_arch = "x86")]
256 pub const G_POLLFD_FORMAT: &'static [u8] = b"%#x\0";
257
258 #[cfg(target_arch = "x86_64")]
259 pub const G_POLLFD_FORMAT: &'static [u8] = b"%#I64x\0";
260 }
261}
262
263pub use consts::os::*;
264pub use consts::datamodel::*;
265pub use consts::filename::*;
266pub use consts::pollfd::*;
267
268pub type GDateDay = u8;
269
270pub type GDateYear = u16;
271
272pub type GMutexLocker = gpointer;
273
274pub type GQuark = u32;
275
276pub type GStrv = gpointer;
277
278pub type GTime = i32;
279
280pub type GTimeSpan = i64;
281
282pub const G_ANALYZER_ANALYZING: gint = 1;
283
284pub const G_ASCII_DTOSTR_BUF_SIZE: gint = 39;
285
286#[repr(C)]
287pub struct GArray {
288 pub data: *mut gchar,
289 pub len: guint,
290}
291
292#[repr(C)]
293pub enum GAsciiType {
294 Alnum = 1,
295 Alpha = 2,
296 Cntrl = 4,
297 Digit = 8,
298 Graph = 16,
299 Lower = 32,
300 Print = 64,
301 Punct = 128,
302 Space = 256,
303 Upper = 512,
304 Xdigit = 1024,
305}
306pub const G_ASCII_ALNUM: guint = 1;
307pub const G_ASCII_ALPHA: guint = 2;
308pub const G_ASCII_CNTRL: guint = 4;
309pub const G_ASCII_DIGIT: guint = 8;
310pub const G_ASCII_GRAPH: guint = 16;
311pub const G_ASCII_LOWER: guint = 32;
312pub const G_ASCII_PRINT: guint = 64;
313pub const G_ASCII_PUNCT: guint = 128;
314pub const G_ASCII_SPACE: guint = 256;
315pub const G_ASCII_UPPER: guint = 512;
316pub const G_ASCII_XDIGIT: guint = 1024;
317
318#[repr(C)]
319pub struct GAsyncQueue(gpointer);
320
321pub const G_BIG_ENDIAN: gint = 4321;
322
323#[repr(C)]
324pub struct GBookmarkFile(gpointer);
325
326#[repr(C)]
327pub enum GBookmarkFileError {
328 InvalidUri = 0,
329 InvalidValue = 1,
330 AppNotRegistered = 2,
331 UriNotFound = 3,
332 Read = 4,
333 UnknownEncoding = 5,
334 Write = 6,
335 FileNotFound = 7,
336}
337pub const G_BOOKMARK_FILE_ERROR_INVALID_URI: GBookmarkFileError = GBookmarkFileError::InvalidUri;
338pub const G_BOOKMARK_FILE_ERROR_INVALID_VALUE: GBookmarkFileError = GBookmarkFileError::InvalidValue;
339pub const G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED: GBookmarkFileError = GBookmarkFileError::AppNotRegistered;
340pub const G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND: GBookmarkFileError = GBookmarkFileError::UriNotFound;
341pub const G_BOOKMARK_FILE_ERROR_READ: GBookmarkFileError = GBookmarkFileError::Read;
342pub const G_BOOKMARK_FILE_ERROR_UNKNOWN_ENCODING: GBookmarkFileError = GBookmarkFileError::UnknownEncoding;
343pub const G_BOOKMARK_FILE_ERROR_WRITE: GBookmarkFileError = GBookmarkFileError::Write;
344pub const G_BOOKMARK_FILE_ERROR_FILE_NOT_FOUND: GBookmarkFileError = GBookmarkFileError::FileNotFound;
345
346#[repr(C)]
347pub struct GByteArray {
348 pub data: u8,
349 pub len: guint,
350}
351
352pub enum GBytes { }
353
354pub const G_CSET_A_2_Z: &'static [u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\0";
355
356pub const G_CSET_DIGITS: &'static [u8] = b"0123456789\0";
357
358pub const G_CSET_a_2_z: &'static [u8] = b"abcdefghijklmnopqrstuvwxyz\0";
359
360pub enum GChecksum { }
361
362#[repr(C)]
363pub enum GChecksumType {
364 Md5 = 0,
365 Sha1 = 1,
366 Sha256 = 2,
367 Sha512 = 3,
368}
369pub const G_CHECKSUM_MD5: GChecksumType = GChecksumType::Md5;
370pub const G_CHECKSUM_SHA1: GChecksumType = GChecksumType::Sha1;
371pub const G_CHECKSUM_SHA256: GChecksumType = GChecksumType::Sha256;
372pub const G_CHECKSUM_SHA512: GChecksumType = GChecksumType::Sha512;
373
374pub type GChildWatchFunc = extern "C" fn (GPid, gint, gpointer);
375
376pub type GCompareDataFunc = extern "C" fn (gconstpointer, gconstpointer, gpointer) -> gint;
377
378pub type GCompareFunc = extern "C" fn (gconstpointer, gconstpointer) -> gint;
379
380#[repr(C)]
381pub struct GCond {
382 p: gpointer,
383 i: [guint; 2],
384}
385
386#[repr(C)]
387pub enum GConvertError {
388 NoConversion = 0,
389 IllegalSequence = 1,
390 Failed = 2,
391 PartialInput = 3,
392 BadUri = 4,
393 NotAbsolutePath = 5,
394 NoMemory = 6,
395}
396pub const G_CONVERT_ERROR_NO_CONVERSION: GConvertError = GConvertError::NoConversion;
397pub const G_CONVERT_ERROR_ILLEGAL_SEQUENCE: GConvertError = GConvertError::IllegalSequence;
398pub const G_CONVERT_ERROR_FAILED: GConvertError = GConvertError::Failed;
399pub const G_CONVERT_ERROR_PARTIAL_INPUT: GConvertError = GConvertError::PartialInput;
400pub const G_CONVERT_ERROR_BAD_URI: GConvertError = GConvertError::BadUri;
401pub const G_CONVERT_ERROR_NOT_ABSOLUTE_PATH: GConvertError = GConvertError::NotAbsolutePath;
402pub const G_CONVERT_ERROR_NO_MEMORY: GConvertError = GConvertError::NoMemory;
403
404pub type GCopyFunc = extern "C" fn (gconstpointer, gpointer) -> gpointer;
405
406pub const G_DATALIST_FLAGS_MASK: gint = 3;
407
408pub const G_DATE_BAD_DAY: gint = 0;
409
410pub const G_DATE_BAD_JULIAN: gint = 0;
411
412pub const G_DATE_BAD_YEAR: gint = 0;
413
414#[repr(C)]
415pub struct GData(gpointer);
416
417pub type GDataForeachFunc = extern "C" fn (GQuark, gpointer, gpointer);
418
419#[repr(C)]
420pub enum GDateDMY {
421 Day = 0,
422 Month = 1,
423 Year = 2,
424}
425pub const G_DATE_DAY: GDateDMY = GDateDMY::Day;
426pub const G_DATE_MONTH: GDateDMY = GDateDMY::Month;
427pub const G_DATE_YEAR: GDateDMY = GDateDMY::Year;
428
429#[repr(C)]
430pub enum GDateMonth {
431 BadMonth = 0,
432 January = 1,
433 February = 2,
434 March = 3,
435 April = 4,
436 May = 5,
437 June = 6,
438 July = 7,
439 August = 8,
440 September = 9,
441 October = 10,
442 November = 11,
443 December = 12,
444}
445pub const G_DATE_BAD_MONTH: GDateMonth = GDateMonth::BadMonth;
446pub const G_DATE_JANUARY: GDateMonth = GDateMonth::January;
447pub const G_DATE_FEBRUARY: GDateMonth = GDateMonth::February;
448pub const G_DATE_MARCH: GDateMonth = GDateMonth::March;
449pub const G_DATE_APRIL: GDateMonth = GDateMonth::April;
450pub const G_DATE_MAY: GDateMonth = GDateMonth::May;
451pub const G_DATE_JUNE: GDateMonth = GDateMonth::June;
452pub const G_DATE_JULY: GDateMonth = GDateMonth::July;
453pub const G_DATE_AUGUST: GDateMonth = GDateMonth::August;
454pub const G_DATE_SEPTEMBER: GDateMonth = GDateMonth::September;
455pub const G_DATE_OCTOBER: GDateMonth = GDateMonth::October;
456pub const G_DATE_NOVEMBER: GDateMonth = GDateMonth::November;
457pub const G_DATE_DECEMBER: GDateMonth = GDateMonth::December;
458
459pub enum GDateTime { }
460
461#[repr(C)]
462pub enum GDateWeekday {
463 BadWeekday = 0,
464 Monday = 1,
465 Tuesday = 2,
466 Wednesday = 3,
467 Thursday = 4,
468 Friday = 5,
469 Saturday = 6,
470 Sunday = 7,
471}
472pub const G_DATE_BAD_WEEKDAY: GDateWeekday = GDateWeekday::BadWeekday;
473pub const G_DATE_MONDAY: GDateWeekday = GDateWeekday::Monday;
474pub const G_DATE_TUESDAY: GDateWeekday = GDateWeekday::Tuesday;
475pub const G_DATE_WEDNESDAY: GDateWeekday = GDateWeekday::Wednesday;
476pub const G_DATE_THURSDAY: GDateWeekday = GDateWeekday::Thursday;
477pub const G_DATE_FRIDAY: GDateWeekday = GDateWeekday::Friday;
478pub const G_DATE_SATURDAY: GDateWeekday = GDateWeekday::Saturday;
479pub const G_DATE_SUNDAY: GDateWeekday = GDateWeekday::Sunday;
480
481#[repr(C)]
482pub struct GDebugKey {
483 pub key: *const gchar,
484 pub value: guint,
485}
486
487pub type GDestroyNotify = extern "C" fn (gpointer);
488
489#[repr(C)]
490pub struct GDir(gpointer);
491
492pub type GDuplicateFunc = extern "C" fn (gpointer, gpointer) -> gpointer;
493
494pub const G_E: gdouble = 2.718282;
495
496pub type GEqualFunc = extern "C" fn (gconstpointer, gconstpointer) -> gboolean;
497
498#[repr(C)]
499pub struct GError {
500 pub domain: GQuark,
501 pub code: gint,
502 pub message: *mut gchar,
503}
504
505#[repr(C)]
506pub enum GErrorType {
507 Unknown = 0,
508 UnexpEof = 1,
509 UnexpEofInString = 2,
510 UnexpEofInComment = 3,
511 NonDigitInConst = 4,
512 DigitRadix = 5,
513 FloatRadix = 6,
514 FloatMalformed = 7,
515}
516pub const G_ERR_UNKNOWN: GErrorType = GErrorType::Unknown;
517pub const G_ERR_UNEXP_EOF: GErrorType = GErrorType::UnexpEof;
518pub const G_ERR_UNEXP_EOF_IN_STRING: GErrorType = GErrorType::UnexpEofInString;
519pub const G_ERR_UNEXP_EOF_IN_COMMENT: GErrorType = GErrorType::UnexpEofInComment;
520pub const G_ERR_NON_DIGIT_IN_CONST: GErrorType = GErrorType::NonDigitInConst;
521pub const G_ERR_DIGIT_RADIX: GErrorType = GErrorType::DigitRadix;
522pub const G_ERR_FLOAT_RADIX: GErrorType = GErrorType::FloatRadix;
523pub const G_ERR_FLOAT_MALFORMED: GErrorType = GErrorType::FloatMalformed;
524
525#[repr(C)]
526pub enum GFileError {
527 Exist = 0,
528 Isdir = 1,
529 Acces = 2,
530 Nametoolong = 3,
531 Noent = 4,
532 Notdir = 5,
533 Nxio = 6,
534 Nodev = 7,
535 Rofs = 8,
536 Txtbsy = 9,
537 Fault = 10,
538 Loop = 11,
539 Nospc = 12,
540 Nomem = 13,
541 Mfile = 14,
542 Nfile = 15,
543 Badf = 16,
544 Inval = 17,
545 Pipe = 18,
546 Again = 19,
547 Intr = 20,
548 Io = 21,
549 Perm = 22,
550 Nosys = 23,
551 Failed = 24,
552}
553pub const G_FILE_ERROR_EXIST: GFileError = GFileError::Exist;
554pub const G_FILE_ERROR_ISDIR: GFileError = GFileError::Isdir;
555pub const G_FILE_ERROR_ACCES: GFileError = GFileError::Acces;
556pub const G_FILE_ERROR_NAMETOOLONG: GFileError = GFileError::Nametoolong;
557pub const G_FILE_ERROR_NOENT: GFileError = GFileError::Noent;
558pub const G_FILE_ERROR_NOTDIR: GFileError = GFileError::Notdir;
559pub const G_FILE_ERROR_NXIO: GFileError = GFileError::Nxio;
560pub const G_FILE_ERROR_NODEV: GFileError = GFileError::Nodev;
561pub const G_FILE_ERROR_ROFS: GFileError = GFileError::Rofs;
562pub const G_FILE_ERROR_TXTBSY: GFileError = GFileError::Txtbsy;
563pub const G_FILE_ERROR_FAULT: GFileError = GFileError::Fault;
564pub const G_FILE_ERROR_LOOP: GFileError = GFileError::Loop;
565pub const G_FILE_ERROR_NOSPC: GFileError = GFileError::Nospc;
566pub const G_FILE_ERROR_NOMEM: GFileError = GFileError::Nomem;
567pub const G_FILE_ERROR_MFILE: GFileError = GFileError::Mfile;
568pub const G_FILE_ERROR_NFILE: GFileError = GFileError::Nfile;
569pub const G_FILE_ERROR_BADF: GFileError = GFileError::Badf;
570pub const G_FILE_ERROR_INVAL: GFileError = GFileError::Inval;
571pub const G_FILE_ERROR_PIPE: GFileError = GFileError::Pipe;
572pub const G_FILE_ERROR_AGAIN: GFileError = GFileError::Again;
573pub const G_FILE_ERROR_INTR: GFileError = GFileError::Intr;
574pub const G_FILE_ERROR_IO: GFileError = GFileError::Io;
575pub const G_FILE_ERROR_PERM: GFileError = GFileError::Perm;
576pub const G_FILE_ERROR_NOSYS: GFileError = GFileError::Nosys;
577pub const G_FILE_ERROR_FAILED: GFileError = GFileError::Failed;
578
579#[repr(C)]
580pub enum GFileTest {
581 IsRegular = 1,
582 IsSymlink = 2,
583 IsDir = 4,
584 IsExecutable = 8,
585 Exists = 16,
586}
587pub const G_FILE_TEST_IS_REGULAR: guint = 1;
588pub const G_FILE_TEST_IS_SYMLINK: guint = 2;
589pub const G_FILE_TEST_IS_DIR: guint = 4;
590pub const G_FILE_TEST_IS_EXECUTABLE: guint = 8;
591pub const G_FILE_TEST_EXISTS: guint = 16;
592
593#[repr(C)]
594pub enum GFormatSizeFlags {
595 Default = 0,
596 LongFormat = 1,
597 IecUnits = 2,
598}
599pub const G_FORMAT_SIZE_DEFAULT: guint = 0;
600pub const G_FORMAT_SIZE_LONG_FORMAT: guint = 1;
601pub const G_FORMAT_SIZE_IEC_UNITS: guint = 2;
602
603pub type GFreeFunc = extern "C" fn (gpointer);
604
605pub type GFunc = extern "C" fn (gpointer, gpointer);
606
607pub const G_GNUC_FUNCTION: &'static [u8] = b"\0";
608
609pub const G_GNUC_PRETTY_FUNCTION: &'static [u8] = b"\0";
610
611pub type GHFunc = extern "C" fn (gpointer, gpointer, gpointer);
612
613pub const G_HOOK_FLAG_USER_SHIFT: gint = 4;
614
615pub type GHRFunc = extern "C" fn (gpointer, gpointer, gpointer) -> gboolean;
616
617pub type GHashFunc = extern "C" fn (gconstpointer) -> guint;
618
619pub enum GHashTable { }
620
621#[repr(C)]
622pub struct GHashTableIter {
623 dummy1: gpointer,
624 dummy2: gpointer,
625 dummy3: gpointer,
626 dummy4: gint,
627 dummy5: gboolean,
628 dummy6: gpointer,
629}
630
631#[repr(C)]
632pub struct GHmac(gpointer);
633
634#[repr(C)]
635pub struct GHook {
636 pub data: gpointer,
637 pub next: *mut GHook,
638 pub prev: *mut GHook,
639 pub ref_count: guint,
640 pub hook_id: gulong,
641 pub flags: guint,
642 pub func: gpointer,
643 pub destroy: Option<GDestroyNotify>,
644}
645
646pub type GHookCheckFunc = extern "C" fn (gpointer) -> gboolean;
647
648pub type GHookCheckMarshaller = extern "C" fn (*mut GHook, gpointer) -> gboolean;
649
650pub type GHookCompareFunc = extern "C" fn (*mut GHook, *mut GHook) -> gint;
651
652pub type GHookFinalizeFunc = extern "C" fn (*mut GHookList, *mut GHook);
653
654pub type GHookFindFunc = extern "C" fn (*mut GHook, gpointer) -> gboolean;
655
656#[repr(C)]
657pub enum GHookFlagMask {
658 Active = 1,
659 InCall = 2,
660 Mask = 15,
661}
662pub const G_HOOK_FLAG_ACTIVE: guint = 1;
663pub const G_HOOK_FLAG_IN_CALL: guint = 2;
664pub const G_HOOK_FLAG_MASK: guint = 15;
665
666pub type GHookFunc = extern "C" fn (gpointer);
667
668pub type GHookMarshaller = extern "C" fn (*mut GHook, gpointer);
669
670#[repr(C)]
671pub struct GIConv(gpointer);
672
673pub const G_IEEE754_DOUBLE_BIAS: gint = 1023;
674
675pub const G_IEEE754_FLOAT_BIAS: gint = 127;
676
677#[repr(C)]
678pub enum GIOChannelError {
679 Fbig = 0,
680 Inval = 1,
681 Io = 2,
682 Isdir = 3,
683 Nospc = 4,
684 Nxio = 5,
685 Overflow = 6,
686 Pipe = 7,
687 Failed = 8,
688}
689pub const G_IO_CHANNEL_ERROR_FBIG: GIOChannelError = GIOChannelError::Fbig;
690pub const G_IO_CHANNEL_ERROR_INVAL: GIOChannelError = GIOChannelError::Inval;
691pub const G_IO_CHANNEL_ERROR_IO: GIOChannelError = GIOChannelError::Io;
692pub const G_IO_CHANNEL_ERROR_ISDIR: GIOChannelError = GIOChannelError::Isdir;
693pub const G_IO_CHANNEL_ERROR_NOSPC: GIOChannelError = GIOChannelError::Nospc;
694pub const G_IO_CHANNEL_ERROR_NXIO: GIOChannelError = GIOChannelError::Nxio;
695pub const G_IO_CHANNEL_ERROR_OVERFLOW: GIOChannelError = GIOChannelError::Overflow;
696pub const G_IO_CHANNEL_ERROR_PIPE: GIOChannelError = GIOChannelError::Pipe;
697pub const G_IO_CHANNEL_ERROR_FAILED: GIOChannelError = GIOChannelError::Failed;
698
699#[repr(C)]
700pub enum GIOError {
701 None = 0,
702 Again = 1,
703 Inval = 2,
704 Unknown = 3,
705}
706pub const G_IO_ERROR_NONE: GIOError = GIOError::None;
707pub const G_IO_ERROR_AGAIN: GIOError = GIOError::Again;
708pub const G_IO_ERROR_INVAL: GIOError = GIOError::Inval;
709pub const G_IO_ERROR_UNKNOWN: GIOError = GIOError::Unknown;
710
711#[repr(C)]
712pub enum GIOFlags {
713 Append = 1,
714 Nonblock = 2,
715 SetMask = 3,
716 IsReadable = 4,
717 IsWritable = 8,
718 IsSeekable = 16,
719 Mask = 31,
720}
721pub const G_IO_FLAG_APPEND: guint = 1;
722pub const G_IO_FLAG_NONBLOCK: guint = 2;
723pub const G_IO_FLAG_IS_READABLE: guint = 4;
724pub const G_IO_FLAG_IS_WRITABLE: guint = 8;
725pub const G_IO_FLAG_IS_WRITEABLE: guint = 8;
726pub const G_IO_FLAG_IS_SEEKABLE: guint = 16;
727pub const G_IO_FLAG_MASK: guint = 31;
728pub const G_IO_FLAG_GET_MASK: guint = 31;
729pub const G_IO_FLAG_SET_MASK: guint = 3;
730
731pub type GIOFunc = extern "C" fn (*mut GIOChannel, GIOCondition, gpointer) -> gboolean;
732
733#[repr(C)]
734pub struct GIOFuncs {
735 pub io_read: Option<extern "C" fn (*mut GIOChannel, *mut gchar, gsize, gsize, *mut *mut GError) -> GIOStatus>,
736 pub io_write: Option<extern "C" fn (*mut GIOChannel, *const gchar, gsize, gsize, *mut *mut GError) -> GIOStatus>,
737 pub io_seek: Option<extern "C" fn (*mut GIOChannel, i64, GSeekType, *mut *mut GError) -> GIOStatus>,
738 pub io_close: Option<extern "C" fn (*mut GIOChannel, *mut *mut GError) -> GIOStatus>,
739 pub io_create_watch: Option<extern "C" fn (*mut GIOChannel, GIOCondition) -> *mut GSource>,
740 pub io_free: Option<extern "C" fn (*mut GIOChannel)>,
741 pub io_set_flags: Option<extern "C" fn (*mut GIOChannel, GIOFlags, *mut *mut GError) -> GIOStatus>,
742 pub io_get_flags: Option<extern "C" fn (*mut GIOChannel) -> GIOFlags>,
743}
744
745#[repr(C)]
746pub enum GIOStatus {
747 Error = 0,
748 Normal = 1,
749 Eof = 2,
750 Again = 3,
751}
752pub const G_IO_STATUS_ERROR: GIOStatus = GIOStatus::Error;
753pub const G_IO_STATUS_NORMAL: GIOStatus = GIOStatus::Normal;
754pub const G_IO_STATUS_EOF: GIOStatus = GIOStatus::Eof;
755pub const G_IO_STATUS_AGAIN: GIOStatus = GIOStatus::Again;
756
757pub const G_KEY_FILE_DESKTOP_GROUP: &'static [u8] = b"Desktop Entry\0";
758
759pub const G_KEY_FILE_DESKTOP_KEY_ACTIONS: &'static [u8] = b"Actions\0";
760
761pub const G_KEY_FILE_DESKTOP_KEY_CATEGORIES: &'static [u8] = b"Categories\0";
762
763pub const G_KEY_FILE_DESKTOP_KEY_COMMENT: &'static [u8] = b"Comment\0";
764
765pub const G_KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE: &'static [u8] = b"DBusActivatable\0";
766
767pub const G_KEY_FILE_DESKTOP_KEY_EXEC: &'static [u8] = b"Exec\0";
768
769pub const G_KEY_FILE_DESKTOP_KEY_GENERIC_NAME: &'static [u8] = b"GenericName\0";
770
771pub const G_KEY_FILE_DESKTOP_KEY_HIDDEN: &'static [u8] = b"Hidden\0";
772
773pub const G_KEY_FILE_DESKTOP_KEY_ICON: &'static [u8] = b"Icon\0";
774
775pub const G_KEY_FILE_DESKTOP_KEY_MIME_TYPE: &'static [u8] = b"MimeType\0";
776
777pub const G_KEY_FILE_DESKTOP_KEY_NAME: &'static [u8] = b"Name\0";
778
779pub const G_KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN: &'static [u8] = b"NotShowIn\0";
780
781pub const G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY: &'static [u8] = b"NoDisplay\0";
782
783pub const G_KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN: &'static [u8] = b"OnlyShowIn\0";
784
785pub const G_KEY_FILE_DESKTOP_KEY_PATH: &'static [u8] = b"Path\0";
786
787pub const G_KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY: &'static [u8] = b"StartupNotify\0";
788
789pub const G_KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS: &'static [u8] = b"StartupWMClass\0";
790
791pub const G_KEY_FILE_DESKTOP_KEY_TERMINAL: &'static [u8] = b"Terminal\0";
792
793pub const G_KEY_FILE_DESKTOP_KEY_TRY_EXEC: &'static [u8] = b"TryExec\0";
794
795pub const G_KEY_FILE_DESKTOP_KEY_TYPE: &'static [u8] = b"Type\0";
796
797pub const G_KEY_FILE_DESKTOP_KEY_URL: &'static [u8] = b"URL\0";
798
799pub const G_KEY_FILE_DESKTOP_KEY_VERSION: &'static [u8] = b"Version\0";
800
801pub const G_KEY_FILE_DESKTOP_TYPE_APPLICATION: &'static [u8] = b"Application\0";
802
803pub const G_KEY_FILE_DESKTOP_TYPE_DIRECTORY: &'static [u8] = b"Directory\0";
804
805pub const G_KEY_FILE_DESKTOP_TYPE_LINK: &'static [u8] = b"Link\0";
806
807pub enum GKeyFile { }
808
809#[repr(C)]
810pub enum GKeyFileError {
811 UnknownEncoding = 0,
812 Parse = 1,
813 NotFound = 2,
814 KeyNotFound = 3,
815 GroupNotFound = 4,
816 InvalidValue = 5,
817}
818pub const G_KEY_FILE_ERROR_UNKNOWN_ENCODING: GKeyFileError = GKeyFileError::UnknownEncoding;
819pub const G_KEY_FILE_ERROR_PARSE: GKeyFileError = GKeyFileError::Parse;
820pub const G_KEY_FILE_ERROR_NOT_FOUND: GKeyFileError = GKeyFileError::NotFound;
821pub const G_KEY_FILE_ERROR_KEY_NOT_FOUND: GKeyFileError = GKeyFileError::KeyNotFound;
822pub const G_KEY_FILE_ERROR_GROUP_NOT_FOUND: GKeyFileError = GKeyFileError::GroupNotFound;
823pub const G_KEY_FILE_ERROR_INVALID_VALUE: GKeyFileError = GKeyFileError::InvalidValue;
824
825#[repr(C)]
826pub enum GKeyFileFlags {
827 None = 0,
828 KeepComments = 1,
829 KeepTranslations = 2,
830}
831pub const G_KEY_FILE_NONE: guint = 0;
832pub const G_KEY_FILE_KEEP_COMMENTS: guint = 1;
833pub const G_KEY_FILE_KEEP_TRANSLATIONS: guint = 2;
834
835pub const G_LITTLE_ENDIAN: gint = 1234;
836
837pub const G_LN10: gdouble = 2.302585;
838
839pub const G_LN2: gdouble = 0.693147;
840
841pub const G_LOG_2_BASE_10: gdouble = 0.301030;
842
843pub const G_LOG_DOMAIN: gchar = 0;
844
845pub const G_LOG_FATAL_MASK: gint = 0;
846
847pub const G_LOG_LEVEL_USER_SHIFT: gint = 8;
848
849#[repr(C)]
850pub struct GList {
851 pub data: gpointer,
852 pub next: *mut GList,
853 pub prev: *mut GList,
854}
855
856pub type GLogFunc = extern "C" fn (*const gchar, GLogLevelFlags, *const gchar, gpointer);
857
858#[repr(C)]
859pub enum GLogLevelFlags {
860 LevelMask = -4,
861 FlagRecursion = 1,
862 FlagFatal = 2,
863 LevelError = 4,
864 LevelCritical = 8,
865 LevelWarning = 16,
866 LevelMessage = 32,
867 LevelInfo = 64,
868 LevelDebug = 128,
869}
870pub const G_LOG_FLAG_RECURSION: guint = 1;
871pub const G_LOG_FLAG_FATAL: guint = 2;
872pub const G_LOG_LEVEL_ERROR: guint = 4;
873pub const G_LOG_LEVEL_CRITICAL: guint = 8;
874pub const G_LOG_LEVEL_WARNING: guint = 16;
875pub const G_LOG_LEVEL_MESSAGE: guint = 32;
876pub const G_LOG_LEVEL_INFO: guint = 64;
877pub const G_LOG_LEVEL_DEBUG: guint = 128;
878pub const G_LOG_LEVEL_MASK: guint = -4i64 as guint;
879
880pub const GLIB_MAJOR_VERSION: gint = 2;
881
882pub const G_MAXINT16: i16 = 32767;
883
884pub const G_MAXINT32: i32 = 2147483647;
885
886pub const G_MAXINT64: i64 = 9223372036854775807;
887
888pub const G_MAXINT8: i8 = 127;
889
890pub const G_MAXUINT16: u16 = 65535;
891
892pub const G_MAXUINT32: u32 = 4294967295;
893
894pub const G_MAXUINT64: u64 = 18446744073709551615;
895
896pub const G_MAXUINT8: u8 = 255;
897
898pub const GLIB_MICRO_VERSION: gint = 2;
899
900pub const G_MININT16: i16 = -32768;
901
902pub const G_MININT32: i32 = -2147483648;
903
904pub const G_MININT64: i64 = -9223372036854775808;
905
906pub const G_MININT8: i8 = -128;
907
908pub const GLIB_MINOR_VERSION: gint = 46;
909
910pub enum GMainContext { }
911
912pub enum GMainLoop { }
913
914pub enum GMappedFile { }
915
916#[repr(C)]
917pub enum GMarkupCollectType {
918 Invalid = 0,
919 String = 1,
920 Strdup = 2,
921 Boolean = 3,
922 Tristate = 4,
923 Optional = 65536,
924}
925pub const G_MARKUP_COLLECT_INVALID: guint = 0;
926pub const G_MARKUP_COLLECT_STRING: guint = 1;
927pub const G_MARKUP_COLLECT_STRDUP: guint = 2;
928pub const G_MARKUP_COLLECT_BOOLEAN: guint = 3;
929pub const G_MARKUP_COLLECT_TRISTATE: guint = 4;
930pub const G_MARKUP_COLLECT_OPTIONAL: guint = 65536;
931
932#[repr(C)]
933pub enum GMarkupError {
934 BadUtf8 = 0,
935 Empty = 1,
936 Parse = 2,
937 UnknownElement = 3,
938 UnknownAttribute = 4,
939 InvalidContent = 5,
940 MissingAttribute = 6,
941}
942pub const G_MARKUP_ERROR_BAD_UTF8: GMarkupError = GMarkupError::BadUtf8;
943pub const G_MARKUP_ERROR_EMPTY: GMarkupError = GMarkupError::Empty;
944pub const G_MARKUP_ERROR_PARSE: GMarkupError = GMarkupError::Parse;
945pub const G_MARKUP_ERROR_UNKNOWN_ELEMENT: GMarkupError = GMarkupError::UnknownElement;
946pub const G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE: GMarkupError = GMarkupError::UnknownAttribute;
947pub const G_MARKUP_ERROR_INVALID_CONTENT: GMarkupError = GMarkupError::InvalidContent;
948pub const G_MARKUP_ERROR_MISSING_ATTRIBUTE: GMarkupError = GMarkupError::MissingAttribute;
949
950pub enum GMarkupParseContext { }
951
952#[repr(C)]
953pub enum GMarkupParseFlags {
954 DoNotUseThisUnsupportedFlag = 1,
955 TreatCdataAsText = 2,
956 PrefixErrorPosition = 4,
957 IgnoreQualified = 8,
958}
959pub const G_MARKUP_DO_NOT_USE_THIS_UNSUPPORTED_FLAG: guint = 1;
960pub const G_MARKUP_TREAT_CDATA_AS_TEXT: guint = 2;
961pub const G_MARKUP_PREFIX_ERROR_POSITION: guint = 4;
962pub const G_MARKUP_IGNORE_QUALIFIED: guint = 8;
963
964#[repr(C)]
965pub struct GMarkupParser {
966 pub start_element: Option<extern "C" fn (*mut GMarkupParseContext, *const gchar, *mut *const gchar, *mut *const gchar, gpointer, *mut *mut GError)>,
967 pub end_element: Option<extern "C" fn (*mut GMarkupParseContext, *const gchar, gpointer, *mut *mut GError)>,
968 pub text: Option<extern "C" fn (*mut GMarkupParseContext, *const gchar, gsize, gpointer, *mut *mut GError)>,
969 pub passthrough: Option<extern "C" fn (*mut GMarkupParseContext, *const gchar, gsize, gpointer, *mut *mut GError)>,
970 pub error: Option<extern "C" fn (*mut GMarkupParseContext, *mut GError, gpointer)>,
971}
972
973pub enum GMatchInfo { }
974
975#[repr(C)]
976pub struct GMemVTable {
977 pub malloc: Option<extern "C" fn (gsize) -> gpointer>,
978 pub realloc: Option<extern "C" fn (gpointer, gsize) -> gpointer>,
979 pub free: Option<extern "C" fn (gpointer)>,
980 pub calloc: Option<extern "C" fn (gsize, gsize) -> gpointer>,
981 pub try_malloc: Option<extern "C" fn (gsize) -> gpointer>,
982 pub try_realloc: Option<extern "C" fn (gpointer, gsize) -> gpointer>,
983}
984
985#[repr(C)]
986pub struct GNode {
987 pub data: gpointer,
988 pub next: *mut GNode,
989 pub prev: *mut GNode,
990 pub parent: *mut GNode,
991 pub children: *mut GNode,
992}
993
994pub type GNodeForeachFunc = extern "C" fn (*mut GNode, gpointer);
995
996pub type GNodeTraverseFunc = extern "C" fn (*mut GNode, gpointer) -> gboolean;
997
998#[repr(C)]
999pub enum GNormalizeMode {
1000 Default = 0,
1001 DefaultCompose = 1,
1002 All = 2,
1003 AllCompose = 3,
1004}
1005pub const G_NORMALIZE_DEFAULT: GNormalizeMode = GNormalizeMode::Default;
1006pub const G_NORMALIZE_NFD: GNormalizeMode = GNormalizeMode::Default;
1007pub const G_NORMALIZE_DEFAULT_COMPOSE: GNormalizeMode = GNormalizeMode::DefaultCompose;
1008pub const G_NORMALIZE_NFC: GNormalizeMode = GNormalizeMode::DefaultCompose;
1009pub const G_NORMALIZE_ALL: GNormalizeMode = GNormalizeMode::All;
1010pub const G_NORMALIZE_NFKD: GNormalizeMode = GNormalizeMode::All;
1011pub const G_NORMALIZE_ALL_COMPOSE: GNormalizeMode = GNormalizeMode::AllCompose;
1012pub const G_NORMALIZE_NFKC: GNormalizeMode = GNormalizeMode::AllCompose;
1013
1014pub const G_OPTION_REMAINING: &'static [u8] = b"\0";
1015
1016#[repr(C)]
1017pub struct GOnce {
1018 pub status: GOnceStatus,
1019 pub retval: gpointer,
1020}
1021
1022#[repr(C)]
1023pub enum GOnceStatus {
1024 Notcalled = 0,
1025 Progress = 1,
1026 Ready = 2,
1027}
1028pub const G_ONCE_STATUS_NOTCALLED: GOnceStatus = GOnceStatus::Notcalled;
1029pub const G_ONCE_STATUS_PROGRESS: GOnceStatus = GOnceStatus::Progress;
1030pub const G_ONCE_STATUS_READY: GOnceStatus = GOnceStatus::Ready;
1031
1032#[repr(C)]
1033pub enum GOptionArg {
1034 None = 0,
1035 String = 1,
1036 Int = 2,
1037 Callback = 3,
1038 Filename = 4,
1039 StringArray = 5,
1040 FilenameArray = 6,
1041 Double = 7,
1042 Int64 = 8,
1043}
1044pub const G_OPTION_ARG_NONE: GOptionArg = GOptionArg::None;
1045pub const G_OPTION_ARG_STRING: GOptionArg = GOptionArg::String;
1046pub const G_OPTION_ARG_INT: GOptionArg = GOptionArg::Int;
1047pub const G_OPTION_ARG_CALLBACK: GOptionArg = GOptionArg::Callback;
1048pub const G_OPTION_ARG_FILENAME: GOptionArg = GOptionArg::Filename;
1049pub const G_OPTION_ARG_STRING_ARRAY: GOptionArg = GOptionArg::StringArray;
1050pub const G_OPTION_ARG_FILENAME_ARRAY: GOptionArg = GOptionArg::FilenameArray;
1051pub const G_OPTION_ARG_DOUBLE: GOptionArg = GOptionArg::Double;
1052pub const G_OPTION_ARG_INT64: GOptionArg = GOptionArg::Int64;
1053
1054pub type GOptionArgFunc = extern "C" fn (*const gchar, *const gchar, gpointer, *mut *mut GError) -> gboolean;
1055
1056#[repr(C)]
1057pub struct GOptionContext(gpointer);
1058
1059#[repr(C)]
1060pub struct GOptionEntry {
1061 pub long_name: *const gchar,
1062 pub short_name: gchar,
1063 pub flags: gint,
1064 pub arg: GOptionArg,
1065 pub arg_data: gpointer,
1066 pub description: *const gchar,
1067 pub arg_description: *const gchar,
1068}
1069
1070#[repr(C)]
1071pub enum GOptionError {
1072 UnknownOption = 0,
1073 BadValue = 1,
1074 Failed = 2,
1075}
1076pub const G_OPTION_ERROR_UNKNOWN_OPTION: GOptionError = GOptionError::UnknownOption;
1077pub const G_OPTION_ERROR_BAD_VALUE: GOptionError = GOptionError::BadValue;
1078pub const G_OPTION_ERROR_FAILED: GOptionError = GOptionError::Failed;
1079
1080pub type GOptionErrorFunc = extern "C" fn (*mut GOptionContext, *mut GOptionGroup, gpointer, *mut *mut GError);
1081
1082#[repr(C)]
1083pub enum GOptionFlags {
1084 None = 0,
1085 Hidden = 1,
1086 InMain = 2,
1087 Reverse = 4,
1088 NoArg = 8,
1089 Filename = 16,
1090 OptionalArg = 32,
1091 Noalias = 64,
1092}
1093pub const G_OPTION_FLAG_NONE: guint = 0;
1094pub const G_OPTION_FLAG_HIDDEN: guint = 1;
1095pub const G_OPTION_FLAG_IN_MAIN: guint = 2;
1096pub const G_OPTION_FLAG_REVERSE: guint = 4;
1097pub const G_OPTION_FLAG_NO_ARG: guint = 8;
1098pub const G_OPTION_FLAG_FILENAME: guint = 16;
1099pub const G_OPTION_FLAG_OPTIONAL_ARG: guint = 32;
1100pub const G_OPTION_FLAG_NOALIAS: guint = 64;
1101
1102pub enum GOptionGroup { }
1103
1104pub type GOptionParseFunc = extern "C" fn (*mut GOptionContext, *mut GOptionGroup, gpointer, *mut *mut GError) -> gboolean;
1105
1106pub const G_PDP_ENDIAN: gint = 3412;
1107
1108pub const G_PI: gdouble = 3.141593;
1109
1110pub const G_PI_2: gdouble = 1.570796;
1111
1112pub const G_PI_4: gdouble = 0.785398;
1113
1114pub const G_PRIORITY_DEFAULT: gint = 0;
1115
1116pub const G_PRIORITY_DEFAULT_IDLE: gint = 200;
1117
1118pub const G_PRIORITY_HIGH: gint = -100;
1119
1120pub const G_PRIORITY_HIGH_IDLE: gint = 100;
1121
1122pub const G_PRIORITY_LOW: gint = 300;
1123
1124#[repr(C)]
1125pub struct GPatternSpec(gpointer);
1126
1127#[repr(C)]
1128pub struct GPollFD {
1129 pub fd: gint,
1130 pub events: gushort,
1131 pub revents: gushort,
1132}
1133
1134pub type GPollFunc = extern "C" fn (*mut GPollFD, guint, gint) -> gint;
1135
1136pub type GPrintFunc = extern "C" fn (*const gchar);
1137
1138#[repr(C)]
1139pub struct GPrivate {
1140 p: gpointer,
1141 notify: Option<GDestroyNotify>,
1142 future: [gpointer; 2],
1143}
1144
1145#[repr(C)]
1146pub struct GPtrArray {
1147 pub pdata: gpointer,
1148 pub len: guint,
1149}
1150
1151#[repr(C)]
1152pub struct GQueue {
1153 pub head: *mut GList,
1154 pub tail: *mut GList,
1155 pub length: guint,
1156}
1157
1158#[repr(C)]
1159pub struct GRWLock {
1160 p: gpointer,
1161 i: [guint; 2],
1162}
1163
1164#[repr(C)]
1165pub struct GRand(gpointer);
1166
1167#[repr(C)]
1168pub struct GRecMutex {
1169 p: gpointer,
1170 i: [guint; 2],
1171}
1172
1173pub enum GRegex { }
1174
1175#[repr(C)]
1176pub enum GRegexCompileFlags {
1177 Caseless = 1,
1178 Multiline = 2,
1179 Dotall = 4,
1180 Extended = 8,
1181 Anchored = 16,
1182 DollarEndonly = 32,
1183 Ungreedy = 512,
1184 Raw = 2048,
1185 NoAutoCapture = 4096,
1186 Optimize = 8192,
1187 Firstline = 262144,
1188 Dupnames = 524288,
1189 NewlineCr = 1048576,
1190 NewlineLf = 2097152,
1191 NewlineCrlf = 3145728,
1192 NewlineAnycrlf = 5242880,
1193 BsrAnycrlf = 8388608,
1194 JavascriptCompat = 33554432,
1195}
1196pub const G_REGEX_CASELESS: guint = 1;
1197pub const G_REGEX_MULTILINE: guint = 2;
1198pub const G_REGEX_DOTALL: guint = 4;
1199pub const G_REGEX_EXTENDED: guint = 8;
1200pub const G_REGEX_ANCHORED: guint = 16;
1201pub const G_REGEX_DOLLAR_ENDONLY: guint = 32;
1202pub const G_REGEX_UNGREEDY: guint = 512;
1203pub const G_REGEX_RAW: guint = 2048;
1204pub const G_REGEX_NO_AUTO_CAPTURE: guint = 4096;
1205pub const G_REGEX_OPTIMIZE: guint = 8192;
1206pub const G_REGEX_FIRSTLINE: guint = 262144;
1207pub const G_REGEX_DUPNAMES: guint = 524288;
1208pub const G_REGEX_NEWLINE_CR: guint = 1048576;
1209pub const G_REGEX_NEWLINE_LF: guint = 2097152;
1210pub const G_REGEX_NEWLINE_CRLF: guint = 3145728;
1211pub const G_REGEX_NEWLINE_ANYCRLF: guint = 5242880;
1212pub const G_REGEX_BSR_ANYCRLF: guint = 8388608;
1213pub const G_REGEX_JAVASCRIPT_COMPAT: guint = 33554432;
1214
1215#[repr(C)]
1216pub enum GRegexError {
1217 Compile = 0,
1218 Optimize = 1,
1219 Replace = 2,
1220 Match = 3,
1221 Internal = 4,
1222 StrayBackslash = 101,
1223 MissingControlChar = 102,
1224 UnrecognizedEscape = 103,
1225 QuantifiersOutOfOrder = 104,
1226 QuantifierTooBig = 105,
1227 UnterminatedCharacterClass = 106,
1228 InvalidEscapeInCharacterClass = 107,
1229 RangeOutOfOrder = 108,
1230 NothingToRepeat = 109,
1231 UnrecognizedCharacter = 112,
1232 PosixNamedClassOutsideClass = 113,
1233 UnmatchedParenthesis = 114,
1234 InexistentSubpatternReference = 115,
1235 UnterminatedComment = 118,
1236 ExpressionTooLarge = 120,
1237 MemoryError = 121,
1238 VariableLengthLookbehind = 125,
1239 MalformedCondition = 126,
1240 TooManyConditionalBranches = 127,
1241 AssertionExpected = 128,
1242 UnknownPosixClassName = 130,
1243 PosixCollatingElementsNotSupported = 131,
1244 HexCodeTooLarge = 134,
1245 InvalidCondition = 135,
1246 SingleByteMatchInLookbehind = 136,
1247 InfiniteLoop = 140,
1248 MissingSubpatternNameTerminator = 142,
1249 DuplicateSubpatternName = 143,
1250 MalformedProperty = 146,
1251 UnknownProperty = 147,
1252 SubpatternNameTooLong = 148,
1253 TooManySubpatterns = 149,
1254 InvalidOctalValue = 151,
1255 TooManyBranchesInDefine = 154,
1256 DefineRepetion = 155,
1257 InconsistentNewlineOptions = 156,
1258 MissingBackReference = 157,
1259 InvalidRelativeReference = 158,
1260 BacktrackingControlVerbArgumentForbidden = 159,
1261 UnknownBacktrackingControlVerb = 160,
1262 NumberTooBig = 161,
1263 MissingSubpatternName = 162,
1264 MissingDigit = 163,
1265 InvalidDataCharacter = 164,
1266 ExtraSubpatternName = 165,
1267 BacktrackingControlVerbArgumentRequired = 166,
1268 InvalidControlChar = 168,
1269 MissingName = 169,
1270 NotSupportedInClass = 171,
1271 TooManyForwardReferences = 172,
1272 NameTooLong = 175,
1273 CharacterValueTooLarge = 176,
1274}
1275pub const G_REGEX_ERROR_COMPILE: GRegexError = GRegexError::Compile;
1276pub const G_REGEX_ERROR_OPTIMIZE: GRegexError = GRegexError::Optimize;
1277pub const G_REGEX_ERROR_REPLACE: GRegexError = GRegexError::Replace;
1278pub const G_REGEX_ERROR_MATCH: GRegexError = GRegexError::Match;
1279pub const G_REGEX_ERROR_INTERNAL: GRegexError = GRegexError::Internal;
1280pub const G_REGEX_ERROR_STRAY_BACKSLASH: GRegexError = GRegexError::StrayBackslash;
1281pub const G_REGEX_ERROR_MISSING_CONTROL_CHAR: GRegexError = GRegexError::MissingControlChar;
1282pub const G_REGEX_ERROR_UNRECOGNIZED_ESCAPE: GRegexError = GRegexError::UnrecognizedEscape;
1283pub const G_REGEX_ERROR_QUANTIFIERS_OUT_OF_ORDER: GRegexError = GRegexError::QuantifiersOutOfOrder;
1284pub const G_REGEX_ERROR_QUANTIFIER_TOO_BIG: GRegexError = GRegexError::QuantifierTooBig;
1285pub const G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS: GRegexError = GRegexError::UnterminatedCharacterClass;
1286pub const G_REGEX_ERROR_INVALID_ESCAPE_IN_CHARACTER_CLASS: GRegexError = GRegexError::InvalidEscapeInCharacterClass;
1287pub const G_REGEX_ERROR_RANGE_OUT_OF_ORDER: GRegexError = GRegexError::RangeOutOfOrder;
1288pub const G_REGEX_ERROR_NOTHING_TO_REPEAT: GRegexError = GRegexError::NothingToRepeat;
1289pub const G_REGEX_ERROR_UNRECOGNIZED_CHARACTER: GRegexError = GRegexError::UnrecognizedCharacter;
1290pub const G_REGEX_ERROR_POSIX_NAMED_CLASS_OUTSIDE_CLASS: GRegexError = GRegexError::PosixNamedClassOutsideClass;
1291pub const G_REGEX_ERROR_UNMATCHED_PARENTHESIS: GRegexError = GRegexError::UnmatchedParenthesis;
1292pub const G_REGEX_ERROR_INEXISTENT_SUBPATTERN_REFERENCE: GRegexError = GRegexError::InexistentSubpatternReference;
1293pub const G_REGEX_ERROR_UNTERMINATED_COMMENT: GRegexError = GRegexError::UnterminatedComment;
1294pub const G_REGEX_ERROR_EXPRESSION_TOO_LARGE: GRegexError = GRegexError::ExpressionTooLarge;
1295pub const G_REGEX_ERROR_MEMORY_ERROR: GRegexError = GRegexError::MemoryError;
1296pub const G_REGEX_ERROR_VARIABLE_LENGTH_LOOKBEHIND: GRegexError = GRegexError::VariableLengthLookbehind;
1297pub const G_REGEX_ERROR_MALFORMED_CONDITION: GRegexError = GRegexError::MalformedCondition;
1298pub const G_REGEX_ERROR_TOO_MANY_CONDITIONAL_BRANCHES: GRegexError = GRegexError::TooManyConditionalBranches;
1299pub const G_REGEX_ERROR_ASSERTION_EXPECTED: GRegexError = GRegexError::AssertionExpected;
1300pub const G_REGEX_ERROR_UNKNOWN_POSIX_CLASS_NAME: GRegexError = GRegexError::UnknownPosixClassName;
1301pub const G_REGEX_ERROR_POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED: GRegexError = GRegexError::PosixCollatingElementsNotSupported;
1302pub const G_REGEX_ERROR_HEX_CODE_TOO_LARGE: GRegexError = GRegexError::HexCodeTooLarge;
1303pub const G_REGEX_ERROR_INVALID_CONDITION: GRegexError = GRegexError::InvalidCondition;
1304pub const G_REGEX_ERROR_SINGLE_BYTE_MATCH_IN_LOOKBEHIND: GRegexError = GRegexError::SingleByteMatchInLookbehind;
1305pub const G_REGEX_ERROR_INFINITE_LOOP: GRegexError = GRegexError::InfiniteLoop;
1306pub const G_REGEX_ERROR_MISSING_SUBPATTERN_NAME_TERMINATOR: GRegexError = GRegexError::MissingSubpatternNameTerminator;
1307pub const G_REGEX_ERROR_DUPLICATE_SUBPATTERN_NAME: GRegexError = GRegexError::DuplicateSubpatternName;
1308pub const G_REGEX_ERROR_MALFORMED_PROPERTY: GRegexError = GRegexError::MalformedProperty;
1309pub const G_REGEX_ERROR_UNKNOWN_PROPERTY: GRegexError = GRegexError::UnknownProperty;
1310pub const G_REGEX_ERROR_SUBPATTERN_NAME_TOO_LONG: GRegexError = GRegexError::SubpatternNameTooLong;
1311pub const G_REGEX_ERROR_TOO_MANY_SUBPATTERNS: GRegexError = GRegexError::TooManySubpatterns;
1312pub const G_REGEX_ERROR_INVALID_OCTAL_VALUE: GRegexError = GRegexError::InvalidOctalValue;
1313pub const G_REGEX_ERROR_TOO_MANY_BRANCHES_IN_DEFINE: GRegexError = GRegexError::TooManyBranchesInDefine;
1314pub const G_REGEX_ERROR_DEFINE_REPETION: GRegexError = GRegexError::DefineRepetion;
1315pub const G_REGEX_ERROR_INCONSISTENT_NEWLINE_OPTIONS: GRegexError = GRegexError::InconsistentNewlineOptions;
1316pub const G_REGEX_ERROR_MISSING_BACK_REFERENCE: GRegexError = GRegexError::MissingBackReference;
1317pub const G_REGEX_ERROR_INVALID_RELATIVE_REFERENCE: GRegexError = GRegexError::InvalidRelativeReference;
1318pub const G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN: GRegexError = GRegexError::BacktrackingControlVerbArgumentForbidden;
1319pub const G_REGEX_ERROR_UNKNOWN_BACKTRACKING_CONTROL_VERB: GRegexError = GRegexError::UnknownBacktrackingControlVerb;
1320pub const G_REGEX_ERROR_NUMBER_TOO_BIG: GRegexError = GRegexError::NumberTooBig;
1321pub const G_REGEX_ERROR_MISSING_SUBPATTERN_NAME: GRegexError = GRegexError::MissingSubpatternName;
1322pub const G_REGEX_ERROR_MISSING_DIGIT: GRegexError = GRegexError::MissingDigit;
1323pub const G_REGEX_ERROR_INVALID_DATA_CHARACTER: GRegexError = GRegexError::InvalidDataCharacter;
1324pub const G_REGEX_ERROR_EXTRA_SUBPATTERN_NAME: GRegexError = GRegexError::ExtraSubpatternName;
1325pub const G_REGEX_ERROR_BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED: GRegexError = GRegexError::BacktrackingControlVerbArgumentRequired;
1326pub const G_REGEX_ERROR_INVALID_CONTROL_CHAR: GRegexError = GRegexError::InvalidControlChar;
1327pub const G_REGEX_ERROR_MISSING_NAME: GRegexError = GRegexError::MissingName;
1328pub const G_REGEX_ERROR_NOT_SUPPORTED_IN_CLASS: GRegexError = GRegexError::NotSupportedInClass;
1329pub const G_REGEX_ERROR_TOO_MANY_FORWARD_REFERENCES: GRegexError = GRegexError::TooManyForwardReferences;
1330pub const G_REGEX_ERROR_NAME_TOO_LONG: GRegexError = GRegexError::NameTooLong;
1331pub const G_REGEX_ERROR_CHARACTER_VALUE_TOO_LARGE: GRegexError = GRegexError::CharacterValueTooLarge;
1332
1333pub type GRegexEvalCallback = extern "C" fn (*const GMatchInfo, *mut GString, gpointer) -> gboolean;
1334
1335#[repr(C)]
1336pub enum GRegexMatchFlags {
1337 Anchored = 16,
1338 Notbol = 128,
1339 Noteol = 256,
1340 Notempty = 1024,
1341 Partial = 32768,
1342 NewlineCr = 1048576,
1343 NewlineLf = 2097152,
1344 NewlineCrlf = 3145728,
1345 NewlineAny = 4194304,
1346 NewlineAnycrlf = 5242880,
1347 BsrAnycrlf = 8388608,
1348 BsrAny = 16777216,
1349 PartialHard = 134217728,
1350 NotemptyAtstart = 268435456,
1351}
1352pub const G_REGEX_MATCH_ANCHORED: guint = 16;
1353pub const G_REGEX_MATCH_NOTBOL: guint = 128;
1354pub const G_REGEX_MATCH_NOTEOL: guint = 256;
1355pub const G_REGEX_MATCH_NOTEMPTY: guint = 1024;
1356pub const G_REGEX_MATCH_PARTIAL: guint = 32768;
1357pub const G_REGEX_MATCH_NEWLINE_CR: guint = 1048576;
1358pub const G_REGEX_MATCH_NEWLINE_LF: guint = 2097152;
1359pub const G_REGEX_MATCH_NEWLINE_CRLF: guint = 3145728;
1360pub const G_REGEX_MATCH_NEWLINE_ANY: guint = 4194304;
1361pub const G_REGEX_MATCH_NEWLINE_ANYCRLF: guint = 5242880;
1362pub const G_REGEX_MATCH_BSR_ANYCRLF: guint = 8388608;
1363pub const G_REGEX_MATCH_BSR_ANY: guint = 16777216;
1364pub const G_REGEX_MATCH_PARTIAL_SOFT: guint = 32768;
1365pub const G_REGEX_MATCH_PARTIAL_HARD: guint = 134217728;
1366pub const G_REGEX_MATCH_NOTEMPTY_ATSTART: guint = 268435456;
1367
1368#[repr(C)]
1369pub struct GSList {
1370 pub data: gpointer,
1371 pub next: *mut GSList,
1372}
1373
1374pub const G_SOURCE_CONTINUE: gboolean = TRUE;
1375
1376pub const G_SOURCE_REMOVE: gboolean = FALSE;
1377
1378pub const G_SQRT2: gdouble = 1.414214;
1379
1380pub const G_STR_DELIMITERS: &'static [u8] = b"_-|> <.\0";
1381
1382#[repr(C)]
1383pub struct GScanner {
1384 pub user_data: gpointer,
1385 pub max_parse_errors: guint,
1386 pub parse_errors: guint,
1387 pub input_name: *const gchar,
1388 pub qdata: *mut GData,
1389 pub config: *mut GScannerConfig,
1390 pub token: GTokenType,
1391 pub value: GTokenValue,
1392 pub line: guint,
1393 pub position: guint,
1394 pub next_token: GTokenType,
1395 pub next_value: GTokenValue,
1396 pub next_line: guint,
1397 pub next_position: guint,
1398 symbol_table: *mut GHashTable,
1399 input_fd: gint,
1400 text: *const gchar,
1401 text_end: *const gchar,
1402 buffer: *mut gchar,
1403 scope_id: guint,
1404 pub msg_handler: Option<GScannerMsgFunc>,
1405}
1406
1407pub type GScannerMsgFunc = extern "C" fn (*mut GScanner, *mut gchar, gboolean);
1408
1409#[repr(C)]
1410pub enum GSeekType {
1411 Cur = 0,
1412 Set = 1,
1413 End = 2,
1414}
1415pub const G_SEEK_CUR: GSeekType = GSeekType::Cur;
1416pub const G_SEEK_SET: GSeekType = GSeekType::Set;
1417pub const G_SEEK_END: GSeekType = GSeekType::End;
1418
1419#[repr(C)]
1420pub struct GSequence(gpointer);
1421
1422#[repr(C)]
1423pub struct GSequenceIter(gpointer);
1424
1425pub type GSequenceIterCompareFunc = extern "C" fn (*mut GSequenceIter, *mut GSequenceIter, gpointer) -> gint;
1426
1427#[repr(C)]
1428pub enum GShellError {
1429 BadQuoting = 0,
1430 EmptyString = 1,
1431 Failed = 2,
1432}
1433pub const G_SHELL_ERROR_BAD_QUOTING: GShellError = GShellError::BadQuoting;
1434pub const G_SHELL_ERROR_EMPTY_STRING: GShellError = GShellError::EmptyString;
1435pub const G_SHELL_ERROR_FAILED: GShellError = GShellError::Failed;
1436
1437#[repr(C)]
1438pub enum GSliceConfig {
1439 AlwaysMalloc = 1,
1440 BypassMagazines = 2,
1441 WorkingSetMsecs = 3,
1442 ColorIncrement = 4,
1443 ChunkSizes = 5,
1444 ContentionCounter = 6,
1445}
1446pub const G_SLICE_CONFIG_ALWAYS_MALLOC: GSliceConfig = GSliceConfig::AlwaysMalloc;
1447pub const G_SLICE_CONFIG_BYPASS_MAGAZINES: GSliceConfig = GSliceConfig::BypassMagazines;
1448pub const G_SLICE_CONFIG_WORKING_SET_MSECS: GSliceConfig = GSliceConfig::WorkingSetMsecs;
1449pub const G_SLICE_CONFIG_COLOR_INCREMENT: GSliceConfig = GSliceConfig::ColorIncrement;
1450pub const G_SLICE_CONFIG_CHUNK_SIZES: GSliceConfig = GSliceConfig::ChunkSizes;
1451pub const G_SLICE_CONFIG_CONTENTION_COUNTER: GSliceConfig = GSliceConfig::ContentionCounter;
1452
1453#[repr(C)]
1454pub struct GSource {
1455 callback_data: gpointer,
1456 callback_funcs: *mut GSourceCallbackFuncs,
1457 source_funcs: *const GSourceFuncs,
1458 ref_count: guint,
1459 context: *mut GMainContext,
1460 priority: gint,
1461 flags: guint,
1462 source_id: guint,
1463 poll_fds: *mut GSList,
1464 prev: *mut GSource,
1465 next: *mut GSource,
1466 name: *mut gchar,
1467 priv_: *mut GSourcePrivate,
1468}
1469
1470#[repr(C)]
1471pub struct GSourceCallbackFuncs {
1472 pub ref_: Option<extern "C" fn (gpointer)>,
1473 pub unref: Option<extern "C" fn (gpointer)>,
1474 pub get: Option<extern "C" fn (gpointer, *mut GSource, *mut GSourceFunc, gpointer)>,
1475}
1476
1477pub type GSourceDummyMarshal = extern "C" fn ();
1478
1479pub type GSourceFunc = extern "C" fn (gpointer) -> gboolean;
1480
1481#[repr(C)]
1482pub struct GSourceFuncs {
1483 pub prepare: Option<extern "C" fn (*mut GSource, gint) -> gboolean>,
1484 pub check: Option<extern "C" fn (*mut GSource) -> gboolean>,
1485 pub dispatch: Option<extern "C" fn (*mut GSource, GSourceFunc, gpointer) -> gboolean>,
1486 pub finalize: Option<extern "C" fn (*mut GSource)>,
1487 closure_callback: Option<GSourceFunc>,
1488 closure_marshal: Option<GSourceDummyMarshal>,
1489}
1490
1491#[repr(C)]
1492pub struct GSourcePrivate(gpointer);
1493
1494pub type GSpawnChildSetupFunc = extern "C" fn (gpointer);
1495
1496#[repr(C)]
1497pub enum GSpawnError {
1498 Fork = 0,
1499 Read = 1,
1500 Chdir = 2,
1501 Acces = 3,
1502 Perm = 4,
1503 TooBig = 5,
1504 Noexec = 6,
1505 Nametoolong = 7,
1506 Noent = 8,
1507 Nomem = 9,
1508 Notdir = 10,
1509 Loop = 11,
1510 Txtbusy = 12,
1511 Io = 13,
1512 Nfile = 14,
1513 Mfile = 15,
1514 Inval = 16,
1515 Isdir = 17,
1516 Libbad = 18,
1517 Failed = 19,
1518}
1519pub const G_SPAWN_ERROR_FORK: GSpawnError = GSpawnError::Fork;
1520pub const G_SPAWN_ERROR_READ: GSpawnError = GSpawnError::Read;
1521pub const G_SPAWN_ERROR_CHDIR: GSpawnError = GSpawnError::Chdir;
1522pub const G_SPAWN_ERROR_ACCES: GSpawnError = GSpawnError::Acces;
1523pub const G_SPAWN_ERROR_PERM: GSpawnError = GSpawnError::Perm;
1524pub const G_SPAWN_ERROR_TOO_BIG: GSpawnError = GSpawnError::TooBig;
1525pub const G_SPAWN_ERROR_2BIG: GSpawnError = GSpawnError::TooBig;
1526pub const G_SPAWN_ERROR_NOEXEC: GSpawnError = GSpawnError::Noexec;
1527pub const G_SPAWN_ERROR_NAMETOOLONG: GSpawnError = GSpawnError::Nametoolong;
1528pub const G_SPAWN_ERROR_NOENT: GSpawnError = GSpawnError::Noent;
1529pub const G_SPAWN_ERROR_NOMEM: GSpawnError = GSpawnError::Nomem;
1530pub const G_SPAWN_ERROR_NOTDIR: GSpawnError = GSpawnError::Notdir;
1531pub const G_SPAWN_ERROR_LOOP: GSpawnError = GSpawnError::Loop;
1532pub const G_SPAWN_ERROR_TXTBUSY: GSpawnError = GSpawnError::Txtbusy;
1533pub const G_SPAWN_ERROR_IO: GSpawnError = GSpawnError::Io;
1534pub const G_SPAWN_ERROR_NFILE: GSpawnError = GSpawnError::Nfile;
1535pub const G_SPAWN_ERROR_MFILE: GSpawnError = GSpawnError::Mfile;
1536pub const G_SPAWN_ERROR_INVAL: GSpawnError = GSpawnError::Inval;
1537pub const G_SPAWN_ERROR_ISDIR: GSpawnError = GSpawnError::Isdir;
1538pub const G_SPAWN_ERROR_LIBBAD: GSpawnError = GSpawnError::Libbad;
1539pub const G_SPAWN_ERROR_FAILED: GSpawnError = GSpawnError::Failed;
1540
1541#[repr(C)]
1542pub enum GSpawnFlags {
1543 Default = 0,
1544 LeaveDescriptorsOpen = 1,
1545 DoNotReapChild = 2,
1546 SearchPath = 4,
1547 StdoutToDevNull = 8,
1548 StderrToDevNull = 16,
1549 ChildInheritsStdin = 32,
1550 FileAndArgvZero = 64,
1551 SearchPathFromEnvp = 128,
1552 CloexecPipes = 256,
1553}
1554pub const G_SPAWN_DEFAULT: guint = 0;
1555pub const G_SPAWN_LEAVE_DESCRIPTORS_OPEN: guint = 1;
1556pub const G_SPAWN_DO_NOT_REAP_CHILD: guint = 2;
1557pub const G_SPAWN_SEARCH_PATH: guint = 4;
1558pub const G_SPAWN_STDOUT_TO_DEV_NULL: guint = 8;
1559pub const G_SPAWN_STDERR_TO_DEV_NULL: guint = 16;
1560pub const G_SPAWN_CHILD_INHERITS_STDIN: guint = 32;
1561pub const G_SPAWN_FILE_AND_ARGV_ZERO: guint = 64;
1562pub const G_SPAWN_SEARCH_PATH_FROM_ENVP: guint = 128;
1563pub const G_SPAWN_CLOEXEC_PIPES: guint = 256;
1564
1565#[repr(C)]
1566pub struct GStatBuf(gpointer);
1567
1568#[repr(C)]
1569pub struct GString {
1570 pub str: *mut gchar,
1571 pub len: gsize,
1572 pub allocated_len: gsize,
1573}
1574
1575#[repr(C)]
1576pub struct GStringChunk(gpointer);
1577
1578pub const G_TIME_SPAN_DAY: i64 = 86400000000;
1579
1580pub const G_TIME_SPAN_HOUR: i64 = 3600000000;
1581
1582pub const G_TIME_SPAN_MILLISECOND: i64 = 1000;
1583
1584pub const G_TIME_SPAN_MINUTE: i64 = 60000000;
1585
1586pub const G_TIME_SPAN_SECOND: i64 = 1000000;
1587
1588#[repr(C)]
1589pub struct GTestCase(gpointer);
1590
1591#[repr(C)]
1592pub struct GTestConfig {
1593 pub test_initialized: gboolean,
1594 pub test_quick: gboolean,
1595 pub test_perf: gboolean,
1596 pub test_verbose: gboolean,
1597 pub test_quiet: gboolean,
1598 pub test_undefined: gboolean,
1599}
1600
1601pub type GTestDataFunc = extern "C" fn (gconstpointer);
1602
1603#[repr(C)]
1604pub enum GTestFileType {
1605 Dist = 0,
1606 Built = 1,
1607}
1608pub const G_TEST_DIST: GTestFileType = GTestFileType::Dist;
1609pub const G_TEST_BUILT: GTestFileType = GTestFileType::Built;
1610
1611pub type GTestFixtureFunc = extern "C" fn (gpointer, gconstpointer);
1612
1613pub type GTestFunc = extern "C" fn ();
1614
1615#[repr(C)]
1616pub struct GTestLogBuffer {
1617 data: *mut GString,
1618 msgs: *mut GSList,
1619}
1620
1621pub type GTestLogFatalFunc = extern "C" fn (*const gchar, GLogLevelFlags, *const gchar, gpointer) -> gboolean;
1622
1623#[repr(C)]
1624pub struct GTestLogMsg {
1625 pub log_type: GTestLogType,
1626 pub n_strings: guint,
1627 pub strings: *mut *mut gchar,
1628 pub n_nums: guint,
1629 pub nums: glong,
1630}
1631
1632#[repr(C)]
1633pub enum GTestLogType {
1634 None = 0,
1635 Error = 1,
1636 StartBinary = 2,
1637 ListCase = 3,
1638 SkipCase = 4,
1639 StartCase = 5,
1640 StopCase = 6,
1641 MinResult = 7,
1642 MaxResult = 8,
1643 Message = 9,
1644 StartSuite = 10,
1645 StopSuite = 11,
1646}
1647pub const G_TEST_LOG_NONE: GTestLogType = GTestLogType::None;
1648pub const G_TEST_LOG_ERROR: GTestLogType = GTestLogType::Error;
1649pub const G_TEST_LOG_START_BINARY: GTestLogType = GTestLogType::StartBinary;
1650pub const G_TEST_LOG_LIST_CASE: GTestLogType = GTestLogType::ListCase;
1651pub const G_TEST_LOG_SKIP_CASE: GTestLogType = GTestLogType::SkipCase;
1652pub const G_TEST_LOG_START_CASE: GTestLogType = GTestLogType::StartCase;
1653pub const G_TEST_LOG_STOP_CASE: GTestLogType = GTestLogType::StopCase;
1654pub const G_TEST_LOG_MIN_RESULT: GTestLogType = GTestLogType::MinResult;
1655pub const G_TEST_LOG_MAX_RESULT: GTestLogType = GTestLogType::MaxResult;
1656pub const G_TEST_LOG_MESSAGE: GTestLogType = GTestLogType::Message;
1657pub const G_TEST_LOG_START_SUITE: GTestLogType = GTestLogType::StartSuite;
1658pub const G_TEST_LOG_STOP_SUITE: GTestLogType = GTestLogType::StopSuite;
1659
1660#[repr(C)]
1661pub enum GTestSubprocessFlags {
1662 Stdin = 1,
1663 Stdout = 2,
1664 Stderr = 4,
1665}
1666pub const G_TEST_SUBPROCESS_INHERIT_STDIN: guint = 1;
1667pub const G_TEST_SUBPROCESS_INHERIT_STDOUT: guint = 2;
1668pub const G_TEST_SUBPROCESS_INHERIT_STDERR: guint = 4;
1669
1670#[repr(C)]
1671pub struct GTestSuite(gpointer);
1672
1673#[repr(C)]
1674pub enum GTestTrapFlags {
1675 SilenceStdout = 128,
1676 SilenceStderr = 256,
1677 InheritStdin = 512,
1678}
1679pub const G_TEST_TRAP_SILENCE_STDOUT: guint = 128;
1680pub const G_TEST_TRAP_SILENCE_STDERR: guint = 256;
1681pub const G_TEST_TRAP_INHERIT_STDIN: guint = 512;
1682
1683pub enum GThread { }
1684
1685#[repr(C)]
1686pub enum GThreadError {
1687 ThreadErrorAgain = 0,
1688 _Dummy = 1,
1689}
1690pub const G_THREAD_ERROR_AGAIN: GThreadError = GThreadError::ThreadErrorAgain;
1691
1692pub type GThreadFunc = extern "C" fn (gpointer) -> gpointer;
1693
1694#[repr(C)]
1695pub struct GThreadPool {
1696 pub func: Option<GFunc>,
1697 pub user_data: gpointer,
1698 pub exclusive: gboolean,
1699}
1700
1701#[repr(C)]
1702pub enum GTimeType {
1703 Standard = 0,
1704 Daylight = 1,
1705 Universal = 2,
1706}
1707pub const G_TIME_TYPE_STANDARD: GTimeType = GTimeType::Standard;
1708pub const G_TIME_TYPE_DAYLIGHT: GTimeType = GTimeType::Daylight;
1709pub const G_TIME_TYPE_UNIVERSAL: GTimeType = GTimeType::Universal;
1710
1711#[repr(C)]
1712pub struct GTimeVal {
1713 pub tv_sec: glong,
1714 pub tv_usec: glong,
1715}
1716
1717pub enum GTimeZone { }
1718
1719#[repr(C)]
1720pub struct GTimer(gpointer);
1721
1722#[repr(C)]
1723pub enum GTokenType {
1724 Eof = 0,
1725 LeftParen = 40,
1726 RightParen = 41,
1727 Comma = 44,
1728 EqualSign = 61,
1729 LeftBrace = 91,
1730 RightBrace = 93,
1731 LeftCurly = 123,
1732 RightCurly = 125,
1733 None = 256,
1734 Error = 257,
1735 Char = 258,
1736 Binary = 259,
1737 Octal = 260,
1738 Int = 261,
1739 Hex = 262,
1740 Float = 263,
1741 String = 264,
1742 Symbol = 265,
1743 Identifier = 266,
1744 IdentifierNull = 267,
1745 CommentSingle = 268,
1746 CommentMulti = 269,
1747}
1748pub const G_TOKEN_EOF: GTokenType = GTokenType::Eof;
1749pub const G_TOKEN_LEFT_PAREN: GTokenType = GTokenType::LeftParen;
1750pub const G_TOKEN_RIGHT_PAREN: GTokenType = GTokenType::RightParen;
1751pub const G_TOKEN_LEFT_CURLY: GTokenType = GTokenType::LeftCurly;
1752pub const G_TOKEN_RIGHT_CURLY: GTokenType = GTokenType::RightCurly;
1753pub const G_TOKEN_LEFT_BRACE: GTokenType = GTokenType::LeftBrace;
1754pub const G_TOKEN_RIGHT_BRACE: GTokenType = GTokenType::RightBrace;
1755pub const G_TOKEN_EQUAL_SIGN: GTokenType = GTokenType::EqualSign;
1756pub const G_TOKEN_COMMA: GTokenType = GTokenType::Comma;
1757pub const G_TOKEN_NONE: GTokenType = GTokenType::None;
1758pub const G_TOKEN_ERROR: GTokenType = GTokenType::Error;
1759pub const G_TOKEN_CHAR: GTokenType = GTokenType::Char;
1760pub const G_TOKEN_BINARY: GTokenType = GTokenType::Binary;
1761pub const G_TOKEN_OCTAL: GTokenType = GTokenType::Octal;
1762pub const G_TOKEN_INT: GTokenType = GTokenType::Int;
1763pub const G_TOKEN_HEX: GTokenType = GTokenType::Hex;
1764pub const G_TOKEN_FLOAT: GTokenType = GTokenType::Float;
1765pub const G_TOKEN_STRING: GTokenType = GTokenType::String;
1766pub const G_TOKEN_SYMBOL: GTokenType = GTokenType::Symbol;
1767pub const G_TOKEN_IDENTIFIER: GTokenType = GTokenType::Identifier;
1768pub const G_TOKEN_IDENTIFIER_NULL: GTokenType = GTokenType::IdentifierNull;
1769pub const G_TOKEN_COMMENT_SINGLE: GTokenType = GTokenType::CommentSingle;
1770pub const G_TOKEN_COMMENT_MULTI: GTokenType = GTokenType::CommentMulti;
1771
1772pub type GTranslateFunc = extern "C" fn (*const gchar, gpointer) -> *const gchar;
1773
1774#[repr(C)]
1775pub struct GTrashStack {
1776 pub next: *mut GTrashStack,
1777}
1778
1779#[repr(C)]
1780pub enum GTraverseFlags {
1781 Leaves = 1,
1782 NonLeaves = 2,
1783 All = 3,
1784}
1785pub const G_TRAVERSE_LEAVES: guint = 1;
1786pub const G_TRAVERSE_NON_LEAVES: guint = 2;
1787pub const G_TRAVERSE_ALL: guint = 3;
1788pub const G_TRAVERSE_MASK: guint = 3;
1789pub const G_TRAVERSE_LEAFS: guint = 1;
1790pub const G_TRAVERSE_NON_LEAFS: guint = 2;
1791
1792pub type GTraverseFunc = extern "C" fn (gpointer, gpointer, gpointer) -> gboolean;
1793
1794#[repr(C)]
1795pub enum GTraverseType {
1796 InOrder = 0,
1797 PreOrder = 1,
1798 PostOrder = 2,
1799 LevelOrder = 3,
1800}
1801pub const G_IN_ORDER: GTraverseType = GTraverseType::InOrder;
1802pub const G_PRE_ORDER: GTraverseType = GTraverseType::PreOrder;
1803pub const G_POST_ORDER: GTraverseType = GTraverseType::PostOrder;
1804pub const G_LEVEL_ORDER: GTraverseType = GTraverseType::LevelOrder;
1805
1806#[repr(C)]
1807pub struct GTree(gpointer);
1808
1809pub const G_UNICHAR_MAX_DECOMPOSITION_LENGTH: gint = 18;
1810
1811pub const G_URI_RESERVED_CHARS_GENERIC_DELIMITERS: &'static [u8] = b":/?#[]@\0";
1812
1813pub const G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS: &'static [u8] = b"!$&'()*+,;=\0";
1814
1815pub const G_USEC_PER_SEC: gint = 1000000;
1816
1817#[repr(C)]
1818pub enum GUnicodeBreakType {
1819 Mandatory = 0,
1820 CarriageReturn = 1,
1821 LineFeed = 2,
1822 CombiningMark = 3,
1823 Surrogate = 4,
1824 ZeroWidthSpace = 5,
1825 Inseparable = 6,
1826 NonBreakingGlue = 7,
1827 Contingent = 8,
1828 Space = 9,
1829 After = 10,
1830 Before = 11,
1831 BeforeAndAfter = 12,
1832 Hyphen = 13,
1833 NonStarter = 14,
1834 OpenPunctuation = 15,
1835 ClosePunctuation = 16,
1836 Quotation = 17,
1837 Exclamation = 18,
1838 Ideographic = 19,
1839 Numeric = 20,
1840 InfixSeparator = 21,
1841 Symbol = 22,
1842 Alphabetic = 23,
1843 Prefix = 24,
1844 Postfix = 25,
1845 ComplexContext = 26,
1846 Ambiguous = 27,
1847 Unknown = 28,
1848 NextLine = 29,
1849 WordJoiner = 30,
1850 HangulLJamo = 31,
1851 HangulVJamo = 32,
1852 HangulTJamo = 33,
1853 HangulLvSyllable = 34,
1854 HangulLvtSyllable = 35,
1855 CloseParanthesis = 36,
1856 ConditionalJapaneseStarter = 37,
1857 HebrewLetter = 38,
1858 RegionalIndicator = 39,
1859}
1860pub const G_UNICODE_BREAK_MANDATORY: GUnicodeBreakType = GUnicodeBreakType::Mandatory;
1861pub const G_UNICODE_BREAK_CARRIAGE_RETURN: GUnicodeBreakType = GUnicodeBreakType::CarriageReturn;
1862pub const G_UNICODE_BREAK_LINE_FEED: GUnicodeBreakType = GUnicodeBreakType::LineFeed;
1863pub const G_UNICODE_BREAK_COMBINING_MARK: GUnicodeBreakType = GUnicodeBreakType::CombiningMark;
1864pub const G_UNICODE_BREAK_SURROGATE: GUnicodeBreakType = GUnicodeBreakType::Surrogate;
1865pub const G_UNICODE_BREAK_ZERO_WIDTH_SPACE: GUnicodeBreakType = GUnicodeBreakType::ZeroWidthSpace;
1866pub const G_UNICODE_BREAK_INSEPARABLE: GUnicodeBreakType = GUnicodeBreakType::Inseparable;
1867pub const G_UNICODE_BREAK_NON_BREAKING_GLUE: GUnicodeBreakType = GUnicodeBreakType::NonBreakingGlue;
1868pub const G_UNICODE_BREAK_CONTINGENT: GUnicodeBreakType = GUnicodeBreakType::Contingent;
1869pub const G_UNICODE_BREAK_SPACE: GUnicodeBreakType = GUnicodeBreakType::Space;
1870pub const G_UNICODE_BREAK_AFTER: GUnicodeBreakType = GUnicodeBreakType::After;
1871pub const G_UNICODE_BREAK_BEFORE: GUnicodeBreakType = GUnicodeBreakType::Before;
1872pub const G_UNICODE_BREAK_BEFORE_AND_AFTER: GUnicodeBreakType = GUnicodeBreakType::BeforeAndAfter;
1873pub const G_UNICODE_BREAK_HYPHEN: GUnicodeBreakType = GUnicodeBreakType::Hyphen;
1874pub const G_UNICODE_BREAK_NON_STARTER: GUnicodeBreakType = GUnicodeBreakType::NonStarter;
1875pub const G_UNICODE_BREAK_OPEN_PUNCTUATION: GUnicodeBreakType = GUnicodeBreakType::OpenPunctuation;
1876pub const G_UNICODE_BREAK_CLOSE_PUNCTUATION: GUnicodeBreakType = GUnicodeBreakType::ClosePunctuation;
1877pub const G_UNICODE_BREAK_QUOTATION: GUnicodeBreakType = GUnicodeBreakType::Quotation;
1878pub const G_UNICODE_BREAK_EXCLAMATION: GUnicodeBreakType = GUnicodeBreakType::Exclamation;
1879pub const G_UNICODE_BREAK_IDEOGRAPHIC: GUnicodeBreakType = GUnicodeBreakType::Ideographic;
1880pub const G_UNICODE_BREAK_NUMERIC: GUnicodeBreakType = GUnicodeBreakType::Numeric;
1881pub const G_UNICODE_BREAK_INFIX_SEPARATOR: GUnicodeBreakType = GUnicodeBreakType::InfixSeparator;
1882pub const G_UNICODE_BREAK_SYMBOL: GUnicodeBreakType = GUnicodeBreakType::Symbol;
1883pub const G_UNICODE_BREAK_ALPHABETIC: GUnicodeBreakType = GUnicodeBreakType::Alphabetic;
1884pub const G_UNICODE_BREAK_PREFIX: GUnicodeBreakType = GUnicodeBreakType::Prefix;
1885pub const G_UNICODE_BREAK_POSTFIX: GUnicodeBreakType = GUnicodeBreakType::Postfix;
1886pub const G_UNICODE_BREAK_COMPLEX_CONTEXT: GUnicodeBreakType = GUnicodeBreakType::ComplexContext;
1887pub const G_UNICODE_BREAK_AMBIGUOUS: GUnicodeBreakType = GUnicodeBreakType::Ambiguous;
1888pub const G_UNICODE_BREAK_UNKNOWN: GUnicodeBreakType = GUnicodeBreakType::Unknown;
1889pub const G_UNICODE_BREAK_NEXT_LINE: GUnicodeBreakType = GUnicodeBreakType::NextLine;
1890pub const G_UNICODE_BREAK_WORD_JOINER: GUnicodeBreakType = GUnicodeBreakType::WordJoiner;
1891pub const G_UNICODE_BREAK_HANGUL_L_JAMO: GUnicodeBreakType = GUnicodeBreakType::HangulLJamo;
1892pub const G_UNICODE_BREAK_HANGUL_V_JAMO: GUnicodeBreakType = GUnicodeBreakType::HangulVJamo;
1893pub const G_UNICODE_BREAK_HANGUL_T_JAMO: GUnicodeBreakType = GUnicodeBreakType::HangulTJamo;
1894pub const G_UNICODE_BREAK_HANGUL_LV_SYLLABLE: GUnicodeBreakType = GUnicodeBreakType::HangulLvSyllable;
1895pub const G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE: GUnicodeBreakType = GUnicodeBreakType::HangulLvtSyllable;
1896pub const G_UNICODE_BREAK_CLOSE_PARANTHESIS: GUnicodeBreakType = GUnicodeBreakType::CloseParanthesis;
1897pub const G_UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER: GUnicodeBreakType = GUnicodeBreakType::ConditionalJapaneseStarter;
1898pub const G_UNICODE_BREAK_HEBREW_LETTER: GUnicodeBreakType = GUnicodeBreakType::HebrewLetter;
1899pub const G_UNICODE_BREAK_REGIONAL_INDICATOR: GUnicodeBreakType = GUnicodeBreakType::RegionalIndicator;
1900
1901#[repr(C)]
1902pub enum GUnicodeScript {
1903 InvalidCode = -1,
1904 Common = 0,
1905 Inherited = 1,
1906 Arabic = 2,
1907 Armenian = 3,
1908 Bengali = 4,
1909 Bopomofo = 5,
1910 Cherokee = 6,
1911 Coptic = 7,
1912 Cyrillic = 8,
1913 Deseret = 9,
1914 Devanagari = 10,
1915 Ethiopic = 11,
1916 Georgian = 12,
1917 Gothic = 13,
1918 Greek = 14,
1919 Gujarati = 15,
1920 Gurmukhi = 16,
1921 Han = 17,
1922 Hangul = 18,
1923 Hebrew = 19,
1924 Hiragana = 20,
1925 Kannada = 21,
1926 Katakana = 22,
1927 Khmer = 23,
1928 Lao = 24,
1929 Latin = 25,
1930 Malayalam = 26,
1931 Mongolian = 27,
1932 Myanmar = 28,
1933 Ogham = 29,
1934 OldItalic = 30,
1935 Oriya = 31,
1936 Runic = 32,
1937 Sinhala = 33,
1938 Syriac = 34,
1939 Tamil = 35,
1940 Telugu = 36,
1941 Thaana = 37,
1942 Thai = 38,
1943 Tibetan = 39,
1944 CanadianAboriginal = 40,
1945 Yi = 41,
1946 Tagalog = 42,
1947 Hanunoo = 43,
1948 Buhid = 44,
1949 Tagbanwa = 45,
1950 Braille = 46,
1951 Cypriot = 47,
1952 Limbu = 48,
1953 Osmanya = 49,
1954 Shavian = 50,
1955 LinearB = 51,
1956 TaiLe = 52,
1957 Ugaritic = 53,
1958 NewTaiLue = 54,
1959 Buginese = 55,
1960 Glagolitic = 56,
1961 Tifinagh = 57,
1962 SylotiNagri = 58,
1963 OldPersian = 59,
1964 Kharoshthi = 60,
1965 Unknown = 61,
1966 Balinese = 62,
1967 Cuneiform = 63,
1968 Phoenician = 64,
1969 PhagsPa = 65,
1970 Nko = 66,
1971 KayahLi = 67,
1972 Lepcha = 68,
1973 Rejang = 69,
1974 Sundanese = 70,
1975 Saurashtra = 71,
1976 Cham = 72,
1977 OlChiki = 73,
1978 Vai = 74,
1979 Carian = 75,
1980 Lycian = 76,
1981 Lydian = 77,
1982 Avestan = 78,
1983 Bamum = 79,
1984 EgyptianHieroglyphs = 80,
1985 ImperialAramaic = 81,
1986 InscriptionalPahlavi = 82,
1987 InscriptionalParthian = 83,
1988 Javanese = 84,
1989 Kaithi = 85,
1990 Lisu = 86,
1991 MeeteiMayek = 87,
1992 OldSouthArabian = 88,
1993 OldTurkic = 89,
1994 Samaritan = 90,
1995 TaiTham = 91,
1996 TaiViet = 92,
1997 Batak = 93,
1998 Brahmi = 94,
1999 Mandaic = 95,
2000 Chakma = 96,
2001 MeroiticCursive = 97,
2002 MeroiticHieroglyphs = 98,
2003 Miao = 99,
2004 Sharada = 100,
2005 SoraSompeng = 101,
2006 Takri = 102,
2007 BassaVah = 103,
2008 CaucasianAlbanian = 104,
2009 Duployan = 105,
2010 Elbasan = 106,
2011 Grantha = 107,
2012 Khojki = 108,
2013 Khudawadi = 109,
2014 LinearA = 110,
2015 Mahajani = 111,
2016 Manichaean = 112,
2017 MendeKikakui = 113,
2018 Modi = 114,
2019 Mro = 115,
2020 Nabataean = 116,
2021 OldNorthArabian = 117,
2022 OldPermic = 118,
2023 PahawhHmong = 119,
2024 Palmyrene = 120,
2025 PauCinHau = 121,
2026 PsalterPahlavi = 122,
2027 Siddham = 123,
2028 Tirhuta = 124,
2029 WarangCiti = 125,
2030}
2031pub const G_UNICODE_SCRIPT_INVALID_CODE: GUnicodeScript = GUnicodeScript::InvalidCode;
2032pub const G_UNICODE_SCRIPT_COMMON: GUnicodeScript = GUnicodeScript::Common;
2033pub const G_UNICODE_SCRIPT_INHERITED: GUnicodeScript = GUnicodeScript::Inherited;
2034pub const G_UNICODE_SCRIPT_ARABIC: GUnicodeScript = GUnicodeScript::Arabic;
2035pub const G_UNICODE_SCRIPT_ARMENIAN: GUnicodeScript = GUnicodeScript::Armenian;
2036pub const G_UNICODE_SCRIPT_BENGALI: GUnicodeScript = GUnicodeScript::Bengali;
2037pub const G_UNICODE_SCRIPT_BOPOMOFO: GUnicodeScript = GUnicodeScript::Bopomofo;
2038pub const G_UNICODE_SCRIPT_CHEROKEE: GUnicodeScript = GUnicodeScript::Cherokee;
2039pub const G_UNICODE_SCRIPT_COPTIC: GUnicodeScript = GUnicodeScript::Coptic;
2040pub const G_UNICODE_SCRIPT_CYRILLIC: GUnicodeScript = GUnicodeScript::Cyrillic;
2041pub const G_UNICODE_SCRIPT_DESERET: GUnicodeScript = GUnicodeScript::Deseret;
2042pub const G_UNICODE_SCRIPT_DEVANAGARI: GUnicodeScript = GUnicodeScript::Devanagari;
2043pub const G_UNICODE_SCRIPT_ETHIOPIC: GUnicodeScript = GUnicodeScript::Ethiopic;
2044pub const G_UNICODE_SCRIPT_GEORGIAN: GUnicodeScript = GUnicodeScript::Georgian;
2045pub const G_UNICODE_SCRIPT_GOTHIC: GUnicodeScript = GUnicodeScript::Gothic;
2046pub const G_UNICODE_SCRIPT_GREEK: GUnicodeScript = GUnicodeScript::Greek;
2047pub const G_UNICODE_SCRIPT_GUJARATI: GUnicodeScript = GUnicodeScript::Gujarati;
2048pub const G_UNICODE_SCRIPT_GURMUKHI: GUnicodeScript = GUnicodeScript::Gurmukhi;
2049pub const G_UNICODE_SCRIPT_HAN: GUnicodeScript = GUnicodeScript::Han;
2050pub const G_UNICODE_SCRIPT_HANGUL: GUnicodeScript = GUnicodeScript::Hangul;
2051pub const G_UNICODE_SCRIPT_HEBREW: GUnicodeScript = GUnicodeScript::Hebrew;
2052pub const G_UNICODE_SCRIPT_HIRAGANA: GUnicodeScript = GUnicodeScript::Hiragana;
2053pub const G_UNICODE_SCRIPT_KANNADA: GUnicodeScript = GUnicodeScript::Kannada;
2054pub const G_UNICODE_SCRIPT_KATAKANA: GUnicodeScript = GUnicodeScript::Katakana;
2055pub const G_UNICODE_SCRIPT_KHMER: GUnicodeScript = GUnicodeScript::Khmer;
2056pub const G_UNICODE_SCRIPT_LAO: GUnicodeScript = GUnicodeScript::Lao;
2057pub const G_UNICODE_SCRIPT_LATIN: GUnicodeScript = GUnicodeScript::Latin;
2058pub const G_UNICODE_SCRIPT_MALAYALAM: GUnicodeScript = GUnicodeScript::Malayalam;
2059pub const G_UNICODE_SCRIPT_MONGOLIAN: GUnicodeScript = GUnicodeScript::Mongolian;
2060pub const G_UNICODE_SCRIPT_MYANMAR: GUnicodeScript = GUnicodeScript::Myanmar;
2061pub const G_UNICODE_SCRIPT_OGHAM: GUnicodeScript = GUnicodeScript::Ogham;
2062pub const G_UNICODE_SCRIPT_OLD_ITALIC: GUnicodeScript = GUnicodeScript::OldItalic;
2063pub const G_UNICODE_SCRIPT_ORIYA: GUnicodeScript = GUnicodeScript::Oriya;
2064pub const G_UNICODE_SCRIPT_RUNIC: GUnicodeScript = GUnicodeScript::Runic;
2065pub const G_UNICODE_SCRIPT_SINHALA: GUnicodeScript = GUnicodeScript::Sinhala;
2066pub const G_UNICODE_SCRIPT_SYRIAC: GUnicodeScript = GUnicodeScript::Syriac;
2067pub const G_UNICODE_SCRIPT_TAMIL: GUnicodeScript = GUnicodeScript::Tamil;
2068pub const G_UNICODE_SCRIPT_TELUGU: GUnicodeScript = GUnicodeScript::Telugu;
2069pub const G_UNICODE_SCRIPT_THAANA: GUnicodeScript = GUnicodeScript::Thaana;
2070pub const G_UNICODE_SCRIPT_THAI: GUnicodeScript = GUnicodeScript::Thai;
2071pub const G_UNICODE_SCRIPT_TIBETAN: GUnicodeScript = GUnicodeScript::Tibetan;
2072pub const G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL: GUnicodeScript = GUnicodeScript::CanadianAboriginal;
2073pub const G_UNICODE_SCRIPT_YI: GUnicodeScript = GUnicodeScript::Yi;
2074pub const G_UNICODE_SCRIPT_TAGALOG: GUnicodeScript = GUnicodeScript::Tagalog;
2075pub const G_UNICODE_SCRIPT_HANUNOO: GUnicodeScript = GUnicodeScript::Hanunoo;
2076pub const G_UNICODE_SCRIPT_BUHID: GUnicodeScript = GUnicodeScript::Buhid;
2077pub const G_UNICODE_SCRIPT_TAGBANWA: GUnicodeScript = GUnicodeScript::Tagbanwa;
2078pub const G_UNICODE_SCRIPT_BRAILLE: GUnicodeScript = GUnicodeScript::Braille;
2079pub const G_UNICODE_SCRIPT_CYPRIOT: GUnicodeScript = GUnicodeScript::Cypriot;
2080pub const G_UNICODE_SCRIPT_LIMBU: GUnicodeScript = GUnicodeScript::Limbu;
2081pub const G_UNICODE_SCRIPT_OSMANYA: GUnicodeScript = GUnicodeScript::Osmanya;
2082pub const G_UNICODE_SCRIPT_SHAVIAN: GUnicodeScript = GUnicodeScript::Shavian;
2083pub const G_UNICODE_SCRIPT_LINEAR_B: GUnicodeScript = GUnicodeScript::LinearB;
2084pub const G_UNICODE_SCRIPT_TAI_LE: GUnicodeScript = GUnicodeScript::TaiLe;
2085pub const G_UNICODE_SCRIPT_UGARITIC: GUnicodeScript = GUnicodeScript::Ugaritic;
2086pub const G_UNICODE_SCRIPT_NEW_TAI_LUE: GUnicodeScript = GUnicodeScript::NewTaiLue;
2087pub const G_UNICODE_SCRIPT_BUGINESE: GUnicodeScript = GUnicodeScript::Buginese;
2088pub const G_UNICODE_SCRIPT_GLAGOLITIC: GUnicodeScript = GUnicodeScript::Glagolitic;
2089pub const G_UNICODE_SCRIPT_TIFINAGH: GUnicodeScript = GUnicodeScript::Tifinagh;
2090pub const G_UNICODE_SCRIPT_SYLOTI_NAGRI: GUnicodeScript = GUnicodeScript::SylotiNagri;
2091pub const G_UNICODE_SCRIPT_OLD_PERSIAN: GUnicodeScript = GUnicodeScript::OldPersian;
2092pub const G_UNICODE_SCRIPT_KHAROSHTHI: GUnicodeScript = GUnicodeScript::Kharoshthi;
2093pub const G_UNICODE_SCRIPT_UNKNOWN: GUnicodeScript = GUnicodeScript::Unknown;
2094pub const G_UNICODE_SCRIPT_BALINESE: GUnicodeScript = GUnicodeScript::Balinese;
2095pub const G_UNICODE_SCRIPT_CUNEIFORM: GUnicodeScript = GUnicodeScript::Cuneiform;
2096pub const G_UNICODE_SCRIPT_PHOENICIAN: GUnicodeScript = GUnicodeScript::Phoenician;
2097pub const G_UNICODE_SCRIPT_PHAGS_PA: GUnicodeScript = GUnicodeScript::PhagsPa;
2098pub const G_UNICODE_SCRIPT_NKO: GUnicodeScript = GUnicodeScript::Nko;
2099pub const G_UNICODE_SCRIPT_KAYAH_LI: GUnicodeScript = GUnicodeScript::KayahLi;
2100pub const G_UNICODE_SCRIPT_LEPCHA: GUnicodeScript = GUnicodeScript::Lepcha;
2101pub const G_UNICODE_SCRIPT_REJANG: GUnicodeScript = GUnicodeScript::Rejang;
2102pub const G_UNICODE_SCRIPT_SUNDANESE: GUnicodeScript = GUnicodeScript::Sundanese;
2103pub const G_UNICODE_SCRIPT_SAURASHTRA: GUnicodeScript = GUnicodeScript::Saurashtra;
2104pub const G_UNICODE_SCRIPT_CHAM: GUnicodeScript = GUnicodeScript::Cham;
2105pub const G_UNICODE_SCRIPT_OL_CHIKI: GUnicodeScript = GUnicodeScript::OlChiki;
2106pub const G_UNICODE_SCRIPT_VAI: GUnicodeScript = GUnicodeScript::Vai;
2107pub const G_UNICODE_SCRIPT_CARIAN: GUnicodeScript = GUnicodeScript::Carian;
2108pub const G_UNICODE_SCRIPT_LYCIAN: GUnicodeScript = GUnicodeScript::Lycian;
2109pub const G_UNICODE_SCRIPT_LYDIAN: GUnicodeScript = GUnicodeScript::Lydian;
2110pub const G_UNICODE_SCRIPT_AVESTAN: GUnicodeScript = GUnicodeScript::Avestan;
2111pub const G_UNICODE_SCRIPT_BAMUM: GUnicodeScript = GUnicodeScript::Bamum;
2112pub const G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS: GUnicodeScript = GUnicodeScript::EgyptianHieroglyphs;
2113pub const G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC: GUnicodeScript = GUnicodeScript::ImperialAramaic;
2114pub const G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI: GUnicodeScript = GUnicodeScript::InscriptionalPahlavi;
2115pub const G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN: GUnicodeScript = GUnicodeScript::InscriptionalParthian;
2116pub const G_UNICODE_SCRIPT_JAVANESE: GUnicodeScript = GUnicodeScript::Javanese;
2117pub const G_UNICODE_SCRIPT_KAITHI: GUnicodeScript = GUnicodeScript::Kaithi;
2118pub const G_UNICODE_SCRIPT_LISU: GUnicodeScript = GUnicodeScript::Lisu;
2119pub const G_UNICODE_SCRIPT_MEETEI_MAYEK: GUnicodeScript = GUnicodeScript::MeeteiMayek;
2120pub const G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN: GUnicodeScript = GUnicodeScript::OldSouthArabian;
2121pub const G_UNICODE_SCRIPT_OLD_TURKIC: GUnicodeScript = GUnicodeScript::OldTurkic;
2122pub const G_UNICODE_SCRIPT_SAMARITAN: GUnicodeScript = GUnicodeScript::Samaritan;
2123pub const G_UNICODE_SCRIPT_TAI_THAM: GUnicodeScript = GUnicodeScript::TaiTham;
2124pub const G_UNICODE_SCRIPT_TAI_VIET: GUnicodeScript = GUnicodeScript::TaiViet;
2125pub const G_UNICODE_SCRIPT_BATAK: GUnicodeScript = GUnicodeScript::Batak;
2126pub const G_UNICODE_SCRIPT_BRAHMI: GUnicodeScript = GUnicodeScript::Brahmi;
2127pub const G_UNICODE_SCRIPT_MANDAIC: GUnicodeScript = GUnicodeScript::Mandaic;
2128pub const G_UNICODE_SCRIPT_CHAKMA: GUnicodeScript = GUnicodeScript::Chakma;
2129pub const G_UNICODE_SCRIPT_MEROITIC_CURSIVE: GUnicodeScript = GUnicodeScript::MeroiticCursive;
2130pub const G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS: GUnicodeScript = GUnicodeScript::MeroiticHieroglyphs;
2131pub const G_UNICODE_SCRIPT_MIAO: GUnicodeScript = GUnicodeScript::Miao;
2132pub const G_UNICODE_SCRIPT_SHARADA: GUnicodeScript = GUnicodeScript::Sharada;
2133pub const G_UNICODE_SCRIPT_SORA_SOMPENG: GUnicodeScript = GUnicodeScript::SoraSompeng;
2134pub const G_UNICODE_SCRIPT_TAKRI: GUnicodeScript = GUnicodeScript::Takri;
2135pub const G_UNICODE_SCRIPT_BASSA_VAH: GUnicodeScript = GUnicodeScript::BassaVah;
2136pub const G_UNICODE_SCRIPT_CAUCASIAN_ALBANIAN: GUnicodeScript = GUnicodeScript::CaucasianAlbanian;
2137pub const G_UNICODE_SCRIPT_DUPLOYAN: GUnicodeScript = GUnicodeScript::Duployan;
2138pub const G_UNICODE_SCRIPT_ELBASAN: GUnicodeScript = GUnicodeScript::Elbasan;
2139pub const G_UNICODE_SCRIPT_GRANTHA: GUnicodeScript = GUnicodeScript::Grantha;
2140pub const G_UNICODE_SCRIPT_KHOJKI: GUnicodeScript = GUnicodeScript::Khojki;
2141pub const G_UNICODE_SCRIPT_KHUDAWADI: GUnicodeScript = GUnicodeScript::Khudawadi;
2142pub const G_UNICODE_SCRIPT_LINEAR_A: GUnicodeScript = GUnicodeScript::LinearA;
2143pub const G_UNICODE_SCRIPT_MAHAJANI: GUnicodeScript = GUnicodeScript::Mahajani;
2144pub const G_UNICODE_SCRIPT_MANICHAEAN: GUnicodeScript = GUnicodeScript::Manichaean;
2145pub const G_UNICODE_SCRIPT_MENDE_KIKAKUI: GUnicodeScript = GUnicodeScript::MendeKikakui;
2146pub const G_UNICODE_SCRIPT_MODI: GUnicodeScript = GUnicodeScript::Modi;
2147pub const G_UNICODE_SCRIPT_MRO: GUnicodeScript = GUnicodeScript::Mro;
2148pub const G_UNICODE_SCRIPT_NABATAEAN: GUnicodeScript = GUnicodeScript::Nabataean;
2149pub const G_UNICODE_SCRIPT_OLD_NORTH_ARABIAN: GUnicodeScript = GUnicodeScript::OldNorthArabian;
2150pub const G_UNICODE_SCRIPT_OLD_PERMIC: GUnicodeScript = GUnicodeScript::OldPermic;
2151pub const G_UNICODE_SCRIPT_PAHAWH_HMONG: GUnicodeScript = GUnicodeScript::PahawhHmong;
2152pub const G_UNICODE_SCRIPT_PALMYRENE: GUnicodeScript = GUnicodeScript::Palmyrene;
2153pub const G_UNICODE_SCRIPT_PAU_CIN_HAU: GUnicodeScript = GUnicodeScript::PauCinHau;
2154pub const G_UNICODE_SCRIPT_PSALTER_PAHLAVI: GUnicodeScript = GUnicodeScript::PsalterPahlavi;
2155pub const G_UNICODE_SCRIPT_SIDDHAM: GUnicodeScript = GUnicodeScript::Siddham;
2156pub const G_UNICODE_SCRIPT_TIRHUTA: GUnicodeScript = GUnicodeScript::Tirhuta;
2157pub const G_UNICODE_SCRIPT_WARANG_CITI: GUnicodeScript = GUnicodeScript::WarangCiti;
2158
2159#[repr(C)]
2160pub enum GUnicodeType {
2161 Control = 0,
2162 Format = 1,
2163 Unassigned = 2,
2164 PrivateUse = 3,
2165 Surrogate = 4,
2166 LowercaseLetter = 5,
2167 ModifierLetter = 6,
2168 OtherLetter = 7,
2169 TitlecaseLetter = 8,
2170 UppercaseLetter = 9,
2171 SpacingMark = 10,
2172 EnclosingMark = 11,
2173 NonSpacingMark = 12,
2174 DecimalNumber = 13,
2175 LetterNumber = 14,
2176 OtherNumber = 15,
2177 ConnectPunctuation = 16,
2178 DashPunctuation = 17,
2179 ClosePunctuation = 18,
2180 FinalPunctuation = 19,
2181 InitialPunctuation = 20,
2182 OtherPunctuation = 21,
2183 OpenPunctuation = 22,
2184 CurrencySymbol = 23,
2185 ModifierSymbol = 24,
2186 MathSymbol = 25,
2187 OtherSymbol = 26,
2188 LineSeparator = 27,
2189 ParagraphSeparator = 28,
2190 SpaceSeparator = 29,
2191}
2192pub const G_UNICODE_CONTROL: GUnicodeType = GUnicodeType::Control;
2193pub const G_UNICODE_FORMAT: GUnicodeType = GUnicodeType::Format;
2194pub const G_UNICODE_UNASSIGNED: GUnicodeType = GUnicodeType::Unassigned;
2195pub const G_UNICODE_PRIVATE_USE: GUnicodeType = GUnicodeType::PrivateUse;
2196pub const G_UNICODE_SURROGATE: GUnicodeType = GUnicodeType::Surrogate;
2197pub const G_UNICODE_LOWERCASE_LETTER: GUnicodeType = GUnicodeType::LowercaseLetter;
2198pub const G_UNICODE_MODIFIER_LETTER: GUnicodeType = GUnicodeType::ModifierLetter;
2199pub const G_UNICODE_OTHER_LETTER: GUnicodeType = GUnicodeType::OtherLetter;
2200pub const G_UNICODE_TITLECASE_LETTER: GUnicodeType = GUnicodeType::TitlecaseLetter;
2201pub const G_UNICODE_UPPERCASE_LETTER: GUnicodeType = GUnicodeType::UppercaseLetter;
2202pub const G_UNICODE_SPACING_MARK: GUnicodeType = GUnicodeType::SpacingMark;
2203pub const G_UNICODE_ENCLOSING_MARK: GUnicodeType = GUnicodeType::EnclosingMark;
2204pub const G_UNICODE_NON_SPACING_MARK: GUnicodeType = GUnicodeType::NonSpacingMark;
2205pub const G_UNICODE_DECIMAL_NUMBER: GUnicodeType = GUnicodeType::DecimalNumber;
2206pub const G_UNICODE_LETTER_NUMBER: GUnicodeType = GUnicodeType::LetterNumber;
2207pub const G_UNICODE_OTHER_NUMBER: GUnicodeType = GUnicodeType::OtherNumber;
2208pub const G_UNICODE_CONNECT_PUNCTUATION: GUnicodeType = GUnicodeType::ConnectPunctuation;
2209pub const G_UNICODE_DASH_PUNCTUATION: GUnicodeType = GUnicodeType::DashPunctuation;
2210pub const G_UNICODE_CLOSE_PUNCTUATION: GUnicodeType = GUnicodeType::ClosePunctuation;
2211pub const G_UNICODE_FINAL_PUNCTUATION: GUnicodeType = GUnicodeType::FinalPunctuation;
2212pub const G_UNICODE_INITIAL_PUNCTUATION: GUnicodeType = GUnicodeType::InitialPunctuation;
2213pub const G_UNICODE_OTHER_PUNCTUATION: GUnicodeType = GUnicodeType::OtherPunctuation;
2214pub const G_UNICODE_OPEN_PUNCTUATION: GUnicodeType = GUnicodeType::OpenPunctuation;
2215pub const G_UNICODE_CURRENCY_SYMBOL: GUnicodeType = GUnicodeType::CurrencySymbol;
2216pub const G_UNICODE_MODIFIER_SYMBOL: GUnicodeType = GUnicodeType::ModifierSymbol;
2217pub const G_UNICODE_MATH_SYMBOL: GUnicodeType = GUnicodeType::MathSymbol;
2218pub const G_UNICODE_OTHER_SYMBOL: GUnicodeType = GUnicodeType::OtherSymbol;
2219pub const G_UNICODE_LINE_SEPARATOR: GUnicodeType = GUnicodeType::LineSeparator;
2220pub const G_UNICODE_PARAGRAPH_SEPARATOR: GUnicodeType = GUnicodeType::ParagraphSeparator;
2221pub const G_UNICODE_SPACE_SEPARATOR: GUnicodeType = GUnicodeType::SpaceSeparator;
2222
2223pub type GUnixFDSourceFunc = extern "C" fn (gint, GIOCondition, gpointer) -> gboolean;
2224
2225#[repr(C)]
2226pub enum GUserDirectory {
2227 DirectoryDesktop = 0,
2228 DirectoryDocuments = 1,
2229 DirectoryDownload = 2,
2230 DirectoryMusic = 3,
2231 DirectoryPictures = 4,
2232 DirectoryPublicShare = 5,
2233 DirectoryTemplates = 6,
2234 DirectoryVideos = 7,
2235 NDirectories = 8,
2236}
2237pub const G_USER_DIRECTORY_DESKTOP: GUserDirectory = GUserDirectory::DirectoryDesktop;
2238pub const G_USER_DIRECTORY_DOCUMENTS: GUserDirectory = GUserDirectory::DirectoryDocuments;
2239pub const G_USER_DIRECTORY_DOWNLOAD: GUserDirectory = GUserDirectory::DirectoryDownload;
2240pub const G_USER_DIRECTORY_MUSIC: GUserDirectory = GUserDirectory::DirectoryMusic;
2241pub const G_USER_DIRECTORY_PICTURES: GUserDirectory = GUserDirectory::DirectoryPictures;
2242pub const G_USER_DIRECTORY_PUBLIC_SHARE: GUserDirectory = GUserDirectory::DirectoryPublicShare;
2243pub const G_USER_DIRECTORY_TEMPLATES: GUserDirectory = GUserDirectory::DirectoryTemplates;
2244pub const G_USER_DIRECTORY_VIDEOS: GUserDirectory = GUserDirectory::DirectoryVideos;
2245pub const G_USER_N_DIRECTORIES: GUserDirectory = GUserDirectory::NDirectories;
2246
2247pub const GLIB_VERSION_MIN_REQUIRED: gint = 2;
2248
2249pub enum GVariant { }
2250
2251#[repr(C)]
2252pub struct GVariantBuilder {
2253 x: [gsize; 16],
2254}
2255
2256#[repr(C)]
2257pub enum GVariantClass {
2258 Tuple = 40,
2259 Array = 97,
2260 Boolean = 98,
2261 Double = 100,
2262 Signature = 103,
2263 Handle = 104,
2264 Int32 = 105,
2265 Maybe = 109,
2266 Int16 = 110,
2267 ObjectPath = 111,
2268 Uint16 = 113,
2269 String = 115,
2270 Uint64 = 116,
2271 Uint32 = 117,
2272 Variant = 118,
2273 Int64 = 120,
2274 Byte = 121,
2275 DictEntry = 123,
2276}
2277pub const G_VARIANT_CLASS_BOOLEAN: GVariantClass = GVariantClass::Boolean;
2278pub const G_VARIANT_CLASS_BYTE: GVariantClass = GVariantClass::Byte;
2279pub const G_VARIANT_CLASS_INT16: GVariantClass = GVariantClass::Int16;
2280pub const G_VARIANT_CLASS_UINT16: GVariantClass = GVariantClass::Uint16;
2281pub const G_VARIANT_CLASS_INT32: GVariantClass = GVariantClass::Int32;
2282pub const G_VARIANT_CLASS_UINT32: GVariantClass = GVariantClass::Uint32;
2283pub const G_VARIANT_CLASS_INT64: GVariantClass = GVariantClass::Int64;
2284pub const G_VARIANT_CLASS_UINT64: GVariantClass = GVariantClass::Uint64;
2285pub const G_VARIANT_CLASS_HANDLE: GVariantClass = GVariantClass::Handle;
2286pub const G_VARIANT_CLASS_DOUBLE: GVariantClass = GVariantClass::Double;
2287pub const G_VARIANT_CLASS_STRING: GVariantClass = GVariantClass::String;
2288pub const G_VARIANT_CLASS_OBJECT_PATH: GVariantClass = GVariantClass::ObjectPath;
2289pub const G_VARIANT_CLASS_SIGNATURE: GVariantClass = GVariantClass::Signature;
2290pub const G_VARIANT_CLASS_VARIANT: GVariantClass = GVariantClass::Variant;
2291pub const G_VARIANT_CLASS_MAYBE: GVariantClass = GVariantClass::Maybe;
2292pub const G_VARIANT_CLASS_ARRAY: GVariantClass = GVariantClass::Array;
2293pub const G_VARIANT_CLASS_TUPLE: GVariantClass = GVariantClass::Tuple;
2294pub const G_VARIANT_CLASS_DICT_ENTRY: GVariantClass = GVariantClass::DictEntry;
2295
2296#[repr(C)]
2297pub struct GVariantDict {
2298 x: [gsize; 16],
2299}
2300
2301#[repr(C)]
2302pub struct GVariantIter {
2303 x: [gsize; 16],
2304}
2305
2306#[repr(C)]
2307pub enum GVariantParseError {
2308 Failed = 0,
2309 BasicTypeExpected = 1,
2310 CannotInferType = 2,
2311 DefiniteTypeExpected = 3,
2312 InputNotAtEnd = 4,
2313 InvalidCharacter = 5,
2314 InvalidFormatString = 6,
2315 InvalidObjectPath = 7,
2316 InvalidSignature = 8,
2317 InvalidTypeString = 9,
2318 NoCommonType = 10,
2319 NumberOutOfRange = 11,
2320 NumberTooBig = 12,
2321 TypeError = 13,
2322 UnexpectedToken = 14,
2323 UnknownKeyword = 15,
2324 UnterminatedStringConstant = 16,
2325 ValueExpected = 17,
2326}
2327pub const G_VARIANT_PARSE_ERROR_FAILED: GVariantParseError = GVariantParseError::Failed;
2328pub const G_VARIANT_PARSE_ERROR_BASIC_TYPE_EXPECTED: GVariantParseError = GVariantParseError::BasicTypeExpected;
2329pub const G_VARIANT_PARSE_ERROR_CANNOT_INFER_TYPE: GVariantParseError = GVariantParseError::CannotInferType;
2330pub const G_VARIANT_PARSE_ERROR_DEFINITE_TYPE_EXPECTED: GVariantParseError = GVariantParseError::DefiniteTypeExpected;
2331pub const G_VARIANT_PARSE_ERROR_INPUT_NOT_AT_END: GVariantParseError = GVariantParseError::InputNotAtEnd;
2332pub const G_VARIANT_PARSE_ERROR_INVALID_CHARACTER: GVariantParseError = GVariantParseError::InvalidCharacter;
2333pub const G_VARIANT_PARSE_ERROR_INVALID_FORMAT_STRING: GVariantParseError = GVariantParseError::InvalidFormatString;
2334pub const G_VARIANT_PARSE_ERROR_INVALID_OBJECT_PATH: GVariantParseError = GVariantParseError::InvalidObjectPath;
2335pub const G_VARIANT_PARSE_ERROR_INVALID_SIGNATURE: GVariantParseError = GVariantParseError::InvalidSignature;
2336pub const G_VARIANT_PARSE_ERROR_INVALID_TYPE_STRING: GVariantParseError = GVariantParseError::InvalidTypeString;
2337pub const G_VARIANT_PARSE_ERROR_NO_COMMON_TYPE: GVariantParseError = GVariantParseError::NoCommonType;
2338pub const G_VARIANT_PARSE_ERROR_NUMBER_OUT_OF_RANGE: GVariantParseError = GVariantParseError::NumberOutOfRange;
2339pub const G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG: GVariantParseError = GVariantParseError::NumberTooBig;
2340pub const G_VARIANT_PARSE_ERROR_TYPE_ERROR: GVariantParseError = GVariantParseError::TypeError;
2341pub const G_VARIANT_PARSE_ERROR_UNEXPECTED_TOKEN: GVariantParseError = GVariantParseError::UnexpectedToken;
2342pub const G_VARIANT_PARSE_ERROR_UNKNOWN_KEYWORD: GVariantParseError = GVariantParseError::UnknownKeyword;
2343pub const G_VARIANT_PARSE_ERROR_UNTERMINATED_STRING_CONSTANT: GVariantParseError = GVariantParseError::UnterminatedStringConstant;
2344pub const G_VARIANT_PARSE_ERROR_VALUE_EXPECTED: GVariantParseError = GVariantParseError::ValueExpected;
2345
2346pub enum GVariantType { }
2347
2348pub type GVoidFunc = extern "C" fn ();
2349
2350pub const G_WIN32_MSG_HANDLE: gint = 19981206;
2351
2352extern {
2353 pub fn g_access(filename: *const gchar, mode: gint) -> gint;
2354 pub fn g_array_append_vals(array: *mut GArray, data: gconstpointer, len: guint) -> *mut GArray;
2355 pub fn g_array_free(array: *mut GArray, free_segment: gboolean) -> *mut gchar;
2356 pub fn g_array_get_element_size(array: *mut GArray) -> guint;
2357 pub fn g_array_insert_vals(array: *mut GArray, index_: guint, data: gconstpointer, len: guint) -> *mut GArray;
2358 pub fn g_array_new(zero_terminated: gboolean, clear_: gboolean, element_size: guint) -> *mut GArray;
2359 pub fn g_array_prepend_vals(array: *mut GArray, data: gconstpointer, len: guint) -> *mut GArray;
2360 pub fn g_array_ref(array: *mut GArray) -> *mut GArray;
2361 pub fn g_array_remove_index(array: *mut GArray, index_: guint) -> *mut GArray;
2362 pub fn g_array_remove_index_fast(array: *mut GArray, index_: guint) -> *mut GArray;
2363 pub fn g_array_remove_range(array: *mut GArray, index_: guint, length: guint) -> *mut GArray;
2364 pub fn g_array_set_clear_func(array: *mut GArray, clear_func: GDestroyNotify);
2365 pub fn g_array_set_size(array: *mut GArray, length: guint) -> *mut GArray;
2366 pub fn g_array_sized_new(zero_terminated: gboolean, clear_: gboolean, element_size: guint, reserved_size: guint) -> *mut GArray;
2367 pub fn g_array_sort(array: *mut GArray, compare_func: GCompareFunc);
2368 pub fn g_array_sort_with_data(array: *mut GArray, compare_func: GCompareDataFunc, user_data: gpointer);
2369 pub fn g_array_unref(array: *mut GArray);
2370 pub fn g_ascii_digit_value(c: gchar) -> gint;
2371 pub fn g_ascii_dtostr(buffer: *mut gchar, buf_len: gint, d: gdouble) -> *mut gchar;
2372 pub fn g_ascii_formatd(buffer: *mut gchar, buf_len: gint, format: *const gchar, d: gdouble) -> *mut gchar;
2373 pub fn g_ascii_strcasecmp(s1: *const gchar, s2: *const gchar) -> gint;
2374 pub fn g_ascii_strdown(str: *const gchar, len: gssize) -> *mut gchar;
2375 pub fn g_ascii_strncasecmp(s1: *const gchar, s2: *const gchar, n: gsize) -> gint;
2376 pub fn g_ascii_strtod(nptr: *const gchar, endptr: *mut *mut gchar) -> gdouble;
2377 pub fn g_ascii_strtoll(nptr: *const gchar, endptr: *mut *mut gchar, base: guint) -> i64;
2378 pub fn g_ascii_strtoull(nptr: *const gchar, endptr: *mut *mut gchar, base: guint) -> u64;
2379 pub fn g_ascii_strup(str: *const gchar, len: gssize) -> *mut gchar;
2380 pub fn g_ascii_tolower(c: gchar) -> gchar;
2381 pub fn g_ascii_toupper(c: gchar) -> gchar;
2382 pub fn g_ascii_xdigit_value(c: gchar) -> gint;
2383 pub fn g_assert_warning(log_domain: *const gchar, file: *const gchar, line: gint, pretty_function: *const gchar, expression: *const gchar);
2384 pub fn g_assertion_message(domain: *const gchar, file: *const gchar, line: gint, func: *const gchar, message: *const gchar);
2385 pub fn g_assertion_message_cmpstr(domain: *const gchar, file: *const gchar, line: gint, func: *const gchar, expr: *const gchar, arg1: *const gchar, cmp: *const gchar, arg2: *const gchar);
2386 pub fn g_assertion_message_error(domain: *const gchar, file: *const gchar, line: gint, func: *const gchar, expr: *const gchar, error: *const GError, error_domain: GQuark, error_code: gint);
2387 pub fn g_assertion_message_expr(domain: *const gchar, file: *const gchar, line: gint, func: *const gchar, expr: *const gchar);
2388 pub fn g_async_queue_length(queue: *mut GAsyncQueue) -> gint;
2389 pub fn g_async_queue_length_unlocked(queue: *mut GAsyncQueue) -> gint;
2390 pub fn g_async_queue_lock(queue: *mut GAsyncQueue);
2391 pub fn g_async_queue_new() -> *mut GAsyncQueue;
2392 pub fn g_async_queue_new_full(item_free_func: GDestroyNotify) -> *mut GAsyncQueue;
2393 pub fn g_async_queue_pop(queue: *mut GAsyncQueue) -> gpointer;
2394 pub fn g_async_queue_pop_unlocked(queue: *mut GAsyncQueue) -> gpointer;
2395 pub fn g_async_queue_push(queue: *mut GAsyncQueue, data: gpointer);
2396 pub fn g_async_queue_push_front(queue: *mut GAsyncQueue, item: gpointer);
2397 pub fn g_async_queue_push_front_unlocked(queue: *mut GAsyncQueue, item: gpointer);
2398 pub fn g_async_queue_push_sorted(queue: *mut GAsyncQueue, data: gpointer, func: GCompareDataFunc, user_data: gpointer);
2399 pub fn g_async_queue_push_sorted_unlocked(queue: *mut GAsyncQueue, data: gpointer, func: GCompareDataFunc, user_data: gpointer);
2400 pub fn g_async_queue_push_unlocked(queue: *mut GAsyncQueue, data: gpointer);
2401 pub fn g_async_queue_ref(queue: *mut GAsyncQueue) -> *mut GAsyncQueue;
2402 pub fn g_async_queue_ref_unlocked(queue: *mut GAsyncQueue);
2403 pub fn g_async_queue_remove(queue: *mut GAsyncQueue, item: gpointer) -> gboolean;
2404 pub fn g_async_queue_remove_unlocked(queue: *mut GAsyncQueue, item: gpointer) -> gboolean;
2405 pub fn g_async_queue_sort(queue: *mut GAsyncQueue, func: GCompareDataFunc, user_data: gpointer);
2406 pub fn g_async_queue_sort_unlocked(queue: *mut GAsyncQueue, func: GCompareDataFunc, user_data: gpointer);
2407 pub fn g_async_queue_timed_pop(queue: *mut GAsyncQueue, end_time: *mut GTimeVal) -> gpointer;
2408 pub fn g_async_queue_timed_pop_unlocked(queue: *mut GAsyncQueue, end_time: *mut GTimeVal) -> gpointer;
2409 pub fn g_async_queue_timeout_pop(queue: *mut GAsyncQueue, timeout: u64) -> gpointer;
2410 pub fn g_async_queue_timeout_pop_unlocked(queue: *mut GAsyncQueue, timeout: u64) -> gpointer;
2411 pub fn g_async_queue_try_pop(queue: *mut GAsyncQueue) -> gpointer;
2412 pub fn g_async_queue_try_pop_unlocked(queue: *mut GAsyncQueue) -> gpointer;
2413 pub fn g_async_queue_unlock(queue: *mut GAsyncQueue);
2414 pub fn g_async_queue_unref(queue: *mut GAsyncQueue);
2415 pub fn g_async_queue_unref_and_unlock(queue: *mut GAsyncQueue);
2416 pub fn g_atexit(func: GVoidFunc);
2417 pub fn g_atomic_int_add(atomic: gint, val: gint) -> gint;
2418 pub fn g_atomic_int_and(atomic: guint, val: guint) -> guint;
2419 pub fn g_atomic_int_compare_and_exchange(atomic: gint, oldval: gint, newval: gint) -> gboolean;
2420 pub fn g_atomic_int_dec_and_test(atomic: gint) -> gboolean;
2421 pub fn g_atomic_int_exchange_and_add(atomic: gint, val: gint) -> gint;
2422 pub fn g_atomic_int_get(atomic: gint) -> gint;
2423 pub fn g_atomic_int_inc(atomic: gint);
2424 pub fn g_atomic_int_or(atomic: guint, val: guint) -> guint;
2425 pub fn g_atomic_int_set(atomic: gint, newval: gint);
2426 pub fn g_atomic_int_xor(atomic: guint, val: guint) -> guint;
2427 pub fn g_atomic_pointer_add(atomic: gpointer, val: gssize) -> gssize;
2428 pub fn g_atomic_pointer_and(atomic: gpointer, val: gsize) -> gsize;
2429 pub fn g_atomic_pointer_compare_and_exchange(atomic: gpointer, oldval: gpointer, newval: gpointer) -> gboolean;
2430 pub fn g_atomic_pointer_get(atomic: gpointer) -> gpointer;
2431 pub fn g_atomic_pointer_or(atomic: gpointer, val: gsize) -> gsize;
2432 pub fn g_atomic_pointer_set(atomic: gpointer, newval: gpointer);
2433 pub fn g_atomic_pointer_xor(atomic: gpointer, val: gsize) -> gsize;
2434 pub fn g_base64_decode(text: *const gchar, out_len: *mut gsize) -> *mut u8;
2435 pub fn g_base64_decode_inplace(text: *mut gchar, out_len: *mut gsize) -> u8;
2436 pub fn g_base64_decode_step(in_: *mut gchar, len: gsize, out: *mut u8, state: *mut gint, save: *mut guint) -> gsize;
2437 pub fn g_base64_encode(data: *mut u8, len: gsize) -> *mut gchar;
2438 pub fn g_base64_encode_close(break_lines: gboolean, out: *mut gchar, state: *mut gint, save: *mut gint) -> gsize;
2439 pub fn g_base64_encode_step(in_: *mut u8, len: gsize, break_lines: gboolean, out: *mut gchar, state: *mut gint, save: *mut gint) -> gsize;
2440 pub fn g_basename(file_name: *const gchar) -> *const gchar;
2441 pub fn g_bit_lock(address: gint, lock_bit: gint);
2442 pub fn g_bit_nth_lsf(mask: gulong, nth_bit: gint) -> gint;
2443 pub fn g_bit_nth_msf(mask: gulong, nth_bit: gint) -> gint;
2444 pub fn g_bit_storage(number: gulong) -> guint;
2445 pub fn g_bit_trylock(address: gint, lock_bit: gint) -> gboolean;
2446 pub fn g_bit_unlock(address: gint, lock_bit: gint);
2447 pub fn g_bookmark_file_add_application(bookmark: *mut GBookmarkFile, uri: *const gchar, name: *const gchar, exec: *const gchar);
2448 pub fn g_bookmark_file_add_group(bookmark: *mut GBookmarkFile, uri: *const gchar, group: *const gchar);
2449 pub fn g_bookmark_file_error_quark() -> GQuark;
2450 pub fn g_bookmark_file_free(bookmark: *mut GBookmarkFile);
2451 pub fn g_bookmark_file_get_added(bookmark: *mut GBookmarkFile, uri: *const gchar, error: *mut *mut GError) -> libc::time_t;
2452 pub fn g_bookmark_file_get_app_info(bookmark: *mut GBookmarkFile, uri: *const gchar, name: *const gchar, exec: *mut *mut gchar, count: *mut guint, stamp: *mut libc::time_t, error: *mut *mut GError) -> gboolean;
2453 pub fn g_bookmark_file_get_applications(bookmark: *mut GBookmarkFile, uri: *const gchar, length: *mut gsize, error: *mut *mut GError) -> *mut *mut gchar;
2454 pub fn g_bookmark_file_get_description(bookmark: *mut GBookmarkFile, uri: *const gchar, error: *mut *mut GError) -> *mut gchar;
2455 pub fn g_bookmark_file_get_groups(bookmark: *mut GBookmarkFile, uri: *const gchar, length: *mut gsize, error: *mut *mut GError) -> *mut *mut gchar;
2456 pub fn g_bookmark_file_get_icon(bookmark: *mut GBookmarkFile, uri: *const gchar, href: *mut *mut gchar, mime_type: *mut *mut gchar, error: *mut *mut GError) -> gboolean;
2457 pub fn g_bookmark_file_get_is_private(bookmark: *mut GBookmarkFile, uri: *const gchar, error: *mut *mut GError) -> gboolean;
2458 pub fn g_bookmark_file_get_mime_type(bookmark: *mut GBookmarkFile, uri: *const gchar, error: *mut *mut GError) -> *mut gchar;
2459 pub fn g_bookmark_file_get_modified(bookmark: *mut GBookmarkFile, uri: *const gchar, error: *mut *mut GError) -> libc::time_t;
2460 pub fn g_bookmark_file_get_size(bookmark: *mut GBookmarkFile) -> gint;
2461 pub fn g_bookmark_file_get_title(bookmark: *mut GBookmarkFile, uri: *const gchar, error: *mut *mut GError) -> *mut gchar;
2462 pub fn g_bookmark_file_get_uris(bookmark: *mut GBookmarkFile, length: *mut gsize) -> *mut *mut gchar;
2463 pub fn g_bookmark_file_get_visited(bookmark: *mut GBookmarkFile, uri: *const gchar, error: *mut *mut GError) -> libc::time_t;
2464 pub fn g_bookmark_file_has_application(bookmark: *mut GBookmarkFile, uri: *const gchar, name: *const gchar, error: *mut *mut GError) -> gboolean;
2465 pub fn g_bookmark_file_has_group(bookmark: *mut GBookmarkFile, uri: *const gchar, group: *const gchar, error: *mut *mut GError) -> gboolean;
2466 pub fn g_bookmark_file_has_item(bookmark: *mut GBookmarkFile, uri: *const gchar) -> gboolean;
2467 pub fn g_bookmark_file_load_from_data(bookmark: *mut GBookmarkFile, data: *const gchar, length: gsize, error: *mut *mut GError) -> gboolean;
2468 pub fn g_bookmark_file_load_from_data_dirs(bookmark: *mut GBookmarkFile, file: *const gchar, full_path: *mut *mut gchar, error: *mut *mut GError) -> gboolean;
2469 pub fn g_bookmark_file_load_from_file(bookmark: *mut GBookmarkFile, filename: *const gchar, error: *mut *mut GError) -> gboolean;
2470 pub fn g_bookmark_file_move_item(bookmark: *mut GBookmarkFile, old_uri: *const gchar, new_uri: *const gchar, error: *mut *mut GError) -> gboolean;
2471 pub fn g_bookmark_file_new() -> *mut GBookmarkFile;
2472 pub fn g_bookmark_file_remove_application(bookmark: *mut GBookmarkFile, uri: *const gchar, name: *const gchar, error: *mut *mut GError) -> gboolean;
2473 pub fn g_bookmark_file_remove_group(bookmark: *mut GBookmarkFile, uri: *const gchar, group: *const gchar, error: *mut *mut GError) -> gboolean;
2474 pub fn g_bookmark_file_remove_item(bookmark: *mut GBookmarkFile, uri: *const gchar, error: *mut *mut GError) -> gboolean;
2475 pub fn g_bookmark_file_set_added(bookmark: *mut GBookmarkFile, uri: *const gchar, added: libc::time_t);
2476 pub fn g_bookmark_file_set_app_info(bookmark: *mut GBookmarkFile, uri: *const gchar, name: *const gchar, exec: *const gchar, count: gint, stamp: libc::time_t, error: *mut *mut GError) -> gboolean;
2477 pub fn g_bookmark_file_set_description(bookmark: *mut GBookmarkFile, uri: *const gchar, description: *const gchar);
2478 pub fn g_bookmark_file_set_groups(bookmark: *mut GBookmarkFile, uri: *const gchar, groups: *mut *const gchar, length: gsize);
2479 pub fn g_bookmark_file_set_icon(bookmark: *mut GBookmarkFile, uri: *const gchar, href: *const gchar, mime_type: *const gchar);
2480 pub fn g_bookmark_file_set_is_private(bookmark: *mut GBookmarkFile, uri: *const gchar, is_private: gboolean);
2481 pub fn g_bookmark_file_set_mime_type(bookmark: *mut GBookmarkFile, uri: *const gchar, mime_type: *const gchar);
2482 pub fn g_bookmark_file_set_modified(bookmark: *mut GBookmarkFile, uri: *const gchar, modified: libc::time_t);
2483 pub fn g_bookmark_file_set_title(bookmark: *mut GBookmarkFile, uri: *const gchar, title: *const gchar);
2484 pub fn g_bookmark_file_set_visited(bookmark: *mut GBookmarkFile, uri: *const gchar, visited: libc::time_t);
2485 pub fn g_bookmark_file_to_data(bookmark: *mut GBookmarkFile, length: *mut gsize, error: *mut *mut GError) -> *mut gchar;
2486 pub fn g_bookmark_file_to_file(bookmark: *mut GBookmarkFile, filename: *const gchar, error: *mut *mut GError) -> gboolean;
2487 pub fn g_build_filename(first_element: *const gchar, ...) -> *mut gchar;
2488 pub fn g_build_filenamev(args: *mut *mut gchar) -> *mut gchar;
2489 pub fn g_build_path(separator: *const gchar, first_element: *const gchar, ...) -> *mut gchar;
2490 pub fn g_build_pathv(separator: *const gchar, args: *mut *mut gchar) -> *mut gchar;
2491 pub fn g_byte_array_append(array: *mut GByteArray, data: u8, len: guint) -> *mut GByteArray;
2492 pub fn g_byte_array_free(array: *mut GByteArray, free_segment: gboolean) -> u8;
2493 pub fn g_byte_array_free_to_bytes(array: *mut GByteArray) -> *mut GBytes;
2494 pub fn g_byte_array_new() -> *mut GByteArray;
2495 pub fn g_byte_array_new_take(data: *mut u8, len: gsize) -> *mut GByteArray;
2496 pub fn g_byte_array_prepend(array: *mut GByteArray, data: u8, len: guint) -> *mut GByteArray;
2497 pub fn g_byte_array_ref(array: *mut GByteArray) -> *mut GByteArray;
2498 pub fn g_byte_array_remove_index(array: *mut GByteArray, index_: guint) -> *mut GByteArray;
2499 pub fn g_byte_array_remove_index_fast(array: *mut GByteArray, index_: guint) -> *mut GByteArray;
2500 pub fn g_byte_array_remove_range(array: *mut GByteArray, index_: guint, length: guint) -> *mut GByteArray;
2501 pub fn g_byte_array_set_size(array: *mut GByteArray, length: guint) -> *mut GByteArray;
2502 pub fn g_byte_array_sized_new(reserved_size: guint) -> *mut GByteArray;
2503 pub fn g_byte_array_sort(array: *mut GByteArray, compare_func: GCompareFunc);
2504 pub fn g_byte_array_sort_with_data(array: *mut GByteArray, compare_func: GCompareDataFunc, user_data: gpointer);
2505 pub fn g_byte_array_unref(array: *mut GByteArray);
2506 pub fn g_bytes_compare(bytes1: gconstpointer, bytes2: gconstpointer) -> gint;
2507 pub fn g_bytes_equal(bytes1: gconstpointer, bytes2: gconstpointer) -> gboolean;
2508 pub fn g_bytes_get_data(bytes: *mut GBytes, size: *mut gsize) -> gconstpointer;
2509 pub fn g_bytes_get_size(bytes: *mut GBytes) -> gsize;
2510 pub fn g_bytes_hash(bytes: gconstpointer) -> guint;
2511 pub fn g_bytes_new(data: gconstpointer, size: gsize) -> *mut GBytes;
2512 pub fn g_bytes_new_from_bytes(bytes: *mut GBytes, offset: gsize, length: gsize) -> *mut GBytes;
2513 pub fn g_bytes_new_static(data: gconstpointer, size: gsize) -> *mut GBytes;
2514 pub fn g_bytes_new_take(data: gpointer, size: gsize) -> *mut GBytes;
2515 pub fn g_bytes_new_with_free_func(data: gconstpointer, size: gsize, free_func: GDestroyNotify, user_data: gpointer) -> *mut GBytes;
2516 pub fn g_bytes_ref(bytes: *mut GBytes) -> *mut GBytes;
2517 pub fn g_bytes_unref(bytes: *mut GBytes);
2518 pub fn g_bytes_unref_to_array(bytes: *mut GBytes) -> *mut GByteArray;
2519 pub fn g_bytes_unref_to_data(bytes: *mut GBytes, size: *mut gsize) -> gpointer;
2520 pub fn g_chdir(path: *const gchar) -> gint;
2521 pub fn g_checksum_copy(checksum: *const GChecksum) -> *mut GChecksum;
2522 pub fn g_checksum_free(checksum: *mut GChecksum);
2523 pub fn g_checksum_get_digest(checksum: *mut GChecksum, buffer: u8, digest_len: gsize);
2524 pub fn g_checksum_get_string(checksum: *mut GChecksum) -> *const gchar;
2525 pub fn g_checksum_new(checksum_type: GChecksumType) -> *mut GChecksum;
2526 pub fn g_checksum_reset(checksum: *mut GChecksum);
2527 pub fn g_checksum_type_get_length(checksum_type: GChecksumType) -> gssize;
2528 pub fn g_checksum_update(checksum: *mut GChecksum, data: *mut u8, length: gssize);
2529 pub fn g_child_watch_add(pid: GPid, function: GChildWatchFunc, data: gpointer) -> guint;
2530 pub fn g_child_watch_add_full(priority: gint, pid: GPid, function: GChildWatchFunc, data: gpointer, notify: Option<GDestroyNotify>) -> guint;
2531 pub fn g_child_watch_source_new(pid: GPid) -> *mut GSource;
2532 pub fn g_clear_error(error: *mut *mut GError);
2533 pub fn g_clear_pointer(pp: gpointer, destroy: GDestroyNotify);
2534 pub fn g_close(fd: gint, error: *mut *mut GError) -> gboolean;
2535 pub fn g_compute_checksum_for_bytes(checksum_type: GChecksumType, data: *mut GBytes) -> *mut gchar;
2536 pub fn g_compute_checksum_for_data(checksum_type: GChecksumType, data: *mut u8, length: gsize) -> *mut gchar;
2537 pub fn g_compute_checksum_for_string(checksum_type: GChecksumType, str: *const gchar, length: gssize) -> *mut gchar;
2538 pub fn g_compute_hmac_for_data(digest_type: GChecksumType, key: *mut u8, key_len: gsize, data: u8, length: gsize) -> *mut gchar;
2539 pub fn g_compute_hmac_for_string(digest_type: GChecksumType, key: *mut u8, key_len: gsize, str: *const gchar, length: gssize) -> *mut gchar;
2540 pub fn g_cond_broadcast(cond: *mut GCond);
2541 pub fn g_cond_clear(cond: *mut GCond);
2542 pub fn g_cond_init(cond: *mut GCond);
2543 pub fn g_cond_signal(cond: *mut GCond);
2544 pub fn g_cond_wait(cond: *mut GCond, mutex: *mut GMutex);
2545 pub fn g_cond_wait_until(cond: *mut GCond, mutex: *mut GMutex, end_time: i64) -> gboolean;
2546 pub fn g_convert(str: *const gchar, len: gssize, to_codeset: *const gchar, from_codeset: *const gchar, bytes_read: *mut gsize, bytes_written: *mut gsize, error: *mut *mut GError) -> *mut gchar;
2547 pub fn g_convert_error_quark() -> GQuark;
2548 pub fn g_convert_with_fallback(str: *const gchar, len: gssize, to_codeset: *const gchar, from_codeset: *const gchar, fallback: *const gchar, bytes_read: gsize, bytes_written: gsize, error: *mut *mut GError) -> *mut gchar;
2549 pub fn g_convert_with_iconv(str: *const gchar, len: gssize, converter: GIConv, bytes_read: gsize, bytes_written: gsize, error: *mut *mut GError) -> *mut gchar;
2550 pub fn g_datalist_clear(datalist: *mut *mut GData);
2551 pub fn g_datalist_foreach(datalist: *mut *mut GData, func: GDataForeachFunc, user_data: gpointer);
2552 pub fn g_datalist_get_data(datalist: *mut *mut GData, key: *const gchar) -> gpointer;
2553 pub fn g_datalist_get_flags(datalist: *mut *mut GData) -> guint;
2554 pub fn g_datalist_id_dup_data(datalist: *mut *mut GData, key_id: GQuark, dup_func: Option<GDuplicateFunc>, user_data: gpointer) -> gpointer;
2555 pub fn g_datalist_id_get_data(datalist: *mut *mut GData, key_id: GQuark) -> gpointer;
2556 pub fn g_datalist_id_remove_no_notify(datalist: *mut *mut GData, key_id: GQuark) -> gpointer;
2557 pub fn g_datalist_id_replace_data(datalist: *mut *mut GData, key_id: GQuark, oldval: gpointer, newval: gpointer, destroy: Option<GDestroyNotify>, old_destroy: *mut GDestroyNotify) -> gboolean;
2558 pub fn g_datalist_id_set_data_full(datalist: *mut *mut GData, key_id: GQuark, data: gpointer, destroy_func: Option<GDestroyNotify>);
2559 pub fn g_datalist_init(datalist: *mut *mut GData);
2560 pub fn g_datalist_set_flags(datalist: *mut *mut GData, flags: guint);
2561 pub fn g_datalist_unset_flags(datalist: *mut *mut GData, flags: guint);
2562 pub fn g_dataset_destroy(dataset_location: gconstpointer);
2563 pub fn g_dataset_foreach(dataset_location: gconstpointer, func: GDataForeachFunc, user_data: gpointer);
2564 pub fn g_dataset_id_get_data(dataset_location: gconstpointer, key_id: GQuark) -> gpointer;
2565 pub fn g_dataset_id_remove_no_notify(dataset_location: gconstpointer, key_id: GQuark) -> gpointer;
2566 pub fn g_dataset_id_set_data_full(dataset_location: gconstpointer, key_id: GQuark, data: gpointer, destroy_func: GDestroyNotify);
2567 pub fn g_date_add_days(date: *mut GDate, n_days: guint);
2568 pub fn g_date_add_months(date: *mut GDate, n_months: guint);
2569 pub fn g_date_add_years(date: *mut GDate, n_years: guint);
2570 pub fn g_date_clamp(date: *mut GDate, min_date: *const GDate, max_date: *const GDate);
2571 pub fn g_date_clear(date: *mut GDate, n_dates: guint);
2572 pub fn g_date_compare(lhs: *const GDate, rhs: *const GDate) -> gint;
2573 pub fn g_date_days_between(date1: *const GDate, date2: *const GDate) -> gint;
2574 pub fn g_date_free(date: *mut GDate);
2575 pub fn g_date_get_day(date: *const GDate) -> GDateDay;
2576 pub fn g_date_get_day_of_year(date: *const GDate) -> guint;
2577 pub fn g_date_get_days_in_month(month: GDateMonth, year: GDateYear) -> u8;
2578 pub fn g_date_get_iso8601_week_of_year(date: *const GDate) -> guint;
2579 pub fn g_date_get_julian(date: *const GDate) -> u32;
2580 pub fn g_date_get_monday_week_of_year(date: *const GDate) -> guint;
2581 pub fn g_date_get_monday_weeks_in_year(year: GDateYear) -> u8;
2582 pub fn g_date_get_month(date: *const GDate) -> GDateMonth;
2583 pub fn g_date_get_sunday_week_of_year(date: *const GDate) -> guint;
2584 pub fn g_date_get_sunday_weeks_in_year(year: GDateYear) -> u8;
2585 pub fn g_date_get_weekday(date: *const GDate) -> GDateWeekday;
2586 pub fn g_date_get_year(date: *const GDate) -> GDateYear;
2587 pub fn g_date_is_first_of_month(date: *const GDate) -> gboolean;
2588 pub fn g_date_is_last_of_month(date: *const GDate) -> gboolean;
2589 pub fn g_date_is_leap_year(year: GDateYear) -> gboolean;
2590 pub fn g_date_new() -> *mut GDate;
2591 pub fn g_date_new_dmy(day: GDateDay, month: GDateMonth, year: GDateYear) -> *mut GDate;
2592 pub fn g_date_new_julian(julian_day: u32) -> *mut GDate;
2593 pub fn g_date_order(date1: *mut GDate, date2: *mut GDate);
2594 pub fn g_date_set_day(date: *mut GDate, day: GDateDay);
2595 pub fn g_date_set_dmy(date: *mut GDate, day: GDateDay, month: GDateMonth, y: GDateYear);
2596 pub fn g_date_set_julian(date: *mut GDate, julian_date: u32);
2597 pub fn g_date_set_month(date: *mut GDate, month: GDateMonth);
2598 pub fn g_date_set_parse(date: *mut GDate, str: *const gchar);
2599 pub fn g_date_set_time(date: *mut GDate, time_: GTime);
2600 pub fn g_date_set_time_t(date: *mut GDate, timet: libc::time_t);
2601 pub fn g_date_set_time_val(date: *mut GDate, timeval: *mut GTimeVal);
2602 pub fn g_date_set_year(date: *mut GDate, year: GDateYear);
2603 pub fn g_date_strftime(s: *mut gchar, slen: gsize, format: *const gchar, date: *const GDate) -> gsize;
2604 pub fn g_date_subtract_days(date: *mut GDate, n_days: guint);
2605 pub fn g_date_subtract_months(date: *mut GDate, n_months: guint);
2606 pub fn g_date_subtract_years(date: *mut GDate, n_years: guint);
2607 pub fn g_date_time_add(datetime: *mut GDateTime, timespan: GTimeSpan) -> *mut GDateTime;
2608 pub fn g_date_time_add_days(datetime: *mut GDateTime, days: gint) -> *mut GDateTime;
2609 pub fn g_date_time_add_full(datetime: *mut GDateTime, years: gint, months: gint, days: gint, hours: gint, minutes: gint, seconds: gdouble) -> *mut GDateTime;
2610 pub fn g_date_time_add_hours(datetime: *mut GDateTime, hours: gint) -> *mut GDateTime;
2611 pub fn g_date_time_add_minutes(datetime: *mut GDateTime, minutes: gint) -> *mut GDateTime;
2612 pub fn g_date_time_add_months(datetime: *mut GDateTime, months: gint) -> *mut GDateTime;
2613 pub fn g_date_time_add_seconds(datetime: *mut GDateTime, seconds: gdouble) -> *mut GDateTime;
2614 pub fn g_date_time_add_weeks(datetime: *mut GDateTime, weeks: gint) -> *mut GDateTime;
2615 pub fn g_date_time_add_years(datetime: *mut GDateTime, years: gint) -> *mut GDateTime;
2616 pub fn g_date_time_compare(dt1: gconstpointer, dt2: gconstpointer) -> gint;
2617 pub fn g_date_time_difference(end: *mut GDateTime, begin: *mut GDateTime) -> GTimeSpan;
2618 pub fn g_date_time_equal(dt1: gconstpointer, dt2: gconstpointer) -> gboolean;
2619 pub fn g_date_time_format(datetime: *mut GDateTime, format: *const gchar) -> *mut gchar;
2620 pub fn g_date_time_get_day_of_month(datetime: *mut GDateTime) -> gint;
2621 pub fn g_date_time_get_day_of_week(datetime: *mut GDateTime) -> gint;
2622 pub fn g_date_time_get_day_of_year(datetime: *mut GDateTime) -> gint;
2623 pub fn g_date_time_get_hour(datetime: *mut GDateTime) -> gint;
2624 pub fn g_date_time_get_microsecond(datetime: *mut GDateTime) -> gint;
2625 pub fn g_date_time_get_minute(datetime: *mut GDateTime) -> gint;
2626 pub fn g_date_time_get_month(datetime: *mut GDateTime) -> gint;
2627 pub fn g_date_time_get_second(datetime: *mut GDateTime) -> gint;
2628 pub fn g_date_time_get_seconds(datetime: *mut GDateTime) -> gdouble;
2629 pub fn g_date_time_get_timezone_abbreviation(datetime: *mut GDateTime) -> *const gchar;
2630 pub fn g_date_time_get_utc_offset(datetime: *mut GDateTime) -> GTimeSpan;
2631 pub fn g_date_time_get_week_numbering_year(datetime: *mut GDateTime) -> gint;
2632 pub fn g_date_time_get_week_of_year(datetime: *mut GDateTime) -> gint;
2633 pub fn g_date_time_get_year(datetime: *mut GDateTime) -> gint;
2634 pub fn g_date_time_get_ymd(datetime: *mut GDateTime, year: *mut gint, month: *mut gint, day: *mut gint);
2635 pub fn g_date_time_hash(datetime: gconstpointer) -> guint;
2636 pub fn g_date_time_is_daylight_savings(datetime: *mut GDateTime) -> gboolean;
2637 pub fn g_date_time_new(tz: *mut GTimeZone, year: gint, month: gint, day: gint, hour: gint, minute: gint, seconds: gdouble) -> *mut GDateTime;
2638 pub fn g_date_time_new_from_timeval_local(tv: *const GTimeVal) -> *mut GDateTime;
2639 pub fn g_date_time_new_from_timeval_utc(tv: *const GTimeVal) -> *mut GDateTime;
2640 pub fn g_date_time_new_from_unix_local(t: i64) -> *mut GDateTime;
2641 pub fn g_date_time_new_from_unix_utc(t: i64) -> *mut GDateTime;
2642 pub fn g_date_time_new_local(year: gint, month: gint, day: gint, hour: gint, minute: gint, seconds: gdouble) -> *mut GDateTime;
2643 pub fn g_date_time_new_now(tz: *mut GTimeZone) -> *mut GDateTime;
2644 pub fn g_date_time_new_now_local() -> *mut GDateTime;
2645 pub fn g_date_time_new_now_utc() -> *mut GDateTime;
2646 pub fn g_date_time_new_utc(year: gint, month: gint, day: gint, hour: gint, minute: gint, seconds: gdouble) -> *mut GDateTime;
2647 pub fn g_date_time_ref(datetime: *mut GDateTime) -> *mut GDateTime;
2648 pub fn g_date_time_to_local(datetime: *mut GDateTime) -> *mut GDateTime;
2649 pub fn g_date_time_to_timeval(datetime: *mut GDateTime, tv: *mut GTimeVal) -> gboolean;
2650 pub fn g_date_time_to_timezone(datetime: *mut GDateTime, tz: *mut GTimeZone) -> *mut GDateTime;
2651 pub fn g_date_time_to_unix(datetime: *mut GDateTime) -> i64;
2652 pub fn g_date_time_to_utc(datetime: *mut GDateTime) -> *mut GDateTime;
2653 pub fn g_date_time_unref(datetime: *mut GDateTime);
2654 pub fn g_date_to_struct_tm(date: *const GDate, tm: gpointer);
2655 pub fn g_date_valid(date: *const GDate) -> gboolean;
2656 pub fn g_date_valid_day(day: GDateDay) -> gboolean;
2657 pub fn g_date_valid_dmy(day: GDateDay, month: GDateMonth, year: GDateYear) -> gboolean;
2658 pub fn g_date_valid_julian(julian_date: u32) -> gboolean;
2659 pub fn g_date_valid_month(month: GDateMonth) -> gboolean;
2660 pub fn g_date_valid_weekday(weekday: GDateWeekday) -> gboolean;
2661 pub fn g_date_valid_year(year: GDateYear) -> gboolean;
2662 pub fn g_dcgettext(domain: *const gchar, msgid: *const gchar, category: gint) -> *const gchar;
2663 pub fn g_dgettext(domain: *const gchar, msgid: *const gchar) -> *const gchar;
2664 pub fn g_dir_close(dir: *mut GDir);
2665 pub fn g_dir_make_tmp(tmpl: *mut gchar, error: *mut *mut GError) -> *mut gchar;
2666 pub fn g_dir_open(path: *const gchar, flags: guint, error: *mut *mut GError) -> *mut GDir;
2667 pub fn g_dir_read_name(dir: *mut GDir) -> *const gchar;
2668 pub fn g_dir_rewind(dir: *mut GDir);
2669 pub fn g_direct_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
2670 pub fn g_direct_hash(v: gconstpointer) -> guint;
2671 pub fn g_dngettext(domain: *const gchar, msgid: *const gchar, msgid_plural: *const gchar, n: gulong) -> *const gchar;
2672 pub fn g_double_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
2673 pub fn g_double_hash(v: gconstpointer) -> guint;
2674 pub fn g_dpgettext(domain: *const gchar, msgctxtid: *const gchar, msgidoffset: gsize) -> *const gchar;
2675 pub fn g_dpgettext2(domain: *const gchar, context: *const gchar, msgid: *const gchar) -> *const gchar;
2676 pub fn g_environ_getenv(envp: *mut *mut gchar, variable: *const gchar) -> *const gchar;
2677 pub fn g_environ_setenv(envp: *mut *mut gchar, variable: *const gchar, value: *const gchar, overwrite: gboolean) -> *mut *mut gchar;
2678 pub fn g_environ_unsetenv(envp: *mut *mut gchar, variable: *const gchar) -> *mut *mut gchar;
2679 pub fn g_error_copy(error: *const GError) -> *mut GError;
2680 pub fn g_error_free(error: *mut GError);
2681 pub fn g_error_matches(error: *const GError, domain: GQuark, code: gint) -> gboolean;
2682 pub fn g_error_new(domain: GQuark, code: gint, format: *const gchar, ...) -> *mut GError;
2683 pub fn g_error_new_literal(domain: GQuark, code: gint, message: *const gchar) -> *mut GError;
2684 pub fn g_file_error_from_errno(err_no: gint) -> GFileError;
2685 pub fn g_file_error_quark() -> GQuark;
2686 pub fn g_file_get_contents(filename: *mut gchar, contents: *mut *mut gchar, length: *mut gsize, error: *mut *mut GError) -> gboolean;
2687 pub fn g_file_open_tmp(tmpl: *mut gchar, name_used: *mut *mut gchar, error: *mut *mut GError) -> gint;
2688 pub fn g_file_read_link(filename: *const gchar, error: *mut *mut GError) -> *mut gchar;
2689 pub fn g_file_set_contents(filename: *mut gchar, contents: *mut gchar, length: gssize, error: *mut *mut GError) -> gboolean;
2690 pub fn g_file_test(filename: *const gchar, test: GFileTest) -> gboolean;
2691 pub fn g_filename_display_basename(filename: *const gchar) -> *mut gchar;
2692 pub fn g_filename_display_name(filename: *const gchar) -> *mut gchar;
2693 pub fn g_filename_from_uri(uri: *const gchar, hostname: *mut *mut gchar, error: *mut *mut GError) -> *mut gchar;
2694 pub fn g_filename_from_utf8(utf8string: *const gchar, len: gssize, bytes_read: *mut gsize, bytes_written: *mut gsize, error: *mut *mut GError) -> *mut gchar;
2695 pub fn g_filename_to_uri(filename: *const gchar, hostname: *const gchar, error: *mut *mut GError) -> *mut gchar;
2696 pub fn g_filename_to_utf8(opsysstring: *const gchar, len: gssize, bytes_read: *mut gsize, bytes_written: *mut gsize, error: *mut *mut GError) -> *mut gchar;
2697 pub fn g_find_program_in_path(program: *const gchar) -> *mut gchar;
2698 pub fn g_format_size(size: u64) -> *mut gchar;
2699 pub fn g_format_size_for_display(size: i64) -> *mut gchar;
2700 pub fn g_format_size_full(size: u64, flags: GFormatSizeFlags) -> *mut gchar;
2701 pub fn g_fprintf(file: gpointer, format: *mut gchar, ...) -> gint;
2702 pub fn g_free(mem: gpointer);
2703 pub fn g_get_application_name() -> *const gchar;
2704 pub fn g_get_charset(charset: *mut *const gchar) -> gboolean;
2705 pub fn g_get_codeset() -> *mut gchar;
2706 pub fn g_get_current_dir() -> *mut gchar;
2707 pub fn g_get_current_time(result: *mut GTimeVal);
2708 pub fn g_get_environ() -> *mut *mut gchar;
2709 pub fn g_get_filename_charsets(charsets: *mut gchar) -> gboolean;
2710 pub fn g_get_home_dir() -> *const gchar;
2711 pub fn g_get_host_name() -> *const gchar;
2712 pub fn g_get_language_names() -> *mut *mut gchar;
2713 pub fn g_get_locale_variants(locale: *const gchar) -> *mut *mut gchar;
2714 pub fn g_get_monotonic_time() -> i64;
2715 pub fn g_get_num_processors() -> guint;
2716 pub fn g_get_prgname() -> *const gchar;
2717 pub fn g_get_real_name() -> *const gchar;
2718 pub fn g_get_real_time() -> i64;
2719 pub fn g_get_system_config_dirs() -> *mut *mut gchar;
2720 pub fn g_get_system_data_dirs() -> *mut *mut gchar;
2721 pub fn g_get_tmp_dir() -> *const gchar;
2722 pub fn g_get_user_cache_dir() -> *const gchar;
2723 pub fn g_get_user_config_dir() -> *const gchar;
2724 pub fn g_get_user_data_dir() -> *const gchar;
2725 pub fn g_get_user_name() -> *const gchar;
2726 pub fn g_get_user_runtime_dir() -> *const gchar;
2727 pub fn g_get_user_special_dir(directory: GUserDirectory) -> *const gchar;
2728 pub fn g_getenv(variable: *const gchar) -> *const gchar;
2729 pub fn g_hash_table_add(hash_table: *mut GHashTable, key: gpointer) -> gboolean;
2730 pub fn g_hash_table_contains(hash_table: *mut GHashTable, key: gconstpointer) -> gboolean;
2731 pub fn g_hash_table_destroy(hash_table: *mut GHashTable);
2732 pub fn g_hash_table_find(hash_table: *mut GHashTable, predicate: GHRFunc, user_data: gpointer) -> gpointer;
2733 pub fn g_hash_table_foreach(hash_table: *mut GHashTable, func: GHFunc, user_data: gpointer);
2734 pub fn g_hash_table_foreach_remove(hash_table: *mut GHashTable, func: GHRFunc, user_data: gpointer) -> guint;
2735 pub fn g_hash_table_foreach_steal(hash_table: *mut GHashTable, func: GHRFunc, user_data: gpointer) -> guint;
2736 pub fn g_hash_table_get_keys(hash_table: *mut GHashTable) -> *mut GList;
2737 pub fn g_hash_table_get_keys_as_array(hash_table: *mut GHashTable, length: *mut guint) -> *mut gpointer;
2738 pub fn g_hash_table_get_values(hash_table: *mut GHashTable) -> *mut GList;
2739 pub fn g_hash_table_insert(hash_table: *mut GHashTable, key: gpointer, value: gpointer) -> gboolean;
2740 pub fn g_hash_table_iter_get_hash_table(iter: *mut GHashTableIter) -> *mut GHashTable;
2741 pub fn g_hash_table_iter_init(iter: *mut GHashTableIter, hash_table: *mut GHashTable);
2742 pub fn g_hash_table_iter_next(iter: *mut GHashTableIter, key: *mut gpointer, value: *mut gpointer) -> gboolean;
2743 pub fn g_hash_table_iter_remove(iter: *mut GHashTableIter);
2744 pub fn g_hash_table_iter_replace(iter: *mut GHashTableIter, value: gpointer);
2745 pub fn g_hash_table_iter_steal(iter: *mut GHashTableIter);
2746 pub fn g_hash_table_lookup(hash_table: *mut GHashTable, key: gconstpointer) -> gpointer;
2747 pub fn g_hash_table_lookup_extended(hash_table: *mut GHashTable, lookup_key: gconstpointer, orig_key: *mut gpointer, value: *mut gpointer) -> gboolean;
2748 pub fn g_hash_table_new(hash_func: GHashFunc, key_equal_func: GEqualFunc) -> *mut GHashTable;
2749 pub fn g_hash_table_new_full(hash_func: GHashFunc, key_equal_func: GEqualFunc, key_destroy_func: Option<GDestroyNotify>, value_destroy_func: Option<GDestroyNotify>) -> *mut GHashTable;
2750 pub fn g_hash_table_ref(hash_table: *mut GHashTable) -> *mut GHashTable;
2751 pub fn g_hash_table_remove(hash_table: *mut GHashTable, key: gconstpointer) -> gboolean;
2752 pub fn g_hash_table_remove_all(hash_table: *mut GHashTable);
2753 pub fn g_hash_table_replace(hash_table: *mut GHashTable, key: gpointer, value: gpointer) -> gboolean;
2754 pub fn g_hash_table_size(hash_table: *mut GHashTable) -> guint;
2755 pub fn g_hash_table_steal(hash_table: *mut GHashTable, key: gconstpointer) -> gboolean;
2756 pub fn g_hash_table_steal_all(hash_table: *mut GHashTable);
2757 pub fn g_hash_table_unref(hash_table: *mut GHashTable);
2758 pub fn g_hmac_copy(hmac: *const GHmac) -> *mut GHmac;
2759 pub fn g_hmac_get_digest(hmac: *mut GHmac, buffer: u8, digest_len: gsize);
2760 pub fn g_hmac_get_string(hmac: *mut GHmac) -> *const gchar;
2761 pub fn g_hmac_new(digest_type: GChecksumType, key: *mut u8, key_len: gsize) -> *mut GHmac;
2762 pub fn g_hmac_ref(hmac: *mut GHmac) -> *mut GHmac;
2763 pub fn g_hmac_unref(hmac: *mut GHmac);
2764 pub fn g_hmac_update(hmac: *mut GHmac, data: *mut u8, length: gssize);
2765 pub fn g_hook_alloc(hook_list: *mut GHookList) -> *mut GHook;
2766 pub fn g_hook_compare_ids(new_hook: *mut GHook, sibling: *mut GHook) -> gint;
2767 pub fn g_hook_destroy(hook_list: *mut GHookList, hook_id: gulong) -> gboolean;
2768 pub fn g_hook_destroy_link(hook_list: *mut GHookList, hook: *mut GHook);
2769 pub fn g_hook_find(hook_list: *mut GHookList, need_valids: gboolean, func: GHookFindFunc, data: gpointer) -> *mut GHook;
2770 pub fn g_hook_find_data(hook_list: *mut GHookList, need_valids: gboolean, data: gpointer) -> *mut GHook;
2771 pub fn g_hook_find_func(hook_list: *mut GHookList, need_valids: gboolean, func: gpointer) -> *mut GHook;
2772 pub fn g_hook_find_func_data(hook_list: *mut GHookList, need_valids: gboolean, func: gpointer, data: gpointer) -> *mut GHook;
2773 pub fn g_hook_first_valid(hook_list: *mut GHookList, may_be_in_call: gboolean) -> *mut GHook;
2774 pub fn g_hook_free(hook_list: *mut GHookList, hook: *mut GHook);
2775 pub fn g_hook_get(hook_list: *mut GHookList, hook_id: gulong) -> *mut GHook;
2776 pub fn g_hook_insert_before(hook_list: *mut GHookList, sibling: *mut GHook, hook: *mut GHook);
2777 pub fn g_hook_insert_sorted(hook_list: *mut GHookList, hook: *mut GHook, func: GHookCompareFunc);
2778 pub fn g_hook_list_clear(hook_list: *mut GHookList);
2779 pub fn g_hook_list_init(hook_list: *mut GHookList, hook_size: guint);
2780 pub fn g_hook_list_invoke(hook_list: *mut GHookList, may_recurse: gboolean);
2781 pub fn g_hook_list_invoke_check(hook_list: *mut GHookList, may_recurse: gboolean);
2782 pub fn g_hook_list_marshal(hook_list: *mut GHookList, may_recurse: gboolean, marshaller: GHookMarshaller, marshal_data: gpointer);
2783 pub fn g_hook_list_marshal_check(hook_list: *mut GHookList, may_recurse: gboolean, marshaller: GHookCheckMarshaller, marshal_data: gpointer);
2784 pub fn g_hook_next_valid(hook_list: *mut GHookList, hook: *mut GHook, may_be_in_call: gboolean) -> *mut GHook;
2785 pub fn g_hook_prepend(hook_list: *mut GHookList, hook: *mut GHook);
2786 pub fn g_hook_ref(hook_list: *mut GHookList, hook: *mut GHook) -> *mut GHook;
2787 pub fn g_hook_unref(hook_list: *mut GHookList, hook: *mut GHook);
2788 pub fn g_hostname_is_ascii_encoded(hostname: *const gchar) -> gboolean;
2789 pub fn g_hostname_is_ip_address(hostname: *const gchar) -> gboolean;
2790 pub fn g_hostname_is_non_ascii(hostname: *const gchar) -> gboolean;
2791 pub fn g_hostname_to_ascii(hostname: *const gchar) -> *mut gchar;
2792 pub fn g_hostname_to_unicode(hostname: *const gchar) -> *mut gchar;
2793 pub fn g_iconv(converter: GIConv, inbuf: *mut *mut gchar, inbytes_left: gsize, outbuf: *mut *mut gchar, outbytes_left: gsize) -> gsize;
2794 pub fn g_iconv_close(converter: GIConv) -> gint;
2795 pub fn g_iconv_open(to_codeset: *const gchar, from_codeset: *const gchar) -> GIConv;
2796 pub fn g_idle_add(function: GSourceFunc, data: gpointer) -> guint;
2797 pub fn g_idle_add_full(priority: gint, function: GSourceFunc, data: gpointer, notify: Option<GDestroyNotify>) -> guint;
2798 pub fn g_idle_remove_by_data(data: gpointer) -> gboolean;
2799 pub fn g_idle_source_new() -> *mut GSource;
2800 pub fn g_int64_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
2801 pub fn g_int64_hash(v: gconstpointer) -> guint;
2802 pub fn g_int_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
2803 pub fn g_int_hash(v: gconstpointer) -> guint;
2804 pub fn g_intern_static_string(string: *const gchar) -> *const gchar;
2805 pub fn g_intern_string(string: *const gchar) -> *const gchar;
2806 pub fn g_io_add_watch(channel: *mut GIOChannel, condition: GIOCondition, func: GIOFunc, user_data: gpointer) -> guint;
2807 pub fn g_io_add_watch_full(channel: *mut GIOChannel, priority: gint, condition: GIOCondition, func: GIOFunc, user_data: gpointer, notify: GDestroyNotify) -> guint;
2808 pub fn g_io_channel_close(channel: *mut GIOChannel);
2809 pub fn g_io_channel_error_from_errno(en: gint) -> GIOChannelError;
2810 pub fn g_io_channel_error_quark() -> GQuark;
2811 pub fn g_io_channel_flush(channel: *mut GIOChannel, error: *mut *mut GError) -> GIOStatus;
2812 pub fn g_io_channel_get_buffer_condition(channel: *mut GIOChannel) -> GIOCondition;
2813 pub fn g_io_channel_get_buffer_size(channel: *mut GIOChannel) -> gsize;
2814 pub fn g_io_channel_get_buffered(channel: *mut GIOChannel) -> gboolean;
2815 pub fn g_io_channel_get_close_on_unref(channel: *mut GIOChannel) -> gboolean;
2816 pub fn g_io_channel_get_encoding(channel: *mut GIOChannel) -> *const gchar;
2817 pub fn g_io_channel_get_flags(channel: *mut GIOChannel) -> GIOFlags;
2818 pub fn g_io_channel_get_line_term(channel: *mut GIOChannel, length: gint) -> *const gchar;
2819 pub fn g_io_channel_init(channel: *mut GIOChannel);
2820 pub fn g_io_channel_new_file(filename: *const gchar, mode: *const gchar, error: *mut *mut GError) -> *mut GIOChannel;
2821 pub fn g_io_channel_read(channel: *mut GIOChannel, buf: *mut gchar, count: gsize, bytes_read: gsize) -> GIOError;
2822 pub fn g_io_channel_read_chars(channel: *mut GIOChannel, buf: *mut gchar, count: gsize, bytes_read: *mut gsize, error: *mut *mut GError) -> GIOStatus;
2823 pub fn g_io_channel_read_line(channel: *mut GIOChannel, str_return: *mut *mut gchar, length: *mut gsize, terminator_pos: *mut gsize, error: *mut *mut GError) -> GIOStatus;
2824 pub fn g_io_channel_read_line_string(channel: *mut GIOChannel, buffer: *mut GString, terminator_pos: gsize, error: *mut *mut GError) -> GIOStatus;
2825 pub fn g_io_channel_read_to_end(channel: *mut GIOChannel, str_return: *mut *mut gchar, length: *mut gsize, error: *mut *mut GError) -> GIOStatus;
2826 pub fn g_io_channel_read_unichar(channel: *mut GIOChannel, thechar: *mut gunichar, error: *mut *mut GError) -> GIOStatus;
2827 pub fn g_io_channel_ref(channel: *mut GIOChannel) -> *mut GIOChannel;
2828 pub fn g_io_channel_seek(channel: *mut GIOChannel, offset: i64, type_: GSeekType) -> GIOError;
2829 pub fn g_io_channel_seek_position(channel: *mut GIOChannel, offset: i64, type_: GSeekType, error: *mut *mut GError) -> GIOStatus;
2830 pub fn g_io_channel_set_buffer_size(channel: *mut GIOChannel, size: gsize);
2831 pub fn g_io_channel_set_buffered(channel: *mut GIOChannel, buffered: gboolean);
2832 pub fn g_io_channel_set_close_on_unref(channel: *mut GIOChannel, do_close: gboolean);
2833 pub fn g_io_channel_set_encoding(channel: *mut GIOChannel, encoding: *const gchar, error: *mut *mut GError) -> GIOStatus;
2834 pub fn g_io_channel_set_flags(channel: *mut GIOChannel, flags: GIOFlags, error: *mut *mut GError) -> GIOStatus;
2835 pub fn g_io_channel_set_line_term(channel: *mut GIOChannel, line_term: *const gchar, length: gint);
2836 pub fn g_io_channel_shutdown(channel: *mut GIOChannel, flush: gboolean, error: *mut *mut GError) -> GIOStatus;
2837 pub fn g_io_channel_unix_get_fd(channel: *mut GIOChannel) -> gint;
2838 pub fn g_io_channel_unix_new(fd: gint) -> *mut GIOChannel;
2839 pub fn g_io_channel_unref(channel: *mut GIOChannel);
2840 pub fn g_io_channel_write(channel: *mut GIOChannel, buf: *const gchar, count: gsize, bytes_written: gsize) -> GIOError;
2841 pub fn g_io_channel_write_chars(channel: *mut GIOChannel, buf: *mut gchar, count: gssize, bytes_written: *mut gsize, error: *mut *mut GError) -> GIOStatus;
2842 pub fn g_io_channel_write_unichar(channel: *mut GIOChannel, thechar: gunichar, error: *mut *mut GError) -> GIOStatus;
2843 pub fn g_io_create_watch(channel: *mut GIOChannel, condition: GIOCondition) -> *mut GSource;
2844 pub fn g_key_file_error_quark() -> GQuark;
2845 pub fn g_key_file_free(key_file: *mut GKeyFile);
2846 pub fn g_key_file_get_boolean(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> gboolean;
2847 pub fn g_key_file_get_boolean_list(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, length: *mut gsize, error: *mut *mut GError) -> *mut gboolean;
2848 pub fn g_key_file_get_comment(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> *mut gchar;
2849 pub fn g_key_file_get_double(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> gdouble;
2850 pub fn g_key_file_get_double_list(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, length: *mut gsize, error: *mut *mut GError) -> *mut gdouble;
2851 pub fn g_key_file_get_groups(key_file: *mut GKeyFile, length: *mut gsize) -> *mut *mut gchar;
2852 pub fn g_key_file_get_int64(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> i64;
2853 pub fn g_key_file_get_integer(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> gint;
2854 pub fn g_key_file_get_integer_list(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, length: *mut gsize, error: *mut *mut GError) -> *mut gint;
2855 pub fn g_key_file_get_keys(key_file: *mut GKeyFile, group_name: *const gchar, length: *mut gsize, error: *mut *mut GError) -> *mut *mut gchar;
2856 pub fn g_key_file_get_locale_string(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, locale: *const gchar, error: *mut *mut GError) -> *mut gchar;
2857 pub fn g_key_file_get_locale_string_list(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, locale: *const gchar, length: *mut gsize, error: *mut *mut GError) -> *mut *mut gchar;
2858 pub fn g_key_file_get_start_group(key_file: *mut GKeyFile) -> *mut gchar;
2859 pub fn g_key_file_get_string(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> *mut gchar;
2860 pub fn g_key_file_get_string_list(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, length: *mut gsize, error: *mut *mut GError) -> *mut *mut gchar;
2861 pub fn g_key_file_get_uint64(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> u64;
2862 pub fn g_key_file_get_value(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> *mut gchar;
2863 pub fn g_key_file_has_group(key_file: *mut GKeyFile, group_name: *const gchar) -> gboolean;
2864 pub fn g_key_file_has_key(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> gboolean;
2865 pub fn g_key_file_load_from_data(key_file: *mut GKeyFile, data: *const gchar, length: gsize, flags: GKeyFileFlags, error: *mut *mut GError) -> gboolean;
2866 pub fn g_key_file_load_from_data_dirs(key_file: *mut GKeyFile, file: *mut gchar, full_path: *mut *mut gchar, flags: GKeyFileFlags, error: *mut *mut GError) -> gboolean;
2867 pub fn g_key_file_load_from_dirs(key_file: *mut GKeyFile, file: *mut gchar, search_dirs: *mut *mut gchar, full_path: *mut *mut gchar, flags: GKeyFileFlags, error: *mut *mut GError) -> gboolean;
2868 pub fn g_key_file_load_from_file(key_file: *mut GKeyFile, file: *mut gchar, flags: GKeyFileFlags, error: *mut *mut GError) -> gboolean;
2869 pub fn g_key_file_new() -> *mut GKeyFile;
2870 pub fn g_key_file_ref(key_file: *mut GKeyFile) -> *mut GKeyFile;
2871 pub fn g_key_file_remove_comment(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> gboolean;
2872 pub fn g_key_file_remove_group(key_file: *mut GKeyFile, group_name: *const gchar, error: *mut *mut GError) -> gboolean;
2873 pub fn g_key_file_remove_key(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, error: *mut *mut GError) -> gboolean;
2874 pub fn g_key_file_save_to_file(key_file: *mut GKeyFile, filename: *const gchar, error: *mut *mut GError) -> gboolean;
2875 pub fn g_key_file_set_boolean(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, value: gboolean);
2876 pub fn g_key_file_set_boolean_list(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, list: gboolean, length: gsize);
2877 pub fn g_key_file_set_comment(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, comment: *const gchar, error: *mut *mut GError) -> gboolean;
2878 pub fn g_key_file_set_double(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, value: gdouble);
2879 pub fn g_key_file_set_double_list(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, list: gdouble, length: gsize);
2880 pub fn g_key_file_set_int64(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, value: i64);
2881 pub fn g_key_file_set_integer(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, value: gint);
2882 pub fn g_key_file_set_integer_list(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, list: gint, length: gsize);
2883 pub fn g_key_file_set_list_separator(key_file: *mut GKeyFile, separator: gchar);
2884 pub fn g_key_file_set_locale_string(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, locale: *const gchar, string: *const gchar);
2885 pub fn g_key_file_set_locale_string_list(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, locale: *const gchar, list: *mut gchar, length: gsize);
2886 pub fn g_key_file_set_string(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, string: *const gchar);
2887 pub fn g_key_file_set_string_list(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, list: *mut gchar, length: gsize);
2888 pub fn g_key_file_set_uint64(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, value: u64);
2889 pub fn g_key_file_set_value(key_file: *mut GKeyFile, group_name: *const gchar, key: *const gchar, value: *const gchar);
2890 pub fn g_key_file_to_data(key_file: *mut GKeyFile, length: *mut gsize, error: *mut *mut GError) -> *mut gchar;
2891 pub fn g_key_file_unref(key_file: *mut GKeyFile);
2892 pub fn g_list_alloc() -> *mut GList;
2893 pub fn g_list_append(list: *mut GList, data: gpointer) -> *mut GList;
2894 pub fn g_list_concat(list1: *mut GList, list2: *mut GList) -> *mut GList;
2895 pub fn g_list_copy(list: *mut GList) -> *mut GList;
2896 pub fn g_list_copy_deep(list: *mut GList, func: GCopyFunc, user_data: gpointer) -> *mut GList;
2897 pub fn g_list_delete_link(list: *mut GList, link_: *mut GList) -> *mut GList;
2898 pub fn g_list_find(list: *mut GList, data: gconstpointer) -> *mut GList;
2899 pub fn g_list_find_custom(list: *mut GList, data: gconstpointer, func: GCompareFunc) -> *mut GList;
2900 pub fn g_list_first(list: *mut GList) -> *mut GList;
2901 pub fn g_list_foreach(list: *mut GList, func: GFunc, user_data: gpointer);
2902 pub fn g_list_free(list: *mut GList);
2903 pub fn g_list_free_1(list: *mut GList);
2904 pub fn g_list_free_full(list: *mut GList, free_func: GDestroyNotify);
2905 pub fn g_list_index(list: *mut GList, data: gconstpointer) -> gint;
2906 pub fn g_list_insert(list: *mut GList, data: gpointer, position: gint) -> *mut GList;
2907 pub fn g_list_insert_before(list: *mut GList, sibling: *mut GList, data: gpointer) -> *mut GList;
2908 pub fn g_list_insert_sorted(list: *mut GList, data: gpointer, func: GCompareFunc) -> *mut GList;
2909 pub fn g_list_insert_sorted_with_data(list: *mut GList, data: gpointer, func: GCompareDataFunc, user_data: gpointer) -> *mut GList;
2910 pub fn g_list_last(list: *mut GList) -> *mut GList;
2911 pub fn g_list_length(list: *mut GList) -> guint;
2912 pub fn g_list_nth(list: *mut GList, n: guint) -> *mut GList;
2913 pub fn g_list_nth_data(list: *mut GList, n: guint) -> gpointer;
2914 pub fn g_list_nth_prev(list: *mut GList, n: guint) -> *mut GList;
2915 pub fn g_list_position(list: *mut GList, llink: *mut GList) -> gint;
2916 pub fn g_list_prepend(list: *mut GList, data: gpointer) -> *mut GList;
2917 pub fn g_list_remove(list: *mut GList, data: gconstpointer) -> *mut GList;
2918 pub fn g_list_remove_all(list: *mut GList, data: gconstpointer) -> *mut GList;
2919 pub fn g_list_remove_link(list: *mut GList, llink: *mut GList) -> *mut GList;
2920 pub fn g_list_reverse(list: *mut GList) -> *mut GList;
2921 pub fn g_list_sort(list: *mut GList, compare_func: GCompareFunc) -> *mut GList;
2922 pub fn g_list_sort_with_data(list: *mut GList, compare_func: GCompareDataFunc, user_data: gpointer) -> *mut GList;
2923 pub fn g_listenv() -> *mut *mut gchar;
2924 pub fn g_locale_from_utf8(utf8string: *const gchar, len: gssize, bytes_read: *mut gsize, bytes_written: *mut gsize, error: *mut *mut GError) -> *mut gchar;
2925 pub fn g_locale_to_utf8(opsysstring: *const gchar, len: gssize, bytes_read: *mut gsize, bytes_written: *mut gsize, error: *mut *mut GError) -> *mut gchar;
2926 pub fn g_log(log_domain: *const gchar, log_level: GLogLevelFlags, format: *const gchar, ...);
2927 pub fn g_log_default_handler(log_domain: *const gchar, log_level: GLogLevelFlags, message: *const gchar, unused_data: gpointer);
2928 pub fn g_log_remove_handler(log_domain: *const gchar, handler_id: guint);
2929 pub fn g_log_set_always_fatal(fatal_mask: GLogLevelFlags) -> GLogLevelFlags;
2930 pub fn g_log_set_default_handler(log_func: GLogFunc, user_data: gpointer) -> GLogFunc;
2931 pub fn g_log_set_fatal_mask(log_domain: *const gchar, fatal_mask: GLogLevelFlags) -> GLogLevelFlags;
2932 pub fn g_log_set_handler(log_domain: *const gchar, log_levels: GLogLevelFlags, log_func: GLogFunc, user_data: gpointer) -> guint;
2933 pub fn g_log_set_handler_full(log_domain: *const gchar, log_levels: GLogLevelFlags, log_func: GLogFunc, user_data: gpointer, destroy: GDestroyNotify) -> guint;
2934 pub fn g_main_context_acquire(context: *mut GMainContext) -> gboolean;
2935 pub fn g_main_context_add_poll(context: *mut GMainContext, fd: *mut GPollFD, priority: gint);
2936 pub fn g_main_context_check(context: *mut GMainContext, max_priority: gint, fds: *mut GPollFD, n_fds: gint) -> gint;
2937 pub fn g_main_context_default() -> *mut GMainContext;
2938 pub fn g_main_context_dispatch(context: *mut GMainContext);
2939 pub fn g_main_context_find_source_by_funcs_user_data(context: *mut GMainContext, funcs: *mut GSourceFuncs, user_data: gpointer) -> *mut GSource;
2940 pub fn g_main_context_find_source_by_id(context: *mut GMainContext, source_id: guint) -> *mut GSource;
2941 pub fn g_main_context_find_source_by_user_data(context: *mut GMainContext, user_data: gpointer) -> *mut GSource;
2942 pub fn g_main_context_get_poll_func(context: *mut GMainContext) -> GPollFunc;
2943 pub fn g_main_context_get_thread_default() -> *mut GMainContext;
2944 pub fn g_main_context_invoke(context: *mut GMainContext, function: GSourceFunc, data: gpointer);
2945 pub fn g_main_context_invoke_full(context: *mut GMainContext, priority: gint, function: GSourceFunc, data: gpointer, notify: Option<GDestroyNotify>);
2946 pub fn g_main_context_is_owner(context: *mut GMainContext) -> gboolean;
2947 pub fn g_main_context_iteration(context: *mut GMainContext, may_block: gboolean) -> gboolean;
2948 pub fn g_main_context_new() -> *mut GMainContext;
2949 pub fn g_main_context_pending(context: *mut GMainContext) -> gboolean;
2950 pub fn g_main_context_pop_thread_default(context: *mut GMainContext);
2951 pub fn g_main_context_prepare(context: *mut GMainContext, priority: gint) -> gboolean;
2952 pub fn g_main_context_push_thread_default(context: *mut GMainContext);
2953 pub fn g_main_context_query(context: *mut GMainContext, max_priority: gint, timeout_: *mut gint, fds: *mut GPollFD, n_fds: gint) -> gint;
2954 pub fn g_main_context_ref(context: *mut GMainContext) -> *mut GMainContext;
2955 pub fn g_main_context_ref_thread_default() -> *mut GMainContext;
2956 pub fn g_main_context_release(context: *mut GMainContext);
2957 pub fn g_main_context_remove_poll(context: *mut GMainContext, fd: *mut GPollFD);
2958 pub fn g_main_context_set_poll_func(context: *mut GMainContext, func: GPollFunc);
2959 pub fn g_main_context_unref(context: *mut GMainContext);
2960 pub fn g_main_context_wait(context: *mut GMainContext, cond: *mut GCond, mutex: *mut GMutex) -> gboolean;
2961 pub fn g_main_context_wakeup(context: *mut GMainContext);
2962 pub fn g_main_current_source() -> *mut GSource;
2963 pub fn g_main_depth() -> gint;
2964 pub fn g_main_loop_get_context(loop_: *mut GMainLoop) -> *mut GMainContext;
2965 pub fn g_main_loop_is_running(loop_: *mut GMainLoop) -> gboolean;
2966 pub fn g_main_loop_new(context: *mut GMainContext, is_running: gboolean) -> *mut GMainLoop;
2967 pub fn g_main_loop_quit(loop_: *mut GMainLoop);
2968 pub fn g_main_loop_ref(loop_: *mut GMainLoop) -> *mut GMainLoop;
2969 pub fn g_main_loop_run(loop_: *mut GMainLoop);
2970 pub fn g_main_loop_unref(loop_: *mut GMainLoop);
2971 pub fn g_malloc(n_bytes: gsize) -> gpointer;
2972 pub fn g_malloc0(n_bytes: gsize) -> gpointer;
2973 pub fn g_malloc0_n(n_blocks: gsize, n_block_bytes: gsize) -> gpointer;
2974 pub fn g_malloc_n(n_blocks: gsize, n_block_bytes: gsize) -> gpointer;
2975 pub fn g_mapped_file_free(file: *mut GMappedFile);
2976 pub fn g_mapped_file_get_bytes(file: *mut GMappedFile) -> *mut GBytes;
2977 pub fn g_mapped_file_get_contents(file: *mut GMappedFile) -> *mut gchar;
2978 pub fn g_mapped_file_get_length(file: *mut GMappedFile) -> gsize;
2979 pub fn g_mapped_file_new(filename: *const gchar, writable: gboolean, error: *mut *mut GError) -> *mut GMappedFile;
2980 pub fn g_mapped_file_new_from_fd(fd: gint, writable: gboolean, error: *mut *mut GError) -> *mut GMappedFile;
2981 pub fn g_mapped_file_ref(file: *mut GMappedFile) -> *mut GMappedFile;
2982 pub fn g_mapped_file_unref(file: *mut GMappedFile);
2983 pub fn g_markup_collect_attributes(element_name: *const gchar, attribute_names: *mut *const gchar, attribute_values: *mut *const gchar, error: *mut *mut GError, first_type: GMarkupCollectType, first_attr: *const gchar, ...) -> gboolean;
2984 pub fn g_markup_error_quark() -> GQuark;
2985 pub fn g_markup_escape_text(text: *const gchar, length: gssize) -> *mut gchar;
2986 pub fn g_markup_parse_context_end_parse(context: *mut GMarkupParseContext, error: *mut *mut GError) -> gboolean;
2987 pub fn g_markup_parse_context_free(context: *mut GMarkupParseContext);
2988 pub fn g_markup_parse_context_get_element(context: *mut GMarkupParseContext) -> *const gchar;
2989 pub fn g_markup_parse_context_get_element_stack(context: *mut GMarkupParseContext) -> *const GSList;
2990 pub fn g_markup_parse_context_get_position(context: *mut GMarkupParseContext, line_number: gint, char_number: gint);
2991 pub fn g_markup_parse_context_get_user_data(context: *mut GMarkupParseContext) -> gpointer;
2992 pub fn g_markup_parse_context_new(parser: *const GMarkupParser, flags: GMarkupParseFlags, user_data: gpointer, user_data_dnotify: GDestroyNotify) -> *mut GMarkupParseContext;
2993 pub fn g_markup_parse_context_parse(context: *mut GMarkupParseContext, text: *const gchar, text_len: gssize, error: *mut *mut GError) -> gboolean;
2994 pub fn g_markup_parse_context_pop(context: *mut GMarkupParseContext) -> gpointer;
2995 pub fn g_markup_parse_context_push(context: *mut GMarkupParseContext, parser: *const GMarkupParser, user_data: gpointer);
2996 pub fn g_markup_parse_context_ref(context: *mut GMarkupParseContext) -> *mut GMarkupParseContext;
2997 pub fn g_markup_parse_context_unref(context: *mut GMarkupParseContext);
2998 pub fn g_markup_printf_escaped(format: *const gchar, ...) -> *mut gchar;
2999 pub fn g_match_info_expand_references(match_info: *const GMatchInfo, string_to_expand: *const gchar, error: *mut *mut GError) -> *mut gchar;
3000 pub fn g_match_info_fetch(match_info: *const GMatchInfo, match_num: gint) -> *mut gchar;
3001 pub fn g_match_info_fetch_all(match_info: *const GMatchInfo) -> *mut *mut gchar;
3002 pub fn g_match_info_fetch_named(match_info: *const GMatchInfo, name: *const gchar) -> *mut gchar;
3003 pub fn g_match_info_fetch_named_pos(match_info: *const GMatchInfo, name: *const gchar, start_pos: *mut gint, end_pos: *mut gint) -> gboolean;
3004 pub fn g_match_info_fetch_pos(match_info: *const GMatchInfo, match_num: gint, start_pos: *mut gint, end_pos: *mut gint) -> gboolean;
3005 pub fn g_match_info_free(match_info: *mut GMatchInfo);
3006 pub fn g_match_info_get_match_count(match_info: *const GMatchInfo) -> gint;
3007 pub fn g_match_info_get_regex(match_info: *const GMatchInfo) -> *mut GRegex;
3008 pub fn g_match_info_get_string(match_info: *const GMatchInfo) -> *const gchar;
3009 pub fn g_match_info_is_partial_match(match_info: *const GMatchInfo) -> gboolean;
3010 pub fn g_match_info_matches(match_info: *const GMatchInfo) -> gboolean;
3011 pub fn g_match_info_next(match_info: *mut GMatchInfo, error: *mut *mut GError) -> gboolean;
3012 pub fn g_match_info_ref(match_info: *mut GMatchInfo) -> *mut GMatchInfo;
3013 pub fn g_match_info_unref(match_info: *mut GMatchInfo);
3014 pub fn g_mem_is_system_malloc() -> gboolean;
3015 pub fn g_mem_profile();
3016 pub fn g_mem_set_vtable(vtable: *mut GMemVTable);
3017 pub fn g_memdup(mem: gconstpointer, byte_size: guint) -> gpointer;
3018 pub fn g_mkdir_with_parents(pathname: *const gchar, mode: gint) -> gint;
3019 pub fn g_mkdtemp(tmpl: *mut gchar) -> *mut gchar;
3020 pub fn g_mkdtemp_full(tmpl: *mut gchar, mode: gint) -> *mut gchar;
3021 pub fn g_mkstemp(tmpl: *mut gchar) -> gint;
3022 pub fn g_mkstemp_full(tmpl: *mut gchar, flags: gint, mode: gint) -> gint;
3023 pub fn g_mutex_clear(mutex: *mut GMutex);
3024 pub fn g_mutex_init(mutex: *mut GMutex);
3025 pub fn g_mutex_lock(mutex: *mut GMutex);
3026 pub fn g_mutex_trylock(mutex: *mut GMutex) -> gboolean;
3027 pub fn g_mutex_unlock(mutex: *mut GMutex);
3028 pub fn g_node_child_index(node: *mut GNode, data: gpointer) -> gint;
3029 pub fn g_node_child_position(node: *mut GNode, child: *mut GNode) -> gint;
3030 pub fn g_node_children_foreach(node: *mut GNode, flags: GTraverseFlags, func: GNodeForeachFunc, data: gpointer);
3031 pub fn g_node_copy(node: *mut GNode) -> *mut GNode;
3032 pub fn g_node_copy_deep(node: *mut GNode, copy_func: GCopyFunc, data: gpointer) -> *mut GNode;
3033 pub fn g_node_depth(node: *mut GNode) -> guint;
3034 pub fn g_node_destroy(root: *mut GNode);
3035 pub fn g_node_find(root: *mut GNode, order: GTraverseType, flags: GTraverseFlags, data: gpointer) -> *mut GNode;
3036 pub fn g_node_find_child(node: *mut GNode, flags: GTraverseFlags, data: gpointer) -> *mut GNode;
3037 pub fn g_node_first_sibling(node: *mut GNode) -> *mut GNode;
3038 pub fn g_node_get_root(node: *mut GNode) -> *mut GNode;
3039 pub fn g_node_insert(parent: *mut GNode, position: gint, node: *mut GNode) -> *mut GNode;
3040 pub fn g_node_insert_after(parent: *mut GNode, sibling: *mut GNode, node: *mut GNode) -> *mut GNode;
3041 pub fn g_node_insert_before(parent: *mut GNode, sibling: *mut GNode, node: *mut GNode) -> *mut GNode;
3042 pub fn g_node_is_ancestor(node: *mut GNode, descendant: *mut GNode) -> gboolean;
3043 pub fn g_node_last_child(node: *mut GNode) -> *mut GNode;
3044 pub fn g_node_last_sibling(node: *mut GNode) -> *mut GNode;
3045 pub fn g_node_max_height(root: *mut GNode) -> guint;
3046 pub fn g_node_n_children(node: *mut GNode) -> guint;
3047 pub fn g_node_n_nodes(root: *mut GNode, flags: GTraverseFlags) -> guint;
3048 pub fn g_node_new(data: gpointer) -> *mut GNode;
3049 pub fn g_node_nth_child(node: *mut GNode, n: guint) -> *mut GNode;
3050 pub fn g_node_prepend(parent: *mut GNode, node: *mut GNode) -> *mut GNode;
3051 pub fn g_node_reverse_children(node: *mut GNode);
3052 pub fn g_node_traverse(root: *mut GNode, order: GTraverseType, flags: GTraverseFlags, max_depth: gint, func: GNodeTraverseFunc, data: gpointer);
3053 pub fn g_node_unlink(node: *mut GNode);
3054 pub fn g_nullify_pointer(nullify_location: gpointer);
3055 pub fn g_on_error_query(prg_name: *const gchar);
3056 pub fn g_on_error_stack_trace(prg_name: *const gchar);
3057 pub fn g_once_impl(once: *mut GOnce, func: GThreadFunc, arg: gpointer) -> gpointer;
3058 pub fn g_once_init_enter(location: gpointer) -> gboolean;
3059 pub fn g_once_init_leave(location: gpointer, result: gsize);
3060 pub fn g_option_context_add_group(context: *mut GOptionContext, group: *mut GOptionGroup);
3061 pub fn g_option_context_add_main_entries(context: *mut GOptionContext, entries: *const GOptionEntry, translation_domain: *const gchar);
3062 pub fn g_option_context_free(context: *mut GOptionContext);
3063 pub fn g_option_context_get_description(context: *mut GOptionContext) -> *const gchar;
3064 pub fn g_option_context_get_help(context: *mut GOptionContext, main_help: gboolean, group: *mut GOptionGroup) -> *mut gchar;
3065 pub fn g_option_context_get_help_enabled(context: *mut GOptionContext) -> gboolean;
3066 pub fn g_option_context_get_ignore_unknown_options(context: *mut GOptionContext) -> gboolean;
3067 pub fn g_option_context_get_main_group(context: *mut GOptionContext) -> *mut GOptionGroup;
3068 pub fn g_option_context_get_strict_posix(context: *mut GOptionContext) -> gboolean;
3069 pub fn g_option_context_get_summary(context: *mut GOptionContext) -> *const gchar;
3070 pub fn g_option_context_new(parameter_string: *const gchar) -> *mut GOptionContext;
3071 pub fn g_option_context_parse(context: *mut GOptionContext, argc: *mut gint, argv: *mut *mut *mut gchar, error: *mut *mut GError) -> gboolean;
3072 pub fn g_option_context_parse_strv(context: *mut GOptionContext, arguments: *mut *mut *mut gchar, error: *mut *mut GError) -> gboolean;
3073 pub fn g_option_context_set_description(context: *mut GOptionContext, description: *const gchar);
3074 pub fn g_option_context_set_help_enabled(context: *mut GOptionContext, help_enabled: gboolean);
3075 pub fn g_option_context_set_ignore_unknown_options(context: *mut GOptionContext, ignore_unknown: gboolean);
3076 pub fn g_option_context_set_main_group(context: *mut GOptionContext, group: *mut GOptionGroup);
3077 pub fn g_option_context_set_strict_posix(context: *mut GOptionContext, strict_posix: gboolean);
3078 pub fn g_option_context_set_summary(context: *mut GOptionContext, summary: *const gchar);
3079 pub fn g_option_context_set_translate_func(context: *mut GOptionContext, func: Option<GTranslateFunc>, data: gpointer, destroy_notify: Option<GDestroyNotify>);
3080 pub fn g_option_context_set_translation_domain(context: *mut GOptionContext, domain: *const gchar);
3081 pub fn g_option_error_quark() -> GQuark;
3082 pub fn g_option_group_add_entries(group: *mut GOptionGroup, entries: *const GOptionEntry);
3083 pub fn g_option_group_free(group: *mut GOptionGroup);
3084 pub fn g_option_group_new(name: *const gchar, description: *const gchar, help_description: *const gchar, user_data: gpointer, destroy: Option<GDestroyNotify>) -> *mut GOptionGroup;
3085 pub fn g_option_group_ref(group: *mut GOptionGroup) -> *mut GOptionGroup;
3086 pub fn g_option_group_set_error_hook(group: *mut GOptionGroup, error_func: GOptionErrorFunc);
3087 pub fn g_option_group_set_parse_hooks(group: *mut GOptionGroup, pre_parse_func: Option<GOptionParseFunc>, post_parse_func: Option<GOptionParseFunc>);
3088 pub fn g_option_group_set_translate_func(group: *mut GOptionGroup, func: Option<GTranslateFunc>, data: gpointer, destroy_notify: Option<GDestroyNotify>);
3089 pub fn g_option_group_set_translation_domain(group: *mut GOptionGroup, domain: *const gchar);
3090 pub fn g_option_group_unref(group: *mut GOptionGroup);
3091 pub fn g_parse_debug_string(string: *const gchar, keys: *mut GDebugKey, nkeys: guint) -> guint;
3092 pub fn g_path_get_basename(file_name: *const gchar) -> *mut gchar;
3093 pub fn g_path_get_dirname(file_name: *const gchar) -> *mut gchar;
3094 pub fn g_path_is_absolute(file_name: *const gchar) -> gboolean;
3095 pub fn g_path_skip_root(file_name: *const gchar) -> *const gchar;
3096 pub fn g_pattern_match(pspec: *mut GPatternSpec, string_length: guint, string: *const gchar, string_reversed: *const gchar) -> gboolean;
3097 pub fn g_pattern_match_simple(pattern: *const gchar, string: *const gchar) -> gboolean;
3098 pub fn g_pattern_match_string(pspec: *mut GPatternSpec, string: *const gchar) -> gboolean;
3099 pub fn g_pattern_spec_equal(pspec1: *mut GPatternSpec, pspec2: *mut GPatternSpec) -> gboolean;
3100 pub fn g_pattern_spec_free(pspec: *mut GPatternSpec);
3101 pub fn g_pattern_spec_new(pattern: *const gchar) -> *mut GPatternSpec;
3102 pub fn g_pointer_bit_lock(address: gpointer, lock_bit: gint);
3103 pub fn g_pointer_bit_trylock(address: gpointer, lock_bit: gint) -> gboolean;
3104 pub fn g_pointer_bit_unlock(address: gpointer, lock_bit: gint);
3105 pub fn g_poll(fds: *mut GPollFD, nfds: guint, timeout: gint) -> gint;
3106 pub fn g_prefix_error(err: *mut *mut GError, format: *const gchar, ...);
3107 pub fn g_print(format: *const gchar, ...);
3108 pub fn g_printerr(format: *const gchar, ...);
3109 pub fn g_printf(format: *mut gchar, ...) -> gint;
3110 pub fn g_private_get(key: *mut GPrivate) -> gpointer;
3111 pub fn g_private_replace(key: *mut GPrivate, value: gpointer);
3112 pub fn g_private_set(key: *mut GPrivate, value: gpointer);
3113 pub fn g_propagate_error(dest: *mut *mut GError, src: *mut GError);
3114 pub fn g_propagate_prefixed_error(dest: *mut *mut GError, src: *mut GError, format: *const gchar, ...);
3115 pub fn g_ptr_array_add(array: *mut GPtrArray, data: gpointer);
3116 pub fn g_ptr_array_foreach(array: *mut GPtrArray, func: GFunc, user_data: gpointer);
3117 pub fn g_ptr_array_free(array: *mut GPtrArray, free_seg: gboolean) -> gpointer;
3118 pub fn g_ptr_array_insert(array: *mut GPtrArray, index_: gint, data: gpointer);
3119 pub fn g_ptr_array_new() -> *mut GPtrArray;
3120 pub fn g_ptr_array_new_full(reserved_size: guint, element_free_func: Option<GDestroyNotify>) -> *mut GPtrArray;
3121 pub fn g_ptr_array_new_with_free_func(element_free_func: Option<GDestroyNotify>) -> *mut GPtrArray;
3122 pub fn g_ptr_array_ref(array: *mut GPtrArray) -> *mut GPtrArray;
3123 pub fn g_ptr_array_remove(array: *mut GPtrArray, data: gpointer) -> gboolean;
3124 pub fn g_ptr_array_remove_fast(array: *mut GPtrArray, data: gpointer) -> gboolean;
3125 pub fn g_ptr_array_remove_index(array: *mut GPtrArray, index_: guint) -> gpointer;
3126 pub fn g_ptr_array_remove_index_fast(array: *mut GPtrArray, index_: guint) -> gpointer;
3127 pub fn g_ptr_array_remove_range(array: *mut GPtrArray, index_: guint, length: guint) -> *mut GPtrArray;
3128 pub fn g_ptr_array_set_free_func(array: *mut GPtrArray, element_free_func: Option<GDestroyNotify>);
3129 pub fn g_ptr_array_set_size(array: *mut GPtrArray, length: gint);
3130 pub fn g_ptr_array_sized_new(reserved_size: guint) -> *mut GPtrArray;
3131 pub fn g_ptr_array_sort(array: *mut GPtrArray, compare_func: GCompareFunc);
3132 pub fn g_ptr_array_sort_with_data(array: *mut GPtrArray, compare_func: GCompareDataFunc, user_data: gpointer);
3133 pub fn g_ptr_array_unref(array: *mut GPtrArray);
3134 pub fn g_qsort_with_data(pbase: gconstpointer, total_elems: gint, size: gsize, compare_func: GCompareDataFunc, user_data: gpointer);
3135 pub fn g_quark_from_static_string(string: *const gchar) -> GQuark;
3136 pub fn g_quark_from_string(string: *const gchar) -> GQuark;
3137 pub fn g_quark_to_string(quark: GQuark) -> *const gchar;
3138 pub fn g_quark_try_string(string: *const gchar) -> GQuark;
3139 pub fn g_queue_clear(queue: *mut GQueue);
3140 pub fn g_queue_copy(queue: *mut GQueue) -> *mut GQueue;
3141 pub fn g_queue_delete_link(queue: *mut GQueue, link_: *mut GList);
3142 pub fn g_queue_find(queue: *mut GQueue, data: gconstpointer) -> *mut GList;
3143 pub fn g_queue_find_custom(queue: *mut GQueue, data: gconstpointer, func: GCompareFunc) -> *mut GList;
3144 pub fn g_queue_foreach(queue: *mut GQueue, func: GFunc, user_data: gpointer);
3145 pub fn g_queue_free(queue: *mut GQueue);
3146 pub fn g_queue_free_full(queue: *mut GQueue, free_func: GDestroyNotify);
3147 pub fn g_queue_get_length(queue: *mut GQueue) -> guint;
3148 pub fn g_queue_index(queue: *mut GQueue, data: gconstpointer) -> gint;
3149 pub fn g_queue_init(queue: *mut GQueue);
3150 pub fn g_queue_insert_after(queue: *mut GQueue, sibling: *mut GList, data: gpointer);
3151 pub fn g_queue_insert_before(queue: *mut GQueue, sibling: *mut GList, data: gpointer);
3152 pub fn g_queue_insert_sorted(queue: *mut GQueue, data: gpointer, func: GCompareDataFunc, user_data: gpointer);
3153 pub fn g_queue_is_empty(queue: *mut GQueue) -> gboolean;
3154 pub fn g_queue_link_index(queue: *mut GQueue, link_: *mut GList) -> gint;
3155 pub fn g_queue_new() -> *mut GQueue;
3156 pub fn g_queue_peek_head(queue: *mut GQueue) -> gpointer;
3157 pub fn g_queue_peek_head_link(queue: *mut GQueue) -> *mut GList;
3158 pub fn g_queue_peek_nth(queue: *mut GQueue, n: guint) -> gpointer;
3159 pub fn g_queue_peek_nth_link(queue: *mut GQueue, n: guint) -> *mut GList;
3160 pub fn g_queue_peek_tail(queue: *mut GQueue) -> gpointer;
3161 pub fn g_queue_peek_tail_link(queue: *mut GQueue) -> *mut GList;
3162 pub fn g_queue_pop_head(queue: *mut GQueue) -> gpointer;
3163 pub fn g_queue_pop_head_link(queue: *mut GQueue) -> *mut GList;
3164 pub fn g_queue_pop_nth(queue: *mut GQueue, n: guint) -> gpointer;
3165 pub fn g_queue_pop_nth_link(queue: *mut GQueue, n: guint) -> *mut GList;
3166 pub fn g_queue_pop_tail(queue: *mut GQueue) -> gpointer;
3167 pub fn g_queue_pop_tail_link(queue: *mut GQueue) -> *mut GList;
3168 pub fn g_queue_push_head(queue: *mut GQueue, data: gpointer);
3169 pub fn g_queue_push_head_link(queue: *mut GQueue, link_: *mut GList);
3170 pub fn g_queue_push_nth(queue: *mut GQueue, data: gpointer, n: gint);
3171 pub fn g_queue_push_nth_link(queue: *mut GQueue, n: gint, link_: *mut GList);
3172 pub fn g_queue_push_tail(queue: *mut GQueue, data: gpointer);
3173 pub fn g_queue_push_tail_link(queue: *mut GQueue, link_: *mut GList);
3174 pub fn g_queue_remove(queue: *mut GQueue, data: gconstpointer) -> gboolean;
3175 pub fn g_queue_remove_all(queue: *mut GQueue, data: gconstpointer) -> guint;
3176 pub fn g_queue_reverse(queue: *mut GQueue);
3177 pub fn g_queue_sort(queue: *mut GQueue, compare_func: GCompareDataFunc, user_data: gpointer);
3178 pub fn g_queue_unlink(queue: *mut GQueue, link_: *mut GList);
3179 pub fn g_rand_copy(rand_: *mut GRand) -> *mut GRand;
3180 pub fn g_rand_double(rand_: *mut GRand) -> gdouble;
3181 pub fn g_rand_double_range(rand_: *mut GRand, begin: gdouble, end: gdouble) -> gdouble;
3182 pub fn g_rand_free(rand_: *mut GRand);
3183 pub fn g_rand_int(rand_: *mut GRand) -> u32;
3184 pub fn g_rand_int_range(rand_: *mut GRand, begin: i32, end: i32) -> i32;
3185 pub fn g_rand_new() -> *mut GRand;
3186 pub fn g_rand_new_with_seed(seed: u32) -> *mut GRand;
3187 pub fn g_rand_new_with_seed_array(seed: u32, seed_length: guint) -> *mut GRand;
3188 pub fn g_rand_set_seed(rand_: *mut GRand, seed: u32);
3189 pub fn g_rand_set_seed_array(rand_: *mut GRand, seed: u32, seed_length: guint);
3190 pub fn g_random_double() -> gdouble;
3191 pub fn g_random_double_range(begin: gdouble, end: gdouble) -> gdouble;
3192 pub fn g_random_int() -> u32;
3193 pub fn g_random_int_range(begin: i32, end: i32) -> i32;
3194 pub fn g_random_set_seed(seed: u32);
3195 pub fn g_realloc(mem: gpointer, n_bytes: gsize) -> gpointer;
3196 pub fn g_realloc_n(mem: gpointer, n_blocks: gsize, n_block_bytes: gsize) -> gpointer;
3197 pub fn g_rec_mutex_clear(rec_mutex: *mut GRecMutex);
3198 pub fn g_rec_mutex_init(rec_mutex: *mut GRecMutex);
3199 pub fn g_rec_mutex_lock(rec_mutex: *mut GRecMutex);
3200 pub fn g_rec_mutex_trylock(rec_mutex: *mut GRecMutex) -> gboolean;
3201 pub fn g_rec_mutex_unlock(rec_mutex: *mut GRecMutex);
3202 pub fn g_regex_check_replacement(replacement: *const gchar, has_references: *mut gboolean, error: *mut *mut GError) -> gboolean;
3203 pub fn g_regex_error_quark() -> GQuark;
3204 pub fn g_regex_escape_nul(string: *const gchar, length: gint) -> *mut gchar;
3205 pub fn g_regex_escape_string(string: *mut gchar, length: gint) -> *mut gchar;
3206 pub fn g_regex_get_capture_count(regex: *const GRegex) -> gint;
3207 pub fn g_regex_get_compile_flags(regex: *const GRegex) -> GRegexCompileFlags;
3208 pub fn g_regex_get_has_cr_or_lf(regex: *const GRegex) -> gboolean;
3209 pub fn g_regex_get_match_flags(regex: *const GRegex) -> GRegexMatchFlags;
3210 pub fn g_regex_get_max_backref(regex: *const GRegex) -> gint;
3211 pub fn g_regex_get_max_lookbehind(regex: *const GRegex) -> gint;
3212 pub fn g_regex_get_pattern(regex: *const GRegex) -> *const gchar;
3213 pub fn g_regex_get_string_number(regex: *const GRegex, name: *const gchar) -> gint;
3214 pub fn g_regex_match(regex: *const GRegex, string: *const gchar, match_options: GRegexMatchFlags, match_info: *mut *mut GMatchInfo) -> gboolean;
3215 pub fn g_regex_match_all(regex: *const GRegex, string: *const gchar, match_options: GRegexMatchFlags, match_info: *mut *mut GMatchInfo) -> gboolean;
3216 pub fn g_regex_match_all_full(regex: *const GRegex, string: *mut gchar, string_len: gssize, start_position: gint, match_options: GRegexMatchFlags, match_info: *mut *mut GMatchInfo, error: *mut *mut GError) -> gboolean;
3217 pub fn g_regex_match_full(regex: *const GRegex, string: *mut gchar, string_len: gssize, start_position: gint, match_options: GRegexMatchFlags, match_info: *mut *mut GMatchInfo, error: *mut *mut GError) -> gboolean;
3218 pub fn g_regex_match_simple(pattern: *const gchar, string: *const gchar, compile_options: GRegexCompileFlags, match_options: GRegexMatchFlags) -> gboolean;
3219 pub fn g_regex_new(pattern: *const gchar, compile_options: GRegexCompileFlags, match_options: GRegexMatchFlags, error: *mut *mut GError) -> *mut GRegex;
3220 pub fn g_regex_ref(regex: *mut GRegex) -> *mut GRegex;
3221 pub fn g_regex_replace(regex: *const GRegex, string: *mut gchar, string_len: gssize, start_position: gint, replacement: *const gchar, match_options: GRegexMatchFlags, error: *mut *mut GError) -> *mut gchar;
3222 pub fn g_regex_replace_eval(regex: *const GRegex, string: *mut gchar, string_len: gssize, start_position: gint, match_options: GRegexMatchFlags, eval: GRegexEvalCallback, user_data: gpointer, error: *mut *mut GError) -> *mut gchar;
3223 pub fn g_regex_replace_literal(regex: *const GRegex, string: *mut gchar, string_len: gssize, start_position: gint, replacement: *const gchar, match_options: GRegexMatchFlags, error: *mut *mut GError) -> *mut gchar;
3224 pub fn g_regex_split(regex: *const GRegex, string: *const gchar, match_options: GRegexMatchFlags) -> *mut *mut gchar;
3225 pub fn g_regex_split_full(regex: *const GRegex, string: *mut gchar, string_len: gssize, start_position: gint, match_options: GRegexMatchFlags, max_tokens: gint, error: *mut *mut GError) -> *mut *mut gchar;
3226 pub fn g_regex_split_simple(pattern: *const gchar, string: *const gchar, compile_options: GRegexCompileFlags, match_options: GRegexMatchFlags) -> *mut *mut gchar;
3227 pub fn g_regex_unref(regex: *mut GRegex);
3228 pub fn g_reload_user_special_dirs_cache();
3229 pub fn g_return_if_fail_warning(log_domain: *const gchar, pretty_function: *const gchar, expression: *const gchar);
3230 pub fn g_rmdir(filename: *const gchar) -> gint;
3231 pub fn g_rw_lock_clear(rw_lock: *mut GRWLock);
3232 pub fn g_rw_lock_init(rw_lock: *mut GRWLock);
3233 pub fn g_rw_lock_reader_lock(rw_lock: *mut GRWLock);
3234 pub fn g_rw_lock_reader_trylock(rw_lock: *mut GRWLock) -> gboolean;
3235 pub fn g_rw_lock_reader_unlock(rw_lock: *mut GRWLock);
3236 pub fn g_rw_lock_writer_lock(rw_lock: *mut GRWLock);
3237 pub fn g_rw_lock_writer_trylock(rw_lock: *mut GRWLock) -> gboolean;
3238 pub fn g_rw_lock_writer_unlock(rw_lock: *mut GRWLock);
3239 pub fn g_scanner_cur_line(scanner: *mut GScanner) -> guint;
3240 pub fn g_scanner_cur_position(scanner: *mut GScanner) -> guint;
3241 pub fn g_scanner_cur_token(scanner: *mut GScanner) -> GTokenType;
3242 pub fn g_scanner_cur_value(scanner: *mut GScanner) -> GTokenValue;
3243 pub fn g_scanner_destroy(scanner: *mut GScanner);
3244 pub fn g_scanner_eof(scanner: *mut GScanner) -> gboolean;
3245 pub fn g_scanner_error(scanner: *mut GScanner, format: *const gchar, ...);
3246 pub fn g_scanner_get_next_token(scanner: *mut GScanner) -> GTokenType;
3247 pub fn g_scanner_input_file(scanner: *mut GScanner, input_fd: gint);
3248 pub fn g_scanner_input_text(scanner: *mut GScanner, text: *const gchar, text_len: guint);
3249 pub fn g_scanner_lookup_symbol(scanner: *mut GScanner, symbol: *const gchar) -> gpointer;
3250 pub fn g_scanner_new(config_templ: *const GScannerConfig) -> *mut GScanner;
3251 pub fn g_scanner_peek_next_token(scanner: *mut GScanner) -> GTokenType;
3252 pub fn g_scanner_scope_add_symbol(scanner: *mut GScanner, scope_id: guint, symbol: *const gchar, value: gpointer);
3253 pub fn g_scanner_scope_foreach_symbol(scanner: *mut GScanner, scope_id: guint, func: GHFunc, user_data: gpointer);
3254 pub fn g_scanner_scope_lookup_symbol(scanner: *mut GScanner, scope_id: guint, symbol: *const gchar) -> gpointer;
3255 pub fn g_scanner_scope_remove_symbol(scanner: *mut GScanner, scope_id: guint, symbol: *const gchar);
3256 pub fn g_scanner_set_scope(scanner: *mut GScanner, scope_id: guint) -> guint;
3257 pub fn g_scanner_sync_file_offset(scanner: *mut GScanner);
3258 pub fn g_scanner_unexp_token(scanner: *mut GScanner, expected_token: GTokenType, identifier_spec: *const gchar, symbol_spec: *const gchar, symbol_name: *const gchar, message: *const gchar, is_error: gint);
3259 pub fn g_scanner_warn(scanner: *mut GScanner, format: *const gchar, ...);
3260 pub fn g_sequence_append(seq: *mut GSequence, data: gpointer) -> *mut GSequenceIter;
3261 pub fn g_sequence_foreach(seq: *mut GSequence, func: GFunc, user_data: gpointer);
3262 pub fn g_sequence_foreach_range(begin: *mut GSequenceIter, end: *mut GSequenceIter, func: GFunc, user_data: gpointer);
3263 pub fn g_sequence_free(seq: *mut GSequence);
3264 pub fn g_sequence_get(iter: *mut GSequenceIter) -> gpointer;
3265 pub fn g_sequence_get_begin_iter(seq: *mut GSequence) -> *mut GSequenceIter;
3266 pub fn g_sequence_get_end_iter(seq: *mut GSequence) -> *mut GSequenceIter;
3267 pub fn g_sequence_get_iter_at_pos(seq: *mut GSequence, pos: gint) -> *mut GSequenceIter;
3268 pub fn g_sequence_get_length(seq: *mut GSequence) -> gint;
3269 pub fn g_sequence_insert_before(iter: *mut GSequenceIter, data: gpointer) -> *mut GSequenceIter;
3270 pub fn g_sequence_insert_sorted(seq: *mut GSequence, data: gpointer, cmp_func: GCompareDataFunc, cmp_data: gpointer) -> *mut GSequenceIter;
3271 pub fn g_sequence_insert_sorted_iter(seq: *mut GSequence, data: gpointer, iter_cmp: GSequenceIterCompareFunc, cmp_data: gpointer) -> *mut GSequenceIter;
3272 pub fn g_sequence_iter_compare(a: *mut GSequenceIter, b: *mut GSequenceIter) -> gint;
3273 pub fn g_sequence_iter_get_position(iter: *mut GSequenceIter) -> gint;
3274 pub fn g_sequence_iter_get_sequence(iter: *mut GSequenceIter) -> *mut GSequence;
3275 pub fn g_sequence_iter_is_begin(iter: *mut GSequenceIter) -> gboolean;
3276 pub fn g_sequence_iter_is_end(iter: *mut GSequenceIter) -> gboolean;
3277 pub fn g_sequence_iter_move(iter: *mut GSequenceIter, delta: gint) -> *mut GSequenceIter;
3278 pub fn g_sequence_iter_next(iter: *mut GSequenceIter) -> *mut GSequenceIter;
3279 pub fn g_sequence_iter_prev(iter: *mut GSequenceIter) -> *mut GSequenceIter;
3280 pub fn g_sequence_lookup(seq: *mut GSequence, data: gpointer, cmp_func: GCompareDataFunc, cmp_data: gpointer) -> *mut GSequenceIter;
3281 pub fn g_sequence_lookup_iter(seq: *mut GSequence, data: gpointer, iter_cmp: GSequenceIterCompareFunc, cmp_data: gpointer) -> *mut GSequenceIter;
3282 pub fn g_sequence_move(src: *mut GSequenceIter, dest: *mut GSequenceIter);
3283 pub fn g_sequence_move_range(dest: *mut GSequenceIter, begin: *mut GSequenceIter, end: *mut GSequenceIter);
3284 pub fn g_sequence_new(data_destroy: Option<GDestroyNotify>) -> *mut GSequence;
3285 pub fn g_sequence_prepend(seq: *mut GSequence, data: gpointer) -> *mut GSequenceIter;
3286 pub fn g_sequence_range_get_midpoint(begin: *mut GSequenceIter, end: *mut GSequenceIter) -> *mut GSequenceIter;
3287 pub fn g_sequence_remove(iter: *mut GSequenceIter);
3288 pub fn g_sequence_remove_range(begin: *mut GSequenceIter, end: *mut GSequenceIter);
3289 pub fn g_sequence_search(seq: *mut GSequence, data: gpointer, cmp_func: GCompareDataFunc, cmp_data: gpointer) -> *mut GSequenceIter;
3290 pub fn g_sequence_search_iter(seq: *mut GSequence, data: gpointer, iter_cmp: GSequenceIterCompareFunc, cmp_data: gpointer) -> *mut GSequenceIter;
3291 pub fn g_sequence_set(iter: *mut GSequenceIter, data: gpointer);
3292 pub fn g_sequence_sort(seq: *mut GSequence, cmp_func: GCompareDataFunc, cmp_data: gpointer);
3293 pub fn g_sequence_sort_changed(iter: *mut GSequenceIter, cmp_func: GCompareDataFunc, cmp_data: gpointer);
3294 pub fn g_sequence_sort_changed_iter(iter: *mut GSequenceIter, iter_cmp: GSequenceIterCompareFunc, cmp_data: gpointer);
3295 pub fn g_sequence_sort_iter(seq: *mut GSequence, cmp_func: GSequenceIterCompareFunc, cmp_data: gpointer);
3296 pub fn g_sequence_swap(a: *mut GSequenceIter, b: *mut GSequenceIter);
3297 pub fn g_set_application_name(application_name: *const gchar);
3298 pub fn g_set_error(err: *mut *mut GError, domain: GQuark, code: gint, format: *const gchar, ...);
3299 pub fn g_set_error_literal(err: *mut *mut GError, domain: GQuark, code: gint, message: *const gchar);
3300 pub fn g_set_prgname(prgname: *const gchar);
3301 pub fn g_set_print_handler(func: GPrintFunc) -> GPrintFunc;
3302 pub fn g_set_printerr_handler(func: GPrintFunc) -> GPrintFunc;
3303 pub fn g_setenv(variable: *const gchar, value: *const gchar, overwrite: gboolean) -> gboolean;
3304 pub fn g_shell_error_quark() -> GQuark;
3305 pub fn g_shell_parse_argv(command_line: *const gchar, argcp: *mut gint, argvp: *mut *mut *mut gchar, error: *mut *mut GError) -> gboolean;
3306 pub fn g_shell_quote(unquoted_string: *const gchar) -> *mut gchar;
3307 pub fn g_shell_unquote(quoted_string: *const gchar, error: *mut *mut GError) -> *mut gchar;
3308 pub fn g_slice_alloc(block_size: gsize) -> gpointer;
3309 pub fn g_slice_alloc0(block_size: gsize) -> gpointer;
3310 pub fn g_slice_copy(block_size: gsize, mem_block: gconstpointer) -> gpointer;
3311 pub fn g_slice_free1(block_size: gsize, mem_block: gpointer);
3312 pub fn g_slice_free_chain_with_offset(block_size: gsize, mem_chain: gpointer, next_offset: gsize);
3313 pub fn g_slice_get_config(ckey: GSliceConfig) -> i64;
3314 pub fn g_slice_get_config_state(ckey: GSliceConfig, address: i64, n_values: guint) -> i64;
3315 pub fn g_slice_set_config(ckey: GSliceConfig, value: i64);
3316 pub fn g_slist_alloc() -> *mut GSList;
3317 pub fn g_slist_append(list: *mut GSList, data: gpointer) -> *mut GSList;
3318 pub fn g_slist_concat(list1: *mut GSList, list2: *mut GSList) -> *mut GSList;
3319 pub fn g_slist_copy(list: *mut GSList) -> *mut GSList;
3320 pub fn g_slist_copy_deep(list: *mut GSList, func: GCopyFunc, user_data: gpointer) -> *mut GSList;
3321 pub fn g_slist_delete_link(list: *mut GSList, link_: *mut GSList) -> *mut GSList;
3322 pub fn g_slist_find(list: *mut GSList, data: gconstpointer) -> *mut GSList;
3323 pub fn g_slist_find_custom(list: *mut GSList, data: gconstpointer, func: GCompareFunc) -> *mut GSList;
3324 pub fn g_slist_foreach(list: *mut GSList, func: GFunc, user_data: gpointer);
3325 pub fn g_slist_free(list: *mut GSList);
3326 pub fn g_slist_free_1(list: *mut GSList);
3327 pub fn g_slist_free_full(list: *mut GSList, free_func: GDestroyNotify);
3328 pub fn g_slist_index(list: *mut GSList, data: gconstpointer) -> gint;
3329 pub fn g_slist_insert(list: *mut GSList, data: gpointer, position: gint) -> *mut GSList;
3330 pub fn g_slist_insert_before(slist: *mut GSList, sibling: *mut GSList, data: gpointer) -> *mut GSList;
3331 pub fn g_slist_insert_sorted(list: *mut GSList, data: gpointer, func: GCompareFunc) -> *mut GSList;
3332 pub fn g_slist_insert_sorted_with_data(list: *mut GSList, data: gpointer, func: GCompareDataFunc, user_data: gpointer) -> *mut GSList;
3333 pub fn g_slist_last(list: *mut GSList) -> *mut GSList;
3334 pub fn g_slist_length(list: *mut GSList) -> guint;
3335 pub fn g_slist_nth(list: *mut GSList, n: guint) -> *mut GSList;
3336 pub fn g_slist_nth_data(list: *mut GSList, n: guint) -> gpointer;
3337 pub fn g_slist_position(list: *mut GSList, llink: *mut GSList) -> gint;
3338 pub fn g_slist_prepend(list: *mut GSList, data: gpointer) -> *mut GSList;
3339 pub fn g_slist_remove(list: *mut GSList, data: gconstpointer) -> *mut GSList;
3340 pub fn g_slist_remove_all(list: *mut GSList, data: gconstpointer) -> *mut GSList;
3341 pub fn g_slist_remove_link(list: *mut GSList, link_: *mut GSList) -> *mut GSList;
3342 pub fn g_slist_reverse(list: *mut GSList) -> *mut GSList;
3343 pub fn g_slist_sort(list: *mut GSList, compare_func: GCompareFunc) -> *mut GSList;
3344 pub fn g_slist_sort_with_data(list: *mut GSList, compare_func: GCompareDataFunc, user_data: gpointer) -> *mut GSList;
3345 pub fn g_snprintf(string: *mut gchar, n: gulong, format: *mut gchar, ...) -> gint;
3346 pub fn g_source_add_child_source(source: *mut GSource, child_source: *mut GSource);
3347 pub fn g_source_add_poll(source: *mut GSource, fd: *mut GPollFD);
3348 pub fn g_source_attach(source: *mut GSource, context: *mut GMainContext) -> guint;
3349 pub fn g_source_destroy(source: *mut GSource);
3350 pub fn g_source_get_can_recurse(source: *mut GSource) -> gboolean;
3351 pub fn g_source_get_context(source: *mut GSource) -> *mut GMainContext;
3352 pub fn g_source_get_current_time(source: *mut GSource, timeval: *mut GTimeVal);
3353 pub fn g_source_get_id(source: *mut GSource) -> guint;
3354 pub fn g_source_get_name(source: *mut GSource) -> *const gchar;
3355 pub fn g_source_get_priority(source: *mut GSource) -> gint;
3356 pub fn g_source_get_ready_time(source: *mut GSource) -> i64;
3357 pub fn g_source_get_time(source: *mut GSource) -> i64;
3358 pub fn g_source_is_destroyed(source: *mut GSource) -> gboolean;
3359 pub fn g_source_new(source_funcs: *mut GSourceFuncs, struct_size: guint) -> *mut GSource;
3360 pub fn g_source_ref(source: *mut GSource) -> *mut GSource;
3361 pub fn g_source_remove(tag: guint) -> gboolean;
3362 pub fn g_source_remove_by_funcs_user_data(funcs: *mut GSourceFuncs, user_data: gpointer) -> gboolean;
3363 pub fn g_source_remove_by_user_data(user_data: gpointer) -> gboolean;
3364 pub fn g_source_remove_child_source(source: *mut GSource, child_source: *mut GSource);
3365 pub fn g_source_remove_poll(source: *mut GSource, fd: *mut GPollFD);
3366 pub fn g_source_set_callback(source: *mut GSource, func: GSourceFunc, data: gpointer, notify: Option<GDestroyNotify>);
3367 pub fn g_source_set_callback_indirect(source: *mut GSource, callback_data: gpointer, callback_funcs: *mut GSourceCallbackFuncs);
3368 pub fn g_source_set_can_recurse(source: *mut GSource, can_recurse: gboolean);
3369 pub fn g_source_set_funcs(source: *mut GSource, funcs: *mut GSourceFuncs);
3370 pub fn g_source_set_name(source: *mut GSource, name: *const gchar);
3371 pub fn g_source_set_name_by_id(tag: guint, name: *const gchar);
3372 pub fn g_source_set_priority(source: *mut GSource, priority: gint);
3373 pub fn g_source_set_ready_time(source: *mut GSource, ready_time: i64);
3374 pub fn g_source_unref(source: *mut GSource);
3375 pub fn g_spaced_primes_closest(num: guint) -> guint;
3376 pub fn g_spawn_async(working_directory: *const gchar, argv: *mut *mut gchar, envp: *mut *mut gchar, flags: GSpawnFlags, child_setup: Option<GSpawnChildSetupFunc>, user_data: gpointer, child_pid: *mut GPid, error: *mut *mut GError) -> gboolean;
3377 pub fn g_spawn_async_with_pipes(working_directory: *const gchar, argv: *mut *mut gchar, envp: *mut *mut gchar, flags: GSpawnFlags, child_setup: Option<GSpawnChildSetupFunc>, user_data: gpointer, child_pid: *mut GPid, standard_input: *mut gint, standard_output: *mut gint, standard_error: *mut gint, error: *mut *mut GError) -> gboolean;
3378 pub fn g_spawn_check_exit_status(exit_status: gint, error: *mut *mut GError) -> gboolean;
3379 pub fn g_spawn_close_pid(pid: GPid);
3380 pub fn g_spawn_command_line_async(command_line: *const gchar, error: *mut *mut GError) -> gboolean;
3381 pub fn g_spawn_command_line_sync(command_line: *const gchar, standard_output: *mut *mut gchar, standard_error: *mut *mut gchar, exit_status: *mut gint, error: *mut *mut GError) -> gboolean;
3382 pub fn g_spawn_error_quark() -> GQuark;
3383 pub fn g_spawn_exit_error_quark() -> GQuark;
3384 pub fn g_spawn_sync(working_directory: *const gchar, argv: *mut *mut gchar, envp: *mut *mut gchar, flags: GSpawnFlags, child_setup: Option<GSpawnChildSetupFunc>, user_data: gpointer, standard_output: *mut *mut gchar, standard_error: *mut *mut gchar, exit_status: *mut gint, error: *mut *mut GError) -> gboolean;
3385 pub fn g_sprintf(string: *mut gchar, format: *mut gchar, ...) -> gint;
3386 pub fn g_stpcpy(dest: *mut gchar, src: *const gchar) -> *mut gchar;
3387 pub fn g_str_equal(v1: gconstpointer, v2: gconstpointer) -> gboolean;
3388 pub fn g_str_has_prefix(str: *const gchar, prefix: *const gchar) -> gboolean;
3389 pub fn g_str_has_suffix(str: *const gchar, suffix: *const gchar) -> gboolean;
3390 pub fn g_str_hash(v: gconstpointer) -> guint;
3391 pub fn g_str_is_ascii(str: *const gchar) -> gboolean;
3392 pub fn g_str_match_string(search_term: *const gchar, potential_hit: *const gchar, accept_alternates: gboolean) -> gboolean;
3393 pub fn g_str_to_ascii(str: *const gchar, from_locale: *const gchar) -> *mut gchar;
3394 pub fn g_str_tokenize_and_fold(string: *const gchar, translit_locale: *const gchar, ascii_alternates: *mut *mut *mut gchar) -> *mut *mut gchar;
3395 pub fn g_strcanon(string: *mut gchar, valid_chars: *const gchar, substitutor: gchar) -> *mut gchar;
3396 pub fn g_strcasecmp(s1: *const gchar, s2: *const gchar) -> gint;
3397 pub fn g_strchomp(string: *mut gchar) -> *mut gchar;
3398 pub fn g_strchug(string: *mut gchar) -> *mut gchar;
3399 pub fn g_strcmp0(str1: *const gchar, str2: *const gchar) -> gint;
3400 pub fn g_strcompress(source: *const gchar) -> *mut gchar;
3401 pub fn g_strconcat(string1: *const gchar, ...) -> *mut gchar;
3402 pub fn g_strdelimit(string: *mut gchar, delimiters: *const gchar, new_delimiter: gchar) -> *mut gchar;
3403 pub fn g_strdown(string: *mut gchar) -> *mut gchar;
3404 pub fn g_strdup(str: *const gchar) -> *mut gchar;
3405 pub fn g_strdup_printf(format: *const gchar, ...) -> *mut gchar;
3406 pub fn g_strdupv(str_array: *mut *mut gchar) -> *mut *mut gchar;
3407 pub fn g_strerror(errnum: gint) -> *const gchar;
3408 pub fn g_strescape(source: *const gchar, exceptions: *const gchar) -> *mut gchar;
3409 pub fn g_strfreev(str_array: *mut *mut gchar);
3410 pub fn g_string_append(string: *mut GString, val: *const gchar) -> *mut GString;
3411 pub fn g_string_append_c(string: *mut GString, c: gchar) -> *mut GString;
3412 pub fn g_string_append_len(string: *mut GString, val: *const gchar, len: gssize) -> *mut GString;
3413 pub fn g_string_append_printf(string: *mut GString, format: *const gchar, ...);
3414 pub fn g_string_append_unichar(string: *mut GString, wc: gunichar) -> *mut GString;
3415 pub fn g_string_append_uri_escaped(string: *mut GString, unescaped: *const gchar, reserved_chars_allowed: *const gchar, allow_utf8: gboolean) -> *mut GString;
3416 pub fn g_string_ascii_down(string: *mut GString) -> *mut GString;
3417 pub fn g_string_ascii_up(string: *mut GString) -> *mut GString;
3418 pub fn g_string_assign(string: *mut GString, rval: *const gchar) -> *mut GString;
3419 pub fn g_string_chunk_clear(chunk: *mut GStringChunk);
3420 pub fn g_string_chunk_free(chunk: *mut GStringChunk);
3421 pub fn g_string_chunk_insert(chunk: *mut GStringChunk, string: *const gchar) -> *mut gchar;
3422 pub fn g_string_chunk_insert_const(chunk: *mut GStringChunk, string: *const gchar) -> *mut gchar;
3423 pub fn g_string_chunk_insert_len(chunk: *mut GStringChunk, string: *const gchar, len: gssize) -> *mut gchar;
3424 pub fn g_string_chunk_new(size: gsize) -> *mut GStringChunk;
3425 pub fn g_string_down(string: *mut GString) -> *mut GString;
3426 pub fn g_string_equal(v: *const GString, v2: *const GString) -> gboolean;
3427 pub fn g_string_erase(string: *mut GString, pos: gssize, len: gssize) -> *mut GString;
3428 pub fn g_string_free(string: *mut GString, free_segment: gboolean) -> *mut gchar;
3429 pub fn g_string_free_to_bytes(string: *mut GString) -> *mut GBytes;
3430 pub fn g_string_hash(str: *const GString) -> guint;
3431 pub fn g_string_insert(string: *mut GString, pos: gssize, val: *const gchar) -> *mut GString;
3432 pub fn g_string_insert_c(string: *mut GString, pos: gssize, c: gchar) -> *mut GString;
3433 pub fn g_string_insert_len(string: *mut GString, pos: gssize, val: *const gchar, len: gssize) -> *mut GString;
3434 pub fn g_string_insert_unichar(string: *mut GString, pos: gssize, wc: gunichar) -> *mut GString;
3435 pub fn g_string_new(init: *const gchar) -> *mut GString;
3436 pub fn g_string_new_len(init: *const gchar, len: gssize) -> *mut GString;
3437 pub fn g_string_overwrite(string: *mut GString, pos: gsize, val: *const gchar) -> *mut GString;
3438 pub fn g_string_overwrite_len(string: *mut GString, pos: gsize, val: *const gchar, len: gssize) -> *mut GString;
3439 pub fn g_string_prepend(string: *mut GString, val: *const gchar) -> *mut GString;
3440 pub fn g_string_prepend_c(string: *mut GString, c: gchar) -> *mut GString;
3441 pub fn g_string_prepend_len(string: *mut GString, val: *const gchar, len: gssize) -> *mut GString;
3442 pub fn g_string_prepend_unichar(string: *mut GString, wc: gunichar) -> *mut GString;
3443 pub fn g_string_printf(string: *mut GString, format: *const gchar, ...);
3444 pub fn g_string_set_size(string: *mut GString, len: gsize) -> *mut GString;
3445 pub fn g_string_sized_new(dfl_size: gsize) -> *mut GString;
3446 pub fn g_string_truncate(string: *mut GString, len: gsize) -> *mut GString;
3447 pub fn g_string_up(string: *mut GString) -> *mut GString;
3448 pub fn g_strip_context(msgid: *const gchar, msgval: *const gchar) -> *const gchar;
3449 pub fn g_strjoin(separator: *const gchar, ...) -> *mut gchar;
3450 pub fn g_strjoinv(separator: *const gchar, str_array: *mut *mut gchar) -> *mut gchar;
3451 pub fn g_strlcat(dest: *mut gchar, src: *const gchar, dest_size: gsize) -> gsize;
3452 pub fn g_strlcpy(dest: *mut gchar, src: *const gchar, dest_size: gsize) -> gsize;
3453 pub fn g_strncasecmp(s1: *const gchar, s2: *const gchar, n: guint) -> gint;
3454 pub fn g_strndup(str: *const gchar, n: gsize) -> *mut gchar;
3455 pub fn g_strnfill(length: gsize, fill_char: gchar) -> *mut gchar;
3456 pub fn g_strreverse(string: *mut gchar) -> *mut gchar;
3457 pub fn g_strrstr(haystack: *const gchar, needle: *const gchar) -> *mut gchar;
3458 pub fn g_strrstr_len(haystack: *const gchar, haystack_len: gssize, needle: *const gchar) -> *mut gchar;
3459 pub fn g_strsignal(signum: gint) -> *const gchar;
3460 pub fn g_strsplit(string: *const gchar, delimiter: *const gchar, max_tokens: gint) -> *mut *mut gchar;
3461 pub fn g_strsplit_set(string: *const gchar, delimiters: *const gchar, max_tokens: gint) -> *mut *mut gchar;
3462 pub fn g_strstr_len(haystack: *const gchar, haystack_len: gssize, needle: *const gchar) -> *mut gchar;
3463 pub fn g_strtod(nptr: *const gchar, endptr: *mut *mut gchar) -> gdouble;
3464 pub fn g_strup(string: *mut gchar) -> *mut gchar;
3465 pub fn g_strv_contains(strv: *const *const gchar, str: *const gchar) -> gboolean;
3466 pub fn g_strv_get_type() -> GType;
3467 pub fn g_strv_length(str_array: *mut *mut gchar) -> guint;
3468 pub fn g_test_add_data_func(testpath: *const gchar, test_data: gconstpointer, test_func: GTestDataFunc);
3469 pub fn g_test_add_data_func_full(testpath: *const gchar, test_data: gpointer, test_func: GTestDataFunc, data_free_func: GDestroyNotify);
3470 pub fn g_test_add_func(testpath: *const gchar, test_func: GTestFunc);
3471 pub fn g_test_add_vtable(testpath: *const gchar, data_size: gsize, test_data: gconstpointer, data_setup: GTestFixtureFunc, data_test: GTestFixtureFunc, data_teardown: GTestFixtureFunc);
3472 pub fn g_test_assert_expected_messages_internal(domain: *const gchar, file: *const gchar, line: gint, func: *const gchar);
3473 pub fn g_test_bug(bug_uri_snippet: *const gchar);
3474 pub fn g_test_bug_base(uri_pattern: *const gchar);
3475 pub fn g_test_build_filename(file_type: GTestFileType, first_path: *const gchar, ...) -> *mut gchar;
3476 pub fn g_test_create_case(test_name: *const gchar, data_size: gsize, test_data: gconstpointer, data_setup: GTestFixtureFunc, data_test: GTestFixtureFunc, data_teardown: GTestFixtureFunc) -> *mut GTestCase;
3477 pub fn g_test_create_suite(suite_name: *const gchar) -> *mut GTestSuite;
3478 pub fn g_test_expect_message(log_domain: *const gchar, log_level: GLogLevelFlags, pattern: *const gchar);
3479 pub fn g_test_fail();
3480 pub fn g_test_failed() -> gboolean;
3481 pub fn g_test_get_dir(file_type: GTestFileType) -> *const gchar;
3482 pub fn g_test_get_filename(file_type: GTestFileType, first_path: *const gchar, ...) -> *const gchar;
3483 pub fn g_test_get_root() -> *mut GTestSuite;
3484 pub fn g_test_incomplete(msg: *const gchar);
3485 pub fn g_test_init(argc: gint, argv: *mut gchar, ...);
3486 pub fn g_test_log_buffer_free(tbuffer: *mut GTestLogBuffer);
3487 pub fn g_test_log_buffer_new() -> *mut GTestLogBuffer;
3488 pub fn g_test_log_buffer_pop(tbuffer: *mut GTestLogBuffer) -> *mut GTestLogMsg;
3489 pub fn g_test_log_buffer_push(tbuffer: *mut GTestLogBuffer, n_bytes: guint, bytes: u8);
3490 pub fn g_test_log_msg_free(tmsg: *mut GTestLogMsg);
3491 pub fn g_test_log_set_fatal_handler(log_func: GTestLogFatalFunc, user_data: gpointer);
3492 pub fn g_test_log_type_name(log_type: GTestLogType) -> *const gchar;
3493 pub fn g_test_maximized_result(maximized_quantity: gdouble, format: *const gchar, ...);
3494 pub fn g_test_message(format: *const gchar, ...);
3495 pub fn g_test_minimized_result(minimized_quantity: gdouble, format: *const gchar, ...);
3496 pub fn g_test_queue_destroy(destroy_func: GDestroyNotify, destroy_data: gpointer);
3497 pub fn g_test_queue_free(gfree_pointer: gpointer);
3498 pub fn g_test_rand_double() -> gdouble;
3499 pub fn g_test_rand_double_range(range_start: gdouble, range_end: gdouble) -> gdouble;
3500 pub fn g_test_rand_int() -> i32;
3501 pub fn g_test_rand_int_range(begin: i32, end: i32) -> i32;
3502 pub fn g_test_run() -> gint;
3503 pub fn g_test_run_suite(suite: *mut GTestSuite) -> gint;
3504 pub fn g_test_set_nonfatal_assertions();
3505 pub fn g_test_skip(msg: *const gchar);
3506 pub fn g_test_subprocess() -> gboolean;
3507 pub fn g_test_suite_add(suite: *mut GTestSuite, test_case: *mut GTestCase);
3508 pub fn g_test_suite_add_suite(suite: *mut GTestSuite, nestedsuite: *mut GTestSuite);
3509 pub fn g_test_timer_elapsed() -> gdouble;
3510 pub fn g_test_timer_last() -> gdouble;
3511 pub fn g_test_timer_start();
3512 pub fn g_test_trap_assertions(domain: *const gchar, file: *const gchar, line: gint, func: *const gchar, assertion_flags: u64, pattern: *const gchar);
3513 pub fn g_test_trap_fork(usec_timeout: u64, test_trap_flags: GTestTrapFlags) -> gboolean;
3514 pub fn g_test_trap_has_passed() -> gboolean;
3515 pub fn g_test_trap_reached_timeout() -> gboolean;
3516 pub fn g_test_trap_subprocess(test_path: *const gchar, usec_timeout: u64, test_flags: GTestSubprocessFlags);
3517 pub fn g_thread_error_quark() -> GQuark;
3518 pub fn g_thread_exit(retval: gpointer);
3519 pub fn g_thread_join(thread: *mut GThread) -> gpointer;
3520 pub fn g_thread_new(name: *const gchar, func: GThreadFunc, data: gpointer) -> *mut GThread;
3521 pub fn g_thread_pool_free(pool: *mut GThreadPool, immediate: gboolean, wait_: gboolean);
3522 pub fn g_thread_pool_get_max_idle_time() -> guint;
3523 pub fn g_thread_pool_get_max_threads(pool: *mut GThreadPool) -> gint;
3524 pub fn g_thread_pool_get_max_unused_threads() -> gint;
3525 pub fn g_thread_pool_get_num_threads(pool: *mut GThreadPool) -> guint;
3526 pub fn g_thread_pool_get_num_unused_threads() -> guint;
3527 pub fn g_thread_pool_move_to_front(pool: *mut GThreadPool, data: gpointer) -> gboolean;
3528 pub fn g_thread_pool_new(func: GFunc, user_data: gpointer, max_threads: gint, exclusive: gboolean, error: *mut *mut GError) -> *mut GThreadPool;
3529 pub fn g_thread_pool_push(pool: *mut GThreadPool, data: gpointer, error: *mut *mut GError) -> gboolean;
3530 pub fn g_thread_pool_set_max_idle_time(interval: guint);
3531 pub fn g_thread_pool_set_max_threads(pool: *mut GThreadPool, max_threads: gint, error: *mut *mut GError) -> gboolean;
3532 pub fn g_thread_pool_set_max_unused_threads(max_threads: gint);
3533 pub fn g_thread_pool_set_sort_function(pool: *mut GThreadPool, func: GCompareDataFunc, user_data: gpointer);
3534 pub fn g_thread_pool_stop_unused_threads();
3535 pub fn g_thread_pool_unprocessed(pool: *mut GThreadPool) -> guint;
3536 pub fn g_thread_ref(thread: *mut GThread) -> *mut GThread;
3537 pub fn g_thread_self() -> *mut GThread;
3538 pub fn g_thread_try_new(name: *const gchar, func: GThreadFunc, data: gpointer, error: *mut *mut GError) -> *mut GThread;
3539 pub fn g_thread_unref(thread: *mut GThread);
3540 pub fn g_thread_yield();
3541 pub fn g_time_val_add(time_: *mut GTimeVal, microseconds: glong);
3542 pub fn g_time_val_from_iso8601(iso_date: *const gchar, time_: *mut GTimeVal) -> gboolean;
3543 pub fn g_time_val_to_iso8601(time_: *mut GTimeVal) -> *mut gchar;
3544 pub fn g_time_zone_adjust_time(tz: *mut GTimeZone, type_: GTimeType, time_: i64) -> gint;
3545 pub fn g_time_zone_find_interval(tz: *mut GTimeZone, type_: GTimeType, time_: i64) -> gint;
3546 pub fn g_time_zone_get_abbreviation(tz: *mut GTimeZone, interval: gint) -> *const gchar;
3547 pub fn g_time_zone_get_offset(tz: *mut GTimeZone, interval: gint) -> i32;
3548 pub fn g_time_zone_is_dst(tz: *mut GTimeZone, interval: gint) -> gboolean;
3549 pub fn g_time_zone_new(identifier: *const gchar) -> *mut GTimeZone;
3550 pub fn g_time_zone_new_local() -> *mut GTimeZone;
3551 pub fn g_time_zone_new_utc() -> *mut GTimeZone;
3552 pub fn g_time_zone_ref(tz: *mut GTimeZone) -> *mut GTimeZone;
3553 pub fn g_time_zone_unref(tz: *mut GTimeZone);
3554 pub fn g_timeout_add(interval: guint, function: GSourceFunc, data: gpointer) -> guint;
3555 pub fn g_timeout_add_full(priority: gint, interval: guint, function: GSourceFunc, data: gpointer, notify: Option<GDestroyNotify>) -> guint;
3556 pub fn g_timeout_add_seconds(interval: guint, function: GSourceFunc, data: gpointer) -> guint;
3557 pub fn g_timeout_add_seconds_full(priority: gint, interval: guint, function: GSourceFunc, data: gpointer, notify: Option<GDestroyNotify>) -> guint;
3558 pub fn g_timeout_source_new(interval: guint) -> *mut GSource;
3559 pub fn g_timeout_source_new_seconds(interval: guint) -> *mut GSource;
3560 pub fn g_timer_continue(timer: *mut GTimer);
3561 pub fn g_timer_destroy(timer: *mut GTimer);
3562 pub fn g_timer_elapsed(timer: *mut GTimer, microseconds: gulong) -> gdouble;
3563 pub fn g_timer_new() -> *mut GTimer;
3564 pub fn g_timer_reset(timer: *mut GTimer);
3565 pub fn g_timer_start(timer: *mut GTimer);
3566 pub fn g_timer_stop(timer: *mut GTimer);
3567 pub fn g_trash_stack_height(stack_p: *mut *mut GTrashStack) -> guint;
3568 pub fn g_trash_stack_peek(stack_p: *mut *mut GTrashStack) -> gpointer;
3569 pub fn g_trash_stack_pop(stack_p: *mut *mut GTrashStack) -> gpointer;
3570 pub fn g_trash_stack_push(stack_p: *mut *mut GTrashStack, data_p: gpointer);
3571 pub fn g_tree_destroy(tree: *mut GTree);
3572 pub fn g_tree_foreach(tree: *mut GTree, func: GTraverseFunc, user_data: gpointer);
3573 pub fn g_tree_height(tree: *mut GTree) -> gint;
3574 pub fn g_tree_insert(tree: *mut GTree, key: gpointer, value: gpointer);
3575 pub fn g_tree_lookup(tree: *mut GTree, key: gconstpointer) -> gpointer;
3576 pub fn g_tree_lookup_extended(tree: *mut GTree, lookup_key: gconstpointer, orig_key: gpointer, value: gpointer) -> gboolean;
3577 pub fn g_tree_new(key_compare_func: GCompareFunc) -> *mut GTree;
3578 pub fn g_tree_new_full(key_compare_func: GCompareDataFunc, key_compare_data: gpointer, key_destroy_func: GDestroyNotify, value_destroy_func: GDestroyNotify) -> *mut GTree;
3579 pub fn g_tree_new_with_data(key_compare_func: GCompareDataFunc, key_compare_data: gpointer) -> *mut GTree;
3580 pub fn g_tree_nnodes(tree: *mut GTree) -> gint;
3581 pub fn g_tree_ref(tree: *mut GTree) -> *mut GTree;
3582 pub fn g_tree_remove(tree: *mut GTree, key: gconstpointer) -> gboolean;
3583 pub fn g_tree_replace(tree: *mut GTree, key: gpointer, value: gpointer);
3584 pub fn g_tree_search(tree: *mut GTree, search_func: GCompareFunc, user_data: gconstpointer) -> gpointer;
3585 pub fn g_tree_steal(tree: *mut GTree, key: gconstpointer) -> gboolean;
3586 pub fn g_tree_traverse(tree: *mut GTree, traverse_func: GTraverseFunc, traverse_type: GTraverseType, user_data: gpointer);
3587 pub fn g_tree_unref(tree: *mut GTree);
3588 pub fn g_try_malloc(n_bytes: gsize) -> gpointer;
3589 pub fn g_try_malloc0(n_bytes: gsize) -> gpointer;
3590 pub fn g_try_malloc0_n(n_blocks: gsize, n_block_bytes: gsize) -> gpointer;
3591 pub fn g_try_malloc_n(n_blocks: gsize, n_block_bytes: gsize) -> gpointer;
3592 pub fn g_try_realloc(mem: gpointer, n_bytes: gsize) -> gpointer;
3593 pub fn g_try_realloc_n(mem: gpointer, n_blocks: gsize, n_block_bytes: gsize) -> gpointer;
3594 pub fn g_ucs4_to_utf16(str: gunichar, len: glong, items_read: glong, items_written: glong, error: *mut *mut GError) -> u16;
3595 pub fn g_ucs4_to_utf8(str: gunichar, len: glong, items_read: glong, items_written: glong, error: *mut *mut GError) -> *mut gchar;
3596 pub fn g_unichar_break_type(c: gunichar) -> GUnicodeBreakType;
3597 pub fn g_unichar_combining_class(uc: gunichar) -> gint;
3598 pub fn g_unichar_compose(a: gunichar, b: gunichar, ch: gunichar) -> gboolean;
3599 pub fn g_unichar_decompose(ch: gunichar, a: gunichar, b: gunichar) -> gboolean;
3600 pub fn g_unichar_digit_value(c: gunichar) -> gint;
3601 pub fn g_unichar_fully_decompose(ch: gunichar, compat: gboolean, result: gunichar, result_len: gsize) -> gsize;
3602 pub fn g_unichar_get_mirror_char(ch: gunichar, mirrored_ch: gunichar) -> gboolean;
3603 pub fn g_unichar_get_script(ch: gunichar) -> GUnicodeScript;
3604 pub fn g_unichar_isalnum(c: gunichar) -> gboolean;
3605 pub fn g_unichar_isalpha(c: gunichar) -> gboolean;
3606 pub fn g_unichar_iscntrl(c: gunichar) -> gboolean;
3607 pub fn g_unichar_isdefined(c: gunichar) -> gboolean;
3608 pub fn g_unichar_isdigit(c: gunichar) -> gboolean;
3609 pub fn g_unichar_isgraph(c: gunichar) -> gboolean;
3610 pub fn g_unichar_islower(c: gunichar) -> gboolean;
3611 pub fn g_unichar_ismark(c: gunichar) -> gboolean;
3612 pub fn g_unichar_isprint(c: gunichar) -> gboolean;
3613 pub fn g_unichar_ispunct(c: gunichar) -> gboolean;
3614 pub fn g_unichar_isspace(c: gunichar) -> gboolean;
3615 pub fn g_unichar_istitle(c: gunichar) -> gboolean;
3616 pub fn g_unichar_isupper(c: gunichar) -> gboolean;
3617 pub fn g_unichar_iswide(c: gunichar) -> gboolean;
3618 pub fn g_unichar_iswide_cjk(c: gunichar) -> gboolean;
3619 pub fn g_unichar_isxdigit(c: gunichar) -> gboolean;
3620 pub fn g_unichar_iszerowidth(c: gunichar) -> gboolean;
3621 pub fn g_unichar_to_utf8(c: gunichar, outbuf: *mut gchar) -> gint;
3622 pub fn g_unichar_tolower(c: gunichar) -> gunichar;
3623 pub fn g_unichar_totitle(c: gunichar) -> gunichar;
3624 pub fn g_unichar_toupper(c: gunichar) -> gunichar;
3625 pub fn g_unichar_type(c: gunichar) -> GUnicodeType;
3626 pub fn g_unichar_validate(ch: gunichar) -> gboolean;
3627 pub fn g_unichar_xdigit_value(c: gunichar) -> gint;
3628 pub fn g_unicode_canonical_decomposition(ch: gunichar, result_len: gsize) -> gunichar;
3629 pub fn g_unicode_canonical_ordering(string: gunichar, len: gsize);
3630 pub fn g_unicode_script_from_iso15924(iso15924: u32) -> GUnicodeScript;
3631 pub fn g_unicode_script_to_iso15924(script: GUnicodeScript) -> u32;
3632 pub fn g_unlink(filename: *const gchar) -> gint;
3633 pub fn g_unsetenv(variable: *const gchar);
3634 pub fn g_uri_escape_string(unescaped: *const gchar, reserved_chars_allowed: *const gchar, allow_utf8: gboolean) -> *mut gchar;
3635 pub fn g_uri_list_extract_uris(uri_list: *const gchar) -> *mut *mut gchar;
3636 pub fn g_uri_parse_scheme(uri: *const gchar) -> *mut gchar;
3637 pub fn g_uri_unescape_segment(escaped_string: *const gchar, escaped_string_end: *const gchar, illegal_characters: *const gchar) -> *mut gchar;
3638 pub fn g_uri_unescape_string(escaped_string: *const gchar, illegal_characters: *const gchar) -> *mut gchar;
3639 pub fn g_usleep(microseconds: gulong);
3640 pub fn g_utf16_to_ucs4(str: u16, len: glong, items_read: glong, items_written: glong, error: *mut *mut GError) -> gunichar;
3641 pub fn g_utf16_to_utf8(str: u16, len: glong, items_read: glong, items_written: glong, error: *mut *mut GError) -> *mut gchar;
3642 pub fn g_utf8_casefold(str: *const gchar, len: gssize) -> *mut gchar;
3643 pub fn g_utf8_collate(str1: *const gchar, str2: *const gchar) -> gint;
3644 pub fn g_utf8_collate_key(str: *const gchar, len: gssize) -> *mut gchar;
3645 pub fn g_utf8_collate_key_for_filename(str: *const gchar, len: gssize) -> *mut gchar;
3646 pub fn g_utf8_find_next_char(p: *const gchar, end: *const gchar) -> *mut gchar;
3647 pub fn g_utf8_find_prev_char(str: *const gchar, p: *const gchar) -> *mut gchar;
3648 pub fn g_utf8_get_char(p: *const gchar) -> gunichar;
3649 pub fn g_utf8_get_char_validated(p: *const gchar, max_len: gssize) -> gunichar;
3650 pub fn g_utf8_normalize(str: *const gchar, len: gssize, mode: GNormalizeMode) -> *mut gchar;
3651 pub fn g_utf8_offset_to_pointer(str: *const gchar, offset: glong) -> *mut gchar;
3652 pub fn g_utf8_pointer_to_offset(str: *const gchar, pos: *const gchar) -> glong;
3653 pub fn g_utf8_prev_char(p: *const gchar) -> *mut gchar;
3654 pub fn g_utf8_strchr(p: *const gchar, len: gssize, c: gunichar) -> *mut gchar;
3655 pub fn g_utf8_strdown(str: *const gchar, len: gssize) -> *mut gchar;
3656 pub fn g_utf8_strlen(p: *const gchar, max: gssize) -> glong;
3657 pub fn g_utf8_strncpy(dest: *mut gchar, src: *const gchar, n: gsize) -> *mut gchar;
3658 pub fn g_utf8_strrchr(p: *const gchar, len: gssize, c: gunichar) -> *mut gchar;
3659 pub fn g_utf8_strreverse(str: *const gchar, len: gssize) -> *mut gchar;
3660 pub fn g_utf8_strup(str: *const gchar, len: gssize) -> *mut gchar;
3661 pub fn g_utf8_substring(str: *const gchar, start_pos: glong, end_pos: glong) -> *mut gchar;
3662 pub fn g_utf8_to_ucs4(str: *const gchar, len: glong, items_read: glong, items_written: glong, error: *mut *mut GError) -> gunichar;
3663 pub fn g_utf8_to_ucs4_fast(str: *const gchar, len: glong, items_written: glong) -> gunichar;
3664 pub fn g_utf8_to_utf16(str: *const gchar, len: glong, items_read: glong, items_written: glong, error: *mut *mut GError) -> u16;
3665 pub fn g_utf8_validate(str: *mut gchar, max_len: gssize, end: *mut *const gchar) -> gboolean;
3666 pub fn g_variant_builder_add(builder: *mut GVariantBuilder, format_string: *const gchar, ...);
3667 pub fn g_variant_builder_add_parsed(builder: *mut GVariantBuilder, format: *const gchar, ...);
3668 pub fn g_variant_builder_add_value(builder: *mut GVariantBuilder, value: *mut GVariant);
3669 pub fn g_variant_builder_clear(builder: *mut GVariantBuilder);
3670 pub fn g_variant_builder_close(builder: *mut GVariantBuilder);
3671 pub fn g_variant_builder_end(builder: *mut GVariantBuilder) -> *mut GVariant;
3672 pub fn g_variant_builder_init(builder: *mut GVariantBuilder, type_: *const GVariantType);
3673 pub fn g_variant_builder_new(type_: *const GVariantType) -> *mut GVariantBuilder;
3674 pub fn g_variant_builder_open(builder: *mut GVariantBuilder, type_: *const GVariantType);
3675 pub fn g_variant_builder_ref(builder: *mut GVariantBuilder) -> *mut GVariantBuilder;
3676 pub fn g_variant_builder_unref(builder: *mut GVariantBuilder);
3677 pub fn g_variant_byteswap(value: *mut GVariant) -> *mut GVariant;
3678 pub fn g_variant_check_format_string(value: *mut GVariant, format_string: *const gchar, copy_only: gboolean) -> gboolean;
3679 pub fn g_variant_classify(value: *mut GVariant) -> GVariantClass;
3680 pub fn g_variant_compare(one: gconstpointer, two: gconstpointer) -> gint;
3681 pub fn g_variant_dict_clear(dict: *mut GVariantDict);
3682 pub fn g_variant_dict_contains(dict: *mut GVariantDict, key: *const gchar) -> gboolean;
3683 pub fn g_variant_dict_end(dict: *mut GVariantDict) -> *mut GVariant;
3684 pub fn g_variant_dict_init(dict: *mut GVariantDict, from_asv: *mut GVariant);
3685 pub fn g_variant_dict_insert(dict: *mut GVariantDict, key: *const gchar, format_string: *const gchar, ...);
3686 pub fn g_variant_dict_insert_value(dict: *mut GVariantDict, key: *const gchar, value: *mut GVariant);
3687 pub fn g_variant_dict_lookup(dict: *mut GVariantDict, key: *const gchar, format_string: *const gchar, ...) -> gboolean;
3688 pub fn g_variant_dict_lookup_value(dict: *mut GVariantDict, key: *const gchar, expected_type: *const GVariantType) -> *mut GVariant;
3689 pub fn g_variant_dict_new(from_asv: *mut GVariant) -> *mut GVariantDict;
3690 pub fn g_variant_dict_ref(dict: *mut GVariantDict) -> *mut GVariantDict;
3691 pub fn g_variant_dict_remove(dict: *mut GVariantDict, key: *const gchar) -> gboolean;
3692 pub fn g_variant_dict_unref(dict: *mut GVariantDict);
3693 pub fn g_variant_dup_bytestring(value: *mut GVariant, length: *mut gsize) -> *mut gchar;
3694 pub fn g_variant_dup_bytestring_array(value: *mut GVariant, length: *mut gsize) -> *mut *mut gchar;
3695 pub fn g_variant_dup_objv(value: *mut GVariant, length: *mut gsize) -> *mut *mut gchar;
3696 pub fn g_variant_dup_string(value: *mut GVariant, length: *mut gsize) -> *mut gchar;
3697 pub fn g_variant_dup_strv(value: *mut GVariant, length: *mut gsize) -> *mut *mut gchar;
3698 pub fn g_variant_equal(one: gconstpointer, two: gconstpointer) -> gboolean;
3699 pub fn g_variant_get(value: *mut GVariant, format_string: *const gchar, ...);
3700 pub fn g_variant_get_boolean(value: *mut GVariant) -> gboolean;
3701 pub fn g_variant_get_byte(value: *mut GVariant) -> u8;
3702 pub fn g_variant_get_bytestring(value: *mut GVariant) -> *mut gchar;
3703 pub fn g_variant_get_bytestring_array(value: *mut GVariant, length: *mut gsize) -> *mut *mut gchar;
3704 pub fn g_variant_get_child(value: *mut GVariant, index_: gsize, format_string: *const gchar, ...);
3705 pub fn g_variant_get_child_value(value: *mut GVariant, index_: gsize) -> *mut GVariant;
3706 pub fn g_variant_get_data(value: *mut GVariant) -> gconstpointer;
3707 pub fn g_variant_get_data_as_bytes(value: *mut GVariant) -> *mut GBytes;
3708 pub fn g_variant_get_double(value: *mut GVariant) -> gdouble;
3709 pub fn g_variant_get_fixed_array(value: *mut GVariant, n_elements: *mut gsize, element_size: gsize) -> gconstpointer;
3710 pub fn g_variant_get_gtype() -> GType;
3711 pub fn g_variant_get_handle(value: *mut GVariant) -> i32;
3712 pub fn g_variant_get_int16(value: *mut GVariant) -> i16;
3713 pub fn g_variant_get_int32(value: *mut GVariant) -> i32;
3714 pub fn g_variant_get_int64(value: *mut GVariant) -> i64;
3715 pub fn g_variant_get_maybe(value: *mut GVariant) -> *mut GVariant;
3716 pub fn g_variant_get_normal_form(value: *mut GVariant) -> *mut GVariant;
3717 pub fn g_variant_get_objv(value: *mut GVariant, length: *mut gsize) -> *mut *mut gchar;
3718 pub fn g_variant_get_size(value: *mut GVariant) -> gsize;
3719 pub fn g_variant_get_string(value: *mut GVariant, length: *mut gsize) -> *const gchar;
3720 pub fn g_variant_get_strv(value: *mut GVariant, length: *mut gsize) -> *mut *mut gchar;
3721 pub fn g_variant_get_type(value: *mut GVariant) -> *const GVariantType;
3722 pub fn g_variant_get_type_string(value: *mut GVariant) -> *const gchar;
3723 pub fn g_variant_get_uint16(value: *mut GVariant) -> u16;
3724 pub fn g_variant_get_uint32(value: *mut GVariant) -> u32;
3725 pub fn g_variant_get_uint64(value: *mut GVariant) -> u64;
3726 pub fn g_variant_get_variant(value: *mut GVariant) -> *mut GVariant;
3727 pub fn g_variant_hash(value: gconstpointer) -> guint;
3728 pub fn g_variant_is_container(value: *mut GVariant) -> gboolean;
3729 pub fn g_variant_is_floating(value: *mut GVariant) -> gboolean;
3730 pub fn g_variant_is_normal_form(value: *mut GVariant) -> gboolean;
3731 pub fn g_variant_is_object_path(string: *const gchar) -> gboolean;
3732 pub fn g_variant_is_of_type(value: *mut GVariant, type_: *const GVariantType) -> gboolean;
3733 pub fn g_variant_is_signature(string: *const gchar) -> gboolean;
3734 pub fn g_variant_iter_copy(iter: *mut GVariantIter) -> *mut GVariantIter;
3735 pub fn g_variant_iter_free(iter: *mut GVariantIter);
3736 pub fn g_variant_iter_init(iter: *mut GVariantIter, value: *mut GVariant) -> gsize;
3737 pub fn g_variant_iter_loop(iter: *mut GVariantIter, format_string: *const gchar, ...) -> gboolean;
3738 pub fn g_variant_iter_n_children(iter: *mut GVariantIter) -> gsize;
3739 pub fn g_variant_iter_new(value: *mut GVariant) -> *mut GVariantIter;
3740 pub fn g_variant_iter_next(iter: *mut GVariantIter, format_string: *const gchar, ...) -> gboolean;
3741 pub fn g_variant_iter_next_value(iter: *mut GVariantIter) -> *mut GVariant;
3742 pub fn g_variant_lookup(dictionary: *mut GVariant, key: *const gchar, format_string: *const gchar, ...) -> gboolean;
3743 pub fn g_variant_lookup_value(dictionary: *mut GVariant, key: *const gchar, expected_type: *const GVariantType) -> *mut GVariant;
3744 pub fn g_variant_n_children(value: *mut GVariant) -> gsize;
3745 pub fn g_variant_new(format_string: *const gchar, ...) -> *mut GVariant;
3746 pub fn g_variant_new_array(child_type: *const GVariantType, children: *mut *mut GVariant, n_children: gsize) -> *mut GVariant;
3747 pub fn g_variant_new_boolean(value: gboolean) -> *mut GVariant;
3748 pub fn g_variant_new_byte(value: u8) -> *mut GVariant;
3749 pub fn g_variant_new_bytestring(string: *mut gchar) -> *mut GVariant;
3750 pub fn g_variant_new_bytestring_array(strv: *mut *mut gchar, length: gssize) -> *mut GVariant;
3751 pub fn g_variant_new_dict_entry(key: *mut GVariant, value: *mut GVariant) -> *mut GVariant;
3752 pub fn g_variant_new_double(value: gdouble) -> *mut GVariant;
3753 pub fn g_variant_new_fixed_array(element_type: *const GVariantType, elements: gconstpointer, n_elements: gsize, element_size: gsize) -> *mut GVariant;
3754 pub fn g_variant_new_from_bytes(type_: *const GVariantType, bytes: *mut GBytes, trusted: gboolean) -> *mut GVariant;
3755 pub fn g_variant_new_from_data(type_: *const GVariantType, data: gconstpointer, size: gsize, trusted: gboolean, notify: GDestroyNotify, user_data: gpointer) -> *mut GVariant;
3756 pub fn g_variant_new_handle(value: i32) -> *mut GVariant;
3757 pub fn g_variant_new_int16(value: i16) -> *mut GVariant;
3758 pub fn g_variant_new_int32(value: i32) -> *mut GVariant;
3759 pub fn g_variant_new_int64(value: i64) -> *mut GVariant;
3760 pub fn g_variant_new_maybe(child_type: *const GVariantType, child: *mut GVariant) -> *mut GVariant;
3761 pub fn g_variant_new_object_path(object_path: *const gchar) -> *mut GVariant;
3762 pub fn g_variant_new_objv(strv: *mut *mut gchar, length: gssize) -> *mut GVariant;
3763 pub fn g_variant_new_parsed(format: *const gchar, ...) -> *mut GVariant;
3764 pub fn g_variant_new_printf(format_string: *const gchar, ...) -> *mut GVariant;
3765 pub fn g_variant_new_signature(signature: *const gchar) -> *mut GVariant;
3766 pub fn g_variant_new_string(string: *const gchar) -> *mut GVariant;
3767 pub fn g_variant_new_strv(strv: *mut *mut gchar, length: gssize) -> *mut GVariant;
3768 pub fn g_variant_new_take_string(string: *mut gchar) -> *mut GVariant;
3769 pub fn g_variant_new_tuple(children: *mut *mut GVariant, n_children: gsize) -> *mut GVariant;
3770 pub fn g_variant_new_uint16(value: u16) -> *mut GVariant;
3771 pub fn g_variant_new_uint32(value: u32) -> *mut GVariant;
3772 pub fn g_variant_new_uint64(value: u64) -> *mut GVariant;
3773 pub fn g_variant_new_variant(value: *mut GVariant) -> *mut GVariant;
3774 pub fn g_variant_parse(type_: *const GVariantType, text: *const gchar, limit: *const gchar, endptr: *mut *const gchar, error: *mut *mut GError) -> *mut GVariant;
3775 pub fn g_variant_parse_error_print_context(error: *mut GError, source_str: *const gchar) -> *mut gchar;
3776 pub fn g_variant_parse_error_quark() -> GQuark;
3777 pub fn g_variant_parser_get_error_quark() -> GQuark;
3778 pub fn g_variant_print(value: *mut GVariant, type_annotate: gboolean) -> *mut gchar;
3779 pub fn g_variant_print_string(value: *mut GVariant, string: *mut GString, type_annotate: gboolean) -> *mut GString;
3780 pub fn g_variant_ref(value: *mut GVariant) -> *mut GVariant;
3781 pub fn g_variant_ref_sink(value: *mut GVariant) -> *mut GVariant;
3782 pub fn g_variant_store(value: *mut GVariant, data: gpointer);
3783 pub fn g_variant_take_ref(value: *mut GVariant) -> *mut GVariant;
3784 pub fn g_variant_type_checked_(arg0: *const gchar) -> *const GVariantType;
3785 pub fn g_variant_type_copy(type_: *const GVariantType) -> *mut GVariantType;
3786 pub fn g_variant_type_dup_string(type_: *const GVariantType) -> *mut gchar;
3787 pub fn g_variant_type_element(type_: *const GVariantType) -> *const GVariantType;
3788 pub fn g_variant_type_equal(type1: gconstpointer, type2: gconstpointer) -> gboolean;
3789 pub fn g_variant_type_first(type_: *const GVariantType) -> *const GVariantType;
3790 pub fn g_variant_type_free(type_: *mut GVariantType);
3791 pub fn g_variant_type_get_string_length(type_: *const GVariantType) -> gsize;
3792 pub fn g_variant_type_hash(type_: gconstpointer) -> guint;
3793 pub fn g_variant_type_is_array(type_: *const GVariantType) -> gboolean;
3794 pub fn g_variant_type_is_basic(type_: *const GVariantType) -> gboolean;
3795 pub fn g_variant_type_is_container(type_: *const GVariantType) -> gboolean;
3796 pub fn g_variant_type_is_definite(type_: *const GVariantType) -> gboolean;
3797 pub fn g_variant_type_is_dict_entry(type_: *const GVariantType) -> gboolean;
3798 pub fn g_variant_type_is_maybe(type_: *const GVariantType) -> gboolean;
3799 pub fn g_variant_type_is_subtype_of(type_: *const GVariantType, supertype: *const GVariantType) -> gboolean;
3800 pub fn g_variant_type_is_tuple(type_: *const GVariantType) -> gboolean;
3801 pub fn g_variant_type_is_variant(type_: *const GVariantType) -> gboolean;
3802 pub fn g_variant_type_key(type_: *const GVariantType) -> *const GVariantType;
3803 pub fn g_variant_type_n_items(type_: *const GVariantType) -> gsize;
3804 pub fn g_variant_type_new(type_string: *const gchar) -> *mut GVariantType;
3805 pub fn g_variant_type_new_array(element: *const GVariantType) -> *mut GVariantType;
3806 pub fn g_variant_type_new_dict_entry(key: *const GVariantType, value: *const GVariantType) -> *mut GVariantType;
3807 pub fn g_variant_type_new_maybe(element: *const GVariantType) -> *mut GVariantType;
3808 pub fn g_variant_type_new_tuple(items: *mut *mut GVariantType, length: gint) -> *mut GVariantType;
3809 pub fn g_variant_type_next(type_: *const GVariantType) -> *const GVariantType;
3810 pub fn g_variant_type_peek_string(type_: *const GVariantType) -> *const gchar;
3811 pub fn g_variant_type_string_is_valid(type_string: *const gchar) -> gboolean;
3812 pub fn g_variant_type_string_scan(string: *const gchar, limit: *const gchar, endptr: *mut *const gchar) -> gboolean;
3813 pub fn g_variant_type_value(type_: *const GVariantType) -> *const GVariantType;
3814 pub fn g_variant_unref(value: *mut GVariant);
3815 pub fn g_warn_message(domain: *const gchar, file: *const gchar, line: gint, func: *const gchar, warnexpr: *const gchar);
3816 pub fn glib_check_version(required_major: guint, required_minor: guint, required_micro: guint) -> *const gchar;
3817}
3818
3819#[cfg(unix)]
3820pub mod unix {
3821 use gtypes::*;
3822 use super::*;
3823
3824 extern {
3825 pub fn g_source_add_unix_fd(source: *mut GSource, fd: gint, events: GIOCondition) -> gpointer;
3826 pub fn g_source_modify_unix_fd(source: *mut GSource, tag: gpointer, new_events: GIOCondition);
3827 pub fn g_source_query_unix_fd(source: *mut GSource, tag: gpointer) -> GIOCondition;
3828 pub fn g_source_remove_unix_fd(source: *mut GSource, tag: gpointer);
3829 pub fn g_unix_error_quark() -> GQuark;
3830 pub fn g_unix_fd_add(fd: gint, condition: GIOCondition, function: GUnixFDSourceFunc, user_data: gpointer) -> guint;
3831 pub fn g_unix_fd_add_full(priority: gint, fd: gint, condition: GIOCondition, function: GUnixFDSourceFunc, user_data: gpointer, notify: GDestroyNotify) -> guint;
3832 pub fn g_unix_fd_source_new(fd: gint, condition: GIOCondition) -> *mut GSource;
3833 pub fn g_unix_open_pipe(fds: gint, flags: gint, error: *mut *mut GError) -> gboolean;
3834 pub fn g_unix_set_fd_nonblocking(fd: gint, nonblock: gboolean, error: *mut *mut GError) -> gboolean;
3835 pub fn g_unix_signal_add(signum: gint, handler: GSourceFunc, user_data: gpointer) -> guint;
3836 pub fn g_unix_signal_add_full(priority: gint, signum: gint, handler: GSourceFunc, user_data: gpointer, notify: GDestroyNotify) -> guint;
3837 pub fn g_unix_signal_source_new(signum: gint) -> *mut GSource;
3838 }
3839}
3840
3841#[cfg(unix)]
3842pub use unix::*;