← Back to branch summary

~ubuntu-branches/ubuntu/hardy/vala/hardy

« back to all changes in this revision

Viewing changes to vapi/gio-standalone.vala

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge, Marc-Andre Lureau, Sebastian Dröge
  • Date: 2007-10-15 14:37:51 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20071015143751-zy7hqcyjutdyfkg3
Tags: 0.1.4-1
[ Marc-Andre Lureau ]
* New Upstream Version
* debian/patches:
  + Remove patch no longer needed in 0.1.4
* debian/rules
  + Add xsltproc build dependency for the Vala manual.
  + Add libenchant-dev build dependency for enchant test case.
* debian/control, debian/vala-doc.install:
  + Add a "vala-doc" documentation package.

[ Sebastian Dröge ]
* debian/control:
  + Let vala-doc suggest valac/devhelp and don't depend on libvala0.
* debian/libvala-dev.install:
  + Add the new vapicheck utility.

Show diffs side-by-side

added added

removed removed

Lines of Context:
vapi/gio-standalone.vala
1
 
[CCode (cprefix = "G", lower_case_cprefix = "g_")]
2
 
namespace GLib {
3
 
        [CCode (cprefix = "G_DIRECTORY_MONITOR_EVENT_", cheader_filename = "gio/gvfs.h,glib.h")]
4
 
        public enum DirectoryMonitorEvent {
5
 
                CHANGED,
6
 
                DELETED,
7
 
                CREATED,
8
 
                ATTRIBUTE_CHANGED,
9
 
                UNMOUNTED,
10
 
        }
11
 
        [CCode (cprefix = "G_FILE_ATTRIBUTE_TYPE_", cheader_filename = "gio/gvfs.h,glib.h")]
12
 
        public enum FileAttributeType {
13
 
                INVALID,
14
 
                STRING,
15
 
                BYTE_STRING,
16
 
                UINT32,
17
 
                INT32,
18
 
                UINT64,
19
 
                INT64,
20
 
        }
21
 
        [CCode (cprefix = "G_FILE_COPY_", cheader_filename = "gio/gvfs.h,glib.h")]
22
 
        public enum FileCopyFlags {
23
 
                OVERWRITE,
24
 
                BACKUP,
25
 
        }
26
 
        [CCode (cprefix = "G_FILE_FLAG_", cheader_filename = "gio/gvfs.h,glib.h")]
27
 
        public enum FileFlags {
28
 
                HIDDEN,
29
 
                SYMLINK,
30
 
                LOCAL,
31
 
                VIRTUAL,
32
 
        }
33
 
        [CCode (cprefix = "G_FILE_GET_INFO_NOFOLLOW_", cheader_filename = "gio/gvfs.h,glib.h")]
34
 
        public enum FileGetInfoFlags {
35
 
                SYMLINKS,
36
 
        }
37
 
        [CCode (cprefix = "G_FILE_MONITOR_EVENT_", cheader_filename = "gio/gvfs.h,glib.h")]
38
 
        public enum FileMonitorEvent {
39
 
                CHANGED,
40
 
                DELETED,
41
 
                CREATED,
42
 
                ATTRIBUTE_CHANGED,
43
 
                UNMOUNTED,
44
 
        }
45
 
        [CCode (cprefix = "G_FILE_TYPE_", cheader_filename = "gio/gvfs.h,glib.h")]
46
 
        public enum FileType {
47
 
                UNKNOWN,
48
 
                REGULAR,
49
 
                DIRECTORY,
50
 
                SYMBOLIC_LINK,
51
 
                SPECIAL,
52
 
                SHORTCUT,
53
 
                MOUNTABLE,
54
 
        }
55
 
        [CCode (cprefix = "G_IO_ERROR_", cheader_filename = "gio/gvfs.h,glib.h")]
56
 
        public enum IOErrorEnum {
57
 
                FAILED,
58
 
                NOT_FOUND,
59
 
                EXISTS,
60
 
                IS_DIRECTORY,
61
 
                NOT_DIRECTORY,
62
 
                NOT_EMPTY,
63
 
                NOT_REGULAR_FILE,
64
 
                NOT_SYMBOLIC_LINK,
65
 
                NOT_MOUNTABLE,
66
 
                FILENAME_TOO_LONG,
67
 
                INVALID_FILENAME,
68
 
                TOO_MANY_LINKS,
69
 
                NO_SPACE,
70
 
                INVALID_ARGUMENT,
71
 
                PERMISSION_DENIED,
72
 
                NOT_SUPPORTED,
73
 
                NOT_MOUNTED,
74
 
                ALREADY_MOUNTED,
75
 
                CLOSED,
76
 
                CANCELLED,
77
 
                PENDING,
78
 
