source: appstream-generator/build/girepo/gi/glib.d

Last change on this file was 4841, checked in by Juanma, 3 years ago

Initial release

File size: 93.1 KB
Line 
1/*
2 * Licensed under the GNU Lesser General Public License Version 3
3 *
4 * This library is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation, either version 3 of the license, or
7 * (at your option) any later version.
8 *
9 * This software is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18// generated automatically - do not change
19
20
21module gi.glib;
22
23import std.stdio;
24import gi.glibtypes;
25import gi.gobjecttypes;
26
27
28__gshared extern(C)
29{
30
31        // glib.ArrayG
32
33        GArray* g_array_append_vals(GArray* array, void* data, uint len);
34        char* g_array_free(GArray* array, int freeSegment);
35        uint g_array_get_element_size(GArray* array);
36        GArray* g_array_insert_vals(GArray* array, uint index, void* data, uint len);
37        GArray* g_array_new(int zeroTerminated, int clear, uint elementSize);
38        GArray* g_array_prepend_vals(GArray* array, void* data, uint len);
39        GArray* g_array_ref(GArray* array);
40        GArray* g_array_remove_index(GArray* array, uint index);
41        GArray* g_array_remove_index_fast(GArray* array, uint index);
42        GArray* g_array_remove_range(GArray* array, uint index, uint length);
43        void g_array_set_clear_func(GArray* array, GDestroyNotify clearFunc);
44        GArray* g_array_set_size(GArray* array, uint length);
45        GArray* g_array_sized_new(int zeroTerminated, int clear, uint elementSize, uint reservedSize);
46        void g_array_sort(GArray* array, GCompareFunc compareFunc);
47        void g_array_sort_with_data(GArray* array, GCompareDataFunc compareFunc, void* userData);
48        void g_array_unref(GArray* array);
49
50        // glib.AsyncQueue
51
52        int g_async_queue_length(GAsyncQueue* queue);
53        int g_async_queue_length_unlocked(GAsyncQueue* queue);
54        void g_async_queue_lock(GAsyncQueue* queue);
55        void* g_async_queue_pop(GAsyncQueue* queue);
56        void* g_async_queue_pop_unlocked(GAsyncQueue* queue);
57        void g_async_queue_push(GAsyncQueue* queue, void* data);
58        void g_async_queue_push_front(GAsyncQueue* queue, void* item);
59        void g_async_queue_push_front_unlocked(GAsyncQueue* queue, void* item);
60        void g_async_queue_push_sorted(GAsyncQueue* queue, void* data, GCompareDataFunc func, void* userData);
61        void g_async_queue_push_sorted_unlocked(GAsyncQueue* queue, void* data, GCompareDataFunc func, void* userData);
62        void g_async_queue_push_unlocked(GAsyncQueue* queue, void* data);
63        GAsyncQueue* g_async_queue_ref(GAsyncQueue* queue);
64        void g_async_queue_ref_unlocked(GAsyncQueue* queue);
65        int g_async_queue_remove(GAsyncQueue* queue, void* item);
66        int g_async_queue_remove_unlocked(GAsyncQueue* queue, void* item);
67        void g_async_queue_sort(GAsyncQueue* queue, GCompareDataFunc func, void* userData);
68        void g_async_queue_sort_unlocked(GAsyncQueue* queue, GCompareDataFunc func, void* userData);
69        void* g_async_queue_timed_pop(GAsyncQueue* queue, GTimeVal* endTime);
70        void* g_async_queue_timed_pop_unlocked(GAsyncQueue* queue, GTimeVal* endTime);
71        void* g_async_queue_timeout_pop(GAsyncQueue* queue, ulong timeout);
72        void* g_async_queue_timeout_pop_unlocked(GAsyncQueue* queue, ulong timeout);
73        void* g_async_queue_try_pop(GAsyncQueue* queue);
74        void* g_async_queue_try_pop_unlocked(GAsyncQueue* queue);
75        void g_async_queue_unlock(GAsyncQueue* queue);
76        void g_async_queue_unref(GAsyncQueue* queue);
77        void g_async_queue_unref_and_unlock(GAsyncQueue* queue);
78        GAsyncQueue* g_async_queue_new();
79        GAsyncQueue* g_async_queue_new_full(GDestroyNotify itemFreeFunc);
80
81        // glib.BookmarkFile
82
83        void g_bookmark_file_add_application(GBookmarkFile* bookmark, const(char)* uri, const(char)* name, const(char)* exec);
84        void g_bookmark_file_add_group(GBookmarkFile* bookmark, const(char)* uri, const(char)* group);
85        void g_bookmark_file_free(GBookmarkFile* bookmark);
86        uint g_bookmark_file_get_added(GBookmarkFile* bookmark, const(char)* uri, GError** err);
87        int g_bookmark_file_get_app_info(GBookmarkFile* bookmark, const(char)* uri, const(char)* name, char** exec, uint* count, uint* stamp, GError** err);
88        char** g_bookmark_file_get_applications(GBookmarkFile* bookmark, const(char)* uri, size_t* length, GError** err);
89        char* g_bookmark_file_get_description(GBookmarkFile* bookmark, const(char)* uri, GError** err);
90        char** g_bookmark_file_get_groups(GBookmarkFile* bookmark, const(char)* uri, size_t* length, GError** err);
91        int g_bookmark_file_get_icon(GBookmarkFile* bookmark, const(char)* uri, char** href, char** mimeType, GError** err);
92        int g_bookmark_file_get_is_private(GBookmarkFile* bookmark, const(char)* uri, GError** err);
93        char* g_bookmark_file_get_mime_type(GBookmarkFile* bookmark, const(char)* uri, GError** err);
94        uint g_bookmark_file_get_modified(GBookmarkFile* bookmark, const(char)* uri, GError** err);
95        int g_bookmark_file_get_size(GBookmarkFile* bookmark);
96        char* g_bookmark_file_get_title(GBookmarkFile* bookmark, const(char)* uri, GError** err);
97        char** g_bookmark_file_get_uris(GBookmarkFile* bookmark, size_t* length);
98        uint g_bookmark_file_get_visited(GBookmarkFile* bookmark, const(char)* uri, GError** err);
99        int g_bookmark_file_has_application(GBookmarkFile* bookmark, const(char)* uri, const(char)* name, GError** err);
100        int g_bookmark_file_has_group(GBookmarkFile* bookmark, const(char)* uri, const(char)* group, GError** err);
101        int g_bookmark_file_has_item(GBookmarkFile* bookmark, const(char)* uri);
102        int g_bookmark_file_load_from_data(GBookmarkFile* bookmark, const(char)* data, size_t length, GError** err);
103        int g_bookmark_file_load_from_data_dirs(GBookmarkFile* bookmark, const(char)* file, char** fullPath, GError** err);
104        int g_bookmark_file_load_from_file(GBookmarkFile* bookmark, const(char)* filename, GError** err);
105        int g_bookmark_file_move_item(GBookmarkFile* bookmark, const(char)* oldUri, const(char)* newUri, GError** err);
106        int g_bookmark_file_remove_application(GBookmarkFile* bookmark, const(char)* uri, const(char)* name, GError** err);
107        int g_bookmark_file_remove_group(GBookmarkFile* bookmark, const(char)* uri, const(char)* group, GError** err);
108        int g_bookmark_file_remove_item(GBookmarkFile* bookmark, const(char)* uri, GError** err);
109        void g_bookmark_file_set_added(GBookmarkFile* bookmark, const(char)* uri, uint added);
110        int g_bookmark_file_set_app_info(GBookmarkFile* bookmark, const(char)* uri, const(char)* name, const(char)* exec, int count, uint stamp, GError** err);
111        void g_bookmark_file_set_description(GBookmarkFile* bookmark, const(char)* uri, const(char)* description);
112        void g_bookmark_file_set_groups(GBookmarkFile* bookmark, const(char)* uri, char** groups, size_t length);
113        void g_bookmark_file_set_icon(GBookmarkFile* bookmark, const(char)* uri, const(char)* href, const(char)* mimeType);
114        void g_bookmark_file_set_is_private(GBookmarkFile* bookmark, const(char)* uri, int isPrivate);
115        void g_bookmark_file_set_mime_type(GBookmarkFile* bookmark, const(char)* uri, const(char)* mimeType);
116        void g_bookmark_file_set_modified(GBookmarkFile* bookmark, const(char)* uri, uint modified);
117        void g_bookmark_file_set_title(GBookmarkFile* bookmark, const(char)* uri, const(char)* title);
118        void g_bookmark_file_set_visited(GBookmarkFile* bookmark, const(char)* uri, uint visited);
119        char* g_bookmark_file_to_data(GBookmarkFile* bookmark, size_t* length, GError** err);
120        int g_bookmark_file_to_file(GBookmarkFile* bookmark, const(char)* filename, GError** err);
121        GQuark g_bookmark_file_error_quark();
122        GBookmarkFile* g_bookmark_file_new();
123
124        // glib.ByteArray
125
126        GByteArray* g_byte_array_append(GByteArray* array, ubyte* data, uint len);
127        ubyte* g_byte_array_free(GByteArray* array, int freeSegment);
128        GBytes* g_byte_array_free_to_bytes(GByteArray* array);
129        GByteArray* g_byte_array_new();
130        GByteArray* g_byte_array_new_take(ubyte* data, size_t len);
131        GByteArray* g_byte_array_prepend(GByteArray* array, ubyte* data, uint len);
132        GByteArray* g_byte_array_ref(GByteArray* array);
133        GByteArray* g_byte_array_remove_index(GByteArray* array, uint index);
134        GByteArray* g_byte_array_remove_index_fast(GByteArray* array, uint index);
135        GByteArray* g_byte_array_remove_range(GByteArray* array, uint index, uint length);
136        GByteArray* g_byte_array_set_size(GByteArray* array, uint length);
137        GByteArray* g_byte_array_sized_new(uint reservedSize);
138        void g_byte_array_sort(GByteArray* array, GCompareFunc compareFunc);
139        void g_byte_array_sort_with_data(GByteArray* array, GCompareDataFunc compareFunc, void* userData);
140        void g_byte_array_unref(GByteArray* array);
141
142        // glib.Bytes
143
144        GBytes* g_bytes_new(void* data, size_t size);
145        GBytes* g_bytes_new_static(void* data, size_t size);
146        GBytes* g_bytes_new_take(void* data, size_t size);
147        GBytes* g_bytes_new_with_free_func(void* data, size_t size, GDestroyNotify freeFunc, void* userData);
148        int g_bytes_compare(void* bytes1, void* bytes2);
149        int g_bytes_equal(void* bytes1, void* bytes2);
150        void* g_bytes_get_data(GBytes* bytes, size_t* size);
151        size_t g_bytes_get_size(GBytes* bytes);
152        uint g_bytes_hash(void* bytes);
153        GBytes* g_bytes_new_from_bytes(GBytes* bytes, size_t offset, size_t length);
154        GBytes* g_bytes_ref(GBytes* bytes);
155        void g_bytes_unref(GBytes* bytes);
156        GByteArray* g_bytes_unref_to_array(GBytes* bytes);
157        void* g_bytes_unref_to_data(GBytes* bytes, size_t* size);
158
159        // glib.Checksum
160
161        GChecksum* g_checksum_new(GChecksumType checksumType);
162        GChecksum* g_checksum_copy(GChecksum* checksum);
163        void g_checksum_free(GChecksum* checksum);
164        void g_checksum_get_digest(GChecksum* checksum, ubyte* buffer, size_t* digestLen);
165        const(char)* g_checksum_get_string(GChecksum* checksum);
166        void g_checksum_reset(GChecksum* checksum);
167        void g_checksum_update(GChecksum* checksum, char* data, ptrdiff_t length);
168        ptrdiff_t g_checksum_type_get_length(GChecksumType checksumType);
169        char* g_compute_checksum_for_bytes(GChecksumType checksumType, GBytes* data);
170        char* g_compute_checksum_for_data(GChecksumType checksumType, char* data, size_t length);
171        char* g_compute_checksum_for_string(GChecksumType checksumType, const(char)* str, ptrdiff_t length);
172
173        // glib.Cond
174
175        void g_cond_broadcast(GCond* cond);
176        void g_cond_clear(GCond* cond);
177        void g_cond_init(GCond* cond);
178        void g_cond_signal(GCond* cond);
179        void g_cond_wait(GCond* cond, GMutex* mutex);
180        int g_cond_wait_until(GCond* cond, GMutex* mutex, long endTime);
181
182        // glib.Date
183
184        GDate* g_date_new();
185        GDate* g_date_new_dmy(GDateDay day, GDateMonth month, GDateYear year);
186        GDate* g_date_new_julian(uint julianDay);
187        void g_date_add_days(GDate* date, uint nDays);
188        void g_date_add_months(GDate* date, uint nMonths);
189        void g_date_add_years(GDate* date, uint nYears);
190        void g_date_clamp(GDate* date, GDate* minDate, GDate* maxDate);
191        void g_date_clear(GDate* date, uint nDates);
192        int g_date_compare(GDate* lhs, GDate* rhs);
193        int g_date_days_between(GDate* date1, GDate* date2);
194        void g_date_free(GDate* date);
195        GDateDay g_date_get_day(GDate* date);
196        uint g_date_get_day_of_year(GDate* date);
197        uint g_date_get_iso8601_week_of_year(GDate* date);
198        uint g_date_get_julian(GDate* date);
199        uint g_date_get_monday_week_of_year(GDate* date);
200        GDateMonth g_date_get_month(GDate* date);
201        uint g_date_get_sunday_week_of_year(GDate* date);
202        GDateWeekday g_date_get_weekday(GDate* date);
203        GDateYear g_date_get_year(GDate* date);
204        int g_date_is_first_of_month(GDate* date);
205        int g_date_is_last_of_month(GDate* date);
206        void g_date_order(GDate* date1, GDate* date2);
207        void g_date_set_day(GDate* date, GDateDay day);
208        void g_date_set_dmy(GDate* date, GDateDay day, GDateMonth month, GDateYear y);
209        void g_date_set_julian(GDate* date, uint julianDate);
210        void g_date_set_month(GDate* date, GDateMonth month);
211        void g_date_set_parse(GDate* date, const(char)* str);
212        void g_date_set_time(GDate* date, GTime time);
213        void g_date_set_time_t(GDate* date, uint timet);
214        void g_date_set_time_val(GDate* date, GTimeVal* timeval);
215        void g_date_set_year(GDate* date, GDateYear year);
216        void g_date_subtract_days(GDate* date, uint nDays);
217        void g_date_subtract_months(GDate* date, uint nMonths);
218        void g_date_subtract_years(GDate* date, uint nYears);
219        void g_date_to_struct_tm(GDate* date, void* tm);
220        int g_date_valid(GDate* date);
221        ubyte g_date_get_days_in_month(GDateMonth month, GDateYear year);
222        ubyte g_date_get_monday_weeks_in_year(GDateYear year);
223        ubyte g_date_get_sunday_weeks_in_year(GDateYear year);
224        int g_date_is_leap_year(GDateYear year);
225        size_t g_date_strftime(char* s, size_t slen, const(char)* format, GDate* date);
226        int g_date_valid_day(GDateDay day);
227        int g_date_valid_dmy(GDateDay day, GDateMonth month, GDateYear year);
228        int g_date_valid_julian(uint julianDate);
229        int g_date_valid_month(GDateMonth month);
230        int g_date_valid_weekday(GDateWeekday weekday);
231        int g_date_valid_year(GDateYear year);
232
233        // glib.DateTime
234
235        GDateTime* g_date_time_new(GTimeZone* tz, int year, int month, int day, int hour, int minute, double seconds);
236        GDateTime* g_date_time_new_from_timeval_local(GTimeVal* tv);
237        GDateTime* g_date_time_new_from_timeval_utc(GTimeVal* tv);
238        GDateTime* g_date_time_new_from_unix_local(long t);
239        GDateTime* g_date_time_new_from_unix_utc(long t);
240        GDateTime* g_date_time_new_local(int year, int month, int day, int hour, int minute, double seconds);
241        GDateTime* g_date_time_new_now(GTimeZone* tz);
242        GDateTime* g_date_time_new_now_local();
243        GDateTime* g_date_time_new_now_utc();
244        GDateTime* g_date_time_new_utc(int year, int month, int day, int hour, int minute, double seconds);
245        GDateTime* g_date_time_add(GDateTime* datetime, GTimeSpan timespan);
246        GDateTime* g_date_time_add_days(GDateTime* datetime, int days);
247        GDateTime* g_date_time_add_full(GDateTime* datetime, int years, int months, int days, int hours, int minutes, double seconds);
248        GDateTime* g_date_time_add_hours(GDateTime* datetime, int hours);
249        GDateTime* g_date_time_add_minutes(GDateTime* datetime, int minutes);
250        GDateTime* g_date_time_add_months(GDateTime* datetime, int months);
251        GDateTime* g_date_time_add_seconds(GDateTime* datetime, double seconds);
252        GDateTime* g_date_time_add_weeks(GDateTime* datetime, int weeks);
253        GDateTime* g_date_time_add_years(GDateTime* datetime, int years);
254        GTimeSpan g_date_time_difference(GDateTime* end, GDateTime* begin);
255        char* g_date_time_format(GDateTime* datetime, const(char)* format);
256        int g_date_time_get_day_of_month(GDateTime* datetime);
257        int g_date_time_get_day_of_week(GDateTime* datetime);
258        int g_date_time_get_day_of_year(GDateTime* datetime);
259        int g_date_time_get_hour(GDateTime* datetime);
260        int g_date_time_get_microsecond(GDateTime* datetime);
261        int g_date_time_get_minute(GDateTime* datetime);
262        int g_date_time_get_month(GDateTime* datetime);
263        int g_date_time_get_second(GDateTime* datetime);
264        double g_date_time_get_seconds(GDateTime* datetime);
265        const(char)* g_date_time_get_timezone_abbreviation(GDateTime* datetime);
266        GTimeSpan g_date_time_get_utc_offset(GDateTime* datetime);
267        int g_date_time_get_week_numbering_year(GDateTime* datetime);
268        int g_date_time_get_week_of_year(GDateTime* datetime);
269        int g_date_time_get_year(GDateTime* datetime);
270        void g_date_time_get_ymd(GDateTime* datetime, int* year, int* month, int* day);
271        int g_date_time_is_daylight_savings(GDateTime* datetime);
272        GDateTime* g_date_time_ref(GDateTime* datetime);
273        GDateTime* g_date_time_to_local(GDateTime* datetime);
274        int g_date_time_to_timeval(GDateTime* datetime, GTimeVal* tv);
275        GDateTime* g_date_time_to_timezone(GDateTime* datetime, GTimeZone* tz);
276        long g_date_time_to_unix(GDateTime* datetime);
277        GDateTime* g_date_time_to_utc(GDateTime* datetime);
278        void g_date_time_unref(GDateTime* datetime);
279        int g_date_time_compare(void* dt1, void* dt2);
280        int g_date_time_equal(void* dt1, void* dt2);
281        uint g_date_time_hash(void* datetime);
282
283        // glib.Directory
284
285        void g_dir_close(GDir* dir);
286        const(char)* g_dir_read_name(GDir* dir);
287        void g_dir_rewind(GDir* dir);
288        char* g_dir_make_tmp(char* tmpl, GError** err);
289        GDir* g_dir_open(const(char)* path, uint flags, GError** err);
290
291        // glib.ErrorG
292
293        GError* g_error_new(GQuark domain, int code, const(char)* format, ... );
294        GError* g_error_new_literal(GQuark domain, int code, const(char)* message);
295        GError* g_error_new_valist(GQuark domain, int code, const(char)* format, void* args);
296        GError* g_error_copy(GError* error);
297        void g_error_free(GError* error);
298        int g_error_matches(GError* error, GQuark domain, int code);
299        void g_propagate_error(GError** dest, GError* src);
300        void g_set_error_literal(GError** err, GQuark domain, int code, const(char)* message);
301        void g_prefix_error(GError** err, const(char)* format, ... );
302        void g_propagate_prefixed_error(GError** dest, GError* src, const(char)* format, ... );
303        void g_set_error(GError** err, GQuark domain, int code, const(char)* format, ... );
304
305        // glib.HashTable
306
307        int g_hash_table_add(GHashTable* hashTable, void* key);
308        int g_hash_table_contains(GHashTable* hashTable, void* key);
309        void g_hash_table_destroy(GHashTable* hashTable);
310        void* g_hash_table_find(GHashTable* hashTable, GHRFunc predicate, void* userData);
311        void g_hash_table_foreach(GHashTable* hashTable, GHFunc func, void* userData);
312        uint g_hash_table_foreach_remove(GHashTable* hashTable, GHRFunc func, void* userData);
313        uint g_hash_table_foreach_steal(GHashTable* hashTable, GHRFunc func, void* userData);
314        GList* g_hash_table_get_keys(GHashTable* hashTable);
315        void** g_hash_table_get_keys_as_array(GHashTable* hashTable, uint* length);
316        GList* g_hash_table_get_values(GHashTable* hashTable);
317        int g_hash_table_insert(GHashTable* hashTable, void* key, void* value);
318        void* g_hash_table_lookup(GHashTable* hashTable, void* key);
319        int g_hash_table_lookup_extended(GHashTable* hashTable, void* lookupKey, void** origKey, void** value);
320        GHashTable* g_hash_table_new(GHashFunc hashFunc, GEqualFunc keyEqualFunc);
321        GHashTable* g_hash_table_new_full(GHashFunc hashFunc, GEqualFunc keyEqualFunc, GDestroyNotify keyDestroyFunc, GDestroyNotify valueDestroyFunc);
322        GHashTable* g_hash_table_ref(GHashTable* hashTable);
323        int g_hash_table_remove(GHashTable* hashTable, void* key);
324        void g_hash_table_remove_all(GHashTable* hashTable);
325        int g_hash_table_replace(GHashTable* hashTable, void* key, void* value);
326        uint g_hash_table_size(GHashTable* hashTable);
327        int g_hash_table_steal(GHashTable* hashTable, void* key);
328        void g_hash_table_steal_all(GHashTable* hashTable);
329        void g_hash_table_unref(GHashTable* hashTable);
330        int g_direct_equal(void* v1, void* v2);
331        uint g_direct_hash(void* v);
332        int g_double_equal(void* v1, void* v2);
333        uint g_double_hash(void* v);
334        int g_int64_equal(void* v1, void* v2);
335        uint g_int64_hash(void* v);
336        int g_int_equal(void* v1, void* v2);
337        uint g_int_hash(void* v);
338        int g_str_equal(void* v1, void* v2);
339        uint g_str_hash(void* v);
340
341        // glib.HashTableIter
342
343        GHashTable* g_hash_table_iter_get_hash_table(GHashTableIter* iter);
344        void g_hash_table_iter_init(GHashTableIter* iter, GHashTable* hashTable);
345        int g_hash_table_iter_next(GHashTableIter* iter, void** key, void** value);
346        void g_hash_table_iter_remove(GHashTableIter* iter);
347        void g_hash_table_iter_replace(GHashTableIter* iter, void* value);
348        void g_hash_table_iter_steal(GHashTableIter* iter);
349
350        // glib.Hmac
351
352        GHmac* g_hmac_copy(GHmac* hmac);
353        void g_hmac_get_digest(GHmac* hmac, ubyte* buffer, size_t* digestLen);
354        const(char)* g_hmac_get_string(GHmac* hmac);
355        GHmac* g_hmac_ref(GHmac* hmac);
356        void g_hmac_unref(GHmac* hmac);
357        void g_hmac_update(GHmac* hmac, char* data, ptrdiff_t length);
358        GHmac* g_hmac_new(GChecksumType digestType, char* key, size_t keyLen);
359        char* g_compute_hmac_for_data(GChecksumType digestType, char* key, size_t keyLen, char* data, size_t length);
360        char* g_compute_hmac_for_string(GChecksumType digestType, char* key, size_t keyLen, const(char)* str, ptrdiff_t length);
361
362        // glib.Hook
363
364        int g_hook_compare_ids(GHook* newHook, GHook* sibling);
365        GHook* g_hook_alloc(GHookList* hookList);
366        int g_hook_destroy(GHookList* hookList, gulong hookId);
367        void g_hook_destroy_link(GHookList* hookList, GHook* hook);
368        GHook* g_hook_find(GHookList* hookList, int needValids, GHookFindFunc func, void* data);
369        GHook* g_hook_find_data(GHookList* hookList, int needValids, void* data);
370        GHook* g_hook_find_func(GHookList* hookList, int needValids, void* func);
371        GHook* g_hook_find_func_data(GHookList* hookList, int needValids, void* func, void* data);
372        GHook* g_hook_first_valid(GHookList* hookList, int mayBeInCall);
373        void g_hook_free(GHookList* hookList, GHook* hook);
374        GHook* g_hook_get(GHookList* hookList, gulong hookId);
375        void g_hook_insert_before(GHookList* hookList, GHook* sibling, GHook* hook);
376        void g_hook_insert_sorted(GHookList* hookList, GHook* hook, GHookCompareFunc func);
377        GHook* g_hook_next_valid(GHookList* hookList, GHook* hook, int mayBeInCall);
378        void g_hook_prepend(GHookList* hookList, GHook* hook);
379        GHook* g_hook_ref(GHookList* hookList, GHook* hook);
380        void g_hook_unref(GHookList* hookList, GHook* hook);
381
382        // glib.HookList
383
384        void g_hook_list_clear(GHookList* hookList);
385        void g_hook_list_init(GHookList* hookList, uint hookSize);
386        void g_hook_list_invoke(GHookList* hookList, int mayRecurse);
387        void g_hook_list_invoke_check(GHookList* hookList, int mayRecurse);
388        void g_hook_list_marshal(GHookList* hookList, int mayRecurse, GHookMarshaller marshaller, void* marshalData);
389        void g_hook_list_marshal_check(GHookList* hookList, int mayRecurse, GHookCheckMarshaller marshaller, void* marshalData);
390
391        // glib.IConv
392
393        size_t g_iconv(GIConv converter, char** inbuf, size_t* inbytesLeft, char** outbuf, size_t* outbytesLeft);
394        int g_iconv_close(GIConv converter);
395        GIConv g_iconv_open(const(char)* toCodeset, const(char)* fromCodeset);
396
397        // glib.IOChannel
398
399        GIOChannel* g_io_channel_new_file(const(char)* filename, const(char)* mode, GError** err);
400        GIOChannel* g_io_channel_unix_new(int fd);
401        void g_io_channel_close(GIOChannel* channel);
402        GIOStatus g_io_channel_flush(GIOChannel* channel, GError** err);
403        GIOCondition g_io_channel_get_buffer_condition(GIOChannel* channel);
404        size_t g_io_channel_get_buffer_size(GIOChannel* channel);
405        int g_io_channel_get_buffered(GIOChannel* channel);
406        int g_io_channel_get_close_on_unref(GIOChannel* channel);
407        const(char)* g_io_channel_get_encoding(GIOChannel* channel);
408        GIOFlags g_io_channel_get_flags(GIOChannel* channel);
409        const(char)* g_io_channel_get_line_term(GIOChannel* channel, int* length);
410        void g_io_channel_init(GIOChannel* channel);
411        GIOError g_io_channel_read(GIOChannel* channel, char* buf, size_t count, size_t* bytesRead);
412        GIOStatus g_io_channel_read_chars(GIOChannel* channel, char* buf, size_t count, size_t* bytesRead, GError** err);
413        GIOStatus g_io_channel_read_line(GIOChannel* channel, char** strReturn, size_t* length, size_t* terminatorPos, GError** err);
414        GIOStatus g_io_channel_read_line_string(GIOChannel* channel, GString* buffer, size_t* terminatorPos, GError** err);
415        GIOStatus g_io_channel_read_to_end(GIOChannel* channel, char** strReturn, size_t* length, GError** err);
416        GIOStatus g_io_channel_read_unichar(GIOChannel* channel, dchar* thechar, GError** err);
417        GIOChannel* g_io_channel_ref(GIOChannel* channel);
418        GIOError g_io_channel_seek(GIOChannel* channel, long offset, GSeekType type);
419        GIOStatus g_io_channel_seek_position(GIOChannel* channel, long offset, GSeekType type, GError** err);
420        void g_io_channel_set_buffer_size(GIOChannel* channel, size_t size);
421        void g_io_channel_set_buffered(GIOChannel* channel, int buffered);
422        void g_io_channel_set_close_on_unref(GIOChannel* channel, int doClose);
423        GIOStatus g_io_channel_set_encoding(GIOChannel* channel, const(char)* encoding, GError** err);
424        GIOStatus g_io_channel_set_flags(GIOChannel* channel, GIOFlags flags, GError** err);
425        void g_io_channel_set_line_term(GIOChannel* channel, const(char)* lineTerm, int length);
426        GIOStatus g_io_channel_shutdown(GIOChannel* channel, int flush, GError** err);
427        int g_io_channel_unix_get_fd(GIOChannel* channel);
428        void g_io_channel_unref(GIOChannel* channel);
429        GIOError g_io_channel_write(GIOChannel* channel, const(char)* buf, size_t count, size_t* bytesWritten);
430        GIOStatus g_io_channel_write_chars(GIOChannel* channel, char* buf, ptrdiff_t count, size_t* bytesWritten, GError** err);
431        GIOStatus g_io_channel_write_unichar(GIOChannel* channel, dchar thechar, GError** err);
432        GIOChannelError g_io_channel_error_from_errno(int en);
433        GQuark g_io_channel_error_quark();
434        uint g_io_add_watch(GIOChannel* channel, GIOCondition condition, GIOFunc func, void* userData);
435        uint g_io_add_watch_full(GIOChannel* channel, int priority, GIOCondition condition, GIOFunc func, void* userData, GDestroyNotify notify);
436        GSource* g_io_create_watch(GIOChannel* channel, GIOCondition condition);
437
438        // glib.KeyFile
439
440        GKeyFile* g_key_file_new();
441        void g_key_file_free(GKeyFile* keyFile);
442        int g_key_file_get_boolean(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
443        int* g_key_file_get_boolean_list(GKeyFile* keyFile, const(char)* groupName, const(char)* key, size_t* length, GError** err);
444        char* g_key_file_get_comment(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
445        double g_key_file_get_double(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
446        double* g_key_file_get_double_list(GKeyFile* keyFile, const(char)* groupName, const(char)* key, size_t* length, GError** err);
447        char** g_key_file_get_groups(GKeyFile* keyFile, size_t* length);
448        long g_key_file_get_int64(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
449        int g_key_file_get_integer(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
450        int* g_key_file_get_integer_list(GKeyFile* keyFile, const(char)* groupName, const(char)* key, size_t* length, GError** err);
451        char** g_key_file_get_keys(GKeyFile* keyFile, const(char)* groupName, size_t* length, GError** err);
452        char* g_key_file_get_locale_string(GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* locale, GError** err);
453        char** g_key_file_get_locale_string_list(GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* locale, size_t* length, GError** err);
454        char* g_key_file_get_start_group(GKeyFile* keyFile);
455        char* g_key_file_get_string(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
456        char** g_key_file_get_string_list(GKeyFile* keyFile, const(char)* groupName, const(char)* key, size_t* length, GError** err);
457        ulong g_key_file_get_uint64(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
458        char* g_key_file_get_value(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
459        int g_key_file_has_group(GKeyFile* keyFile, const(char)* groupName);
460        int g_key_file_has_key(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
461        int g_key_file_load_from_data(GKeyFile* keyFile, const(char)* data, size_t length, GKeyFileFlags flags, GError** err);
462        int g_key_file_load_from_data_dirs(GKeyFile* keyFile, char* file, char** fullPath, GKeyFileFlags flags, GError** err);
463        int g_key_file_load_from_dirs(GKeyFile* keyFile, char* file, char** searchDirs, char** fullPath, GKeyFileFlags flags, GError** err);
464        int g_key_file_load_from_file(GKeyFile* keyFile, char* file, GKeyFileFlags flags, GError** err);
465        GKeyFile* g_key_file_ref(GKeyFile* keyFile);
466        int g_key_file_remove_comment(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
467        int g_key_file_remove_group(GKeyFile* keyFile, const(char)* groupName, GError** err);
468        int g_key_file_remove_key(GKeyFile* keyFile, const(char)* groupName, const(char)* key, GError** err);
469        int g_key_file_save_to_file(GKeyFile* keyFile, const(char)* filename, GError** err);
470        void g_key_file_set_boolean(GKeyFile* keyFile, const(char)* groupName, const(char)* key, int value);
471        void g_key_file_set_boolean_list(GKeyFile* keyFile, const(char)* groupName, const(char)* key, int* list, size_t length);
472        int g_key_file_set_comment(GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* comment, GError** err);
473        void g_key_file_set_double(GKeyFile* keyFile, const(char)* groupName, const(char)* key, double value);
474        void g_key_file_set_double_list(GKeyFile* keyFile, const(char)* groupName, const(char)* key, double* list, size_t length);
475        void g_key_file_set_int64(GKeyFile* keyFile, const(char)* groupName, const(char)* key, long value);
476        void g_key_file_set_integer(GKeyFile* keyFile, const(char)* groupName, const(char)* key, int value);
477        void g_key_file_set_integer_list(GKeyFile* keyFile, const(char)* groupName, const(char)* key, int* list, size_t length);
478        void g_key_file_set_list_separator(GKeyFile* keyFile, char separator);
479        void g_key_file_set_locale_string(GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* locale, const(char)* str);
480        void g_key_file_set_locale_string_list(GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* locale, char* list, size_t length);
481        void g_key_file_set_string(GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* str);
482        void g_key_file_set_string_list(GKeyFile* keyFile, const(char)* groupName, const(char)* key, char** list, size_t length);
483        void g_key_file_set_uint64(GKeyFile* keyFile, const(char)* groupName, const(char)* key, ulong value);
484        void g_key_file_set_value(GKeyFile* keyFile, const(char)* groupName, const(char)* key, const(char)* value);
485        char* g_key_file_to_data(GKeyFile* keyFile, size_t* length, GError** err);
486        void g_key_file_unref(GKeyFile* keyFile);
487        GQuark g_key_file_error_quark();
488
489        // glib.ListG
490
491        GList* g_list_alloc();
492        GList* g_list_append(GList* list, void* data);
493        GList* g_list_concat(GList* list1, GList* list2);
494        GList* g_list_copy(GList* list);
495        GList* g_list_copy_deep(GList* list, GCopyFunc func, void* userData);
496        GList* g_list_delete_link(GList* list, GList* link);
497        GList* g_list_find(GList* list, void* data);
498        GList* g_list_find_custom(GList* list, void* data, GCompareFunc func);
499        GList* g_list_first(GList* list);
500        void g_list_foreach(GList* list, GFunc func, void* userData);
501        void g_list_free(GList* list);
502        void g_list_free_1(GList* list);
503        void g_list_free_full(GList* list, GDestroyNotify freeFunc);
504        int g_list_index(GList* list, void* data);
505        GList* g_list_insert(GList* list, void* data, int position);
506        GList* g_list_insert_before(GList* list, GList* sibling, void* data);
507        GList* g_list_insert_sorted(GList* list, void* data, GCompareFunc func);
508        GList* g_list_insert_sorted_with_data(GList* list, void* data, GCompareDataFunc func, void* userData);
509        GList* g_list_last(GList* list);
510        uint g_list_length(GList* list);
511        GList* g_list_nth(GList* list, uint n);
512        void* g_list_nth_data(GList* list, uint n);
513        GList* g_list_nth_prev(GList* list, uint n);
514        int g_list_position(GList* list, GList* llink);
515        GList* g_list_prepend(GList* list, void* data);
516        GList* g_list_remove(GList* list, void* data);
517        GList* g_list_remove_all(GList* list, void* data);
518        GList* g_list_remove_link(GList* list, GList* llink);
519        GList* g_list_reverse(GList* list);
520        GList* g_list_sort(GList* list, GCompareFunc compareFunc);
521        GList* g_list_sort_with_data(GList* list, GCompareDataFunc compareFunc, void* userData);
522
523        // glib.MainContext
524
525        GMainContext* g_main_context_new();
526        int g_main_context_acquire(GMainContext* context);
527        void g_main_context_add_poll(GMainContext* context, GPollFD* fd, int priority);
528        int g_main_context_check(GMainContext* context, int maxPriority, GPollFD* fds, int nFds);
529        void g_main_context_dispatch(GMainContext* context);
530        GSource* g_main_context_find_source_by_funcs_user_data(GMainContext* context, GSourceFuncs* funcs, void* userData);
531        GSource* g_main_context_find_source_by_id(GMainContext* context, uint sourceId);
532        GSource* g_main_context_find_source_by_user_data(GMainContext* context, void* userData);
533        GPollFunc g_main_context_get_poll_func(GMainContext* context);
534        void g_main_context_invoke(GMainContext* context, GSourceFunc funct, void* data);
535        void g_main_context_invoke_full(GMainContext* context, int priority, GSourceFunc funct, void* data, GDestroyNotify notify);
536        int g_main_context_is_owner(GMainContext* context);
537        int g_main_context_iteration(GMainContext* context, int mayBlock);
538        int g_main_context_pending(GMainContext* context);
539        void g_main_context_pop_thread_default(GMainContext* context);
540        int g_main_context_prepare(GMainContext* context, int* priority);
541        void g_main_context_push_thread_default(GMainContext* context);
542        int g_main_context_query(GMainContext* context, int maxPriority, int* timeout, GPollFD* fds, int nFds);
543        GMainContext* g_main_context_ref(GMainContext* context);
544        void g_main_context_release(GMainContext* context);
545        void g_main_context_remove_poll(GMainContext* context, GPollFD* fd);
546        void g_main_context_set_poll_func(GMainContext* context, GPollFunc func);
547        void g_main_context_unref(GMainContext* context);
548        int g_main_context_wait(GMainContext* context, GCond* cond, GMutex* mutex);
549        void g_main_context_wakeup(GMainContext* context);
550        GMainContext* g_main_context_default();
551        GMainContext* g_main_context_get_thread_default();
552        GMainContext* g_main_context_ref_thread_default();
553
554        // glib.MainLoop
555
556        GMainLoop* g_main_loop_new(GMainContext* context, int isRunning);
557        GMainContext* g_main_loop_get_context(GMainLoop* loop);
558        int g_main_loop_is_running(GMainLoop* loop);
559        void g_main_loop_quit(GMainLoop* loop);
560        GMainLoop* g_main_loop_ref(GMainLoop* loop);
561        void g_main_loop_run(GMainLoop* loop);
562        void g_main_loop_unref(GMainLoop* loop);
563        GSource* g_main_current_source();
564        int g_main_depth();
565        int g_poll(GPollFD* fds, uint nfds, int timeout);
566
567        // glib.MappedFile
568
569        GMappedFile* g_mapped_file_new(const(char)* filename, int writable, GError** err);
570        GMappedFile* g_mapped_file_new_from_fd(int fd, int writable, GError** err);
571        void g_mapped_file_free(GMappedFile* file);
572        GBytes* g_mapped_file_get_bytes(GMappedFile* file);
573        char* g_mapped_file_get_contents(GMappedFile* file);
574        size_t g_mapped_file_get_length(GMappedFile* file);
575        GMappedFile* g_mapped_file_ref(GMappedFile* file);
576        void g_mapped_file_unref(GMappedFile* file);
577
578        // glib.SimpleXML
579
580        GMarkupParseContext* g_markup_parse_context_new(GMarkupParser* parser, GMarkupParseFlags flags, void* userData, GDestroyNotify userDataDnotify);
581        int g_markup_parse_context_end_parse(GMarkupParseContext* context, GError** err);
582        void g_markup_parse_context_free(GMarkupParseContext* context);
583        const(char)* g_markup_parse_context_get_element(GMarkupParseContext* context);
584        GSList* g_markup_parse_context_get_element_stack(GMarkupParseContext* context);
585        void g_markup_parse_context_get_position(GMarkupParseContext* context, int* lineNumber, int* charNumber);
586        void* g_markup_parse_context_get_user_data(GMarkupParseContext* context);
587        int g_markup_parse_context_parse(GMarkupParseContext* context, const(char)* text, ptrdiff_t textLen, GError** err);
588        void* g_markup_parse_context_pop(GMarkupParseContext* context);
589        void g_markup_parse_context_push(GMarkupParseContext* context, GMarkupParser* parser, void* userData);
590        GMarkupParseContext* g_markup_parse_context_ref(GMarkupParseContext* context);
591        void g_markup_parse_context_unref(GMarkupParseContext* context);
592        int g_markup_collect_attributes(const(char)* elementName, char** attributeNames, char** attributeValues, GError** error, GMarkupCollectType firstType, const(char)* firstAttr, ... );
593        GQuark g_markup_error_quark();
594        char* g_markup_escape_text(const(char)* text, ptrdiff_t length);
595        char* g_markup_printf_escaped(const(char)* format, ... );
596        char* g_markup_vprintf_escaped(const(char)* format, void* args);
597
598        // glib.MatchInfo
599
600        char* g_match_info_expand_references(GMatchInfo* matchInfo, const(char)* stringToExpand, GError** err);
601        char* g_match_info_fetch(GMatchInfo* matchInfo, int matchNum);
602        char** g_match_info_fetch_all(GMatchInfo* matchInfo);
603        char* g_match_info_fetch_named(GMatchInfo* matchInfo, const(char)* name);
604        int g_match_info_fetch_named_pos(GMatchInfo* matchInfo, const(char)* name, int* startPos, int* endPos);
605        int g_match_info_fetch_pos(GMatchInfo* matchInfo, int matchNum, int* startPos, int* endPos);
606        void g_match_info_free(GMatchInfo* matchInfo);
607        int g_match_info_get_match_count(GMatchInfo* matchInfo);
608        GRegex* g_match_info_get_regex(GMatchInfo* matchInfo);
609        const(char)* g_match_info_get_string(GMatchInfo* matchInfo);
610        int g_match_info_is_partial_match(GMatchInfo* matchInfo);
611        int g_match_info_matches(GMatchInfo* matchInfo);
612        int g_match_info_next(GMatchInfo* matchInfo, GError** err);
613        GMatchInfo* g_match_info_ref(GMatchInfo* matchInfo);
614        void g_match_info_unref(GMatchInfo* matchInfo);
615
616        // glib.Mutex
617
618        void g_mutex_clear(GMutex* mutex);
619        void g_mutex_init(GMutex* mutex);
620        void g_mutex_lock(GMutex* mutex);
621        int g_mutex_trylock(GMutex* mutex);
622        void g_mutex_unlock(GMutex* mutex);
623
624        // glib.Node
625
626        int g_node_child_index(GNode* node, void* data);
627        int g_node_child_position(GNode* node, GNode* child);
628        void g_node_children_foreach(GNode* node, GTraverseFlags flags, GNodeForeachFunc func, void* data);
629        GNode* g_node_copy(GNode* node);
630        GNode* g_node_copy_deep(GNode* node, GCopyFunc copyFunc, void* data);
631        uint g_node_depth(GNode* node);
632        void g_node_destroy(GNode* root);
633        GNode* g_node_find(GNode* root, GTraverseType order, GTraverseFlags flags, void* data);
634        GNode* g_node_find_child(GNode* node, GTraverseFlags flags, void* data);
635        GNode* g_node_first_sibling(GNode* node);
636        GNode* g_node_get_root(GNode* node);
637        GNode* g_node_insert(GNode* parent, int position, GNode* node);
638        GNode* g_node_insert_after(GNode* parent, GNode* sibling, GNode* node);
639        GNode* g_node_insert_before(GNode* parent, GNode* sibling, GNode* node);
640        int g_node_is_ancestor(GNode* node, GNode* descendant);
641        GNode* g_node_last_child(GNode* node);
642        GNode* g_node_last_sibling(GNode* node);
643        uint g_node_max_height(GNode* root);
644        uint g_node_n_children(GNode* node);
645        uint g_node_n_nodes(GNode* root, GTraverseFlags flags);
646        GNode* g_node_nth_child(GNode* node, uint n);
647        GNode* g_node_prepend(GNode* parent, GNode* node);
648        void g_node_reverse_children(GNode* node);
649        void g_node_traverse(GNode* root, GTraverseType order, GTraverseFlags flags, int maxDepth, GNodeTraverseFunc func, void* data);
650        void g_node_unlink(GNode* node);
651        GNode* g_node_new(void* data);
652
653        // glib.Once
654
655        void* g_once_impl(GOnce* once, GThreadFunc func, void* arg);
656        int g_once_init_enter(void* location);
657        void g_once_init_leave(void* location, size_t result);
658
659        // glib.OptionContext
660
661        void g_option_context_add_group(GOptionContext* context, GOptionGroup* group);
662        void g_option_context_add_main_entries(GOptionContext* context, GOptionEntry* entries, const(char)* translationDomain);
663        void g_option_context_free(GOptionContext* context);
664        const(char)* g_option_context_get_description(GOptionContext* context);
665        char* g_option_context_get_help(GOptionContext* context, int mainHelp, GOptionGroup* group);
666        int g_option_context_get_help_enabled(GOptionContext* context);
667        int g_option_context_get_ignore_unknown_options(GOptionContext* context);
668        GOptionGroup* g_option_context_get_main_group(GOptionContext* context);
669        int g_option_context_get_strict_posix(GOptionContext* context);
670        const(char)* g_option_context_get_summary(GOptionContext* context);
671        int g_option_context_parse(GOptionContext* context, int* argc, char*** argv, GError** err);
672        int g_option_context_parse_strv(GOptionContext* context, char*** arguments, GError** err);
673        void g_option_context_set_description(GOptionContext* context, const(char)* description);
674        void g_option_context_set_help_enabled(GOptionContext* context, int helpEnabled);
675        void g_option_context_set_ignore_unknown_options(GOptionContext* context, int ignoreUnknown);
676        void g_option_context_set_main_group(GOptionContext* context, GOptionGroup* group);
677        void g_option_context_set_strict_posix(GOptionContext* context, int strictPosix);
678        void g_option_context_set_summary(GOptionContext* context, const(char)* summary);
679        void g_option_context_set_translate_func(GOptionContext* context, GTranslateFunc func, void* data, GDestroyNotify destroyNotify);
680        void g_option_context_set_translation_domain(GOptionContext* context, const(char)* domain);
681        GOptionContext* g_option_context_new(const(char)* parameterString);
682        GQuark g_option_error_quark();
683
684        // glib.OptionGroup
685
686        GOptionGroup* g_option_group_new(const(char)* name, const(char)* description, const(char)* helpDescription, void* userData, GDestroyNotify destroy);
687        void g_option_group_add_entries(GOptionGroup* group, GOptionEntry* entries);
688        void g_option_group_free(GOptionGroup* group);
689        GOptionGroup* g_option_group_ref(GOptionGroup* group);
690        void g_option_group_set_error_hook(GOptionGroup* group, GOptionErrorFunc errorFunc);
691        void g_option_group_set_parse_hooks(GOptionGroup* group, GOptionParseFunc preParseFunc, GOptionParseFunc postParseFunc);
692        void g_option_group_set_translate_func(GOptionGroup* group, GTranslateFunc func, void* data, GDestroyNotify destroyNotify);
693        void g_option_group_set_translation_domain(GOptionGroup* group, const(char)* domain);
694        void g_option_group_unref(GOptionGroup* group);
695
696        // glib.Pattern
697
698        int g_pattern_spec_equal(GPatternSpec* pspec1, GPatternSpec* pspec2);
699        void g_pattern_spec_free(GPatternSpec* pspec);
700        GPatternSpec* g_pattern_spec_new(const(char)* pattern);
701        int g_pattern_match(GPatternSpec* pspec, uint stringLength, const(char)* str, const(char)* stringReversed);
702        int g_pattern_match_simple(const(char)* pattern, const(char)* str);
703        int g_pattern_match_string(GPatternSpec* pspec, const(char)* str);
704
705        // glib.Private
706
707        void* g_private_get(GPrivate* key);
708        void g_private_replace(GPrivate* key, void* value);
709        void g_private_set(GPrivate* key, void* value);
710
711        // glib.PtrArray
712
713        void g_ptr_array_add(GPtrArray* array, void* data);
714        void g_ptr_array_foreach(GPtrArray* array, GFunc func, void* userData);
715        void** g_ptr_array_free(GPtrArray* array, int freeSeg);
716        void g_ptr_array_insert(GPtrArray* array, int index, void* data);
717        GPtrArray* g_ptr_array_new();
718        GPtrArray* g_ptr_array_new_full(uint reservedSize, GDestroyNotify elementFreeFunc);
719        GPtrArray* g_ptr_array_new_with_free_func(GDestroyNotify elementFreeFunc);
720        GPtrArray* g_ptr_array_ref(GPtrArray* array);
721        int g_ptr_array_remove(GPtrArray* array, void* data);
722        int g_ptr_array_remove_fast(GPtrArray* array, void* data);
723        void* g_ptr_array_remove_index(GPtrArray* array, uint index);
724        void* g_ptr_array_remove_index_fast(GPtrArray* array, uint index);
725        GPtrArray* g_ptr_array_remove_range(GPtrArray* array, uint index, uint length);
726        void g_ptr_array_set_free_func(GPtrArray* array, GDestroyNotify elementFreeFunc);
727        void g_ptr_array_set_size(GPtrArray* array, int length);
728        GPtrArray* g_ptr_array_sized_new(uint reservedSize);
729        void g_ptr_array_sort(GPtrArray* array, GCompareFunc compareFunc);
730        void g_ptr_array_sort_with_data(GPtrArray* array, GCompareDataFunc compareFunc, void* userData);
731        void g_ptr_array_unref(GPtrArray* array);
732
733        // glib.QueueG
734
735        void g_queue_clear(GQueue* queue);
736        GQueue* g_queue_copy(GQueue* queue);
737        void g_queue_delete_link(GQueue* queue, GList* link);
738        GList* g_queue_find(GQueue* queue, void* data);
739        GList* g_queue_find_custom(GQueue* queue, void* data, GCompareFunc func);
740        void g_queue_foreach(GQueue* queue, GFunc func, void* userData);
741        void g_queue_free(GQueue* queue);
742        void g_queue_free_full(GQueue* queue, GDestroyNotify freeFunc);
743        uint g_queue_get_length(GQueue* queue);
744        int g_queue_index(GQueue* queue, void* data);
745        void g_queue_init(GQueue* queue);
746        void g_queue_insert_after(GQueue* queue, GList* sibling, void* data);
747        void g_queue_insert_before(GQueue* queue, GList* sibling, void* data);
748        void g_queue_insert_sorted(GQueue* queue, void* data, GCompareDataFunc func, void* userData);
749        int g_queue_is_empty(GQueue* queue);
750        int g_queue_link_index(GQueue* queue, GList* link);
751        void* g_queue_peek_head(GQueue* queue);
752        GList* g_queue_peek_head_link(GQueue* queue);
753        void* g_queue_peek_nth(GQueue* queue, uint n);
754        GList* g_queue_peek_nth_link(GQueue* queue, uint n);
755        void* g_queue_peek_tail(GQueue* queue);
756        GList* g_queue_peek_tail_link(GQueue* queue);
757        void* g_queue_pop_head(GQueue* queue);
758        GList* g_queue_pop_head_link(GQueue* queue);
759        void* g_queue_pop_nth(GQueue* queue, uint n);
760        GList* g_queue_pop_nth_link(GQueue* queue, uint n);
761        void* g_queue_pop_tail(GQueue* queue);
762        GList* g_queue_pop_tail_link(GQueue* queue);
763        void g_queue_push_head(GQueue* queue, void* data);
764        void g_queue_push_head_link(GQueue* queue, GList* link);
765        void g_queue_push_nth(GQueue* queue, void* data, int n);
766        void g_queue_push_nth_link(GQueue* queue, int n, GList* link);
767        void g_queue_push_tail(GQueue* queue, void* data);
768        void g_queue_push_tail_link(GQueue* queue, GList* link);
769        int g_queue_remove(GQueue* queue, void* data);
770        uint g_queue_remove_all(GQueue* queue, void* data);
771        void g_queue_reverse(GQueue* queue);
772        void g_queue_sort(GQueue* queue, GCompareDataFunc compareFunc, void* userData);
773        void g_queue_unlink(GQueue* queue, GList* link);
774        GQueue* g_queue_new();
775
776        // glib.RWLock
777
778        void g_rw_lock_clear(GRWLock* rwLock);
779        void g_rw_lock_init(GRWLock* rwLock);
780        void g_rw_lock_reader_lock(GRWLock* rwLock);
781        int g_rw_lock_reader_trylock(GRWLock* rwLock);
782        void g_rw_lock_reader_unlock(GRWLock* rwLock);
783        void g_rw_lock_writer_lock(GRWLock* rwLock);
784        int g_rw_lock_writer_trylock(GRWLock* rwLock);
785        void g_rw_lock_writer_unlock(GRWLock* rwLock);
786
787        // glib.RandG
788
789        GRand* g_rand_copy(GRand* rand);
790        double g_rand_double(GRand* rand);
791        double g_rand_double_range(GRand* rand, double begin, double end);
792        void g_rand_free(GRand* rand);
793        uint g_rand_int(GRand* rand);
794        int g_rand_int_range(GRand* rand, int begin, int end);
795        void g_rand_set_seed(GRand* rand, uint seed);
796        void g_rand_set_seed_array(GRand* rand, uint* seed, uint seedLength);
797        GRand* g_rand_new();
798        GRand* g_rand_new_with_seed(uint seed);
799        GRand* g_rand_new_with_seed_array(uint* seed, uint seedLength);
800        double g_random_double();
801        double g_random_double_range(double begin, double end);
802        uint g_random_int();
803        int g_random_int_range(int begin, int end);
804        void g_random_set_seed(uint seed);
805
806        // glib.RecMutex
807
808        void g_rec_mutex_clear(GRecMutex* recMutex);
809        void g_rec_mutex_init(GRecMutex* recMutex);
810        void g_rec_mutex_lock(GRecMutex* recMutex);
811        int g_rec_mutex_trylock(GRecMutex* recMutex);
812        void g_rec_mutex_unlock(GRecMutex* recMutex);
813
814        // glib.Regex
815
816        GRegex* g_regex_new(const(char)* pattern, GRegexCompileFlags compileOptions, GRegexMatchFlags matchOptions, GError** err);
817        int g_regex_get_capture_count(GRegex* regex);
818        GRegexCompileFlags g_regex_get_compile_flags(GRegex* regex);
819        int g_regex_get_has_cr_or_lf(GRegex* regex);
820        GRegexMatchFlags g_regex_get_match_flags(GRegex* regex);
821        int g_regex_get_max_backref(GRegex* regex);
822        int g_regex_get_max_lookbehind(GRegex* regex);
823        const(char)* g_regex_get_pattern(GRegex* regex);
824        int g_regex_get_string_number(GRegex* regex, const(char)* name);
825        int g_regex_match(GRegex* regex, const(char)* str, GRegexMatchFlags matchOptions, GMatchInfo** matchInfo);
826        int g_regex_match_all(GRegex* regex, const(char)* str, GRegexMatchFlags matchOptions, GMatchInfo** matchInfo);
827        int g_regex_match_all_full(GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, GRegexMatchFlags matchOptions, GMatchInfo** matchInfo, GError** err);
828        int g_regex_match_full(GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, GRegexMatchFlags matchOptions, GMatchInfo** matchInfo, GError** err);
829        GRegex* g_regex_ref(GRegex* regex);
830        char* g_regex_replace(GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, const(char)* replacement, GRegexMatchFlags matchOptions, GError** err);
831        char* g_regex_replace_eval(GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, GRegexMatchFlags matchOptions, GRegexEvalCallback eval, void* userData, GError** err);
832        char* g_regex_replace_literal(GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, const(char)* replacement, GRegexMatchFlags matchOptions, GError** err);
833        char** g_regex_split(GRegex* regex, const(char)* str, GRegexMatchFlags matchOptions);
834        char** g_regex_split_full(GRegex* regex, char* str, ptrdiff_t stringLen, int startPosition, GRegexMatchFlags matchOptions, int maxTokens, GError** err);
835        void g_regex_unref(GRegex* regex);
836        int g_regex_check_replacement(const(char)* replacement, int* hasReferences, GError** err);
837        GQuark g_regex_error_quark();
838        char* g_regex_escape_nul(const(char)* str, int length);
839        char* g_regex_escape_string(char* str, int length);
840        int g_regex_match_simple(const(char)* pattern, const(char)* str, GRegexCompileFlags compileOptions, GRegexMatchFlags matchOptions);
841        char** g_regex_split_simple(const(char)* pattern, const(char)* str, GRegexCompileFlags compileOptions, GRegexMatchFlags matchOptions);
842
843        // glib.ListSG
844
845        GSList* g_slist_alloc();
846        GSList* g_slist_append(GSList* list, void* data);
847        GSList* g_slist_concat(GSList* list1, GSList* list2);
848        GSList* g_slist_copy(GSList* list);
849        GSList* g_slist_copy_deep(GSList* list, GCopyFunc func, void* userData);
850        GSList* g_slist_delete_link(GSList* list, GSList* link);
851        GSList* g_slist_find(GSList* list, void* data);
852        GSList* g_slist_find_custom(GSList* list, void* data, GCompareFunc func);
853        void g_slist_foreach(GSList* list, GFunc func, void* userData);
854        void g_slist_free(GSList* list);
855        void g_slist_free_1(GSList* list);
856        void g_slist_free_full(GSList* list, GDestroyNotify freeFunc);
857        int g_slist_index(GSList* list, void* data);
858        GSList* g_slist_insert(GSList* list, void* data, int position);
859        GSList* g_slist_insert_before(GSList* slist, GSList* sibling, void* data);
860        GSList* g_slist_insert_sorted(GSList* list, void* data, GCompareFunc func);
861        GSList* g_slist_insert_sorted_with_data(GSList* list, void* data, GCompareDataFunc func, void* userData);
862        GSList* g_slist_last(GSList* list);
863        uint g_slist_length(GSList* list);
864        GSList* g_slist_nth(GSList* list, uint n);
865        void* g_slist_nth_data(GSList* list, uint n);
866        int g_slist_position(GSList* list, GSList* llink);
867        GSList* g_slist_prepend(GSList* list, void* data);
868        GSList* g_slist_remove(GSList* list, void* data);
869        GSList* g_slist_remove_all(GSList* list, void* data);
870        GSList* g_slist_remove_link(GSList* list, GSList* link);
871        GSList* g_slist_reverse(GSList* list);
872        GSList* g_slist_sort(GSList* list, GCompareFunc compareFunc);
873        GSList* g_slist_sort_with_data(GSList* list, GCompareDataFunc compareFunc, void* userData);
874
875        // glib.ScannerG
876
877        uint g_scanner_cur_line(GScanner* scanner);
878        uint g_scanner_cur_position(GScanner* scanner);
879        GTokenType g_scanner_cur_token(GScanner* scanner);
880        GTokenValue g_scanner_cur_value(GScanner* scanner);
881        void g_scanner_destroy(GScanner* scanner);
882        int g_scanner_eof(GScanner* scanner);
883        void g_scanner_error(GScanner* scanner, const(char)* format, ... );
884        GTokenType g_scanner_get_next_token(GScanner* scanner);
885        void g_scanner_input_file(GScanner* scanner, int inputFd);
886        void g_scanner_input_text(GScanner* scanner, const(char)* text, uint textLen);
887        void* g_scanner_lookup_symbol(GScanner* scanner, const(char)* symbol);
888        GTokenType g_scanner_peek_next_token(GScanner* scanner);
889        void g_scanner_scope_add_symbol(GScanner* scanner, uint scopeId, const(char)* symbol, void* value);
890        void g_scanner_scope_foreach_symbol(GScanner* scanner, uint scopeId, GHFunc func, void* userData);
891        void* g_scanner_scope_lookup_symbol(GScanner* scanner, uint scopeId, const(char)* symbol);
892        void g_scanner_scope_remove_symbol(GScanner* scanner, uint scopeId, const(char)* symbol);
893        uint g_scanner_set_scope(GScanner* scanner, uint scopeId);
894        void g_scanner_sync_file_offset(GScanner* scanner);
895        void g_scanner_unexp_token(GScanner* scanner, GTokenType expectedToken, const(char)* identifierSpec, const(char)* symbolSpec, const(char)* symbolName, const(char)* message, int isError);
896        void g_scanner_warn(GScanner* scanner, const(char)* format, ... );
897        GScanner* g_scanner_new(GScannerConfig* configTempl);
898
899        // glib.Sequence
900
901        GSequenceIter* g_sequence_append(GSequence* seq, void* data);
902        void g_sequence_foreach(GSequence* seq, GFunc func, void* userData);
903        void g_sequence_free(GSequence* seq);
904        GSequenceIter* g_sequence_get_begin_iter(GSequence* seq);
905        GSequenceIter* g_sequence_get_end_iter(GSequence* seq);
906        GSequenceIter* g_sequence_get_iter_at_pos(GSequence* seq, int pos);
907        int g_sequence_get_length(GSequence* seq);
908        GSequenceIter* g_sequence_insert_sorted(GSequence* seq, void* data, GCompareDataFunc cmpFunc, void* cmpData);
909        GSequenceIter* g_sequence_insert_sorted_iter(GSequence* seq, void* data, GSequenceIterCompareFunc iterCmp, void* cmpData);
910        int g_sequence_is_empty(GSequence* seq);
911        GSequenceIter* g_sequence_lookup(GSequence* seq, void* data, GCompareDataFunc cmpFunc, void* cmpData);
912        GSequenceIter* g_sequence_lookup_iter(GSequence* seq, void* data, GSequenceIterCompareFunc iterCmp, void* cmpData);
913        GSequenceIter* g_sequence_prepend(GSequence* seq, void* data);
914        GSequenceIter* g_sequence_search(GSequence* seq, void* data, GCompareDataFunc cmpFunc, void* cmpData);
915        GSequenceIter* g_sequence_search_iter(GSequence* seq, void* data, GSequenceIterCompareFunc iterCmp, void* cmpData);
916        void g_sequence_sort(GSequence* seq, GCompareDataFunc cmpFunc, void* cmpData);
917        void g_sequence_sort_iter(GSequence* seq, GSequenceIterCompareFunc cmpFunc, void* cmpData);
918        void g_sequence_foreach_range(GSequenceIter* begin, GSequenceIter* end, GFunc func, void* userData);
919        void* g_sequence_get(GSequenceIter* iter);
920        GSequenceIter* g_sequence_insert_before(GSequenceIter* iter, void* data);
921        void g_sequence_move(GSequenceIter* src, GSequenceIter* dest);
922        void g_sequence_move_range(GSequenceIter* dest, GSequenceIter* begin, GSequenceIter* end);
923        GSequence* g_sequence_new(GDestroyNotify dataDestroy);
924        GSequenceIter* g_sequence_range_get_midpoint(GSequenceIter* begin, GSequenceIter* end);
925        void g_sequence_remove(GSequenceIter* iter);
926        void g_sequence_remove_range(GSequenceIter* begin, GSequenceIter* end);
927        void g_sequence_set(GSequenceIter* iter, void* data);
928        void g_sequence_sort_changed(GSequenceIter* iter, GCompareDataFunc cmpFunc, void* cmpData);
929        void g_sequence_sort_changed_iter(GSequenceIter* iter, GSequenceIterCompareFunc iterCmp, void* cmpData);
930        void g_sequence_swap(GSequenceIter* a, GSequenceIter* b);
931
932        // glib.SequenceIter
933
934        int g_sequence_iter_compare(GSequenceIter* a, GSequenceIter* b);
935        int g_sequence_iter_get_position(GSequenceIter* iter);
936        GSequence* g_sequence_iter_get_sequence(GSequenceIter* iter);
937        int g_sequence_iter_is_begin(GSequenceIter* iter);
938        int g_sequence_iter_is_end(GSequenceIter* iter);
939        GSequenceIter* g_sequence_iter_move(GSequenceIter* iter, int delta);
940        GSequenceIter* g_sequence_iter_next(GSequenceIter* iter);
941        GSequenceIter* g_sequence_iter_prev(GSequenceIter* iter);
942
943        // glib.Source
944
945        GSource* g_source_new(GSourceFuncs* sourceFuncs, uint structSize);
946        void g_source_add_child_source(GSource* source, GSource* childSource);
947        void g_source_add_poll(GSource* source, GPollFD* fd);
948        void* g_source_add_unix_fd(GSource* source, int fd, GIOCondition events);
949        uint g_source_attach(GSource* source, GMainContext* context);
950        void g_source_destroy(GSource* source);
951        int g_source_get_can_recurse(GSource* source);
952        GMainContext* g_source_get_context(GSource* source);
953        void g_source_get_current_time(GSource* source, GTimeVal* timeval);
954        uint g_source_get_id(GSource* source);
955        const(char)* g_source_get_name(GSource* source);
956        int g_source_get_priority(GSource* source);
957        long g_source_get_ready_time(GSource* source);
958        long g_source_get_time(GSource* source);
959        int g_source_is_destroyed(GSource* source);
960        void g_source_modify_unix_fd(GSource* source, void* tag, GIOCondition newEvents);
961        GIOCondition g_source_query_unix_fd(GSource* source, void* tag);
962        GSource* g_source_ref(GSource* source);
963        void g_source_remove_child_source(GSource* source, GSource* childSource);
964        void g_source_remove_poll(GSource* source, GPollFD* fd);
965        void g_source_remove_unix_fd(GSource* source, void* tag);
966        void g_source_set_callback(GSource* source, GSourceFunc func, void* data, GDestroyNotify notify);
967        void g_source_set_callback_indirect(GSource* source, void* callbackData, GSourceCallbackFuncs* callbackFuncs);
968        void g_source_set_can_recurse(GSource* source, int canRecurse);
969        void g_source_set_funcs(GSource* source, GSourceFuncs* funcs);
970        void g_source_set_name(GSource* source, const(char)* name);
971        void g_source_set_priority(GSource* source, int priority);
972        void g_source_set_ready_time(GSource* source, long readyTime);
973        void g_source_unref(GSource* source);
974        int g_source_remove(uint tag);
975        int g_source_remove_by_funcs_user_data(GSourceFuncs* funcs, void* userData);
976        int g_source_remove_by_user_data(void* userData);
977        void g_source_set_name_by_id(uint tag, const(char)* name);
978
979        // glib.StringG
980
981        GString* g_string_append(GString* str, const(char)* val);
982        GString* g_string_append_c(GString* str, char c);
983        GString* g_string_append_len(GString* str, const(char)* val, ptrdiff_t len);
984        void g_string_append_printf(GString* str, const(char)* format, ... );
985        GString* g_string_append_unichar(GString* str, dchar wc);
986        GString* g_string_append_uri_escaped(GString* str, const(char)* unescaped, const(char)* reservedCharsAllowed, int allowUtf8);
987        void g_string_append_vprintf(GString* str, const(char)* format, void* args);
988        GString* g_string_ascii_down(GString* str);
989        GString* g_string_ascii_up(GString* str);
990        GString* g_string_assign(GString* str, const(char)* rval);
991        GString* g_string_down(GString* str);
992        int g_string_equal(GString* v, GString* v2);
993        GString* g_string_erase(GString* str, ptrdiff_t pos, ptrdiff_t len);
994        char* g_string_free(GString* str, int freeSegment);
995        GBytes* g_string_free_to_bytes(GString* str);
996        uint g_string_hash(GString* str);
997        GString* g_string_insert(GString* str, ptrdiff_t pos, const(char)* val);
998        GString* g_string_insert_c(GString* str, ptrdiff_t pos, char c);
999        GString* g_string_insert_len(GString* str, ptrdiff_t pos, const(char)* val, ptrdiff_t len);
1000        GString* g_string_insert_unichar(GString* str, ptrdiff_t pos, dchar wc);
1001        GString* g_string_overwrite(GString* str, size_t pos, const(char)* val);
1002        GString* g_string_overwrite_len(GString* str, size_t pos, const(char)* val, ptrdiff_t len);
1003        GString* g_string_prepend(GString* str, const(char)* val);
1004        GString* g_string_prepend_c(GString* str, char c);
1005        GString* g_string_prepend_len(GString* str, const(char)* val, ptrdiff_t len);
1006        GString* g_string_prepend_unichar(GString* str, dchar wc);
1007        void g_string_printf(GString* str, const(char)* format, ... );
1008        GString* g_string_set_size(GString* str, size_t len);
1009        GString* g_string_truncate(GString* str, size_t len);
1010        GString* g_string_up(GString* str);
1011        void g_string_vprintf(GString* str, const(char)* format, void* args);
1012        GString* g_string_new(const(char)* init);
1013        GString* g_string_new_len(const(char)* init, ptrdiff_t len);
1014        GString* g_string_sized_new(size_t dflSize);
1015
1016        // glib.StringChunk
1017
1018        void g_string_chunk_clear(GStringChunk* chunk);
1019        void g_string_chunk_free(GStringChunk* chunk);
1020        char* g_string_chunk_insert(GStringChunk* chunk, const(char)* str);
1021        char* g_string_chunk_insert_const(GStringChunk* chunk, const(char)* str);
1022        char* g_string_chunk_insert_len(GStringChunk* chunk, const(char)* str, ptrdiff_t len);
1023        GStringChunk* g_string_chunk_new(size_t size);
1024
1025        // glib.TestLogBuffer
1026
1027        void g_test_log_buffer_free(GTestLogBuffer* tbuffer);
1028        GTestLogMsg* g_test_log_buffer_pop(GTestLogBuffer* tbuffer);
1029        void g_test_log_buffer_push(GTestLogBuffer* tbuffer, uint nBytes, ubyte* bytes);
1030        GTestLogBuffer* g_test_log_buffer_new();
1031
1032        // glib.TestLogMsg
1033
1034        void g_test_log_msg_free(GTestLogMsg* tmsg);
1035
1036        // glib.TestSuite
1037
1038        void g_test_suite_add(GTestSuite* suite, GTestCase* testCase);
1039        void g_test_suite_add_suite(GTestSuite* suite, GTestSuite* nestedsuite);
1040
1041        // glib.Thread
1042
1043        GThread* g_thread_new(const(char)* name, GThreadFunc func, void* data);
1044        GThread* g_thread_try_new(const(char)* name, GThreadFunc func, void* data, GError** err);
1045        void* g_thread_join(GThread* thread);
1046        GThread* g_thread_ref(GThread* thread);
1047        void g_thread_unref(GThread* thread);
1048        GQuark g_thread_error_quark();
1049        void g_thread_exit(void* retval);
1050        GThread* g_thread_self();
1051        void g_thread_yield();
1052        void g_bit_lock(int* address, int lockBit);
1053        int g_bit_trylock(int* address, int lockBit);
1054        void g_bit_unlock(int* address, int lockBit);
1055        uint g_get_num_processors();
1056        void g_pointer_bit_lock(void* address, int lockBit);
1057        int g_pointer_bit_trylock(void* address, int lockBit);
1058        void g_pointer_bit_unlock(void* address, int lockBit);
1059
1060        // glib.ThreadPool
1061
1062        void g_thread_pool_free(GThreadPool* pool, int immediate, int wait);
1063        int g_thread_pool_get_max_threads(GThreadPool* pool);
1064        uint g_thread_pool_get_num_threads(GThreadPool* pool);
1065        int g_thread_pool_move_to_front(GThreadPool* pool, void* data);
1066        int g_thread_pool_push(GThreadPool* pool, void* data, GError** err);
1067        int g_thread_pool_set_max_threads(GThreadPool* pool, int maxThreads, GError** err);
1068        void g_thread_pool_set_sort_function(GThreadPool* pool, GCompareDataFunc func, void* userData);
1069        uint g_thread_pool_unprocessed(GThreadPool* pool);
1070        uint g_thread_pool_get_max_idle_time();
1071        int g_thread_pool_get_max_unused_threads();
1072        uint g_thread_pool_get_num_unused_threads();
1073        GThreadPool* g_thread_pool_new(GFunc func, void* userData, int maxThreads, int exclusive, GError** err);
1074        void g_thread_pool_set_max_idle_time(uint interval);
1075        void g_thread_pool_set_max_unused_threads(int maxThreads);
1076        void g_thread_pool_stop_unused_threads();
1077
1078        // glib.TimeVal
1079
1080        void g_time_val_add(GTimeVal* time, glong microseconds);
1081        char* g_time_val_to_iso8601(GTimeVal* time);
1082        int g_time_val_from_iso8601(const(char)* isoDate, GTimeVal* time);
1083        void g_get_current_time(GTimeVal* result);
1084        long g_get_monotonic_time();
1085        long g_get_real_time();
1086        void g_usleep(gulong microseconds);
1087
1088        // glib.TimeZone
1089
1090        GTimeZone* g_time_zone_new(const(char)* identifier);
1091        GTimeZone* g_time_zone_new_local();
1092        GTimeZone* g_time_zone_new_utc();
1093        int g_time_zone_adjust_time(GTimeZone* tz, GTimeType type, long* time);
1094        int g_time_zone_find_interval(GTimeZone* tz, GTimeType type, long time);
1095        const(char)* g_time_zone_get_abbreviation(GTimeZone* tz, int interval);
1096        int g_time_zone_get_offset(GTimeZone* tz, int interval);
1097        int g_time_zone_is_dst(GTimeZone* tz, int interval);
1098        GTimeZone* g_time_zone_ref(GTimeZone* tz);
1099        void g_time_zone_unref(GTimeZone* tz);
1100
1101        // glib.Timer
1102
1103        void g_timer_continue(GTimer* timer);
1104        void g_timer_destroy(GTimer* timer);
1105        double g_timer_elapsed(GTimer* timer, gulong* microseconds);
1106        void g_timer_reset(GTimer* timer);
1107        void g_timer_start(GTimer* timer);
1108        void g_timer_stop(GTimer* timer);
1109        GTimer* g_timer_new();
1110
1111        // glib.TrashStack
1112
1113        uint g_trash_stack_height(GTrashStack** stackP);
1114        void* g_trash_stack_peek(GTrashStack** stackP);
1115        void* g_trash_stack_pop(GTrashStack** stackP);
1116        void g_trash_stack_push(GTrashStack** stackP, void* dataP);
1117
1118        // glib.BBTree
1119
1120        void g_tree_destroy(GTree* tree);
1121        void g_tree_foreach(GTree* tree, GTraverseFunc func, void* userData);
1122        int g_tree_height(GTree* tree);
1123        void g_tree_insert(GTree* tree, void* key, void* value);
1124        void* g_tree_lookup(GTree* tree, void* key);
1125        int g_tree_lookup_extended(GTree* tree, void* lookupKey, void** origKey, void** value);
1126        int g_tree_nnodes(GTree* tree);
1127        GTree* g_tree_ref(GTree* tree);
1128        int g_tree_remove(GTree* tree, void* key);
1129        void g_tree_replace(GTree* tree, void* key, void* value);
1130        void* g_tree_search(GTree* tree, GCompareFunc searchFunc, void* userData);
1131        int g_tree_steal(GTree* tree, void* key);
1132        void g_tree_traverse(GTree* tree, GTraverseFunc traverseFunc, GTraverseType traverseType, void* userData);
1133        void g_tree_unref(GTree* tree);
1134        GTree* g_tree_new(GCompareFunc keyCompareFunc);
1135        GTree* g_tree_new_full(GCompareDataFunc keyCompareFunc, void* keyCompareData, GDestroyNotify keyDestroyFunc, GDestroyNotify valueDestroyFunc);
1136        GTree* g_tree_new_with_data(GCompareDataFunc keyCompareFunc, void* keyCompareData);
1137
1138        // glib.Variant
1139
1140        GVariant* g_variant_new(const(char)* formatString, ... );
1141        GVariant* g_variant_new_array(GVariantType* childType, GVariant** children, size_t nChildren);
1142        GVariant* g_variant_new_boolean(int value);
1143        GVariant* g_variant_new_byte(char value);
1144        GVariant* g_variant_new_bytestring(char* str);
1145        GVariant* g_variant_new_bytestring_array(char** strv, ptrdiff_t length);
1146        GVariant* g_variant_new_dict_entry(GVariant* key, GVariant* value);
1147        GVariant* g_variant_new_double(double value);
1148        GVariant* g_variant_new_fixed_array(GVariantType* elementType, void* elements, size_t nElements, size_t elementSize);
1149        GVariant* g_variant_new_from_bytes(GVariantType* type, GBytes* bytes, int trusted);
1150        GVariant* g_variant_new_from_data(GVariantType* type, void* data, size_t size, int trusted, GDestroyNotify notify, void* userData);
1151        GVariant* g_variant_new_handle(int value);
1152        GVariant* g_variant_new_int16(short value);
1153        GVariant* g_variant_new_int32(int value);
1154        GVariant* g_variant_new_int64(long value);
1155        GVariant* g_variant_new_maybe(GVariantType* childType, GVariant* child);
1156        GVariant* g_variant_new_object_path(const(char)* objectPath);
1157        GVariant* g_variant_new_objv(char** strv, ptrdiff_t length);
1158        GVariant* g_variant_new_parsed(const(char)* format, ... );
1159        GVariant* g_variant_new_parsed_va(const(char)* format, void** app);
1160        GVariant* g_variant_new_printf(const(char)* formatString, ... );
1161        GVariant* g_variant_new_signature(const(char)* signature);
1162        GVariant* g_variant_new_string(const(char)* str);
1163        GVariant* g_variant_new_strv(char** strv, ptrdiff_t length);
1164        GVariant* g_variant_new_take_string(char* str);
1165        GVariant* g_variant_new_tuple(GVariant** children, size_t nChildren);
1166        GVariant* g_variant_new_uint16(ushort value);
1167        GVariant* g_variant_new_uint32(uint value);
1168        GVariant* g_variant_new_uint64(ulong value);
1169        GVariant* g_variant_new_va(const(char)* formatString, char** endptr, void** app);
1170        GVariant* g_variant_new_variant(GVariant* value);
1171        GVariant* g_variant_byteswap(GVariant* value);
1172        int g_variant_check_format_string(GVariant* value, const(char)* formatString, int copyOnly);
1173        GVariantClass g_variant_classify(GVariant* value);
1174        int g_variant_compare(void* one, void* two);
1175        char* g_variant_dup_bytestring(GVariant* value, size_t* length);
1176        char** g_variant_dup_bytestring_array(GVariant* value, size_t* length);
1177        char** g_variant_dup_objv(GVariant* value, size_t* length);
1178        char* g_variant_dup_string(GVariant* value, size_t* length);
1179        char** g_variant_dup_strv(GVariant* value, size_t* length);
1180        int g_variant_equal(void* one, void* two);
1181        void g_variant_get(GVariant* value, const(char)* formatString, ... );
1182        int g_variant_get_boolean(GVariant* value);
1183        char g_variant_get_byte(GVariant* value);
1184        char* g_variant_get_bytestring(GVariant* value);
1185        char** g_variant_get_bytestring_array(GVariant* value, size_t* length);
1186        void g_variant_get_child(GVariant* value, size_t index, const(char)* formatString, ... );
1187        GVariant* g_variant_get_child_value(GVariant* value, size_t index);
1188        void* g_variant_get_data(GVariant* value);
1189        GBytes* g_variant_get_data_as_bytes(GVariant* value);
1190        double g_variant_get_double(GVariant* value);
1191        void* g_variant_get_fixed_array(GVariant* value, size_t* nElements, size_t elementSize);
1192        int g_variant_get_handle(GVariant* value);
1193        short g_variant_get_int16(GVariant* value);
1194        int g_variant_get_int32(GVariant* value);
1195        long g_variant_get_int64(GVariant* value);
1196        GVariant* g_variant_get_maybe(GVariant* value);
1197        GVariant* g_variant_get_normal_form(GVariant* value);
1198        char** g_variant_get_objv(GVariant* value, size_t* length);
1199        size_t g_variant_get_size(GVariant* value);
1200        const(char)* g_variant_get_string(GVariant* value, size_t* length);
1201        char** g_variant_get_strv(GVariant* value, size_t* length);
1202        GVariantType* g_variant_get_type(GVariant* value);
1203        const(char)* g_variant_get_type_string(GVariant* value);
1204        ushort g_variant_get_uint16(GVariant* value);
1205        uint g_variant_get_uint32(GVariant* value);
1206        ulong g_variant_get_uint64(GVariant* value);
1207        void g_variant_get_va(GVariant* value, const(char)* formatString, char** endptr, void** app);
1208        GVariant* g_variant_get_variant(GVariant* value);
1209        uint g_variant_hash(void* value);
1210        int g_variant_is_container(GVariant* value);
1211        int g_variant_is_floating(GVariant* value);
1212        int g_variant_is_normal_form(GVariant* value);
1213        int g_variant_is_of_type(GVariant* value, GVariantType* type);
1214        GVariantIter* g_variant_iter_new(GVariant* value);
1215        int g_variant_lookup(GVariant* dictionary, const(char)* key, const(char)* formatString, ... );
1216        GVariant* g_variant_lookup_value(GVariant* dictionary, const(char)* key, GVariantType* expectedType);
1217        size_t g_variant_n_children(GVariant* value);
1218        char* g_variant_print(GVariant* value, int typeAnnotate);
1219        GString* g_variant_print_string(GVariant* value, GString* str, int typeAnnotate);
1220        GVariant* g_variant_ref(GVariant* value);
1221        GVariant* g_variant_ref_sink(GVariant* value);
1222        void g_variant_store(GVariant* value, void* data);
1223        GVariant* g_variant_take_ref(GVariant* value);
1224        void g_variant_unref(GVariant* value);
1225        int g_variant_is_object_path(const(char)* str);
1226        int g_variant_is_signature(const(char)* str);
1227        GVariant* g_variant_parse(GVariantType* type, const(char)* text, const(char)* limit, char** endptr, GError** err);
1228        char* g_variant_parse_error_print_context(GError* error, const(char)* sourceStr);
1229        GQuark g_variant_parse_error_quark();
1230        GQuark g_variant_parser_get_error_quark();
1231
1232        // glib.VariantBuilder
1233
1234        GVariantBuilder* g_variant_builder_new(GVariantType* type);
1235        void g_variant_builder_add(GVariantBuilder* builder, const(char)* formatString, ... );
1236        void g_variant_builder_add_parsed(GVariantBuilder* builder, const(char)* format, ... );
1237        void g_variant_builder_add_value(GVariantBuilder* builder, GVariant* value);
1238        void g_variant_builder_clear(GVariantBuilder* builder);
1239        void g_variant_builder_close(GVariantBuilder* builder);
1240        GVariant* g_variant_builder_end(GVariantBuilder* builder);
1241        void g_variant_builder_init(GVariantBuilder* builder, GVariantType* type);
1242        void g_variant_builder_open(GVariantBuilder* builder, GVariantType* type);
1243        GVariantBuilder* g_variant_builder_ref(GVariantBuilder* builder);
1244        void g_variant_builder_unref(GVariantBuilder* builder);
1245
1246        // glib.VariantDict
1247
1248        GVariantDict* g_variant_dict_new(GVariant* fromAsv);
1249        void g_variant_dict_clear(GVariantDict* dict);
1250        int g_variant_dict_contains(GVariantDict* dict, const(char)* key);
1251        GVariant* g_variant_dict_end(GVariantDict* dict);
1252        void g_variant_dict_init(GVariantDict* dict, GVariant* fromAsv);
1253        void g_variant_dict_insert(GVariantDict* dict, const(char)* key, const(char)* formatString, ... );
1254        void g_variant_dict_insert_value(GVariantDict* dict, const(char)* key, GVariant* value);
1255        int g_variant_dict_lookup(GVariantDict* dict, const(char)* key, const(char)* formatString, ... );
1256        GVariant* g_variant_dict_lookup_value(GVariantDict* dict, const(char)* key, GVariantType* expectedType);
1257        GVariantDict* g_variant_dict_ref(GVariantDict* dict);
1258        int g_variant_dict_remove(GVariantDict* dict, const(char)* key);
1259        void g_variant_dict_unref(GVariantDict* dict);
1260
1261        // glib.VariantIter
1262
1263        GVariantIter* g_variant_iter_copy(GVariantIter* iter);
1264        void g_variant_iter_free(GVariantIter* iter);
1265        size_t g_variant_iter_init(GVariantIter* iter, GVariant* value);
1266        int g_variant_iter_loop(GVariantIter* iter, const(char)* formatString, ... );
1267        size_t g_variant_iter_n_children(GVariantIter* iter);
1268        int g_variant_iter_next(GVariantIter* iter, const(char)* formatString, ... );
1269        GVariant* g_variant_iter_next_value(GVariantIter* iter);
1270
1271        // glib.VariantType
1272
1273        GVariantType* g_variant_type_new(const(char)* typeString);
1274        GVariantType* g_variant_type_new_array(GVariantType* element);
1275        GVariantType* g_variant_type_new_dict_entry(GVariantType* key, GVariantType* value);
1276        GVariantType* g_variant_type_new_maybe(GVariantType* element);
1277        GVariantType* g_variant_type_new_tuple(GVariantType** items, int length);
1278        GVariantType* g_variant_type_copy(GVariantType* type);
1279        char* g_variant_type_dup_string(GVariantType* type);
1280        GVariantType* g_variant_type_element(GVariantType* type);
1281        int g_variant_type_equal(void* type1, void* type2);
1282        GVariantType* g_variant_type_first(GVariantType* type);
1283        void g_variant_type_free(GVariantType* type);
1284        size_t g_variant_type_get_string_length(GVariantType* type);
1285        uint g_variant_type_hash(void* type);
1286        int g_variant_type_is_array(GVariantType* type);
1287        int g_variant_type_is_basic(GVariantType* type);
1288        int g_variant_type_is_container(GVariantType* type);
1289        int g_variant_type_is_definite(GVariantType* type);
1290        int g_variant_type_is_dict_entry(GVariantType* type);
1291        int g_variant_type_is_maybe(GVariantType* type);
1292        int g_variant_type_is_subtype_of(GVariantType* type, GVariantType* supertype);
1293        int g_variant_type_is_tuple(GVariantType* type);
1294        int g_variant_type_is_variant(GVariantType* type);
1295        GVariantType* g_variant_type_key(GVariantType* type);
1296        size_t g_variant_type_n_items(GVariantType* type);
1297        GVariantType* g_variant_type_next(GVariantType* type);
1298        const(char)* g_variant_type_peek_string(GVariantType* type);
1299        GVariantType* g_variant_type_value(GVariantType* type);
1300        GVariantType* g_variant_type_checked_(const(char)* arg0);
1301        int g_variant_type_string_is_valid(const(char)* typeString);
1302        int g_variant_type_string_scan(const(char)* str, const(char)* limit, char** endptr);
1303
1304        // glib.Module
1305
1306        int g_module_close(GModule* modul);
1307        void g_module_make_resident(GModule* modul);
1308        const(char)* g_module_name(GModule* modul);
1309        int g_module_symbol(GModule* modul, const(char)* symbolName, void** symbol);
1310        char* g_module_build_path(const(char)* directory, const(char)* moduleName);
1311        const(char)* g_module_error();
1312        GModule* g_module_open(const(char)* fileName, GModuleFlags flags);
1313        int g_module_supported();
1314
1315        // glib.Base64
1316
1317        size_t g_base64_decode_step(char* inn, size_t len, char* output, int* state, uint* save);
1318        char* g_base64_decode_inplace(char* text, size_t* outLen);
1319        char* g_base64_decode(const(char)* text, size_t* outLen);
1320        char* g_base64_encode(char* data, size_t len);
1321        size_t g_base64_encode_close(int breakLines, char* output, int* state, int* save);
1322        size_t g_base64_encode_step(char* inn, size_t len, int breakLines, char* output, int* state, int* save);
1323
1324        // glib.Idle
1325
1326        uint g_idle_add(GSourceFunc funct, void* data);
1327        uint g_idle_add_full(int priority, GSourceFunc funct, void* data, GDestroyNotify notify);
1328        int g_idle_remove_by_data(void* data);
1329        GSource* g_idle_source_new();
1330
1331        // glib.MemorySlice
1332
1333        void* g_slice_alloc(size_t blockSize);
1334        void* g_slice_alloc0(size_t blockSize);
1335        void* g_slice_copy(size_t blockSize, void* memBlock);
1336        void g_slice_free1(size_t blockSize, void* memBlock);
1337        void g_slice_free_chain_with_offset(size_t blockSize, void* memChain, size_t nextOffset);
1338        long g_slice_get_config(GSliceConfig ckey);
1339        long* g_slice_get_config_state(GSliceConfig ckey, long address, uint* nValues);
1340        void g_slice_set_config(GSliceConfig ckey, long value);
1341
1342        // glib.Spawn
1343
1344        int g_spawn_async(const(char)* workingDirectory, char** argv, char** envp, GSpawnFlags flags, GSpawnChildSetupFunc childSetup, void* userData, GPid* childPid, GError** err);
1345        int g_spawn_async_with_pipes(const(char)* workingDirectory, char** argv, char** envp, GSpawnFlags flags, GSpawnChildSetupFunc childSetup, void* userData, GPid* childPid, int* standardInput, int* standardOutput, int* standardError, GError** err);
1346        int g_spawn_check_exit_status(int exitStatus, GError** err);
1347        void g_spawn_close_pid(GPid pid);
1348        int g_spawn_command_line_async(const(char)* commandLine, GError** err);
1349        int g_spawn_command_line_sync(const(char)* commandLine, char** standardOutput, char** standardError, int* exitStatus, GError** err);
1350        GQuark g_spawn_error_quark();
1351        GQuark g_spawn_exit_error_quark();
1352        int g_spawn_sync(const(char)* workingDirectory, char** argv, char** envp, GSpawnFlags flags, GSpawnChildSetupFunc childSetup, void* userData, char** standardOutput, char** standardError, int* exitStatus, GError** err);
1353
1354        // glib.Str
1355
1356        int g_ascii_digit_value(char c);
1357        char* g_ascii_dtostr(char* buffer, int bufLen, double d);
1358        char* g_ascii_formatd(char* buffer, int bufLen, const(char)* format, double d);
1359        int g_ascii_strcasecmp(const(char)* s1, const(char)* s2);
1360        char* g_ascii_strdown(const(char)* str, ptrdiff_t len);
1361        int g_ascii_strncasecmp(const(char)* s1, const(char)* s2, size_t n);
1362        double g_ascii_strtod(const(char)* nptr, char** endptr);
1363        long g_ascii_strtoll(const(char)* nptr, char** endptr, uint base);
1364        ulong g_ascii_strtoull(const(char)* nptr, char** endptr, uint base);
1365        char* g_ascii_strup(const(char)* str, ptrdiff_t len);
1366        char g_ascii_tolower(char c);
1367        char g_ascii_toupper(char c);
1368        int g_ascii_xdigit_value(char c);
1369        int g_fprintf(FILE* file, char* format, ... );
1370        int g_printf(char* format, ... );
1371        size_t g_printf_string_upper_bound(const(char)* format, void* args);
1372        int g_snprintf(char* str, gulong n, char* format, ... );
1373        int g_sprintf(char* str, char* format, ... );
1374        char* g_stpcpy(char* dest, const(char)* src);
1375        int g_str_has_prefix(const(char)* str, const(char)* prefix);
1376        int g_str_has_suffix(const(char)* str, const(char)* suffix);
1377        int g_str_is_ascii(const(char)* str);
1378        int g_str_match_string(const(char)* searchTerm, const(char)* potentialHit, int acceptAlternates);
1379        char* g_str_to_ascii(const(char)* str, const(char)* fromLocale);
1380        char** g_str_tokenize_and_fold(const(char)* str, const(char)* translitLocale, char*** asciiAlternates);
1381        char* g_strcanon(char* str, const(char)* validChars, char substitutor);
1382        int g_strcasecmp(const(char)* s1, const(char)* s2);
1383        char* g_strchomp(char* str);
1384        char* g_strchug(char* str);
1385        int g_strcmp0(const(char)* str1, const(char)* str2);
1386        char* g_strcompress(const(char)* source);
1387        char* g_strconcat(const(char)* string1, ... );
1388        char* g_strdelimit(char* str, const(char)* delimiters, char newDelimiter);
1389        char* g_strdown(char* str);
1390        char* g_strdup(const(char)* str);
1391        char* g_strdup_printf(const(char)* format, ... );
1392        char* g_strdup_vprintf(const(char)* format, void* args);
1393        char** g_strdupv(char** strArray);
1394        const(char)* g_strerror(int errnum);
1395        char* g_strescape(const(char)* source, const(char)* exceptions);
1396        void g_strfreev(char** strArray);
1397        char* g_strjoin(const(char)* separator, ... );
1398        char* g_strjoinv(const(char)* separator, char** strArray);
1399        size_t g_strlcat(char* dest, const(char)* src, size_t destSize);
1400        size_t g_strlcpy(char* dest, const(char)* src, size_t destSize);
1401        int g_strncasecmp(const(char)* s1, const(char)* s2, uint n);
1402        char* g_strndup(const(char)* str, size_t n);
1403        char* g_strnfill(size_t length, char fillChar);
1404        char* g_strreverse(char* str);
1405        char* g_strrstr(const(char)* haystack, const(char)* needle);
1406        char* g_strrstr_len(const(char)* haystack, ptrdiff_t haystackLen, const(char)* needle);
1407        const(char)* g_strsignal(int signum);
1408        char** g_strsplit(const(char)* str, const(char)* delimiter, int maxTokens);
1409        char** g_strsplit_set(const(char)* str, const(char)* delimiters, int maxTokens);
1410        char* g_strstr_len(const(char)* haystack, ptrdiff_t haystackLen, const(char)* needle);
1411        double g_strtod(const(char)* nptr, char** endptr);
1412        char* g_strup(char* str);
1413        GType g_strv_get_type();
1414        uint g_strv_length(char** strArray);
1415        int g_strv_contains(const(char)* strv, const(char)* str);
1416        int g_vasprintf(char** str, char* format, void* args);
1417        int g_vfprintf(FILE* file, char* format, void* args);
1418        int g_vprintf(char* format, void* args);
1419        int g_vsnprintf(char* str, gulong n, char* format, void* args);
1420        int g_vsprintf(char* str, char* format, void* args);
1421
1422        // glib.Timeout
1423
1424        uint g_timeout_add(uint interval, GSourceFunc funct, void* data);
1425        uint g_timeout_add_full(int priority, uint interval, GSourceFunc funct, void* data, GDestroyNotify notify);
1426        uint g_timeout_add_seconds(uint interval, GSourceFunc funct, void* data);
1427        uint g_timeout_add_seconds_full(int priority, uint interval, GSourceFunc funct, void* data, GDestroyNotify notify);
1428        GSource* g_timeout_source_new(uint interval);
1429        GSource* g_timeout_source_new_seconds(uint interval);
1430
1431        // glib.Util
1432
1433        char* g_build_filenamev(char** args);
1434        char* g_build_pathv(const(char)* separator, char** args);
1435        void g_atexit(GVoidFunc func);
1436        const(char)* g_basename(const(char)* fileName);
1437        int g_bit_nth_lsf(gulong mask, int nthBit);
1438        int g_bit_nth_msf(gulong mask, int nthBit);
1439        uint g_bit_storage(gulong number);
1440        char* g_build_path(const(char)* separator, const(char)* firstElement, ... );
1441        const(char)* g_environ_getenv(char** envp, const(char)* variable);
1442        char** g_environ_setenv(char** envp, const(char)* variable, const(char)* value, int overwrite);
1443        char** g_environ_unsetenv(char** envp, const(char)* variable);
1444        char* g_find_program_in_path(const(char)* program);
1445        char* g_format_size(ulong size);
1446        char* g_format_size_for_display(long size);
1447        char* g_format_size_full(ulong size, GFormatSizeFlags flags);
1448        const(char)* g_get_application_name();
1449        char** g_get_environ();
1450        char* g_get_current_dir();
1451        const(char)* g_get_home_dir();
1452        const(char)* g_get_host_name();
1453        const(char)* g_get_prgname();
1454        const(char)* g_get_real_name();
1455        char** g_get_system_config_dirs();
1456        char** g_get_system_data_dirs();
1457        const(char)* g_get_tmp_dir();
1458        const(char)* g_get_user_cache_dir();
1459        const(char)* g_get_user_config_dir();
1460        const(char)* g_get_user_data_dir();
1461        const(char)* g_get_user_name();
1462        const(char)* g_get_user_runtime_dir();
1463        const(char)* g_get_user_special_dir(GUserDirectory directory);
1464        const(char)* g_getenv(const(char)* variable);
1465        char** g_listenv();
1466        void g_nullify_pointer(void** nullifyLocation);
1467        uint g_parse_debug_string(const(char)* str, GDebugKey* keys, uint nkeys);
1468        char* g_path_get_basename(const(char)* fileName);
1469        char* g_path_get_dirname(const(char)* fileName);
1470        int g_path_is_absolute(const(char)* fileName);
1471        const(char)* g_path_skip_root(const(char)* fileName);
1472        void g_qsort_with_data(void* pbase, int totalElems, size_t size, GCompareDataFunc compareFunc, void* userData);
1473        void g_reload_user_special_dirs_cache();
1474        void g_set_application_name(const(char)* applicationName);
1475        void g_set_prgname(const(char)* prgname);
1476        int g_setenv(const(char)* variable, const(char)* value, int overwrite);
1477        uint g_spaced_primes_closest(uint num);
1478        void g_unsetenv(const(char)* variable);
1479
1480        // glib.Atomic
1481
1482        int g_atomic_int_add(int* atomic, int val);
1483        uint g_atomic_int_and(uint* atomic, uint val);
1484        int g_atomic_int_compare_and_exchange(int* atomic, int oldval, int newval);
1485        int g_atomic_int_dec_and_test(int* atomic);
1486        int g_atomic_int_exchange_and_add(int* atomic, int val);
1487        int g_atomic_int_get(int* atomic);
1488        void g_atomic_int_inc(int* atomic);
1489        uint g_atomic_int_or(uint* atomic, uint val);
1490        void g_atomic_int_set(int* atomic, int newval);
1491        uint g_atomic_int_xor(uint* atomic, uint val);
1492        ptrdiff_t g_atomic_pointer_add(void* atomic, ptrdiff_t val);
1493        size_t g_atomic_pointer_and(void* atomic, size_t val);
1494        int g_atomic_pointer_compare_and_exchange(void* atomic, void* oldval, void* newval);
1495        void* g_atomic_pointer_get(void* atomic);
1496        size_t g_atomic_pointer_or(void* atomic, size_t val);
1497        void g_atomic_pointer_set(void* atomic, void* newval);
1498        size_t g_atomic_pointer_xor(void* atomic, size_t val);
1499
1500        // glib.CharacterSet
1501
1502        char* g_convert(const(char)* str, ptrdiff_t len, const(char)* toCodeset, const(char)* fromCodeset, size_t* bytesRead, size_t* bytesWritten, GError** err);
1503        GQuark g_convert_error_quark();
1504        char* g_convert_with_fallback(const(char)* str, ptrdiff_t len, const(char)* toCodeset, const(char)* fromCodeset, const(char)* fallback, size_t* bytesRead, size_t* bytesWritten, GError** err);
1505        char* g_convert_with_iconv(const(char)* str, ptrdiff_t len, GIConv converter, size_t* bytesRead, size_t* bytesWritten, GError** err);
1506        char* g_filename_display_basename(const(char)* filename);
1507        char* g_filename_display_name(const(char)* filename);
1508        char* g_filename_from_utf8(const(char)* utf8string, ptrdiff_t len, size_t* bytesRead, size_t* bytesWritten, GError** err);
1509        char* g_filename_to_utf8(const(char)* opsysstring, ptrdiff_t len, size_t* bytesRead, size_t* bytesWritten, GError** err);
1510        int g_get_charset(char** charset);
1511        char* g_get_codeset();
1512        int g_get_filename_charsets(char*** charsets);
1513        char* g_locale_from_utf8(const(char)* utf8string, ptrdiff_t len, size_t* bytesRead, size_t* bytesWritten, GError** err);
1514        char* g_locale_to_utf8(const(char)* opsysstring, ptrdiff_t len, size_t* bytesRead, size_t* bytesWritten, GError** err);
1515
1516        // glib.Child
1517
1518        uint g_child_watch_add(GPid pid, GChildWatchFunc funct, void* data);
1519        uint g_child_watch_add_full(int priority, GPid pid, GChildWatchFunc funct, void* data, GDestroyNotify notify);
1520        GSource* g_child_watch_source_new(GPid pid);
1521
1522        // glib.DataList
1523
1524        void g_datalist_clear(GData** datalist);
1525        void g_datalist_foreach(GData** datalist, GDataForeachFunc func, void* userData);
1526        void* g_datalist_get_data(GData** datalist, const(char)* key);
1527        uint g_datalist_get_flags(GData** datalist);
1528        void* g_datalist_id_dup_data(GData** datalist, GQuark keyId, GDuplicateFunc dupFunc, void* userData);
1529        void* g_datalist_id_get_data(GData** datalist, GQuark keyId);
1530        void* g_datalist_id_remove_no_notify(GData** datalist, GQuark keyId);
1531        int g_datalist_id_replace_data(GData** datalist, GQuark keyId, void* oldval, void* newval, GDestroyNotify destroy, GDestroyNotify* oldDestroy);
1532        void g_datalist_id_set_data_full(GData** datalist, GQuark keyId, void* data, GDestroyNotify destroyFunc);
1533        void g_datalist_init(GData** datalist);
1534        void g_datalist_set_flags(GData** datalist, uint flags);
1535        void g_datalist_unset_flags(GData** datalist, uint flags);
1536
1537        // glib.DataSet
1538
1539        void g_dataset_destroy(void* datasetLocation);
1540        void g_dataset_foreach(void* datasetLocation, GDataForeachFunc func, void* userData);
1541        void* g_dataset_id_get_data(void* datasetLocation, GQuark keyId);
1542        void* g_dataset_id_remove_no_notify(void* datasetLocation, GQuark keyId);
1543        void g_dataset_id_set_data_full(void* datasetLocation, GQuark keyId, void* data, GDestroyNotify destroyFunc);
1544
1545        // glib.FileUtils
1546
1547        int g_access(const(char)* filename, int mode);
1548        int g_chdir(const(char)* path);
1549        int g_close(int fd, GError** err);
1550        GFileError g_file_error_from_errno(int errNo);
1551        GQuark g_file_error_quark();
1552        int g_file_get_contents(char* filename, char** contents, size_t* length, GError** err);
1553        int g_file_open_tmp(char* tmpl, char** nameUsed, GError** err);
1554        char* g_file_read_link(const(char)* filename, GError** err);
1555        int g_file_set_contents(char* filename, char* contents, ptrdiff_t length, GError** err);
1556        int g_file_test(const(char)* filename, GFileTest test);
1557        int g_mkdir_with_parents(const(char)* pathname, int mode);
1558        char* g_mkdtemp(char* tmpl);
1559        char* g_mkdtemp_full(char* tmpl, int mode);
1560        int g_mkstemp(char* tmpl);
1561        int g_mkstemp_full(char* tmpl, int flags, int mode);
1562        int g_rmdir(const(char)* filename);
1563        int g_unlink(const(char)* filename);
1564
1565        // glib.Hostname
1566
1567        int g_hostname_is_ascii_encoded(const(char)* hostname);
1568        int g_hostname_is_ip_address(const(char)* hostname);
1569        int g_hostname_is_non_ascii(const(char)* hostname);
1570        char* g_hostname_to_ascii(const(char)* hostname);
1571        char* g_hostname_to_unicode(const(char)* hostname);
1572
1573        // glib.Internationalization
1574
1575        const(char)* g_dcgettext(const(char)* domain, const(char)* msgid, int category);
1576        const(char)* g_dgettext(const(char)* domain, const(char)* msgid);
1577        const(char)* g_dngettext(const(char)* domain, const(char)* msgid, const(char)* msgidPlural, gulong n);
1578        const(char)* g_dpgettext(const(char)* domain, const(char)* msgctxtid, size_t msgidoffset);
1579        const(char)* g_dpgettext2(const(char)* domain, const(char)* context, const(char)* msgid);
1580        char** g_get_language_names();
1581        char** g_get_locale_variants(const(char)* locale);
1582        const(char)* g_strip_context(const(char)* msgid, const(char)* msgval);
1583
1584        // glib.Memory
1585
1586        void g_clear_pointer(void** pp, GDestroyNotify destroy);
1587        void g_free(void* mem);
1588        void* g_malloc(size_t nBytes);
1589        void* g_malloc0(size_t nBytes);
1590        void* g_malloc0_n(size_t nBlocks, size_t nBlockBytes);
1591        void* g_malloc_n(size_t nBlocks, size_t nBlockBytes);
1592        int g_mem_is_system_malloc();
1593        void g_mem_profile();
1594        void g_mem_set_vtable(GMemVTable* vtable);
1595        void* g_memdup(void* mem, uint byteSize);
1596        void* g_realloc(void* mem, size_t nBytes);
1597        void* g_realloc_n(void* mem, size_t nBlocks, size_t nBlockBytes);
1598        void* g_try_malloc(size_t nBytes);
1599        void* g_try_malloc0(size_t nBytes);
1600        void* g_try_malloc0_n(size_t nBlocks, size_t nBlockBytes);
1601        void* g_try_malloc_n(size_t nBlocks, size_t nBlockBytes);
1602        void* g_try_realloc(void* mem, size_t nBytes);
1603        void* g_try_realloc_n(void* mem, size_t nBlocks, size_t nBlockBytes);
1604
1605        // glib.MessageLog
1606
1607        void g_log(const(char)* logDomain, GLogLevelFlags logLevel, const(char)* format, ... );
1608        void g_log_default_handler(const(char)* logDomain, GLogLevelFlags logLevel, const(char)* message, void* unusedData);
1609        void g_log_remove_handler(const(char)* logDomain, uint handlerId);
1610        GLogLevelFlags g_log_set_always_fatal(GLogLevelFlags fatalMask);
1611        GLogFunc g_log_set_default_handler(GLogFunc logFunc, void* userData);
1612        GLogLevelFlags g_log_set_fatal_mask(const(char)* logDomain, GLogLevelFlags fatalMask);
1613        uint g_log_set_handler(const(char)* logDomain, GLogLevelFlags logLevels, GLogFunc logFunc, void* userData);
1614        uint g_log_set_handler_full(const(char)* logDomain, GLogLevelFlags logLevels, GLogFunc logFunc, void* userData, GDestroyNotify destroy);
1615        void g_logv(const(char)* logDomain, GLogLevelFlags logLevel, const(char)* format, void* args);
1616
1617        // glib.Messages
1618
1619        void g_on_error_query(const(char)* prgName);
1620        void g_on_error_stack_trace(const(char)* prgName);
1621        void g_print(const(char)* format, ... );
1622        void g_printerr(const(char)* format, ... );
1623        GPrintFunc g_set_print_handler(GPrintFunc func);
1624        GPrintFunc g_set_printerr_handler(GPrintFunc func);
1625
1626        // glib.Quark
1627
1628        const(char)* g_intern_static_string(const(char)* str);
1629        const(char)* g_intern_string(const(char)* str);
1630        GQuark g_quark_from_static_string(const(char)* str);
1631        GQuark g_quark_from_string(const(char)* str);
1632        const(char)* g_quark_to_string(GQuark quark);
1633        GQuark g_quark_try_string(const(char)* str);
1634
1635        // glib.ShellUtils
1636
1637        GQuark g_shell_error_quark();
1638        int g_shell_parse_argv(const(char)* commandLine, int* argcp, char*** argvp, GError** err);
1639        char* g_shell_quote(const(char)* unquotedString);
1640        char* g_shell_unquote(const(char)* quotedString, GError** err);
1641
1642        // glib.Unicode
1643
1644        wchar* g_ucs4_to_utf16(dchar* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
1645        char* g_ucs4_to_utf8(dchar* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
1646        GUnicodeBreakType g_unichar_break_type(dchar c);
1647        int g_unichar_combining_class(dchar uc);
1648        int g_unichar_compose(dchar a, dchar b, dchar* ch);
1649        int g_unichar_decompose(dchar ch, dchar* a, dchar* b);
1650        int g_unichar_digit_value(dchar c);
1651        size_t g_unichar_fully_decompose(dchar ch, int compat, dchar* result, size_t resultLen);
1652        int g_unichar_get_mirror_char(dchar ch, dchar* mirroredCh);
1653        GUnicodeScript g_unichar_get_script(dchar ch);
1654        int g_unichar_isalnum(dchar c);
1655        int g_unichar_isalpha(dchar c);
1656        int g_unichar_iscntrl(dchar c);
1657        int g_unichar_isdefined(dchar c);
1658        int g_unichar_isdigit(dchar c);
1659        int g_unichar_isgraph(dchar c);
1660        int g_unichar_islower(dchar c);
1661        int g_unichar_ismark(dchar c);
1662        int g_unichar_isprint(dchar c);
1663        int g_unichar_ispunct(dchar c);
1664        int g_unichar_isspace(dchar c);
1665        int g_unichar_istitle(dchar c);
1666        int g_unichar_isupper(dchar c);
1667        int g_unichar_iswide(dchar c);
1668        int g_unichar_iswide_cjk(dchar c);
1669        int g_unichar_isxdigit(dchar c);
1670        int g_unichar_iszerowidth(dchar c);
1671        int g_unichar_to_utf8(dchar c, char* outbuf);
1672        dchar g_unichar_tolower(dchar c);
1673        dchar g_unichar_totitle(dchar c);
1674        dchar g_unichar_toupper(dchar c);
1675        GUnicodeType g_unichar_type(dchar c);
1676        int g_unichar_validate(dchar ch);
1677        int g_unichar_xdigit_value(dchar c);
1678        dchar* g_unicode_canonical_decomposition(dchar ch, size_t* resultLen);
1679        void g_unicode_canonical_ordering(dchar* str, size_t len);
1680        GUnicodeScript g_unicode_script_from_iso15924(uint iso15924);
1681        uint g_unicode_script_to_iso15924(GUnicodeScript script);
1682        dchar* g_utf16_to_ucs4(wchar* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
1683        char* g_utf16_to_utf8(wchar* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
1684        char* g_utf8_casefold(const(char)* str, ptrdiff_t len);
1685        int g_utf8_collate(const(char)* str1, const(char)* str2);
1686        char* g_utf8_collate_key(const(char)* str, ptrdiff_t len);
1687        char* g_utf8_collate_key_for_filename(const(char)* str, ptrdiff_t len);
1688        char* g_utf8_find_next_char(const(char)* p, const(char)* end);
1689        char* g_utf8_find_prev_char(const(char)* str, const(char)* p);
1690        dchar g_utf8_get_char(const(char)* p);
1691        dchar g_utf8_get_char_validated(const(char)* p, ptrdiff_t maxLen);
1692        char* g_utf8_normalize(const(char)* str, ptrdiff_t len, GNormalizeMode mode);
1693        char* g_utf8_offset_to_pointer(const(char)* str, glong offset);
1694        glong g_utf8_pointer_to_offset(const(char)* str, const(char)* pos);
1695        char* g_utf8_prev_char(const(char)* p);
1696        char* g_utf8_strchr(const(char)* p, ptrdiff_t len, dchar c);
1697        char* g_utf8_strdown(const(char)* str, ptrdiff_t len);
1698        glong g_utf8_strlen(const(char)* p, ptrdiff_t max);
1699        char* g_utf8_strncpy(char* dest, const(char)* src, size_t n);
1700        char* g_utf8_strrchr(const(char)* p, ptrdiff_t len, dchar c);
1701        char* g_utf8_strreverse(const(char)* str, ptrdiff_t len);
1702        char* g_utf8_strup(const(char)* str, ptrdiff_t len);
1703        char* g_utf8_substring(const(char)* str, glong startPos, glong endPos);
1704        dchar* g_utf8_to_ucs4(const(char)* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
1705        dchar* g_utf8_to_ucs4_fast(const(char)* str, glong len, glong* itemsWritten);
1706        wchar* g_utf8_to_utf16(const(char)* str, glong len, glong* itemsRead, glong* itemsWritten, GError** err);
1707        int g_utf8_validate(char* str, ptrdiff_t maxLen, char** end);
1708
1709        // glib.UnixUtils
1710
1711        GQuark g_unix_error_quark();
1712        uint g_unix_fd_add(int fd, GIOCondition condition, GUnixFDSourceFunc funct, void* userData);
1713        uint g_unix_fd_add_full(int priority, int fd, GIOCondition condition, GUnixFDSourceFunc funct, void* userData, GDestroyNotify notify);
1714        GSource* g_unix_fd_source_new(int fd, GIOCondition condition);
1715        int g_unix_open_pipe(int* fds, int flags, GError** err);
1716        int g_unix_set_fd_nonblocking(int fd, int nonblock, GError** err);
1717        uint g_unix_signal_add(int signum, GSourceFunc handler, void* userData);
1718        uint g_unix_signal_add_full(int priority, int signum, GSourceFunc handler, void* userData, GDestroyNotify notify);
1719        GSource* g_unix_signal_source_new(int signum);
1720
1721        // glib.URI
1722
1723        char* g_filename_from_uri(const(char)* uri, char** hostname, GError** err);
1724        char* g_filename_to_uri(const(char)* filename, const(char)* hostname, GError** err);
1725        char* g_uri_escape_string(const(char)* unescaped, const(char)* reservedCharsAllowed, int allowUtf8);
1726        char** g_uri_list_extract_uris(const(char)* uriList);
1727        char* g_uri_parse_scheme(const(char)* uri);
1728        char* g_uri_unescape_segment(const(char)* escapedString, const(char)* escapedStringEnd, const(char)* illegalCharacters);
1729        char* g_uri_unescape_string(const(char)* escapedString, const(char)* illegalCharacters);
1730
1731        // glib.Version
1732
1733        const(char)* glib_check_version(uint requiredMajor, uint requiredMinor, uint requiredMicro);
1734}
Note: See TracBrowser for help on using the repository browser.