gio/gfileinfo.h

   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 #ifndef __G_FILE_INFO_H__
  24 #define __G_FILE_INFO_H__
  25
  26 #include <glib-object.h>
  27 #include <gio/gfileattribute.h>
  28 #include <gio/gicon.h>
  29
  30 G_BEGIN_DECLS
  31
  32 #define G_TYPE_FILE_INFO         (g_file_info_get_type ())
  33 #define G_FILE_INFO(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_FILE_INFO, GFileInfo))
  34 #define G_FILE_INFO_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), G_TYPE_FILE_INFO, GFileInfoClass))
  35 #define G_IS_FILE_INFO(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_FILE_INFO))
  36 #define G_IS_FILE_INFO_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), G_TYPE_FILE_INFO))
  37 #define G_FILE_INFO_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), G_TYPE_FILE_INFO, GFileInfoClass))
  38
  39 /**
  40  * GFileInfo:
  41  *
  42  * Stores information about a file system object referenced by a #GFile.
  43  **/
  44 typedef struct _GFileInfo        GFileInfo;
  45 typedef struct _GFileInfoClass   GFileInfoClass;
  46
  47 /**
  48  * GFileAttributeMatcher:
  49  *
  50  * Determines if a string matches a file attribute.
  51  **/
  52 typedef struct _GFileAttributeMatcher GFileAttributeMatcher;
  53
  54 /**
  55  * GFileType:
  56  * @G_FILE_TYPE_UNKNOWN: File's type is unknown.
  57  * @G_FILE_TYPE_REGULAR: File handle represents a regular file.
  58  * @G_FILE_TYPE_DIRECTORY: File handle represents a directory.
  59  * @G_FILE_TYPE_SYMBOLIC_LINK: File handle represents a symbolic link (Unix systems)
  60  * @G_FILE_TYPE_SPECIAL: File is a "special" file, such as a socket, fifo, blockdev,  or chardev.
  61  * @G_FILE_TYPE_SHORTCUT: File is a shortcut (Windows systems)
  62  * @G_FILE_TYPE_MOUNTABLE: File is a mountable location.
  63  *
  64  * Indicates the file's on-disk type.
  65  **/
  66 typedef enum {
  67   G_FILE_TYPE_UNKNOWN = 0,
  68   G_FILE_TYPE_REGULAR,
  69   G_FILE_TYPE_DIRECTORY,
  70   G_FILE_TYPE_SYMBOLIC_LINK,
  71   G_FILE_TYPE_SPECIAL, /* socket, fifo, blockdev, chardev */
  72   G_FILE_TYPE_SHORTCUT,
  73   G_FILE_TYPE_MOUNTABLE
  74 } GFileType;
  75
  76 /* Common Attributes:  */
  77 /**
  78  * G_FILE_ATTRIBUTE_STD_TYPE:
  79  *
  80  * A key in the "std" namespace for storing file types.
  81  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
  82  * The value for this key should contain a #GFileType.
  83  **/
  84 #define G_FILE_ATTRIBUTE_STD_TYPE "std:type"                     /* uint32 (GFileType) */
  85
  86 /**
  87  * G_FILE_ATTRIBUTE_STD_IS_HIDDEN:
  88  *
  89  * A key in the "std" namespace for checking if a file is hidden.
  90  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
  91  **/
  92 #define G_FILE_ATTRIBUTE_STD_IS_HIDDEN "std:is_hidden"           /* boolean */
  93
  94 /**
  95  * G_FILE_ATTRIBUTE_STD_IS_BACKUP:
  96  *
  97  * A key in the "std" namespace for checking if a file is a backup file.
  98  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
  99  **/
 100 #define G_FILE_ATTRIBUTE_STD_IS_BACKUP "std:is_backup"           /* boolean */
 101
 102 /**
 103  * G_FILE_ATTRIBUTE_STD_IS_SYMLINK:
 104  *
 105  * A key in the "std" namespace for checking if the file is a symlink.
 106  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 107  **/
 108 #define G_FILE_ATTRIBUTE_STD_IS_SYMLINK "std:is_symlink"         /* boolean */
 109
 110 /**
 111  * G_FILE_ATTRIBUTE_STD_IS_VIRTUAL:
 112  *
 113  * A key in the "std" namespace for checking if a file is virtual.
 114  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 115  **/
 116 #define G_FILE_ATTRIBUTE_STD_IS_VIRTUAL "std:is_virtual"         /* boolean */
 117
 118 /**
 119  * G_FILE_ATTRIBUTE_STD_NAME:
 120  *
 121  * A key in the "std" namespace for getting the name of the file.
 122  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
 123  **/
 124 #define G_FILE_ATTRIBUTE_STD_NAME "std:name"                     /* byte string */
 125
 126 /**
 127  * G_FILE_ATTRIBUTE_STD_DISPLAY_NAME:
 128  *
 129  * A key in the "std" namespace for getting the display name of the file.
 130  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 131  **/
 132 #define G_FILE_ATTRIBUTE_STD_DISPLAY_NAME "std:display_name"     /* string */
 133
 134 /**
 135  * G_FILE_ATTRIBUTE_STD_EDIT_NAME:
 136  *
 137  * A key in the "std" namespace for edit name of the file.
 138  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 139  **/
 140 #define G_FILE_ATTRIBUTE_STD_EDIT_NAME "std:edit_name"           /* string */
 141
 142 /**
 143  * G_FILE_ATTRIBUTE_STD_COPY_NAME:
 144  *
 145  * A key in the "std" namespace for getting the copy name of the file.
 146  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 147  **/
 148 #define G_FILE_ATTRIBUTE_STD_COPY_NAME "std:copy_name"           /* string */
 149
 150 /**
 151  * G_FILE_ATTRIBUTE_STD_ICON:
 152  *
 153  * A key in the "std" namespace for getting the icon for the file.
 154  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.
 155  * The value for this key should contain a #GIcon.
 156  **/
 157 #define G_FILE_ATTRIBUTE_STD_ICON "std:icon"                     /* object (GIcon) */
 158
 159 /**
 160  * G_FILE_ATTRIBUTE_STD_CONTENT_TYPE:
 161  *
 162  * A key in the "std" namespace for getting the content type of the file.
 163  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 164  * The value for this key should contain a valid content type.
 165  **/
 166 #define G_FILE_ATTRIBUTE_STD_CONTENT_TYPE "std:content_type"     /* string */
 167
 168 /**
 169  * G_FILE_ATTRIBUTE_STD_FAST_CONTENT_TYPE:
 170  *
 171  * A key in the "std" namespace for getting the fast content type.
 172  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 173  *
 174  **/
 175 #define G_FILE_ATTRIBUTE_STD_FAST_CONTENT_TYPE "std:fast_content_type" /* string */
 176
 177 /**
 178  * G_FILE_ATTRIBUTE_STD_SIZE:
 179  *
 180  * A key in the "std" namespace for getting the file's size.
 181  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
 182  **/
 183 #define G_FILE_ATTRIBUTE_STD_SIZE "std:size"                     /* uint64 */
 184
 185 /**
 186  * G_FILE_ATTRIBUTE_STD_SYMLINK_TARGET:
 187  *
 188  * A key in the "std" namespace for getting the symlink target, if the file
 189  * is a symlink. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
 190  **/
 191 #define G_FILE_ATTRIBUTE_STD_SYMLINK_TARGET "std:symlink_target" /* byte string */
 192
 193 /**
 194  * G_FILE_ATTRIBUTE_STD_TARGET_URI:
 195  *
 196  * A key in the "std" namespace for getting the target URI for the file.
 197  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 198  **/
 199 #define G_FILE_ATTRIBUTE_STD_TARGET_URI "std:target_uri"         /* string */
 200
 201 /**
 202  * G_FILE_ATTRIBUTE_STD_SORT_ORDER:
 203  *
 204  * A key in the "std" namespace for setting the sort order of a file.
 205  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_INT32.
 206  * An example use would be in file managers, which would use this key to set
 207  * the order files are displayed.
 208  **/
 209 #define G_FILE_ATTRIBUTE_STD_SORT_ORDER "std:sort_order"         /* int32  */
 210
 211 /* Entity tags, used to avoid missing updates on save */
 212 /**
 213  * G_FILE_ATTRIBUTE_ETAG_VALUE:
 214  *
 215  * A key in the "etag" namespace for getting the value of the file's
 216  * entity tag. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 217  **/
 218 #define G_FILE_ATTRIBUTE_ETAG_VALUE "etag:value"                 /* string */
 219
 220 /* File identifier, for e.g. avoiding loops when doing recursive directory scanning */
 221 /**
 222  * G_FILE_ATTRIBUTE_ID_FILE:
 223  *
 224  * A key in the "id" namespace for getting a file identifier.
 225  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 226  * An example use would be during listing files, to avoid recursive
 227  * directory scanning.
 228  **/
 229 #define G_FILE_ATTRIBUTE_ID_FILE "id:file"                     /* string */
 230
 231 /**
 232  * G_FILE_ATTRIBUTE_ID_FS:
 233  *
 234  * A key in the "id" namespace for getting the file system identifier.
 235  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 236  * An example use would be during listing files, to avoid recursive
 237  * directory scanning.
 238  **/
 239 #define G_FILE_ATTRIBUTE_ID_FS "id:fs"                         /* string */
 240
 241 /* Calculated Access Rights for current user */
 242
 243 /**
 244  * G_FILE_ATTRIBUTE_ACCESS_CAN_READ:
 245  *
 246  * A key in the "access" namespace for getting read privilidges.
 247  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 248  * This key will be true if the user is able to read the file.
 249  **/
 250 #define G_FILE_ATTRIBUTE_ACCESS_CAN_READ "access:can_read"       /* boolean */
 251
 252 /**
 253  * G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE:
 254  *
 255  * A key in the "access" namespace for getting write privilidges.
 256  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 257  * This key will be true if the user is able to write to the file.
 258  **/
 259 #define G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE "access:can_write"     /* boolean */
 260
 261 /**
 262  * G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE:
 263  *
 264  * A key in the "access" namespace for getting execution privilidges.
 265  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 266  * This key will be true if the user is able to execute the file.
 267  **/
 268 #define G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE "access:can_execute" /* boolean */
 269
 270 /**
 271  * G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE:
 272  *
 273  * A key in the "access" namespace for checking deletion privilidges.
 274  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 275  * This key will be true if the user is able to delete the file.
 276  **/
 277 #define G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE "access:can_delete"   /* boolean */
 278
 279 /**
 280  * G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH:
 281  *
 282  * A key in the "access" namespace for checking trashing privilidges.
 283  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 284  * This key will be true if the user is able to send the file to the
 285  * virtual file system trash location.
 286  **/
 287 #define G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH "access:can_trash"     /* boolean */
 288
 289 /**
 290  * G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME:
 291  *
 292  * A key in the "access" namespace for checking renaming privilidges.
 293  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 294  * This key will be true if the user is able to rename the file.
 295  **/
 296 #define G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME "access:can_rename"   /* boolean */
 297 /* TODO: Should we have special version for directories? can_enumerate, etc */
 298
 299 /* Mountable attributes */
 300 /**
 301  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT:
 302  *
 303  * A key in the "mountable" namespace for checking if a file is mountable.
 304  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 305  **/
 306 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT "mountable:can_mount"     /* boolean */
 307
 308 /**
 309  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT:
 310  *
 311  * A key in the "mountable" namespace for checking if a file is unmountable.
 312  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 313  **/
 314 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT "mountable:can_unmount" /* boolean */
 315
 316 /**
 317  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT:
 318  *
 319  * A key in the "mountable" namespace for checking if a file can be ejected.
 320  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 321  **/
 322 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT "mountable:can_eject"     /* boolean */
 323
 324 /**
 325  * G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE:
 326  *
 327  * A key in the "mountable" namespace for getting the unix device.
 328  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 329  **/
 330 #define G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE "mountable:unix_device" /* uint32 */
 331
 332 /**
 333  * G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI:
 334  *
 335  * A key in the "mountable" namespace for getting the HAL UDI for the mounted
 336  * file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 337  **/
 338 #define G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI "mountable:hal_udi"         /* string */
 339
 340 /* Time attributes */
 341
 342   /* The last time the file content or an attribute was modified */
 343 /**
 344  * G_FILE_ATTRIBUTE_TIME_MODIFIED:
 345  *
 346  * A key in the "time" namespace for getting the time the file was last
 347  * modified. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
 348  * and contains the UNIX time since the file was modified.
 349  **/
 350 #define G_FILE_ATTRIBUTE_TIME_MODIFIED "time:modified"           /* uint64 */
 351
 352 /**
 353  * G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC:
 354  *
 355  * A key in the "time" namespace for getting the milliseconds of the time
 356  * the file was last modified. This should be used in conjunction with
 357  * #G_FILE_ATTRIBUTE_TIME_MODIFIED. Corresponding #GFileAttributeType is
 358  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 359  **/
 360 #define G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC "time:modified_usec" /* uint32 */
 361   /* The last time the file was read */
 362 /**
 363  * G_FILE_ATTRIBUTE_TIME_ACCESS:
 364  *
 365  * A key in the "time" namespace for getting the time the file was last
 366  * accessed. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
 367  * and contains the UNIX time since the file was last accessed.
 368  **/
 369 #define G_FILE_ATTRIBUTE_TIME_ACCESS "time:access"               /* uint64 */
 370 /**
 371  * G_FILE_ATTRIBUTE_TIME_ACCESS_USEC:
 372  *
 373  * A key in the "time" namespace for getting the milliseconds of the time
 374  * the file was last accessed. This should be used in conjunction with
 375  * #G_FILE_ATTRIBUTE_TIME_ACCESS. Corresponding #GFileAttributeType is
 376  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 377  **/
 378 #define G_FILE_ATTRIBUTE_TIME_ACCESS_USEC "time:access_usec"     /* uint32 */
 379   /* The last time a file attribute was changed (e.g. unix ctime) */
 380 /**
 381  * G_FILE_ATTRIBUTE_TIME_CHANGED:
 382  *
 383  * A key in the "time" namespace for getting the time the file was last
 384  * changed. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
 385  * and contains the UNIX time since the file was last changed.
 386  **/
 387 #define G_FILE_ATTRIBUTE_TIME_CHANGED "time:changed"             /* uint64 */
 388 /**
 389  * G_FILE_ATTRIBUTE_TIME_CHANGED_USEC:
 390  *
 391  * A key in the "time" namespace for getting the milliseconds of the time
 392  * the file was last changed. This should be used in conjunction with
 393  * #G_FILE_ATTRIBUTE_TIME_CHANGED. Corresponding #GFileAttributeType is
 394  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 395  **/
 396 #define G_FILE_ATTRIBUTE_TIME_CHANGED_USEC "time:changed_usec"   /* uint32 */
 397   /* When the file was originally created (e.g. ntfs ctime) */
 398 /**
 399  * G_FILE_ATTRIBUTE_TIME_CREATED:
 400  *
 401  * A key in the "time" namespace for getting the time the file was created.
 402  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
 403  * and contains the UNIX time since the file was created.
 404  **/
 405 #define G_FILE_ATTRIBUTE_TIME_CREATED "time:created"             /* uint64 */
 406
 407 /**
 408  * G_FILE_ATTRIBUTE_TIME_CREATED_USEC:
 409  *
 410  * A key in the "time" namespace for getting the milliseconds of the time
 411  * the file was created. This should be used in conjunction with
 412  * #G_FILE_ATTRIBUTE_TIME_CREATED. Corresponding #GFileAttributeType is
 413  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 414  **/
 415 #define G_FILE_ATTRIBUTE_TIME_CREATED_USEC "time:created_usec"   /* uint32 */
 416
 417 /* Unix specific attributes */
 418 /**
 419  * G_FILE_ATTRIBUTE_UNIX_DEVICE:
 420  *
 421  * A key in the "unix" namespace for getting the device id of the device the
 422  * file is located on (see man stat(2)). This attribute is only available
 423  * for UNIX file systems. Corresponding #GFileAttributeType is
 424  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 425  *
 426  **/
 427 #define G_FILE_ATTRIBUTE_UNIX_DEVICE "unix:device"               /* uint32 */
 428 /**
 429  * G_FILE_ATTRIBUTE_UNIX_INODE:
 430  *
 431  * A key in the "unix" namespace for getting the inode of the file.
 432  * This attribute is only available for UNIX file systems. Corresponding
 433  * #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
 434  **/
 435 #define G_FILE_ATTRIBUTE_UNIX_INODE "unix:inode"                 /* uint64 */
 436 /**
 437  * G_FILE_ATTRIBUTE_UNIX_MODE:
 438  *
 439  * A key in the "unix" namespace for getting the mode of the file (e.g. whether the file
 440  * is a regular file, symlink, etc). See man lstat(2). This attribute is only available
 441  * for UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 442  **/
 443 #define G_FILE_ATTRIBUTE_UNIX_MODE "unix:mode"                   /* uint32 */
 444
 445 /**
 446  * G_FILE_ATTRIBUTE_UNIX_NLINK:
 447  *
 448  * A key in the "unix" namespace for getting the number of hard links for a
 449  * file. See man lstat(2). This attribute is only available for UNIX file systems.
 450  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 451  *
 452  **/
 453 #define G_FILE_ATTRIBUTE_UNIX_NLINK "unix:nlink"                 /* uint32 */
 454 /**
 455  * G_FILE_ATTRIBUTE_UNIX_UID:
 456  *
 457  * A key in the "unix" namespace for getting the user ID for the file.
 458  * This attribute is only available for UNIX file systems.
 459  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 460  **/
 461 #define G_FILE_ATTRIBUTE_UNIX_UID "unix:uid"                     /* uint32 */
 462 /**
 463  * G_FILE_ATTRIBUTE_UNIX_GID:
 464  *
 465  * A key in the "unix" namespace for getting the group ID for the file.
 466  * This attribute is only available for UNIX file systems.
 467  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 468  **/
 469 #define G_FILE_ATTRIBUTE_UNIX_GID "unix:gid"                     /* uint32 */
 470 /**
 471  * G_FILE_ATTRIBUTE_UNIX_RDEV:
 472  *
 473  * A key in the "unix" namespace for getting the device ID for the file (if it
 474  * is a special file). See man lstat(2). This attribute is only available for
 475  * UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 476  **/
 477 #define G_FILE_ATTRIBUTE_UNIX_RDEV "unix:rdev"                   /* uint32 */
 478 /**
 479  * G_FILE_ATTRIBUTE_UNIX_BLOCK_SIZE:
 480  *
 481  * A key in the "unix" namespace for getting the block size for the file system.
 482  * This attribute is only available for UNIX file systems.
 483  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 484  **/
 485 #define G_FILE_ATTRIBUTE_UNIX_BLOCK_SIZE "unix:block_size"       /* uint32 */
 486 /**
 487  * G_FILE_ATTRIBUTE_UNIX_BLOCKS:
 488  *
 489  * A key in the "unix" namespace for getting the number of blocks allocated for the file.
 490  * This attribute is only available for UNIX file systems.
 491  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
 492  **/
 493 #define G_FILE_ATTRIBUTE_UNIX_BLOCKS "unix:blocks"               /* uint64 */
 494
 495 /**
 496  * G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT:
 497  *
 498  * A key in the "unix" namespace for checking if the file represents a unix mount point.
 499  * Returns %TRUE if the file is a unix mount point. This attribute is only available for
 500  * UNIX file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 501  **/
 502 #define G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT "unix:is_mountpoint" /* boolean */
 503
 504 /* DOS specific attributes */
 505 /**
 506  * G_FILE_ATTRIBUTE_DOS_IS_ARCHIVE:
 507  *
 508  * A key in the "dos" namespace for checking if the file's archive flag is set.
 509  * Returns %TRUE if the archive flag is set. This attribute is only available for
 510  * DOS file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 511  **/
 512 #define G_FILE_ATTRIBUTE_DOS_IS_ARCHIVE "dos:is_archive"         /* boolean */
 513
 514 /**
 515  * G_FILE_ATTRIBUTE_DOS_IS_SYSTEM:
 516  *
 517  * A key in the "dos" namespace for checking if the file's backup flag is set.
 518  * Returns %TRUE if the backup flag is set. This attribute is only available for
 519  * DOS file systems. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 520  **/
 521 #define G_FILE_ATTRIBUTE_DOS_IS_SYSTEM "dos:is_system"           /* boolean */
 522
 523 /* Owner attributes */
 524 /**
 525  * G_FILE_ATTRIBUTE_OWNER_USER:
 526  *
 527  * A key in the "owner" namespace for getting the user name of the file's owner.
 528  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 529  **/
 530 #define G_FILE_ATTRIBUTE_OWNER_USER "owner:user"                 /* string */
 531
 532 /**
 533  * G_FILE_ATTRIBUTE_OWNER_USER_REAL:
 534  *
 535  * A key in the "owner" namespace for getting the real name of the user that owns the file.
 536  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 537  **/
 538 #define G_FILE_ATTRIBUTE_OWNER_USER_REAL "owner:user_real"       /* string */
 539
 540 /**
 541  * G_FILE_ATTRIBUTE_OWNER_GROUP:
 542  *
 543  * A key in the "owner" namespace for getting the file owner's group.
 544  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 545  **/
 546 #define G_FILE_ATTRIBUTE_OWNER_GROUP "owner:group"               /* string */
 547
 548 /* Thumbnails */
 549
 550 /**
 551  * G_FILE_ATTRIBUTE_THUMBNAIL_PATH:
 552  *
 553  * A key in the "thumbnail" namespace for getting the path to the thumbnail image.
 554  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
 555  **/
 556 #define G_FILE_ATTRIBUTE_THUMBNAIL_PATH "thumbnail:path"         /* bytestring */
 557 /**
 558  * G_FILE_ATTRIBUTE_THUMBNAIL_THUMNAILING_FAILED:
 559  *
 560  * A key in the "thumbnail" namespace for checking if thumbnailing failed.
 561  * Is set to %TRUE if thumbnailing failed. Corresponding #GFileAttributeType
 562  * is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 563  **/
 564 #define G_FILE_ATTRIBUTE_THUMBNAILING_FAILED "thumbnail:failed"         /* boolean */
 565
 566 /* File system info (for g_file_get_filesystem_info) */
 567
 568 /**
 569  * G_FILE_ATTRIBUTE_FS_SIZE:
 570  *
 571  * A key in the "fs" namespace for getting the size of the file system, used in
 572  * g_file_get_filesystem_info(). Corresponding #GFileAttributeType is
 573  * %G_FILE_ATTRIBUTE_TYPE_UINT64.
 574  **/
 575 #define G_FILE_ATTRIBUTE_FS_SIZE "fs:size"                       /* uint64 */
 576
 577 /**
 578  * G_FILE_ATTRIBUTE_FS_FREE:
 579  *
 580  * A key in the "fs" namespace for getting the free space left on the file system.
 581  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
 582  **/
 583 #define G_FILE_ATTRIBUTE_FS_FREE "fs:free"                       /* uint64 */
 584
 585 /**
 586  * G_FILE_ATTRIBUTE_FS_TYPE:
 587  *
 588  * A key in the "fs" namespace for getting the file system's type.
 589  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 590  **/
 591 #define G_FILE_ATTRIBUTE_FS_TYPE "fs:type"                       /* string */
 592
 593 /**
 594  * G_FILE_ATTRIBUTE_FS_READONLY:
 595  *
 596  * A key in the "fs" namespace for checking if the file system is read only.
 597  * Is set to %TRUE if the file system is read only. Corresponding #GFileAttributeType is
 598  * %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 599  **/
 600 #define G_FILE_ATTRIBUTE_FS_READONLY "fs:readonly"               /* boolean */
 601
 602 /**
 603  * G_FILE_ATTRIBUTE_GVFS_BACKEND:
 604  *
 605  * A key in the "gvfs" namespace that gets the name of the current
 606  * GVFS backend in use. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 607  **/
 608 #define G_FILE_ATTRIBUTE_GVFS_BACKEND "gvfs:backend"             /* string */
 609
 610 GType g_file_info_get_type (void) G_GNUC_CONST;
 611
 612 GFileInfo *        g_file_info_new                       (void);
 613 GFileInfo *        g_file_info_dup                       (GFileInfo  *other);
 614 void               g_file_info_copy_into                 (GFileInfo  *src_info,
 615                                                           GFileInfo  *dest_info);
 616 gboolean           g_file_info_has_attribute             (GFileInfo  *info,
 617                                                           const char *attribute);
 618 char **            g_file_info_list_attributes           (GFileInfo  *info,
 619                                                           const char *name_space);
 620 GFileAttributeType g_file_info_get_attribute_type        (GFileInfo  *info,
 621                                                           const char *attribute);
 622 void               g_file_info_remove_attribute          (GFileInfo  *info,
 623                                                           const char *attribute);
 624 GFileAttributeValue * g_file_info_get_attribute          (GFileInfo  *info,
 625                                                           const char *attribute);
 626 const char *       g_file_info_get_attribute_string      (GFileInfo  *info,
 627                                                           const char *attribute);
 628 const char *       g_file_info_get_attribute_byte_string (GFileInfo  *info,
 629                                                           const char *attribute);
 630 gboolean           g_file_info_get_attribute_boolean     (GFileInfo  *info,
 631                                                           const char *attribute);
 632 guint32            g_file_info_get_attribute_uint32      (GFileInfo  *info,
 633                                                           const char *attribute);
 634 gint32             g_file_info_get_attribute_int32       (GFileInfo  *info,
 635                                                           const char *attribute);
 636 guint64            g_file_info_get_attribute_uint64      (GFileInfo  *info,
 637                                                           const char *attribute);
 638 gint64             g_file_info_get_attribute_int64       (GFileInfo  *info,
 639                                                           const char *attribute);
 640 GObject *          g_file_info_get_attribute_object      (GFileInfo  *info,
 641                                                           const char *attribute);
 642
 643 void               g_file_info_set_attribute             (GFileInfo  *info,
 644                                                           const char *attribute,
 645                                                           const GFileAttributeValue *attr_value);
 646 void               g_file_info_set_attribute_string      (GFileInfo  *info,
 647                                                           const char *attribute,
 648                                                           const char *attr_value);
 649 void               g_file_info_set_attribute_byte_string (GFileInfo  *info,
 650                                                           const char *attribute,
 651                                                           const char *attr_value);
 652 void               g_file_info_set_attribute_boolean     (GFileInfo  *info,
 653                                                           const char *attribute,
 654                                                           gboolean    attr_value);
 655 void               g_file_info_set_attribute_uint32      (GFileInfo  *info,
 656                                                           const char *attribute,
 657                                                           guint32     attr_value);
 658 void               g_file_info_set_attribute_int32       (GFileInfo  *info,
 659                                                           const char *attribute,
 660                                                           gint32      attr_value);
 661 void               g_file_info_set_attribute_uint64      (GFileInfo  *info,
 662                                                           const char *attribute,
 663                                                           guint64     attr_value);
 664 void               g_file_info_set_attribute_int64       (GFileInfo  *info,
 665                                                           const char *attribute,
 666                                                           gint64      attr_value);
 667 void               g_file_info_set_attribute_object      (GFileInfo  *info,
 668                                                           const char *attribute,
 669                                                           GObject    *attr_value);
 670
 671 void               g_file_info_clear_status              (GFileInfo  *info);
 672
 673 /* Helper getters: */
 674 GFileType         g_file_info_get_file_type          (GFileInfo         *info);
 675 gboolean          g_file_info_get_is_hidden          (GFileInfo         *info);
 676 gboolean          g_file_info_get_is_backup          (GFileInfo         *info);
 677 gboolean          g_file_info_get_is_symlink         (GFileInfo         *info);
 678 const char *      g_file_info_get_name               (GFileInfo         *info);
 679 const char *      g_file_info_get_display_name       (GFileInfo         *info);
 680 const char *      g_file_info_get_edit_name          (GFileInfo         *info);
 681 GIcon *           g_file_info_get_icon               (GFileInfo         *info);
 682 const char *      g_file_info_get_content_type       (GFileInfo         *info);
 683 goffset           g_file_info_get_size               (GFileInfo         *info);
 684 void              g_file_info_get_modification_time  (GFileInfo         *info,
 685                                                       GTimeVal          *result);
 686 const char *      g_file_info_get_symlink_target     (GFileInfo         *info);
 687 const char *      g_file_info_get_etag               (GFileInfo         *info);
 688 gint32            g_file_info_get_sort_order         (GFileInfo         *info);
 689
 690 void              g_file_info_set_attribute_mask     (GFileInfo         *info,
 691                                                       GFileAttributeMatcher *mask);
 692 void              g_file_info_unset_attribute_mask   (GFileInfo         *info);
 693
 694 /* Helper setters: */
 695 void              g_file_info_set_file_type          (GFileInfo         *info,
 696                                                       GFileType          type);
 697 void              g_file_info_set_is_hidden          (GFileInfo         *info,
 698                                                       gboolean           is_hidden);
 699 void              g_file_info_set_is_symlink         (GFileInfo         *info,
 700                                                       gboolean           is_symlink);
 701 void              g_file_info_set_name               (GFileInfo         *info,
 702                                                       const char        *name);
 703 void              g_file_info_set_display_name       (GFileInfo         *info,
 704                                                       const char        *display_name);
 705 void              g_file_info_set_edit_name          (GFileInfo         *info,
 706                                                       const char        *edit_name);
 707 void              g_file_info_set_icon               (GFileInfo         *info,
 708                                                       GIcon             *icon);
 709 void              g_file_info_set_content_type       (GFileInfo         *info,
 710                                                       const char        *content_type);
 711 void              g_file_info_set_size               (GFileInfo         *info,
 712                                                       goffset            size);
 713 void              g_file_info_set_modification_time  (GFileInfo         *info,
 714                                                       GTimeVal          *mtime);
 715 void              g_file_info_set_symlink_target     (GFileInfo         *info,
 716                                                       const char        *symlink_target);
 717 void              g_file_info_set_sort_order         (GFileInfo         *info,
 718                                                       gint32             sort_order);
 719
 720 /* Helper functions for attributes: */
 721 /* TODO: Move this to glib when merging */
 722 char *g_format_file_size_for_display (goffset size);
 723
 724 GFileAttributeMatcher *g_file_attribute_matcher_new            (const char            *attributes);
 725 GFileAttributeMatcher *g_file_attribute_matcher_ref            (GFileAttributeMatcher *matcher);
 726 void                   g_file_attribute_matcher_unref          (GFileAttributeMatcher *matcher);
 727 gboolean               g_file_attribute_matcher_matches        (GFileAttributeMatcher *matcher,
 728                                                                 const char            *attribute);
 729 gboolean               g_file_attribute_matcher_matches_only   (GFileAttributeMatcher *matcher,
 730                                                                 const char            *attribute);
 731 gboolean               g_file_attribute_matcher_enumerate_namespace (GFileAttributeMatcher *matcher,
 732                                                                      const char            *ns);
 733 const char *           g_file_attribute_matcher_enumerate_next (GFileAttributeMatcher *matcher);
 734
 735 G_END_DECLS
 736
 737
 738 #endif /* __G_FILE_INFO_H__ */