                READ_ONLY,
79
 
                CANT_CREATE_BACKUP,
80
 
                WRONG_MTIME,
81
 
                TIMED_OUT,
82
 
        }
83
 
        [CCode (cprefix = "G_PASSWORD_FLAGS_", cheader_filename = "gio/gvfs.h,glib.h")]
84
 
        public enum PasswordFlags {
85
 
                NEED_PASSWORD,
86
 
                NEED_USERNAME,
87
 
                NEED_DOMAIN,
88
 
                SAVING_SUPPORTED,
89
 
                ANON_SUPPORTED,
90
 
        }
91
 
        [CCode (cprefix = "G_PASSWORD_SAVE_", cheader_filename = "gio/gvfs.h,glib.h")]
92
 
        public enum PasswordSave {
93
 
                NEVER,
94
 
                FOR_SESSION,
95
 
                PERMANENTLY,
96
 
        }
97
 
        [CCode (cprefix = "G_UNIX_MOUNT_TYPE_", cheader_filename = "gio/gvfs.h,glib.h")]
98
 
        public enum UnixMountType {
99
 
                UNKNOWN,
100
 
                FLOPPY,
101
 
                CDROM,
102
 
                NFS,
103
 
                ZIP,
104
 
                JAZ,
105
 
                MEMSTICK,
106
 
                CF,
107
 
                SM,
108
 
                SDMMC,
109
 
                IPOD,
110
 
                CAMERA,
111
 
                HD,
112
 
        }
113
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
114
 
        public class BufferedInputStream : GLib.FilterInputStream {
115
 
                public static GLib.Type get_type ();
116
 
                public BufferedInputStream (GLib.InputStream base_stream);
117
 
                public BufferedInputStream.sized (GLib.InputStream base_stream, uint size);
118
 
                [NoAccessorMethod]
119
 
                public weak uint buffer_size { get; construct; }
120
 
        }
121
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
122
 
        public class BufferedOutputStream : GLib.FilterOutputStream {
123
 
                public static GLib.Type get_type ();
124
 
                public BufferedOutputStream (GLib.OutputStream base_stream);
125
 
                public BufferedOutputStream.sized (GLib.OutputStream base_stream, uint size);
126
 
                [NoAccessorMethod]
127
 
                public weak uint buffer_size { get; construct; }
128
 
        }
129
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
130
 
        public class Cancellable : GLib.Object {
131
 
                public void cancel ();
132
 
                public int get_fd ();
133
 
                public static GLib.Type get_type ();
134
 
                public bool is_cancelled ();
135
 
                public Cancellable ();
136
 
                public void reset ();
137
 
                public signal void cancelled ();
138
 
        }
139
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
140
 
        public class DesktopAppInfo : GLib.Object, GLib.AppInfo {
141
 
                public static GLib.Type get_type ();
142
 
                public DesktopAppInfo (string desktop_id);
143
 
        }
144
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
145
 
        public class DirectoryMonitor : GLib.Object {
146
 
                public virtual bool cancel ();
147
 
                public void emit_event (GLib.File child, GLib.File other_file, GLib.DirectoryMonitorEvent event_type);
148
 
                public static GLib.Type get_type ();
149
 
                public void set_rate_limit (int limit_msecs);
150
 
                public signal void changed (GLib.File child, GLib.File other_file, GLib.DirectoryMonitorEvent event_type);
151
 
        }
152
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
153
 
        public class FileEnumerator : GLib.Object {
154
 
                public static GLib.Type get_type ();
155
 
                public bool has_pending ();
156
 
                public bool is_stopped ();
157
 
                public virtual weak GLib.FileInfo next_file (GLib.Cancellable cancellable, GLib.Error error);
158
 
                public virtual void next_files_async (int num_files, int io_priority, GLib.AsyncNextFilesCallback callback, pointer user_data, GLib.Cancellable cancellable);
159
 
                public void set_pending (bool pending);
160
 
                public virtual bool stop (GLib.Cancellable cancellable, GLib.Error error);
161
 
                public virtual void stop_async (int io_priority, GLib.AsyncStopEnumeratingCallback callback, pointer user_data, GLib.Cancellable cancellable);
162
 
        }
163
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
164
 
        public class FileIcon : GLib.Object, GLib.Icon, GLib.LoadableIcon {
165
 
                public weak GLib.File get_file ();
166
 
                public static GLib.Type get_type ();
167
 
                public FileIcon (GLib.File file);
168
 
        }
169
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
170
 
        public class FileInfo : GLib.Object {
171
 
                public weak GLib.FileInfo copy ();
172
 
                public weak string get_attribute_as_string (string attribute);
173
 
                public weak string get_attribute_byte_string (string attribute);
174
 
