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 #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_SYMBOLIC_ICON:
 167  *
 168  * A key in the "standard" namespace for getting the symbolic icon for the file.
 169  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.
 170  * The value for this key should contain a #GIcon.
 171  *
 172  * Since: 2.34
 173  **/
 174 #define G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON "standard::symbolic-icon"   /* object (GIcon) */
 175
 176 /**
 177  * G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE:
 178  *
 179  * A key in the "standard" namespace for getting the content type of the file.
 180  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 181  * The value for this key should contain a valid content type.
 182  **/
 183 #define G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE "standard::content-type"     /* string */
 184
 185 /**
 186  * G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE:
 187  *
 188  * A key in the "standard" namespace for getting the fast content type.
 189  * The fast content type isn't as reliable as the regular one, as it
 190  * only uses the filename to guess it, but it is faster to calculate than the
 191  * regular content type.
 192  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 193  *
 194  **/
 195 #define G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE "standard::fast-content-type" /* string */
 196
 197 /**
 198  * G_FILE_ATTRIBUTE_STANDARD_SIZE:
 199  *
 200  * A key in the "standard" namespace for getting the file's size (in bytes).
 201  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
 202  **/
 203 #define G_FILE_ATTRIBUTE_STANDARD_SIZE "standard::size"                     /* uint64 */
 204
 205 /**
 206  * G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE:
 207  *
 208  * A key in the "standard" namespace for getting the amount of disk space
 209  * that is consumed by the file (in bytes).  This will generally be larger
 210  * than the file size (due to block size overhead) but can occasionally be
 211  * smaller (for example, for sparse files).
 212  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
 213  *
 214  * Since: 2.20
 215  **/
 216 #define G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE "standard::allocated-size" /* uint64 */
 217
 218 /**
 219  * G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET:
 220  *
 221  * A key in the "standard" namespace for getting the symlink target, if the file
 222  * is a symlink. Corresponding #GFileAttributeType is
 223  * %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
 224  **/
 225 #define G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET "standard::symlink-target" /* byte string */
 226
 227 /**
 228  * G_FILE_ATTRIBUTE_STANDARD_TARGET_URI:
 229  *
 230  * A key in the "standard" namespace for getting the target URI for the file, in
 231  * the case of %G_FILE_TYPE_SHORTCUT or %G_FILE_TYPE_MOUNTABLE files.
 232  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 233  **/
 234 #define G_FILE_ATTRIBUTE_STANDARD_TARGET_URI "standard::target-uri"         /* string */
 235
 236 /**
 237  * G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER:
 238  *
 239  * A key in the "standard" namespace for setting the sort order of a file.
 240  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_INT32.
 241  * An example use would be in file managers, which would use this key
 242  * to set the order files are displayed. Files with smaller sort order
 243  * should be sorted first, and files without sort order as if sort order
 244  * was zero.
 245  **/
 246 #define G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER "standard::sort-order"         /* int32  */
 247
 248 /* Entity tags, used to avoid missing updates on save */
 249
 250 /**
 251  * G_FILE_ATTRIBUTE_ETAG_VALUE:
 252  *
 253  * A key in the "etag" namespace for getting the value of the file's
 254  * entity tag. Corresponding #GFileAttributeType is
 255  * %G_FILE_ATTRIBUTE_TYPE_STRING.
 256  **/
 257 #define G_FILE_ATTRIBUTE_ETAG_VALUE "etag::value"                 /* string */
 258
 259 /* File identifier, for e.g. avoiding loops when doing recursive
 260  * directory scanning
 261  */
 262
 263 /**
 264  * G_FILE_ATTRIBUTE_ID_FILE:
 265  *
 266  * A key in the "id" namespace for getting a file identifier.
 267  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 268  * An example use would be during listing files, to avoid recursive
 269  * directory scanning.
 270  **/
 271 #define G_FILE_ATTRIBUTE_ID_FILE "id::file"                     /* string */
 272
 273 /**
 274  * G_FILE_ATTRIBUTE_ID_FILESYSTEM:
 275  *
 276  * A key in the "id" namespace for getting the file system identifier.
 277  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 278  * An example use would be during drag and drop to see if the source
 279  * and target are on the same filesystem (default to move) or not (default
 280  * to copy).
 281  **/
 282 #define G_FILE_ATTRIBUTE_ID_FILESYSTEM "id::filesystem"         /* string */
 283
 284 /* Calculated Access Rights for current user */
 285
 286 /**
 287  * G_FILE_ATTRIBUTE_ACCESS_CAN_READ:
 288  *
 289  * A key in the "access" namespace for getting read privileges.
 290  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 291  * This attribute will be %TRUE if the user is able to read the file.
 292  **/
 293 #define G_FILE_ATTRIBUTE_ACCESS_CAN_READ "access::can-read"       /* boolean */
 294
 295 /**
 296  * G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE:
 297  *
 298  * A key in the "access" namespace for getting write privileges.
 299  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 300  * This attribute will be %TRUE if the user is able to write to the file.
 301  **/
 302 #define G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE "access::can-write"     /* boolean */
 303
 304 /**
 305  * G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE:
 306  *
 307  * A key in the "access" namespace for getting execution privileges.
 308  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 309  * This attribute will be %TRUE if the user is able to execute the file.
 310  **/
 311 #define G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE "access::can-execute" /* boolean */
 312
 313 /**
 314  * G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE:
 315  *
 316  * A key in the "access" namespace for checking deletion privileges.
 317  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 318  * This attribute will be %TRUE if the user is able to delete the file.
 319  **/
 320 #define G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE "access::can-delete"   /* boolean */
 321
 322 /**
 323  * G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH:
 324  *
 325  * A key in the "access" namespace for checking trashing privileges.
 326  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 327  * This attribute will be %TRUE if the user is able to move the file to
 328  * the trash.
 329  **/
 330 #define G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH "access::can-trash"     /* boolean */
 331
 332 /**
 333  * G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME:
 334  *
 335  * A key in the "access" namespace for checking renaming privileges.
 336  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 337  * This attribute will be %TRUE if the user is able to rename the file.
 338  **/
 339 #define G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME "access::can-rename"   /* boolean */
 340
 341 /* TODO: Should we have special version for directories? can_enumerate, etc */
 342
 343 /* Mountable attributes */
 344
 345 /**
 346  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT:
 347  *
 348  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) is mountable.
 349  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 350  **/
 351 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT "mountable::can-mount"     /* boolean */
 352
 353 /**
 354  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT:
 355  *
 356  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE)  is unmountable.
 357  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 358  **/
 359 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT "mountable::can-unmount" /* boolean */
 360
 361 /**
 362  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT:
 363  *
 364  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be ejected.
 365  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 366  **/
 367 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT "mountable::can-eject"     /* boolean */
 368
 369 /**
 370  * G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE:
 371  *
 372  * A key in the "mountable" namespace for getting the unix device.
 373  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 374  **/
 375 #define G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE "mountable::unix-device" /* uint32 */
 376
 377 /**
 378  * G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE:
 379  *
 380  * A key in the "mountable" namespace for getting the unix device file.
 381  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 382  *
 383  * Since: 2.22
 384  **/
 385 #define G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE "mountable::unix-device-file" /* string */
 386
 387 /**
 388  * G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI:
 389  *
 390  * A key in the "mountable" namespace for getting the HAL UDI for the mountable
 391  * file. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 392  **/
 393 #define G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI "mountable::hal-udi"         /* string */
 394
 395 /**
 396  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START:
 397  *
 398  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be started.
 399  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 400  *
 401  * Since: 2.22
 402  */
 403 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START "mountable::can-start"     /* boolean */
 404
 405 /**
 406  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED:
 407  *
 408  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be started
 409  * degraded.
 410  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 411  *
 412  * Since: 2.22
 413  */
 414 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED "mountable::can-start-degraded"     /* boolean */
 415
 416 /**
 417  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP:
 418  *
 419  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be stopped.
 420  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 421  *
 422  * Since: 2.22
 423  */
 424 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP "mountable::can-stop"      /* boolean */
 425
 426 /**
 427  * G_FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE:
 428  *
 429  * A key in the "mountable" namespace for getting the #GDriveStartStopType.
 430  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 431  *
 432  * Since: 2.22
 433  */
 434 #define G_FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE "mountable::start-stop-type" /* uint32 (GDriveStartStopType) */
 435
 436 /**
 437  * G_FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL:
 438  *
 439  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be polled.
 440  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 441  *
 442  * Since: 2.22
 443  */
 444 #define G_FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL "mountable::can-poll"      /* boolean */
 445
 446 /**
 447  * G_FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC:
 448  *
 449  * A key in the "mountable" namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE)
 450  * is automatically polled for media.
 451  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 452  *
 453  * Since: 2.22
 454  */
 455 #define G_FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC "mountable::is-media-check-automatic"      /* boolean */
 456
 457 /* Time attributes */
 458
 459 /**
 460  * G_FILE_ATTRIBUTE_TIME_MODIFIED:
 461  *
 462  * A key in the "time" namespace for getting the time the file was last
 463  * modified. Corresponding #GFileAttributeType is
 464  * %G_FILE_ATTRIBUTE_TYPE_UINT64, and contains the UNIX time since the
 465  * file was modified.
 466  **/
 467 #define G_FILE_ATTRIBUTE_TIME_MODIFIED "time::modified"           /* uint64 */
 468
 469 /**
 470  * G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC:
 471  *
 472  * A key in the "time" namespace for getting the miliseconds of the time
 473  * the file was last modified. This should be used in conjunction with
 474  * #G_FILE_ATTRIBUTE_TIME_MODIFIED. Corresponding #GFileAttributeType is
 475  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 476  **/
 477 #define G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC "time::modified-usec" /* uint32 */
 478
 479 /**
 480  * G_FILE_ATTRIBUTE_TIME_ACCESS:
 481  *
 482  * A key in the "time" namespace for getting the time the file was last
 483  * accessed. Corresponding #GFileAttributeType is
 484  * %G_FILE_ATTRIBUTE_TYPE_UINT64, and contains the UNIX time since the
 485  * file was last accessed.
 486  **/
 487 #define G_FILE_ATTRIBUTE_TIME_ACCESS "time::access"               /* uint64 */
 488
 489 /**
 490  * G_FILE_ATTRIBUTE_TIME_ACCESS_USEC:
 491  *
 492  * A key in the "time" namespace for getting the microseconds of the time
 493  * the file was last accessed. This should be used in conjunction with
 494  * #G_FILE_ATTRIBUTE_TIME_ACCESS. Corresponding #GFileAttributeType is
 495  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 496  **/
 497 #define G_FILE_ATTRIBUTE_TIME_ACCESS_USEC "time::access-usec"     /* uint32 */
 498
 499 /**
 500  * G_FILE_ATTRIBUTE_TIME_CHANGED:
 501  *
 502  * A key in the "time" namespace for getting the time the file was last
 503  * changed. Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
 504  * and contains the UNIX time since the file was last changed.
 505  *
 506  * This corresponds to the traditional UNIX ctime.
 507  **/
 508 #define G_FILE_ATTRIBUTE_TIME_CHANGED "time::changed"             /* uint64 */
 509
 510 /**
 511  * G_FILE_ATTRIBUTE_TIME_CHANGED_USEC:
 512  *
 513  * A key in the "time" namespace for getting the microseconds of the time
 514  * the file was last changed. This should be used in conjunction with
 515  * #G_FILE_ATTRIBUTE_TIME_CHANGED. Corresponding #GFileAttributeType is
 516  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 517  **/
 518 #define G_FILE_ATTRIBUTE_TIME_CHANGED_USEC "time::changed-usec"   /* uint32 */
 519
 520 /**
 521  * G_FILE_ATTRIBUTE_TIME_CREATED:
 522  *
 523  * A key in the "time" namespace for getting the time the file was created.
 524  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
 525  * and contains the UNIX time since the file was created.
 526  *
 527  * This corresponds to the NTFS ctime.
 528  **/
 529 #define G_FILE_ATTRIBUTE_TIME_CREATED "time::created"             /* uint64 */
 530
 531 /**
 532  * G_FILE_ATTRIBUTE_TIME_CREATED_USEC:
 533  *
 534  * A key in the "time" namespace for getting the microseconds of the time
 535  * the file was created. This should be used in conjunction with
 536  * #G_FILE_ATTRIBUTE_TIME_CREATED. Corresponding #GFileAttributeType is
 537  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 538  **/
 539 #define G_FILE_ATTRIBUTE_TIME_CREATED_USEC "time::created-usec"   /* uint32 */
 540
 541 /* Unix specific attributes */
 542
 543 /**
 544  * G_FILE_ATTRIBUTE_UNIX_DEVICE:
 545  *
 546  * A key in the "unix" namespace for getting the device id of the device the
 547  * file is located on (see stat() documentation). This attribute is only
 548  * available for UNIX file systems. Corresponding #GFileAttributeType is
 549  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 550  **/
 551 #define G_FILE_ATTRIBUTE_UNIX_DEVICE "unix::device"               /* uint32 */
 552
 553 /**
 554  * G_FILE_ATTRIBUTE_UNIX_INODE:
 555  *
 556  * A key in the "unix" namespace for getting the inode of the file.
 557  * This attribute is only available for UNIX file systems. Corresponding
 558  * #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
 559  **/
 560 #define G_FILE_ATTRIBUTE_UNIX_INODE "unix::inode"                 /* uint64 */
 561
 562 /**
 563  * G_FILE_ATTRIBUTE_UNIX_MODE:
 564  *
 565  * A key in the "unix" namespace for getting the mode of the file
 566  * (e.g. whether the file is a regular file, symlink, etc). See lstat()
 567  * documentation. This attribute is only available for UNIX file systems.
 568  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 569  **/
 570 #define G_FILE_ATTRIBUTE_UNIX_MODE "unix::mode"                   /* uint32 */
 571
 572 /**
 573  * G_FILE_ATTRIBUTE_UNIX_NLINK:
 574  *
 575  * A key in the "unix" namespace for getting the number of hard links
 576  * for a file. See lstat() documentation. This attribute is only available
 577  * for UNIX file systems. Corresponding #GFileAttributeType is
 578  * %G_FILE_ATTRIBUTE_TYPE_UINT32.
 579  **/
 580 #define G_FILE_ATTRIBUTE_UNIX_NLINK "unix::nlink"                 /* uint32 */
 581
 582 /**
 583  * G_FILE_ATTRIBUTE_UNIX_UID:
 584  *
 585  * A key in the "unix" namespace for getting the user ID for the file.
 586  * This attribute is only available for UNIX file systems.
 587  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 588  **/
 589 #define G_FILE_ATTRIBUTE_UNIX_UID "unix::uid"                     /* uint32 */
 590
 591 /**
 592  * G_FILE_ATTRIBUTE_UNIX_GID:
 593  *
 594  * A key in the "unix" namespace for getting the group ID for the file.
 595  * This attribute is only available for UNIX file systems.
 596  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 597  **/
 598 #define G_FILE_ATTRIBUTE_UNIX_GID "unix::gid"                     /* uint32 */
 599
 600 /**
 601  * G_FILE_ATTRIBUTE_UNIX_RDEV:
 602  *
 603  * A key in the "unix" namespace for getting the device ID for the file
 604  * (if it is a special file). See lstat() documentation. This attribute
 605  * is only available for UNIX file systems. Corresponding #GFileAttributeType
 606  * is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 607  **/
 608 #define G_FILE_ATTRIBUTE_UNIX_RDEV "unix::rdev"                   /* uint32 */
 609
 610 /**
 611  * G_FILE_ATTRIBUTE_UNIX_BLOCK_SIZE:
 612  *
 613  * A key in the "unix" namespace for getting the block size for the file
 614  * system. This attribute is only available for UNIX file systems.
 615  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 616  **/
 617 #define G_FILE_ATTRIBUTE_UNIX_BLOCK_SIZE "unix::block-size"       /* uint32 */
 618
 619 /**
 620  * G_FILE_ATTRIBUTE_UNIX_BLOCKS:
 621  *
 622  * A key in the "unix" namespace for getting the number of blocks allocated
 623  * for the file. This attribute is only available for UNIX file systems.
 624  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
 625  **/
 626 #define G_FILE_ATTRIBUTE_UNIX_BLOCKS "unix::blocks"               /* uint64 */
 627
 628 /**
 629  * G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT:
 630  *
 631  * A key in the "unix" namespace for checking if the file represents a
 632  * UNIX mount point. This attribute is %TRUE if the file is a UNIX mount
 633  * point. This attribute is only available for UNIX file systems.
 634  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 635  **/
 636 #define G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT "unix::is-mountpoint" /* boolean */
 637
 638 /* DOS specific attributes */
 639
 640 /**
 641  * G_FILE_ATTRIBUTE_DOS_IS_ARCHIVE:
 642  *
 643  * A key in the "dos" namespace for checking if the file's archive flag
 644  * is set. This attribute is %TRUE if the archive flag is set. This attribute
 645  * is only available for DOS file systems. Corresponding #GFileAttributeType
 646  * is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 647  **/
 648 #define G_FILE_ATTRIBUTE_DOS_IS_ARCHIVE "dos::is-archive"         /* boolean */
 649
 650 /**
 651  * G_FILE_ATTRIBUTE_DOS_IS_SYSTEM:
 652  *
 653  * A key in the "dos" namespace for checking if the file's backup flag
 654  * is set. This attribute is %TRUE if the backup flag is set. This attribute
 655  * is only available for DOS file systems. Corresponding #GFileAttributeType
 656  * is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 657  **/
 658 #define G_FILE_ATTRIBUTE_DOS_IS_SYSTEM "dos::is-system"           /* boolean */
 659
 660 /* Owner attributes */
 661
 662 /**
 663  * G_FILE_ATTRIBUTE_OWNER_USER:
 664  *
 665  * A key in the "owner" namespace for getting the user name of the
 666  * file's owner. Corresponding #GFileAttributeType is
 667  * %G_FILE_ATTRIBUTE_TYPE_STRING.
 668  **/
 669 #define G_FILE_ATTRIBUTE_OWNER_USER "owner::user"                 /* string */
 670
 671 /**
 672  * G_FILE_ATTRIBUTE_OWNER_USER_REAL:
 673  *
 674  * A key in the "owner" namespace for getting the real name of the
 675  * user that owns the file. Corresponding #GFileAttributeType is
 676  * %G_FILE_ATTRIBUTE_TYPE_STRING.
 677  **/
 678 #define G_FILE_ATTRIBUTE_OWNER_USER_REAL "owner::user-real"       /* string */
 679
 680 /**
 681  * G_FILE_ATTRIBUTE_OWNER_GROUP:
 682  *
 683  * A key in the "owner" namespace for getting the file owner's group.
 684  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 685  **/
 686 #define G_FILE_ATTRIBUTE_OWNER_GROUP "owner::group"               /* string */
 687
 688 /* Thumbnails */
 689
 690 /**
 691  * G_FILE_ATTRIBUTE_THUMBNAIL_PATH:
 692  *
 693  * A key in the "thumbnail" namespace for getting the path to the thumbnail
 694  * image. Corresponding #GFileAttributeType is
 695  * %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
 696  **/
 697 #define G_FILE_ATTRIBUTE_THUMBNAIL_PATH "thumbnail::path"         /* bytestring */
 698 /**
 699  * G_FILE_ATTRIBUTE_THUMBNAILING_FAILED:
 700  *
 701  * A key in the "thumbnail" namespace for checking if thumbnailing failed.
 702  * This attribute is %TRUE if thumbnailing failed. Corresponding
 703  * #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 704  **/
 705 #define G_FILE_ATTRIBUTE_THUMBNAILING_FAILED "thumbnail::failed"         /* boolean */
 706
 707 /* Preview */
 708
 709 /**
 710  * G_FILE_ATTRIBUTE_PREVIEW_ICON:
 711  *
 712  * A key in the "preview" namespace for getting a #GIcon that can be
 713  * used to get preview of the file. For example, it may be a low
 714  * resolution thumbnail without metadata. Corresponding
 715  * #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.  The value
 716  * for this key should contain a #GIcon.
 717  *
 718  * Since: 2.20
 719  **/
 720 #define G_FILE_ATTRIBUTE_PREVIEW_ICON "preview::icon"         /* object (GIcon) */
 721
 722 /* File system info (for g_file_get_filesystem_info) */
 723
 724 /**
 725  * G_FILE_ATTRIBUTE_FILESYSTEM_SIZE:
 726  *
 727  * A key in the "filesystem" namespace for getting the total size (in bytes) of the file system,
 728  * used in g_file_query_filesystem_info(). Corresponding #GFileAttributeType
 729  * is %G_FILE_ATTRIBUTE_TYPE_UINT64.
 730  **/
 731 #define G_FILE_ATTRIBUTE_FILESYSTEM_SIZE "filesystem::size"                       /* uint64 */
 732
 733 /**
 734  * G_FILE_ATTRIBUTE_FILESYSTEM_FREE:
 735  *
 736  * A key in the "filesystem" namespace for getting the number of bytes of free space left on the
 737  * file system. Corresponding #GFileAttributeType is
 738  * %G_FILE_ATTRIBUTE_TYPE_UINT64.
 739  **/
 740 #define G_FILE_ATTRIBUTE_FILESYSTEM_FREE "filesystem::free"                       /* uint64 */
 741
 742 /**
 743  * G_FILE_ATTRIBUTE_FILESYSTEM_USED:
 744  *
 745  * A key in the "filesystem" namespace for getting the number of bytes of used on the
 746  * file system. Corresponding #GFileAttributeType is
 747  * %G_FILE_ATTRIBUTE_TYPE_UINT64.
 748  *
 749  * Since: 2.32
 750  */
 751 #define G_FILE_ATTRIBUTE_FILESYSTEM_USED "filesystem::used"                       /* uint64 */
 752
 753 /**
 754  * G_FILE_ATTRIBUTE_FILESYSTEM_TYPE:
 755  *
 756  * A key in the "filesystem" namespace for getting the file system's type.
 757  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 758  **/
 759 #define G_FILE_ATTRIBUTE_FILESYSTEM_TYPE "filesystem::type"                       /* string */
 760
 761 /**
 762  * G_FILE_ATTRIBUTE_FILESYSTEM_READONLY:
 763  *
 764  * A key in the "filesystem" namespace for checking if the file system
 765  * is read only. Is set to %TRUE if the file system is read only.
 766  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
 767  **/
 768 #define G_FILE_ATTRIBUTE_FILESYSTEM_READONLY "filesystem::readonly"               /* boolean */
 769
 770 /**
 771  * G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW:
 772  *
 773  * A key in the "filesystem" namespace for hinting a file manager
 774  * application whether it should preview (e.g. thumbnail) files on the
 775  * file system. The value for this key contain a
 776  * #GFilesystemPreviewType.
 777  **/
 778 #define G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW "filesystem::use-preview"        /* uint32 (GFilesystemPreviewType) */
 779
 780 /**
 781  * G_FILE_ATTRIBUTE_GVFS_BACKEND:
 782  *
 783  * A key in the "gvfs" namespace that gets the name of the current
 784  * GVFS backend in use. Corresponding #GFileAttributeType is
 785  * %G_FILE_ATTRIBUTE_TYPE_STRING.
 786  **/
 787 #define G_FILE_ATTRIBUTE_GVFS_BACKEND "gvfs::backend"             /* string */
 788
 789 /**
 790  * G_FILE_ATTRIBUTE_SELINUX_CONTEXT:
 791  *
 792  * A key in the "selinux" namespace for getting the file's SELinux
 793  * context. Corresponding #GFileAttributeType is
 794  * %G_FILE_ATTRIBUTE_TYPE_STRING. Note that this attribute is only
 795  * available if GLib has been built with SELinux support.
 796  **/
 797 #define G_FILE_ATTRIBUTE_SELINUX_CONTEXT "selinux::context"       /* string */
 798
 799 /**
 800  * G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT:
 801  *
 802  * A key in the "trash" namespace.  When requested against
 803  * "trash:///" returns the number of (toplevel) items in the trash folder.
 804  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
 805  **/
 806 #define G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT "trash::item-count"     /* uint32 */
 807
 808 /**
 809  * G_FILE_ATTRIBUTE_TRASH_ORIG_PATH:
 810  *
 811  * A key in the "trash" namespace.  When requested against
 812  * items in "trash:///", will return the original path to the file before it
 813  * was trashed. Corresponding #GFileAttributeType is
 814  * %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
 815  *
 816  * Since: 2.24.
 817  **/
 818 #define G_FILE_ATTRIBUTE_TRASH_ORIG_PATH "trash::orig-path"     /* byte string */
 819
 820 /**
 821  * G_FILE_ATTRIBUTE_TRASH_DELETION_DATE:
 822  *
 823  * A key in the "trash" namespace.  When requested against
 824  * items in "trash:///", will return the date and time when the file
 825  * was trashed. The format of the returned string is YYYY-MM-DDThh:mm:ss.
 826  * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
 827  *
 828  * Since: 2.24.
 829  **/
 830 #define G_FILE_ATTRIBUTE_TRASH_DELETION_DATE "trash::deletion-date"  /* string */
 831
 832 GType              g_file_info_get_type                  (void) G_GNUC_CONST;
 833
 834 GFileInfo *        g_file_info_new                       (void);
 835 GFileInfo *        g_file_info_dup                       (GFileInfo  *other);
 836 void               g_file_info_copy_into                 (GFileInfo  *src_info,
 837                                                           GFileInfo  *dest_info);
 838 gboolean           g_file_info_has_attribute             (GFileInfo  *info,
 839                                                           const char *attribute);
 840 gboolean           g_file_info_has_namespace             (GFileInfo  *info,
 841                                                           const char *name_space);
 842 char **            g_file_info_list_attributes           (GFileInfo  *info,
 843                                                           const char *name_space);
 844 gboolean           g_file_info_get_attribute_data        (GFileInfo  *info,
 845                                                           const char *attribute,
 846                                                           GFileAttributeType *type,
 847                                                           gpointer   *value_pp,
 848                                                           GFileAttributeStatus *status);
 849 GFileAttributeType g_file_info_get_attribute_type        (GFileInfo  *info,
 850                                                           const char *attribute);
 851 void               g_file_info_remove_attribute          (GFileInfo  *info,
 852                                                           const char *attribute);
 853 GFileAttributeStatus g_file_info_get_attribute_status    (GFileInfo  *info,
 854                                                           const char *attribute);
 855 gboolean           g_file_info_set_attribute_status      (GFileInfo  *info,
 856                                                           const char *attribute,
 857                                                           GFileAttributeStatus status);
 858 char *             g_file_info_get_attribute_as_string   (GFileInfo  *info,
 859                                                           const char *attribute);
 860 const char *       g_file_info_get_attribute_string      (GFileInfo  *info,
 861                                                           const char *attribute);
 862 const char *       g_file_info_get_attribute_byte_string (GFileInfo  *info,
 863                                                           const char *attribute);
 864 gboolean           g_file_info_get_attribute_boolean     (GFileInfo  *info,
 865                                                           const char *attribute);
 866 guint32            g_file_info_get_attribute_uint32      (GFileInfo  *info,
 867                                                           const char *attribute);
 868 gint32             g_file_info_get_attribute_int32       (GFileInfo  *info,
 869                                                           const char *attribute);
 870 guint64            g_file_info_get_attribute_uint64      (GFileInfo  *info,
 871                                                           const char *attribute);
 872 gint64             g_file_info_get_attribute_int64       (GFileInfo  *info,
 873                                                           const char *attribute);
 874 GObject *          g_file_info_get_attribute_object      (GFileInfo  *info,
 875                                                           const char *attribute);
 876 char **            g_file_info_get_attribute_stringv     (GFileInfo  *info,
 877                                                           const char *attribute);
 878
 879 void               g_file_info_set_attribute             (GFileInfo  *info,
 880                                                           const char *attribute,
 881                                                           GFileAttributeType type,
 882                                                           gpointer    value_p);
 883 void               g_file_info_set_attribute_string      (GFileInfo  *info,
 884                                                           const char *attribute,
 885                                                           const char *attr_value);
 886 void               g_file_info_set_attribute_byte_string (GFileInfo  *info,
 887                                                           const char *attribute,
 888                                                           const char *attr_value);
 889 void               g_file_info_set_attribute_boolean     (GFileInfo  *info,
 890                                                           const char *attribute,
 891                                                           gboolean    attr_value);
 892 void               g_file_info_set_attribute_uint32      (GFileInfo  *info,
 893                                                           const char *attribute,
 894                                                           guint32     attr_value);
 895 void               g_file_info_set_attribute_int32       (GFileInfo  *info,
 896                                                           const char *attribute,
 897                                                           gint32      attr_value);
 898 void               g_file_info_set_attribute_uint64      (GFileInfo  *info,
 899                                                           const char *attribute,
 900                                                           guint64     attr_value);
 901 void               g_file_info_set_attribute_int64       (GFileInfo  *info,
 902                                                           const char *attribute,
 903                                                           gint64      attr_value);
 904 void               g_file_info_set_attribute_object      (GFileInfo  *info,
 905                                                           const char *attribute,
 906                                                           GObject    *attr_value);
 907 void               g_file_info_set_attribute_stringv     (GFileInfo  *info,
 908                                                           const char *attribute,
 909                                                           char      **attr_value);
 910
 911 void               g_file_info_clear_status              (GFileInfo  *info);
 912
 913 /* Helper getters: */
 914 GDateTime *       g_file_info_get_get_deletion_date  (GFileInfo         *info);
 915 GFileType         g_file_info_get_file_type          (GFileInfo         *info);
 916 gboolean          g_file_info_get_is_hidden          (GFileInfo         *info);
 917 gboolean          g_file_info_get_is_backup          (GFileInfo         *info);
 918 gboolean          g_file_info_get_is_symlink         (GFileInfo         *info);
 919 const char *      g_file_info_get_name               (GFileInfo         *info);
 920 const char *      g_file_info_get_display_name       (GFileInfo         *info);
 921 const char *      g_file_info_get_edit_name          (GFileInfo         *info);
 922 GIcon *           g_file_info_get_icon               (GFileInfo         *info);
 923 GIcon *           g_file_info_get_symbolic_icon      (GFileInfo         *info);
 924 const char *      g_file_info_get_content_type       (GFileInfo         *info);
 925 goffset           g_file_info_get_size               (GFileInfo         *info);
 926 void              g_file_info_get_modification_time  (GFileInfo         *info,
 927                                                       GTimeVal          *result);
 928 const char *      g_file_info_get_symlink_target     (GFileInfo         *info);
 929 const char *      g_file_info_get_etag               (GFileInfo         *info);
 930 gint32            g_file_info_get_sort_order         (GFileInfo         *info);
 931
 932 void              g_file_info_set_attribute_mask     (GFileInfo         *info,
 933                                                       GFileAttributeMatcher *mask);
 934 void              g_file_info_unset_attribute_mask   (GFileInfo         *info);
 935
 936 /* Helper setters: */
 937 void              g_file_info_set_file_type          (GFileInfo         *info,
 938                                                       GFileType          type);
 939 void              g_file_info_set_is_hidden          (GFileInfo         *info,
 940                                                       gboolean           is_hidden);
 941 void              g_file_info_set_is_symlink         (GFileInfo         *info,
 942                                                       gboolean           is_symlink);
 943 void              g_file_info_set_name               (GFileInfo         *info,
 944                                                       const char        *name);
 945 void              g_file_info_set_display_name       (GFileInfo         *info,
 946                                                       const char        *display_name);
 947 void              g_file_info_set_edit_name          (GFileInfo         *info,
 948                                                       const char        *edit_name);
 949 void              g_file_info_set_icon               (GFileInfo         *info,
 950                                                       GIcon             *icon);
 951 void              g_file_info_set_symbolic_icon      (GFileInfo         *info,
 952                                                       GIcon             *icon);
 953 void              g_file_info_set_content_type       (GFileInfo         *info,
 954                                                       const char        *content_type);
 955 void              g_file_info_set_size               (GFileInfo         *info,
 956                                                       goffset            size);
 957 void              g_file_info_set_modification_time  (GFileInfo         *info,
 958                                                       GTimeVal          *mtime);
 959 void              g_file_info_set_symlink_target     (GFileInfo         *info,
 960                                                       const char        *symlink_target);
 961 void              g_file_info_set_sort_order         (GFileInfo         *info,
 962                                                       gint32             sort_order);
 963
 964 #define G_TYPE_FILE_ATTRIBUTE_MATCHER (g_file_attribute_matcher_get_type ())
 965 GType g_file_attribute_matcher_get_type (void) G_GNUC_CONST;
 966
 967 GFileAttributeMatcher *g_file_attribute_matcher_new            (const char            *attributes);
 968 GFileAttributeMatcher *g_file_attribute_matcher_ref            (GFileAttributeMatcher *matcher);
 969 void                   g_file_attribute_matcher_unref          (GFileAttributeMatcher *matcher);
 970 GFileAttributeMatcher *g_file_attribute_matcher_subtract       (GFileAttributeMatcher *matcher,
 971                                                                 GFileAttributeMatcher *subtract);
 972 gboolean               g_file_attribute_matcher_matches        (GFileAttributeMatcher *matcher,
 973                                                                 const char            *attribute);
 974 gboolean               g_file_attribute_matcher_matches_only   (GFileAttributeMatcher *matcher,
 975                                                                 const char            *attribute);
 976 gboolean               g_file_attribute_matcher_enumerate_namespace (GFileAttributeMatcher *matcher,
 977                                                                      const char            *ns);
 978 const char *           g_file_attribute_matcher_enumerate_next (GFileAttributeMatcher *matcher);
 979 GLIB_AVAILABLE_IN_2_32
 980 char *                 g_file_attribute_matcher_to_string      (GFileAttributeMatcher *matcher);
 981
 982 G_END_DECLS
 983
 984 #endif /* __G_FILE_INFO_H__ */