• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* GIO - GLib Input, Output and Streaming Library
2  *
3  * Copyright (C) 2006-2007 Red Hat, Inc.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General
16  * Public License along with this library; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18  * Boston, MA 02111-1307, USA.
19  *
20  * Author: Alexander Larsson <alexl@redhat.com>
21  */
22 
23 #if !defined (__GIO_GIO_H_INSIDE__) && !defined (GIO_COMPILATION)
24 #error "Only <gio/gio.h> can be included directly."
25 #endif
26 
27 #ifndef __G_FILE_INFO_H__
28 #define __G_FILE_INFO_H__
29 
30 #include <gio/giotypes.h>
31 
32 G_BEGIN_DECLS
33 
34 #define G_TYPE_FILE_INFO         (g_file_info_get_type ())
35 #define G_FILE_INFO(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_FILE_INFO, GFileInfo))
36 #define G_FILE_INFO_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_FILE_INFO, GFileInfoClass))
37 #define G_IS_FILE_INFO(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_FILE_INFO))
38 #define G_IS_FILE_INFO_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_FILE_INFO))
39 #define G_FILE_INFO_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_FILE_INFO, GFileInfoClass))
40 
41 /**
42  * GFileInfo:
43  *
44  * Stores information about a file system object referenced by a #GFile.
45  **/
46 typedef struct _GFileInfoClass   GFileInfoClass;
47 
48 
49 /* Common Attributes:  */
50 /**
51  * G_FILE_ATTRIBUTE_STANDARD_TYPE:
52  *
53  * A key in the "standard" namespace for storing file types.
54  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
55  * The value for this key should contain a #GFileType.
56  **/
57 #define G_FILE_ATTRIBUTE_STANDARD_TYPE "standard::type"                     /* uint32 (GFileType) */
58 
59 /**
60  * G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN:
61  *
62  * A key in the "standard" namespace for checking if a file is hidden.
63  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
64  **/
65 #define G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN "standard::is-hidden"           /* boolean */
66 
67 /**
68  * G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP:
69  *
70  * A key in the "standard" namespace for checking if a file is a backup file.
71  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
72  **/
73 #define G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP "standard::is-backup"           /* boolean */
74 
75 /**
76  * G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK:
77  *
78  * A key in the "standard" namespace for checking if the file is a symlink.
79  * Typically the actual type is something else, if we followed the symlink
80  * to get the type.
81  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
82  **/
83 #define G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK "standard::is-symlink"         /* boolean */
84 
85 /**
86  * G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL:
87  *
88  * A key in the "standard" namespace for checking if a file is virtual.
89  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
90  **/
91 #define G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL "standard::is-virtual"         /* boolean */
92 
93 /**
94  * G_FILE_ATTRIBUTE_STANDARD_NAME:
95  *
96  * A key in the "standard" namespace for getting the name of the file.
97  * The name is the on-disk filename which may not be in any known encoding,
98  * and can thus not be generally displayed as is.
99  * Use #G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME if you need to display the
100  * name in a user interface.
101  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
102  **/
103 #define G_FILE_ATTRIBUTE_STANDARD_NAME "standard::name"                     /* byte string */
104 
105 /**
106  * G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME:
107  *
108  * A key in the "standard" namespace for getting the display name of the file.
109  * A display name is guaranteed to be in UTF8 and can thus be displayed in
110  * the UI.
111  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
112  **/
113 #define G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "standard::display-name"     /* string */
114 
115 /**
116  * G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME:
117  *
118  * A key in the "standard" namespace for edit name of the file.
119  * An edit name is similar to the display name, but it is meant to be
120  * used when you want to rename the file in the UI. The display name
121  * might contain information you don't want in the new filename (such as
122  * "(invalid unicode)" if the filename was in an invalid encoding).
123  *
124  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
125  **/
126 #define G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME "standard::edit-name"           /* string */
127 
128 /**
129  * G_FILE_ATTRIBUTE_STANDARD_COPY_NAME:
130  *
131  * A key in the "standard" namespace for getting the copy name of the file.
132  * The copy name is an optional version of the name. If available it's always
133  * in UTF8, and corresponds directly to the original filename (only transcoded to
134  * UTF8). This is useful if you want to copy the file to another filesystem that
135  * might have a different encoding. If the filename is not a valid string in the
136  * encoding selected for the filesystem it is in then the copy name will not be set.
137  *
138  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
139  **/
140 #define G_FILE_ATTRIBUTE_STANDARD_COPY_NAME "standard::copy-name"           /* string */
141 
142 /**
143  * G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION:
144  *
145  * A key in the "standard" namespace for getting the description of the file.
146  * The description is a utf8 string that describes the file, generally containing
147  * the filename, but can also contain furter information. Example descriptions
148  * could be "filename (on hostname)" for a remote file or "filename (in trash)"
149  * for a file in the trash. This is useful for instance as the window title
150  * when displaying a directory or for a bookmarks menu.
151  *
152  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
153  **/
154 #define G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION "standard::description"        /* string */
155 
156 /**
157  * G_FILE_ATTRIBUTE_STANDARD_ICON:
158  *
159  * A key in the "standard" namespace for getting the icon for the file.
160  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.
161  * The value for this key should contain a #GIcon.
162  **/
163 #define G_FILE_ATTRIBUTE_STANDARD_ICON "standard::icon"                     /* object (GIcon) */
164 
165 /**
166  * G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE:
167  *
168  * A key in the "standard" namespace for getting the content type of the file.
169  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
170  * The value for this key should contain a valid content type.
171  **/
172 #define G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE "standard::content-type"     /* string */
173 
174 /**
175  * G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE:
176  *
177  * A key in the "standard" namespace for getting the fast content type.
178  * The fast content type isn't as reliable as the regular one, as it
179  * only uses the filename to guess it, but it is faster to calculate than the
180  * regular content type.
181  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
182  *
183  **/
184 #define G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE "standard::fast-content-type" /* string */
185 
186 /**
187  * G_FILE_ATTRIBUTE_STANDARD_SIZE:
188  *
189  * A key in the "standard" namespace for getting the file's size (in bytes).
190  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
191  **/
192 #define G_FILE_ATTRIBUTE_STANDARD_SIZE "standard::size"                     /* uint64 */
193 
194 /**
195  * G_FILE_ATTRIBUTE_ALLOCATED_SIZE:
196  *
197  * A key in the "standard" namespace for getting the amount of disk space
198  * that is consumed by the file (in bytes).  This will generally be larger
199  * than the file size (due to block size overhead) but can occasionally be
200  * smaller (for example, for sparse files).
201  *
202  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
203  **/
204 #define G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE "standard::allocated-size" /* uint64 */
205 
206 /**
207  * G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET:
208  *
209  * A key in the "standard" namespace for getting the symlink target, if the file
210  * is a symlink. Corresponding #GFileAttributeType is
211  * %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
212  **/
213 #define G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET "standard::symlink-target" /* byte string */
214 
215 /**
216  * G_FILE_ATTRIBUTE_STANDARD_TARGET_URI:
217  *
218  * A key in the "standard" namespace for getting the target URI for the file, in
219  * the case of %G_FILE_TYPE_SHORTCUT or %G_FILE_TYPE_MOUNTABLE files.
220  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
221  **/
222 #define G_FILE_ATTRIBUTE_STANDARD_TARGET_URI "standard::target-uri"         /* string */
223 
224 /**
225  * G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER:
226  *
227  * A key in the "standard" namespace for setting the sort order of a file.
228  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_INT32.
229  * An example use would be in file managers, which would use this key
230  * to set the order files are displayed. Files with smaller sort order
231  * should be sorted first, and files without sort order as if sort order
232  * was zero.
233  **/
234 #define G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER "standard::sort-order"         /* int32  */
235 
236 /* Entity tags, used to avoid missing updates on save */
237 
238 /**
239  * G_FILE_ATTRIBUTE_ETAG_VALUE:
240  *
241  * A key in the "etag" namespace for getting the value of the file's
242  * entity tag. Corresponding #GFileAttributeType is
243  * %G_FILE_ATTRIBUTE_TYPE_STRING.
244  **/
245 #define G_FILE_ATTRIBUTE_ETAG_VALUE "etag::value"                 /* string */
246 
247 /* File identifier, for e.g. avoiding loops when doing recursive
248  * directory scanning
249  */
250 
251 /**
252  * G_FILE_ATTRIBUTE_ID_FILE:
253  *
254  * A key in the "id" namespace for getting a file identifier.
255  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
256  * An example use would be during listing files, to avoid recursive
257  * directory scanning.
258  **/
259 #define G_FILE_ATTRIBUTE_ID_FILE "id::file"                     /* string */
260 
261 /**
262  * G_FILE_ATTRIBUTE_ID_FILESYSTEM:
263  *
264  * A key in the "id" namespace for getting the file system identifier.
265  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
266  * An example use would be during drag and drop to see if the source
267  * and target are on the same filesystem (default to move) or not (default
268  * to copy).
269  **/
270 #define G_FILE_ATTRIBUTE_ID_FILESYSTEM "id::filesystem"         /* string */
271 
272 /* Calculated Access Rights for current user */
273 
274 /**
275  * G_FILE_ATTRIBUTE_ACCESS_CAN_READ:
276  *
277  * A key in the "access" namespace for getting read privileges.
278  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
279  * This attribute will be %TRUE if the user is able to read the file.
280  **/
281 #define G_FILE_ATTRIBUTE_ACCESS_CAN_READ "access::can-read"       /* boolean */
282 
283 /**
284  * G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE:
285  *
286  * A key in the "access" namespace for getting write privileges.
287  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
288  * This attribute will be %TRUE if the user is able to write to the file.
289  **/
290 #define G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE "access::can-write"     /* boolean */
291 
292 /**
293  * G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE:
294  *
295  * A key in the "access" namespace for getting execution privileges.
296  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
297  * This attribute will be %TRUE if the user is able to execute the file.
298  **/
299 #define G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE "access::can-execute" /* boolean */
300 
301 /**
302  * G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE:
303  *
304  * A key in the "access" namespace for checking deletion privileges.
305  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
306  * This attribute will be %TRUE if the user is able to delete the file.
307  **/
308 #define G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE "access::can-delete"   /* boolean */
309 
310 /**
311  * G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH:
312  *
313  * A key in the "access" namespace for checking trashing privileges.
314  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
315  * This attribute will be %TRUE if the user is able to move the file to
316  * the trash.
317  **/
318 #define G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH "access::can-trash"     /* boolean */
319 
320 /**
321  * G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME:
322  *
323  * A key in the "access" namespace for checking renaming privileges.
324  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
325  * This attribute will be %TRUE if the user is able to rename the file.
326  **/
327 #define G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME "access::can-rename"   /* boolean */
328 
329 /* TODO: Should we have special version for directories? can_enumerate, etc */
330 
331 /* Mountable attributes */
332 
333 /**
334  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT:
335  *
336  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) is mountable.
337  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
338  **/
339 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT "mountable::can-mount"     /* boolean */
340 
341 /**
342  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT:
343  *
344  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE)  is unmountable.
345  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
346  **/
347 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT "mountable::can-unmount" /* boolean */
348 
349 /**
350  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT:
351  *
352  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be ejected.
353  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
354  **/
355 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT "mountable::can-eject"     /* boolean */
356 
357 /**
358  * G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE:
359  *
360  * A key in the "mountable" namespace for getting the unix device.
361  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
362  **/
363 #define G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE "mountable::unix-device" /* uint32 */
364 
365 /**
366  * G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI:
367  *
368  * A key in the "mountable" namespace for getting the HAL UDI for the mountable
369  * file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
370  **/
371 #define G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI "mountable::hal-udi"         /* string */
372 
373 /* Time attributes */
374 
375 /**
376  * G_FILE_ATTRIBUTE_TIME_MODIFIED:
377  *
378  * A key in the "time" namespace for getting the time the file was last
379  * modified. Corresponding #GFileAttributeType is
380  * %G_FILE_ATTRIBUTE_TYPE_UINT64, and contains the UNIX time since the
381  * file was modified.
382  **/
383 #define G_FILE_ATTRIBUTE_TIME_MODIFIED "time::modified"           /* uint64 */
384 
385 /**
386  * G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC:
387  *
388  * A key in the "time" namespace for getting the miliseconds of the time
389  * the file was last modified. This should be used in conjunction with
390  * #G_FILE_ATTRIBUTE_TIME_MODIFIED. Corresponding #GFileAttributeType is
391  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
392  **/
393 #define G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC "time::modified-usec" /* uint32 */
394 
395 /**
396  * G_FILE_ATTRIBUTE_TIME_ACCESS:
397  *
398  * A key in the "time" namespace for getting the time the file was last
399  * accessed. Corresponding #GFileAttributeType is
400  * %G_FILE_ATTRIBUTE_TYPE_UINT64, and contains the UNIX time since the
401  * file was last accessed.
402  **/
403 #define G_FILE_ATTRIBUTE_TIME_ACCESS "time::access"               /* uint64 */
404 
405 /**
406  * G_FILE_ATTRIBUTE_TIME_ACCESS_USEC:
407  *
408  * A key in the "time" namespace for getting the microseconds of the time
409  * the file was last accessed. This should be used in conjunction with
410  * #G_FILE_ATTRIBUTE_TIME_ACCESS. Corresponding #GFileAttributeType is
411  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
412  **/
413 #define G_FILE_ATTRIBUTE_TIME_ACCESS_USEC "time::access-usec"     /* uint32 */
414 
415 /**
416  * G_FILE_ATTRIBUTE_TIME_CHANGED:
417  *
418  * A key in the "time" namespace for getting the time the file was last
419  * changed. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
420  * and contains the UNIX time since the file was last changed.
421  *
422  * This corresponds to the traditional UNIX ctime.
423  **/
424 #define G_FILE_ATTRIBUTE_TIME_CHANGED "time::changed"             /* uint64 */
425 
426 /**
427  * G_FILE_ATTRIBUTE_TIME_CHANGED_USEC:
428  *
429  * A key in the "time" namespace for getting the microseconds of the time
430  * the file was last changed. This should be used in conjunction with
431  * #G_FILE_ATTRIBUTE_TIME_CHANGED. Corresponding #GFileAttributeType is
432  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
433  **/
434 #define G_FILE_ATTRIBUTE_TIME_CHANGED_USEC "time::changed-usec"   /* uint32 */
435 
436 /**
437  * G_FILE_ATTRIBUTE_TIME_CREATED:
438  *
439  * A key in the "time" namespace for getting the time the file was created.
440  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
441  * and contains the UNIX time since the file was created.
442  *
443  * This corresponds to the NTFS ctime.
444  **/
445 #define G_FILE_ATTRIBUTE_TIME_CREATED "time::created"             /* uint64 */
446 
447 /**
448  * G_FILE_ATTRIBUTE_TIME_CREATED_USEC:
449  *
450  * A key in the "time" namespace for getting the microseconds of the time
451  * the file was created. This should be used in conjunction with
452  * #G_FILE_ATTRIBUTE_TIME_CREATED. Corresponding #GFileAttributeType is
453  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
454  **/
455 #define G_FILE_ATTRIBUTE_TIME_CREATED_USEC "time::created-usec"   /* uint32 */
456 
457 /* Unix specific attributes */
458 
459 /**
460  * G_FILE_ATTRIBUTE_UNIX_DEVICE:
461  *
462  * A key in the "unix" namespace for getting the device id of the device the
463  * file is located on (see stat() documentation). This attribute is only
464  * available for UNIX file systems. Corresponding #GFileAttributeType is
465  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
466  **/
467 #define G_FILE_ATTRIBUTE_UNIX_DEVICE "unix::device"               /* uint32 */
468 
469 /**
470  * G_FILE_ATTRIBUTE_UNIX_INODE:
471  *
472  * A key in the "unix" namespace for getting the inode of the file.
473  * This attribute is only available for UNIX file systems. Corresponding
474  * #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
475  **/
476 #define G_FILE_ATTRIBUTE_UNIX_INODE "unix::inode"                 /* uint64 */
477 
478 /**
479  * G_FILE_ATTRIBUTE_UNIX_MODE:
480  *
481  * A key in the "unix" namespace for getting the mode of the file
482  * (e.g. whether the file is a regular file, symlink, etc). See lstat()
483  * documentation. This attribute is only available for UNIX file systems.
484  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
485  **/
486 #define G_FILE_ATTRIBUTE_UNIX_MODE "unix::mode"                   /* uint32 */
487 
488 /**
489  * G_FILE_ATTRIBUTE_UNIX_NLINK:
490  *
491  * A key in the "unix" namespace for getting the number of hard links
492  * for a file. See lstat() documentation. This attribute is only available
493  * for UNIX file systems. Corresponding #GFileAttributeType is
494  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
495  **/
496 #define G_FILE_ATTRIBUTE_UNIX_NLINK "unix::nlink"                 /* uint32 */
497 
498 /**
499  * G_FILE_ATTRIBUTE_UNIX_UID:
500  *
501  * A key in the "unix" namespace for getting the user ID for the file.
502  * This attribute is only available for UNIX file systems.
503  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
504  **/
505 #define G_FILE_ATTRIBUTE_UNIX_UID "unix::uid"                     /* uint32 */
506 
507 /**
508  * G_FILE_ATTRIBUTE_UNIX_GID:
509  *
510  * A key in the "unix" namespace for getting the group ID for the file.
511  * This attribute is only available for UNIX file systems.
512  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
513  **/
514 #define G_FILE_ATTRIBUTE_UNIX_GID "unix::gid"                     /* uint32 */
515 
516 /**
517  * G_FILE_ATTRIBUTE_UNIX_RDEV:
518  *
519  * A key in the "unix" namespace for getting the device ID for the file
520  * (if it is a special file). See lstat() documentation. This attribute
521  * is only available for UNIX file systems. Corresponding #GFileAttributeType
522  * is %G_FILE_ATTRIBUTE_TYPE_UINT32.
523  **/
524 #define G_FILE_ATTRIBUTE_UNIX_RDEV "unix::rdev"                   /* uint32 */
525 
526 /**
527  * G_FILE_ATTRIBUTE_UNIX_BLOCK_SIZE:
528  *
529  * A key in the "unix" namespace for getting the block size for the file
530  * system. This attribute is only available for UNIX file systems.
531  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
532  **/
533 #define G_FILE_ATTRIBUTE_UNIX_BLOCK_SIZE "unix::block-size"       /* uint32 */
534 
535 /**
536  * G_FILE_ATTRIBUTE_UNIX_BLOCKS:
537  *
538  * A key in the "unix" namespace for getting the number of blocks allocated
539  * for the file. This attribute is only available for UNIX file systems.
540  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
541  **/
542 #define G_FILE_ATTRIBUTE_UNIX_BLOCKS "unix::blocks"               /* uint64 */
543 
544 /**
545  * G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT:
546  *
547  * A key in the "unix" namespace for checking if the file represents a
548  * UNIX mount point. This attribute is %TRUE if the file is a UNIX mount
549  * point. This attribute is only available for UNIX file systems.
550  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
551  **/
552 #define G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT "unix::is-mountpoint" /* boolean */
553 
554 /* DOS specific attributes */
555 
556 /**
557  * G_FILE_ATTRIBUTE_DOS_IS_ARCHIVE:
558  *
559  * A key in the "dos" namespace for checking if the file's archive flag
560  * is set. This attribute is %TRUE if the archive flag is set. This attribute
561  * is only available for DOS file systems. Corresponding #GFileAttributeType
562  * is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
563  **/
564 #define G_FILE_ATTRIBUTE_DOS_IS_ARCHIVE "dos::is-archive"         /* boolean */
565 
566 /**
567  * G_FILE_ATTRIBUTE_DOS_IS_SYSTEM:
568  *
569  * A key in the "dos" namespace for checking if the file's backup flag
570  * is set. This attribute is %TRUE if the backup flag is set. This attribute
571  * is only available for DOS file systems. Corresponding #GFileAttributeType
572  * is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
573  **/
574 #define G_FILE_ATTRIBUTE_DOS_IS_SYSTEM "dos::is-system"           /* boolean */
575 
576 /* Owner attributes */
577 
578 /**
579  * G_FILE_ATTRIBUTE_OWNER_USER:
580  *
581  * A key in the "owner" namespace for getting the user name of the
582  * file's owner. Corresponding #GFileAttributeType is
583  * %G_FILE_ATTRIBUTE_TYPE_STRING.
584  **/
585 #define G_FILE_ATTRIBUTE_OWNER_USER "owner::user"                 /* string */
586 
587 /**
588  * G_FILE_ATTRIBUTE_OWNER_USER_REAL:
589  *
590  * A key in the "owner" namespace for getting the real name of the
591  * user that owns the file. Corresponding #GFileAttributeType is
592  * %G_FILE_ATTRIBUTE_TYPE_STRING.
593  **/
594 #define G_FILE_ATTRIBUTE_OWNER_USER_REAL "owner::user-real"       /* string */
595 
596 /**
597  * G_FILE_ATTRIBUTE_OWNER_GROUP:
598  *
599  * A key in the "owner" namespace for getting the file owner's group.
600  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
601  **/
602 #define G_FILE_ATTRIBUTE_OWNER_GROUP "owner::group"               /* string */
603 
604 /* Thumbnails */
605 
606 /**
607  * G_FILE_ATTRIBUTE_THUMBNAIL_PATH:
608  *
609  * A key in the "thumbnail" namespace for getting the path to the thumbnail
610  * image. Corresponding #GFileAttributeType is
611  * %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
612  **/
613 #define G_FILE_ATTRIBUTE_THUMBNAIL_PATH "thumbnail::path"         /* bytestring */
614 /**
615  * G_FILE_ATTRIBUTE_THUMBNAILING_FAILED:
616  *
617  * A key in the "thumbnail" namespace for checking if thumbnailing failed.
618  * This attribute is %TRUE if thumbnailing failed. Corresponding
619  * #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
620  **/
621 #define G_FILE_ATTRIBUTE_THUMBNAILING_FAILED "thumbnail::failed"         /* boolean */
622 
623 /* Preview */
624 
625 /**
626  * G_FILE_ATTRIBUTE_PREVIEW_ICON:
627  *
628  * A key in the "preview" namespace for getting a #GIcon that can be
629  * used to get preview of the file. For example, it may be a low
630  * resolution thumbnail without metadata. Corresponding
631  * #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.  The value
632  * for this key should contain a #GIcon.
633  *
634  * Since: 2.20
635  **/
636 #define G_FILE_ATTRIBUTE_PREVIEW_ICON "preview::icon"         /* object (GIcon) */
637 
638 /* File system info (for g_file_get_filesystem_info) */
639 
640 /**
641  * G_FILE_ATTRIBUTE_FILESYSTEM_SIZE:
642  *
643  * A key in the "filesystem" namespace for getting the total size (in bytes) of the file system,
644  * used in g_file_query_filesystem_info(). Corresponding #GFileAttributeType
645  * is %G_FILE_ATTRIBUTE_TYPE_UINT64.
646  **/
647 #define G_FILE_ATTRIBUTE_FILESYSTEM_SIZE "filesystem::size"                       /* uint64 */
648 
649 /**
650  * G_FILE_ATTRIBUTE_FILESYSTEM_FREE:
651  *
652  * A key in the "filesystem" namespace for getting the number of bytes of free space left on the
653  * file system. Corresponding #GFileAttributeType is
654  * %G_FILE_ATTRIBUTE_TYPE_UINT64.
655  **/
656 #define G_FILE_ATTRIBUTE_FILESYSTEM_FREE "filesystem::free"                       /* uint64 */
657 
658 /**
659  * G_FILE_ATTRIBUTE_FILESYSTEM_TYPE:
660  *
661  * A key in the "filesystem" namespace for getting the file system's type.
662  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
663  **/
664 #define G_FILE_ATTRIBUTE_FILESYSTEM_TYPE "filesystem::type"                       /* string */
665 
666 /**
667  * G_FILE_ATTRIBUTE_FILESYSTEM_READONLY:
668  *
669  * A key in the "filesystem" namespace for checking if the file system
670  * is read only. Is set to %TRUE if the file system is read only.
671  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
672  **/
673 #define G_FILE_ATTRIBUTE_FILESYSTEM_READONLY "filesystem::readonly"               /* boolean */
674 
675 /**
676  * G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW:
677  *
678  * A key in the "filesystem" namespace for hinting a file manager
679  * application whether it should preview (e.g. thumbnail) files on the
680  * file system. The value for this key contain a
681  * #GFilesystemPreviewType.
682  **/
683 #define G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW "filesystem::use-preview"        /* uint32 (GFilesystemPreviewType) */
684 
685 /**
686  * G_FILE_ATTRIBUTE_GVFS_BACKEND:
687  *
688  * A key in the "gvfs" namespace that gets the name of the current
689  * GVFS backend in use. Corresponding #GFileAttributeType is
690  * %G_FILE_ATTRIBUTE_TYPE_STRING.
691  **/
692 #define G_FILE_ATTRIBUTE_GVFS_BACKEND "gvfs::backend"             /* string */
693 
694 /**
695  * G_FILE_ATTRIBUTE_SELINUX_CONTEXT:
696  *
697  * A key in the "selinux" namespace for getting the file's SELinux
698  * context. Corresponding #GFileAttributeType is
699  * %G_FILE_ATTRIBUTE_TYPE_STRING. Note that this attribute is only
700  * available if GLib has been built with SELinux support.
701  **/
702 #define G_FILE_ATTRIBUTE_SELINUX_CONTEXT "selinux::context"       /* string */
703 
704 /**
705  * G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT:
706  *
707  * A key in the "trash" namespace.  When requested against
708  * "trash:///" returns the number of (toplevel) items in the trash folder.
709  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
710  **/
711 #define G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT "trash::item-count"     /* uint32 */
712 
713 GType              g_file_info_get_type                  (void) G_GNUC_CONST;
714 
715 GFileInfo *        g_file_info_new                       (void);
716 GFileInfo *        g_file_info_dup                       (GFileInfo  *other);
717 void               g_file_info_copy_into                 (GFileInfo  *src_info,
718 							  GFileInfo  *dest_info);
719 gboolean           g_file_info_has_attribute             (GFileInfo  *info,
720 							  const char *attribute);
721 char **            g_file_info_list_attributes           (GFileInfo  *info,
722 							  const char *name_space);
723 gboolean           g_file_info_get_attribute_data        (GFileInfo  *info,
724 							  const char *attribute,
725 							  GFileAttributeType *type,
726 							  gpointer   *value_pp,
727 							  GFileAttributeStatus *status);
728 GFileAttributeType g_file_info_get_attribute_type        (GFileInfo  *info,
729 							  const char *attribute);
730 void               g_file_info_remove_attribute          (GFileInfo  *info,
731 							  const char *attribute);
732 GFileAttributeStatus g_file_info_get_attribute_status    (GFileInfo  *info,
733 							  const char *attribute);
734 char *             g_file_info_get_attribute_as_string   (GFileInfo  *info,
735 							  const char *attribute);
736 const char *       g_file_info_get_attribute_string      (GFileInfo  *info,
737 							  const char *attribute);
738 const char *       g_file_info_get_attribute_byte_string (GFileInfo  *info,
739 							  const char *attribute);
740 gboolean           g_file_info_get_attribute_boolean     (GFileInfo  *info,
741 							  const char *attribute);
742 guint32            g_file_info_get_attribute_uint32      (GFileInfo  *info,
743 							  const char *attribute);
744 gint32             g_file_info_get_attribute_int32       (GFileInfo  *info,
745 							  const char *attribute);
746 guint64            g_file_info_get_attribute_uint64      (GFileInfo  *info,
747 							  const char *attribute);
748 gint64             g_file_info_get_attribute_int64       (GFileInfo  *info,
749 							  const char *attribute);
750 GObject *          g_file_info_get_attribute_object      (GFileInfo  *info,
751 							  const char *attribute);
752 
753 void               g_file_info_set_attribute             (GFileInfo  *info,
754 							  const char *attribute,
755 							  GFileAttributeType type,
756 							  gpointer    value_p);
757 void               g_file_info_set_attribute_string      (GFileInfo  *info,
758 							  const char *attribute,
759 							  const char *attr_value);
760 void               g_file_info_set_attribute_byte_string (GFileInfo  *info,
761 							  const char *attribute,
762 							  const char *attr_value);
763 void               g_file_info_set_attribute_boolean     (GFileInfo  *info,
764 							  const char *attribute,
765 							  gboolean    attr_value);
766 void               g_file_info_set_attribute_uint32      (GFileInfo  *info,
767 							  const char *attribute,
768 							  guint32     attr_value);
769 void               g_file_info_set_attribute_int32       (GFileInfo  *info,
770 							  const char *attribute,
771 							  gint32      attr_value);
772 void               g_file_info_set_attribute_uint64      (GFileInfo  *info,
773 							  const char *attribute,
774 							  guint64     attr_value);
775 void               g_file_info_set_attribute_int64       (GFileInfo  *info,
776 							  const char *attribute,
777 							  gint64      attr_value);
778 void               g_file_info_set_attribute_object      (GFileInfo  *info,
779 							  const char *attribute,
780 							  GObject    *attr_value);
781 
782 void               g_file_info_clear_status              (GFileInfo  *info);
783 
784 /* Helper getters: */
785 GFileType         g_file_info_get_file_type          (GFileInfo         *info);
786 gboolean          g_file_info_get_is_hidden          (GFileInfo         *info);
787 gboolean          g_file_info_get_is_backup          (GFileInfo         *info);
788 gboolean          g_file_info_get_is_symlink         (GFileInfo         *info);
789 const char *      g_file_info_get_name               (GFileInfo         *info);
790 const char *      g_file_info_get_display_name       (GFileInfo         *info);
791 const char *      g_file_info_get_edit_name          (GFileInfo         *info);
792 GIcon *           g_file_info_get_icon               (GFileInfo         *info);
793 const char *      g_file_info_get_content_type       (GFileInfo         *info);
794 goffset           g_file_info_get_size               (GFileInfo         *info);
795 void              g_file_info_get_modification_time  (GFileInfo         *info,
796 						      GTimeVal          *result);
797 const char *      g_file_info_get_symlink_target     (GFileInfo         *info);
798 const char *      g_file_info_get_etag               (GFileInfo         *info);
799 gint32            g_file_info_get_sort_order         (GFileInfo         *info);
800 
801 void              g_file_info_set_attribute_mask     (GFileInfo         *info,
802 						      GFileAttributeMatcher *mask);
803 void              g_file_info_unset_attribute_mask   (GFileInfo         *info);
804 
805 /* Helper setters: */
806 void              g_file_info_set_file_type          (GFileInfo         *info,
807 						      GFileType          type);
808 void              g_file_info_set_is_hidden          (GFileInfo         *info,
809 						      gboolean           is_hidden);
810 void              g_file_info_set_is_symlink         (GFileInfo         *info,
811 						      gboolean           is_symlink);
812 void              g_file_info_set_name               (GFileInfo         *info,
813 						      const char        *name);
814 void              g_file_info_set_display_name       (GFileInfo         *info,
815 						      const char        *display_name);
816 void              g_file_info_set_edit_name          (GFileInfo         *info,
817 						      const char        *edit_name);
818 void              g_file_info_set_icon               (GFileInfo         *info,
819 						      GIcon             *icon);
820 void              g_file_info_set_content_type       (GFileInfo         *info,
821 						      const char        *content_type);
822 void              g_file_info_set_size               (GFileInfo         *info,
823 						      goffset            size);
824 void              g_file_info_set_modification_time  (GFileInfo         *info,
825 						      GTimeVal          *mtime);
826 void              g_file_info_set_symlink_target     (GFileInfo         *info,
827 						      const char        *symlink_target);
828 void              g_file_info_set_sort_order         (GFileInfo         *info,
829 						      gint32             sort_order);
830 
831 GFileAttributeMatcher *g_file_attribute_matcher_new            (const char            *attributes);
832 GFileAttributeMatcher *g_file_attribute_matcher_ref            (GFileAttributeMatcher *matcher);
833 void                   g_file_attribute_matcher_unref          (GFileAttributeMatcher *matcher);
834 gboolean               g_file_attribute_matcher_matches        (GFileAttributeMatcher *matcher,
835 								const char            *attribute);
836 gboolean               g_file_attribute_matcher_matches_only   (GFileAttributeMatcher *matcher,
837 								const char            *attribute);
838 gboolean               g_file_attribute_matcher_enumerate_namespace (GFileAttributeMatcher *matcher,
839 								     const char            *ns);
840 const char *           g_file_attribute_matcher_enumerate_next (GFileAttributeMatcher *matcher);
841 
842 G_END_DECLS
843 
844 #endif /* __G_FILE_INFO_H__ */
845