                public int get_attribute_int32 (string attribute);
175
 
                public int64 get_attribute_int64 (string attribute);
176
 
                public weak string get_attribute_string (string attribute);
177
 
                public GLib.FileAttributeType get_attribute_type (string attribute);
178
 
                public uint get_attribute_uint32 (string attribute);
179
 
                public uint64 get_attribute_uint64 (string attribute);
180
 
                public weak string get_content_type ();
181
 
                public weak string get_display_name ();
182
 
                public weak string get_edit_name ();
183
 
                public GLib.FileType get_file_type ();
184
 
                public GLib.FileFlags get_flags ();
185
 
                public weak string get_icon ();
186
 
                public void get_modification_time (GLib.TimeVal result);
187
 
                public weak string get_name ();
188
 
                public int64 get_size ();
189
 
                public weak string get_symlink_target ();
190
 
                public static GLib.Type get_type ();
191
 
                public bool has_attribute (string attribute);
192
 
                public weak string list_attributes (string name_space);
193
 
                public FileInfo ();
194
 
                public void remove_attribute (string attribute);
195
 
                public void set_attribute_byte_string (string attribute, string value);
196
 
                public void set_attribute_int32 (string attribute, int value);
197
 
                public void set_attribute_int64 (string attribute, int64 value);
198
 
                public void set_attribute_string (string attribute, string value);
199
 
                public void set_attribute_uint32 (string attribute, uint value);
200
 
                public void set_attribute_uint64 (string attribute, uint64 value);
201
 
                public void set_content_type (string content_type);
202
 
                public void set_display_name (string display_name);
203
 
                public void set_edit_name (string edit_name);
204
 
                public void set_file_type (GLib.FileType type);
205
 
                public void set_flags (GLib.FileFlags flags);
206
 
                public void set_icon (string icon);
207
 
                public void set_modification_time (GLib.TimeVal mtime);
208
 
                public void set_name (string name);
209
 
                public void set_size (int64 size);
210
 
                public void set_symlink_target (string symlink_target);
211
 
        }
212
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
213
 
        public class FileInputStream : GLib.InputStream, GLib.Seekable {
214
 
                public virtual weak GLib.FileInfo get_file_info (string attributes, GLib.Cancellable cancellable, GLib.Error error);
215
 
                public static GLib.Type get_type ();
216
 
        }
217
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
218
 
        public class FileMonitor : GLib.Object {
219
 
                public virtual bool cancel ();
220
 
                public static weak GLib.DirectoryMonitor directory (GLib.File file);
221
 
                public void emit_event (GLib.File file, GLib.File other_file, GLib.FileMonitorEvent event_type);
222
 
                public static weak GLib.FileMonitor file (GLib.File file);
223
 
                public static GLib.Type get_type ();
224
 
                public void set_rate_limit (int limit_msecs);
225
 
                public signal void changed (GLib.File file, GLib.File other_file, GLib.FileMonitorEvent event_type);
226
 
        }
227
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
228
 
        public class FileOutputStream : GLib.OutputStream {
229
 
                public virtual weak GLib.FileInfo get_file_info (string attributes, GLib.Cancellable cancellable, GLib.Error error);
230
 
                public void get_final_mtime (GLib.TimeVal mtime);
231
 
                public bool get_should_get_final_mtime ();
232
 
                public static GLib.Type get_type ();
233
 
                public void set_final_mtime (GLib.TimeVal final_mtime);
234
 
                public void set_should_get_final_mtime (bool get_final_mtime);
235
 
        }
236
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
237
 
        public class FilterInputStream : GLib.InputStream {
238
 
                public weak GLib.InputStream get_base_stream ();
239
 
                public static GLib.Type get_type ();
240
 
                [NoAccessorMethod]
241
 
                public weak GLib.InputStream base_stream { get; construct; }
242
 
        }
243
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
244
 
        public class FilterOutputStream : GLib.OutputStream {
245
 
                public weak GLib.OutputStream get_base_stream ();
246
 
                public static GLib.Type get_type ();
247
 
                [NoAccessorMethod]
248
 
                public weak GLib.OutputStream base_stream { get; construct; }
249
 
        }
250
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
251
 
        public class InputStream : GLib.Object {
252
 
                public virtual bool close (GLib.Cancellable cancellable, GLib.Error error);
253
 
                public virtual void close_async (int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
254
 
                public virtual bool close_finish (GLib.AsyncResult result, GLib.Error error);
255
 
                public static GLib.Type get_type ();
256
 
                public bool has_pending ();
257
 
                public bool is_closed ();
258
 
                public virtual long read (pointer buffer, ulong count, GLib.Cancellable cancellable, GLib.Error error);
259
 
                public bool read_all (pointer buffer, ulong count, ulong bytes_read, GLib.Cancellable cancellable, GLib.Error error);
260
 
                public virtual void read_async (pointer buffer, ulong count, int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
261
 
                public virtual long read_finish (GLib.AsyncResult result, GLib.Error error);
262
 
                public void set_pending (bool pending);
263
 
                public virtual long skip (ulong count, GLib.Cancellable cancellable, GLib.Error error);
264
 
                public virtual void skip_async (ulong count, int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
265
 
                public virtual long skip_finish (GLib.AsyncResult result, GLib.Error error);
266
 
        }
267
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
268
 
        public class LocalDirectoryMonitor : GLib.DirectoryMonitor {
269
 
                public static GLib.Type get_type ();
270
 
                public static weak GLib.DirectoryMonitor start (string dirname);
271
 
        }
272
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
273
 
        public class LocalFile : GLib.Object, GLib.File {
274
 
                public static GLib.Type get_type ();
275
 
                public static weak GLib.FileInfo info_get (string basename, string path, GLib.FileAttributeMatcher attribute_matcher, GLib.FileGetInfoFlags flags, GLib.LocalParentFileInfo parent_info, GLib.Error error);
276
 
                public static weak GLib.FileInfo info_get_from_fd (int fd, string attributes, GLib.Error error);
277
 
                public static void info_get_parent_info (string dir, GLib.FileAttributeMatcher attribute_matcher, GLib.LocalParentFileInfo parent_info);
278
 
                public LocalFile (string filename);
279
 
        }
280
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
281
 
        public class LocalFileEnumerator : GLib.FileEnumerator {
282
 
                public static GLib.Type get_type ();
283
 
                public LocalFileEnumerator (string filename, string attributes, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
284
 
        }
285
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
286
 
        public class LocalFileInputStream : GLib.FileInputStream {
287
 
                public static GLib.Type get_type ();
288
 
                public LocalFileInputStream (int fd);
289
 
        }
290
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
291
 
        public class LocalFileMonitor : GLib.FileMonitor {
292
 
                public static GLib.Type get_type ();
293
 
                public static weak GLib.FileMonitor start (string dirname);
294
 
        }
295
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
296
 
        public class LocalFileOutputStream : GLib.FileOutputStream {
297
 
                public static weak GLib.FileOutputStream append (string filename, GLib.Cancellable cancellable, GLib.Error error);
298
 
                public static weak GLib.FileOutputStream create (string filename, GLib.Cancellable cancellable, GLib.Error error);
299
 
                public static GLib.Type get_type ();
300
 
                public static weak GLib.FileOutputStream replace (string filename, ulong mtime, bool make_backup, GLib.Cancellable cancellable, GLib.Error error);
301
 
        }
302
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
303
 
        public class LocalVfs : GLib.Object, GLib.Vfs {
304
 
                public static GLib.Type get_type ();
305
 
                public LocalVfs ();
306
 
        }
307
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
308
 
        public class MemoryInputStream : GLib.InputStream, GLib.Seekable {
309
 
                public static weak GLib.InputStream from_data (pointer data, ulong len);
310
 
                public static GLib.Type get_type ();
311
 
        }
312
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
313
 
        public class MemoryOutputStream : GLib.OutputStream, GLib.Seekable {
314
 
                public static GLib.Type get_type ();
315
 
                public MemoryOutputStream (GLib.ByteArray data);
316
 
                public void set_max_size (uint max_size);
317
 
                [NoAccessorMethod]
318
 
                public weak pointer data { get; set construct; }
319
 
                [NoAccessorMethod]
320
 
                public weak bool free_array { get; set; }
321
 
                [NoAccessorMethod]
322
 
                public weak uint size_limit { get; set; }
323
 
        }
324
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
325
 
        public class MountOperation : GLib.Object {
326
 
                public bool get_anonymous ();
327
 
                public int get_choice ();
328
 
                public weak string get_domain ();
329
 
                public weak string get_password ();
330
 
                public GLib.PasswordSave get_password_save ();
331
 
                public static GLib.Type get_type ();
332
 
                public weak string get_username ();
333
 
                public MountOperation ();
334
 
                public void set_anonymous (bool anonymous);
335
 
                public void set_choice (int choice);
336
 
                public void set_domain (string domain);
337
 
                public void set_password (string password);
338
 
                public void set_password_save (GLib.PasswordSave save);
339
 
                public void set_username (string username);
340
 
                public signal bool ask_password (string message, string default_user, string default_domain, GLib.PasswordFlags flags);
341
 
                public signal bool ask_question (string message, string[] choices);
342
 
                [HasEmitter]
343
 
                public signal void reply (bool abort);
344
 
        }
345
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
346
 
        public class OutputStream : GLib.Object {
347
 
                public virtual bool close (GLib.Cancellable cancellable, GLib.Error error);
348
 
                public virtual void close_async (int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
349
 
                public virtual bool close_finish (GLib.AsyncResult result, GLib.Error error);
350
 
                public virtual bool flush (GLib.Cancellable cancellable, GLib.Error error);
351
 
                public virtual void flush_async (int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
352
 
                public virtual bool flush_finish (GLib.AsyncResult result, GLib.Error error);
353
 
                public static GLib.Type get_type ();
354
 
                public bool has_pending ();
355
 
                public bool is_closed ();
356
 
                public void set_pending (bool pending);
357
 
                public virtual long write (pointer buffer, ulong count, GLib.Cancellable cancellable, GLib.Error error);
358
 
                public bool write_all (pointer buffer, ulong count, ulong bytes_written, GLib.Cancellable cancellable, GLib.Error error);
359
 
                public virtual void write_async (pointer buffer, ulong count, int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
360
 
                public virtual long write_finish (GLib.AsyncResult result, GLib.Error error);
361
 
        }
362
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
363
 
        public class SimpleAsyncResult : GLib.Object, GLib.AsyncResult {
364
 
                public void complete ();
365
 
                public void complete_in_idle ();
366
 
                public bool get_op_res_gboolean ();
367
 
                public pointer get_op_res_gpointer ();
368
 
                public long get_op_res_gssize ();
369
 
                public pointer get_source_tag ();
370
 
                public static GLib.Type get_type ();
371
 
                public SimpleAsyncResult (GLib.Object source_object, GLib.AsyncReadyCallback callback, pointer user_data, pointer source_tag);
372
 
                public SimpleAsyncResult.error (GLib.Object source_object, GLib.AsyncReadyCallback callback, pointer user_data, GLib.Quark domain, int code, string format);
373
 
                public SimpleAsyncResult.from_error (GLib.Object source_object, GLib.AsyncReadyCallback callback, pointer user_data, GLib.Error error);
374
 
                public bool propagate_error (GLib.Error dest);
375
 
                public void run_in_thread (GLib.SimpleAsyncThreadFunc func, int io_priority, GLib.Cancellable cancellable);
376
 
                public void set_error (GLib.Quark domain, int code, string format);
377
 
                public void set_error_va (GLib.Quark domain, int code, string format, pointer args);
378
 
                public void set_from_error (GLib.Error error);
379
 
                public void set_handle_cancellation (bool handle_cancellation);
380
 
                public void set_op_res_gboolean (bool op_res);
381
 
                public void set_op_res_gpointer (pointer op_res, GLib.DestroyNotify destroy_op_res);
382
 
                public void set_op_res_gssize (long op_res);
383
 
        }
384
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
385
 
        public class SocketInputStream : GLib.InputStream {
386
 
                public static GLib.Type get_type ();
387
 
                public SocketInputStream (int fd, bool close_fd_at_close);
388
 
        }
389
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
390
 
        public class SocketOutputStream : GLib.OutputStream {
391
 
                public static GLib.Type get_type ();
392
 
                public SocketOutputStream (int fd, bool close_fd_at_close);
393
 
        }
394
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
395
 
        public class ThemedIcon : GLib.Object, GLib.Icon {
396
 
                public weak string get_names ();
397
 
                public static GLib.Type get_type ();
398
 
                public ThemedIcon (string iconname);
399
 
                public ThemedIcon.from_names (string iconnames);
400
 
        }
401
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
402
 
        public class UnionDrive : GLib.Object, GLib.Drive {
403
 
                public bool child_is_for_monitor (GLib.VolumeMonitor child_monitor);
404
 
                public static GLib.Type get_type ();
405
 
                public bool is_for_child_drive (GLib.Drive child_drive);
406
 
                public UnionDrive (GLib.VolumeMonitor union_monitor, GLib.Drive child_drive, GLib.VolumeMonitor child_monitor);
407
 
        }
408
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
409
 
        public class UnionVolume : GLib.Object, GLib.Volume {
410
 
                public void add_volume (GLib.Volume volume, GLib.VolumeMonitor monitor);
411
 
                public weak GLib.Volume get_child_for_monitor (GLib.VolumeMonitor child_monitor);
412
 
                public static GLib.Type get_type ();
413
 
                public bool has_child_volume (GLib.Volume child_volume);
414
 
                public bool is_last_child (GLib.Volume child_volume);
415
 
                public UnionVolume (GLib.VolumeMonitor union_monitor, GLib.Volume volume, GLib.VolumeMonitor monitor);
416
 
                public void remove_volume (GLib.Volume volume);
417
 
        }
418
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
419
 
        public class UnionVolumeMonitor : GLib.VolumeMonitor {
420
 
                public weak GLib.Drive convert_drive (GLib.Drive child_drive);
421
 
                public weak GLib.List convert_volumes (GLib.List child_volumes);
422
 
                public static GLib.Type get_type ();
423
 
        }
424
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
425
 
        public class UnixDrive : GLib.Object, GLib.Drive {
426
 
                public void disconnected ();
427
 
                public static GLib.Type get_type ();
428
 
                public bool has_mountpoint (string mountpoint);
429
 
                public UnixDrive (GLib.VolumeMonitor volume_monitor, GLib.UnixMountPoint mountpoint);
430
 
                public void set_volume (GLib.UnixVolume volume);
431
 
                public void unset_volume (GLib.UnixVolume volume);
432
 
        }
433
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
434
 
        public class UnixVolume : GLib.Object, GLib.Volume {
435
 
                public static GLib.Type get_type ();
436
 
                public bool has_mountpoint (string mountpoint);
437
 
                public UnixVolume (GLib.VolumeMonitor volume_monitor, GLib.UnixMount mount);
438
 
                public void unmounted ();
439
 
                public void unset_drive (GLib.UnixDrive drive);
440
 
        }
441
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
442
 
        public class UnixVolumeMonitor : GLib.VolumeMonitor {
443
 
                public static GLib.Type get_type ();
444
 
                public weak GLib.UnixDrive lookup_drive_for_mountpoint (string mountpoint);
445
 
                public UnixVolumeMonitor ();
446
 
        }
447
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
448
 
        public class VolumeMonitor : GLib.Object {
449
 
                public virtual weak GLib.List get_connected_drives ();
450
 
                public virtual weak GLib.List get_mounted_volumes ();
451
 
                public static GLib.Type get_type ();
452
 
                public signal void volume_mounted (GLib.Volume volume);
453
 
                public signal void volume_pre_unmount (GLib.Volume volume);
454
 
                public signal void volume_unmounted (GLib.Volume volume);
455
 
                public signal void drive_connected (GLib.Drive drive);
456
 
                public signal void drive_disconnected (GLib.Drive drive);
457
 
        }
458
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
459
 
        public class Win32AppInfo : GLib.Object, GLib.AppInfo {
460
 
                public static GLib.Type get_type ();
461
 
        }
462
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
463
 
        public interface AppInfo {
464
 
                public static weak GLib.AppInfo create_from_commandline (string commandline, string application_name, GLib.Error error);
465
 
                public virtual weak GLib.AppInfo dup ();
466
 
                public virtual bool equal (GLib.AppInfo appinfo2);
467
 
                public virtual weak string get_description ();
468
 
                public virtual weak string get_icon ();
469
 
                public virtual weak string get_name ();
470
 
                public static GLib.Type get_type ();
471
 
                public virtual bool launch (GLib.List filenames, string envp, GLib.Error error);
472
 
                public virtual bool launch_uris (GLib.List uris, string envp, GLib.Error error);
473
 
                public virtual bool set_as_default_for_type (string content_type, GLib.Error error);
474
 
                public virtual bool should_show (string desktop_env);
475
 
                public virtual bool supports_uris ();
476
 
                public virtual bool supports_xdg_startup_notify ();
477
 
        }
478
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
479
 
        public interface AsyncResult {
480
 
                public virtual weak GLib.Object get_source_object ();
481
 
                public static GLib.Type get_type ();
482
 
                public virtual pointer get_user_data ();
483
 
        }
484
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
485
 
        public interface Drive {
486
 
                public virtual bool can_eject ();
487
 
                public virtual bool can_mount ();
488
 
                public virtual void eject (GLib.AsyncReadyCallback callback, pointer user_data);
489
 
                public virtual bool eject_finish (GLib.AsyncResult result, GLib.Error error);
490
 
                public virtual weak string get_icon ();
491
 
                public virtual weak string get_name ();
492
 
                public weak string get_platform_id ();
493
 
                public static GLib.Type get_type ();
494
 
                public virtual weak GLib.List get_volumes ();
495
 
                public virtual bool is_automounted ();
496
 
                public virtual void mount (GLib.MountOperation mount_operation, GLib.AsyncReadyCallback callback, pointer user_data);
497
 
                public virtual bool mount_finish (GLib.AsyncResult result, GLib.Error error);
498
 
                public signal void changed ();
499
 
        }
500
 
        [CCode (cheader_filename = "gio/gfile.h")]
501
 
        public interface File {
502
 
                public virtual weak GLib.FileOutputStream append_to (GLib.Cancellable cancellable, GLib.Error error);
503
 
                public virtual bool copy (GLib.File destination, GLib.FileCopyFlags flags, GLib.Cancellable cancellable, GLib.FileProgressCallback progress_callback, pointer progress_callback_data, GLib.Error error);
504
 
                public virtual weak GLib.FileOutputStream create (GLib.Cancellable cancellable, GLib.Error error);
505
 
                public bool delete (GLib.Cancellable cancellable, GLib.Error error);
506
 
                public virtual weak GLib.File dup ();
507
 
                public virtual void eject_mountable (GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
508
 
                public virtual bool eject_mountable_finish (GLib.AsyncResult result, GLib.Error error);
509
 
                public virtual weak GLib.FileEnumerator enumerate_children (string attributes, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
510
 
                public virtual bool equal (GLib.File file2);
511
 
                public virtual weak string get_basename ();
512
 
                public weak GLib.File get_child (string name);
513
 
                public virtual weak GLib.File get_child_for_display_name (string display_name, GLib.Error error);
514
 
                public void get_contents_async (GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
515
 
                public bool get_contents_finish (GLib.AsyncResult res, string contents, ulong length, GLib.Error error);
516
 
                public virtual weak GLib.FileInfo get_filesystem_info (string attributes, GLib.Cancellable cancellable, GLib.Error error);
517
 
                public static weak GLib.File get_for_commandline_arg (string arg);
518
 
                public static weak GLib.File get_for_path (string path);
519
 
                public static weak GLib.File get_for_uri (string uri);
520
 
                public virtual weak GLib.FileInfo get_info (string attributes, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
521
 
                public virtual weak GLib.File get_parent ();
522
 
                public virtual weak string get_parse_name ();
523
 
                public virtual weak string get_path ();
524
 
                public static GLib.Type get_type ();
525
 
                public virtual weak string get_uri ();
526
 
                public static uint hash (pointer file);
527
 
                public virtual bool is_native ();
528
 
                public virtual bool make_directory (GLib.Cancellable cancellable, GLib.Error error);
529
 
                public virtual bool make_symbolic_link (string symlink_value, GLib.Cancellable cancellable, GLib.Error error);
530
 
                public virtual void mount_mountable (GLib.MountOperation mount_operation, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
531
 
                public virtual weak GLib.File mount_mountable_finish (GLib.AsyncResult result, GLib.Error error);
532
 
                public virtual bool move (GLib.File destination, GLib.FileCopyFlags flags, GLib.Cancellable cancellable, GLib.FileProgressCallback progress_callback, pointer progress_callback_data, GLib.Error error);
533
 
                public static weak GLib.File parse_name (string parse_name);
534
 
                public virtual weak GLib.FileInputStream read (GLib.Cancellable cancellable, GLib.Error error);
535
 
                public virtual void read_async (int io_priority, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
536
 
                public virtual weak GLib.FileInputStream read_finish (GLib.AsyncResult res, GLib.Error error);
537
 
                public virtual weak GLib.FileOutputStream replace (ulong mtime, bool make_backup, GLib.Cancellable cancellable, GLib.Error error);
538
 
                public virtual weak GLib.File resolve_relative (string relative_path);
539
 
                public virtual bool set_attribute (string attribute, GLib.FileAttributeType type, pointer value, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
540
 
                public bool set_attribute_byte_string (string attribute, string value, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
541
 
                public bool set_attribute_int32 (string attribute, string value, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
542
 
                public bool set_attribute_int64 (string attribute, int64 value, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
543
 
                public bool set_attribute_string (string attribute, string value, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
544
 
                public bool set_attribute_uint32 (string attribute, uint value, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
545
 
                public bool set_attribute_uint64 (string attribute, uint64 value, GLib.FileGetInfoFlags flags, GLib.Cancellable cancellable, GLib.Error error);
546
 
                public virtual weak GLib.File set_display_name (string display_name, GLib.Cancellable cancellable, GLib.Error error);
547
 
                public virtual bool trash (GLib.Cancellable cancellable, GLib.Error error);
548
 
                public virtual void unmount_mountable (GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
549
 
                public virtual bool unmount_mountable_finish (GLib.AsyncResult result, GLib.Error error);
550
 
        }
551
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
552
 
        public interface Icon {
553
 
                public virtual bool equal (GLib.Icon icon2);
554
 
                public static GLib.Type get_type ();
555
 
                public static uint hash (pointer icon);
556
 
        }
557
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
558
 
        public interface LoadableIcon {
559
 
                public static GLib.Type get_type ();
560
 
                public virtual weak GLib.InputStream load (int size, string type, GLib.Cancellable cancellable, GLib.Error error);
561
 
                public virtual void load_async (int size, GLib.Cancellable cancellable, GLib.AsyncReadyCallback callback, pointer user_data);
562
 
                public virtual weak GLib.InputStream load_finish (GLib.AsyncResult res, string type, GLib.Error error);
563
 
        }
564
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
565
 
        public interface Seekable {
566
 
                public virtual bool can_seek ();
567
 
                public virtual bool can_truncate ();
568
 
                public static GLib.Type get_type ();
569
 
                public virtual bool seek (int64 offset, GLib.SeekType type, GLib.Cancellable cancellable, GLib.Error err);
570
 
                public virtual int64 tell ();
571
 
                public virtual bool truncate (int64 offset, GLib.Cancellable cancellable, GLib.Error err);
572
 
        }
573
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
574
 
        public interface Vfs {
575
 
                public static weak GLib.Vfs get ();
576
 
                public virtual weak GLib.File get_file_for_path (string path);
577
 
                public virtual weak GLib.File get_file_for_uri (string uri);
578
 
                public static GLib.Type get_type ();
579
 
                public virtual weak GLib.File parse_name (string parse_name);
580
 
        }
581
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
582
 
        public interface Volume {
583
 
                public virtual bool can_eject ();
584
 
                public virtual bool can_unmount ();
585
 
                public virtual void eject (GLib.AsyncReadyCallback callback, pointer user_data);
586
 
                public virtual bool eject_finish (GLib.AsyncResult result, GLib.Error error);
587
 
                public virtual weak GLib.Drive get_drive ();
588
 
                public virtual weak string get_icon ();
589
 
                public virtual weak string get_name ();
590
 
                public virtual weak string get_platform_id ();
591
 
                public virtual weak GLib.File get_root ();
592
 
                public static GLib.Type get_type ();
593
 
                public virtual void unmount (GLib.AsyncReadyCallback callback, pointer user_data);
594
 
                public virtual bool unmount_finish (GLib.AsyncResult result, GLib.Error error);
595
 
                public signal void changed ();
596
 
        }
597
 
        [ReferenceType]
598
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
599
 
        public struct AsyncResultData {
600
 
                public pointer async_object;
601
 
                public weak GLib.Error error;
602
 
                public pointer user_data;
603
 
        }
604
 
        [ReferenceType]
605
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
606
 
        public struct FileAttributeMatcher {
607
 
                public bool enumerate_namespace (string @namespace);
608
 
                public weak string enumerate_next ();
609
 
                public void free ();
610
 
                public bool matches (string full_name);
611
 
                public bool matches_only (string full_name);
612
 
                public FileAttributeMatcher (string attributes);
613
 
        }
614
 
        [ReferenceType]
615
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
616
 
        public struct IOJob {
617
 
                public void send_to_mainloop (GLib.IODataFunc func, pointer user_data, GLib.DestroyNotify notify, bool block);
618
 
        }
619
 
        [ReferenceType]
620
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
621
 
        public struct LocalParentFileInfo {
622
 
                public bool writable;
623
 
                public bool is_sticky;
624
 
                public int owner;
625
 
        }
626
 
        [ReferenceType]
627
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
628
 
        public struct UnixMount {
629
 
                public weak string mount_path;
630
 
                public weak string device_path;
631
 
                public weak string filesystem_type;
632
 
                public bool is_read_only;
633
 
        }
634
 
        [ReferenceType]
635
 
        [CCode (cheader_filename = "gio/gvfs.h,glib.h")]
636
 
        public struct UnixMountPoint {
637
 
                public weak string mount_path;
638
 
                public weak string device_path;
639
 
                public weak string filesystem_type;
640
 
                public weak string dev_opt;
641
 
                public bool is_read_only;
642
 
                public bool is_user_mountable;
643
 
                public bool is_loopback;
644
 
        }
645
 
        public static delegate void AsyncNextFilesCallback (GLib.FileEnumerator enumerator, GLib.List files, int num_files, pointer user_data, GLib.Error error);
646
 
        public static delegate void AsyncReadyCallback (GLib.Object source_object, GLib.AsyncResult res, pointer user_data);
647
 
        public static delegate void AsyncStopEnumeratingCallback (GLib.FileEnumerator enumerator, bool result, pointer user_data, GLib.Error error);
648
 
        public static delegate bool FDSourceFunc (pointer user_data, GLib.IOCondition condition, int fd);
649
 
        public static delegate void FileProgressCallback (int64 current_num_bytes, int64 total_num_bytes, pointer user_data);
650
 
        public static delegate void IODataFunc (pointer user_data);
651
 
        public static delegate void IOJobFunc (GLib.IOJob job, GLib.Cancellable cancellable, pointer user_data);
652
 
        public static delegate void SimpleAsyncThreadFunc (GLib.SimpleAsyncResult res, GLib.Object object, GLib.Cancellable cancellable);
653
 
        public static delegate void UnixMountCallback (pointer user_data);
654
 
}