libnautilus-private/nautilus-file.h

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-
   2
   3    nautilus-file.h: Nautilus file model.
   4
   5    Copyright (C) 1999, 2000, 2001 Eazel, Inc.
   6
   7    This program is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU General Public License as
   9    published by the Free Software Foundation; either version 2 of the
  10    License, or (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public
  18    License along with this program; if not, write to the
  19    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.
  21
  22    Author: Darin Adler <darin@bentspoon.com>
  23 */
  24
  25 #ifndef NAUTILUS_FILE_H
  26 #define NAUTILUS_FILE_H
  27
  28 #include <gtk/gtkobject.h>
  29 #include <gio/gio.h>
  30 #include <libnautilus-private/nautilus-file-attributes.h>
  31 #include <libnautilus-private/nautilus-icon-info.h>
  32
  33 /* NautilusFile is an object used to represent a single element of a
  34  * NautilusDirectory. It's lightweight and relies on NautilusDirectory
  35  * to do most of the work.
  36  */
  37
  38 /* NautilusFile is defined both here and in nautilus-directory.h. */
  39 #ifndef NAUTILUS_FILE_DEFINED
  40 #define NAUTILUS_FILE_DEFINED
  41 typedef struct NautilusFile NautilusFile;
  42 #endif
  43
  44 #define NAUTILUS_TYPE_FILE \
  45         (nautilus_file_get_type ())
  46 #define NAUTILUS_FILE(obj) \
  47         (GTK_CHECK_CAST ((obj), NAUTILUS_TYPE_FILE, NautilusFile))
  48 #define NAUTILUS_FILE_CLASS(klass) \
  49         (GTK_CHECK_CLASS_CAST ((klass), NAUTILUS_TYPE_FILE, NautilusFileClass))
  50 #define NAUTILUS_IS_FILE(obj) \
  51         (GTK_CHECK_TYPE ((obj), NAUTILUS_TYPE_FILE))
  52 #define NAUTILUS_IS_FILE_CLASS(klass) \
  53         (GTK_CHECK_CLASS_TYPE ((klass), NAUTILUS_TYPE_FILE))
  54 #define NAUTILUS_FILE_GET_CLASS(obj) \
  55         (G_TYPE_INSTANCE_GET_CLASS ((obj), NAUTILUS_TYPE_FILE, NautilusFileClass))
  56
  57 typedef enum {
  58         NAUTILUS_FILE_SORT_NONE,
  59         NAUTILUS_FILE_SORT_BY_DISPLAY_NAME,
  60         NAUTILUS_FILE_SORT_BY_DIRECTORY,
  61         NAUTILUS_FILE_SORT_BY_SIZE,
  62         NAUTILUS_FILE_SORT_BY_TYPE,
  63         NAUTILUS_FILE_SORT_BY_MTIME,
  64         NAUTILUS_FILE_SORT_BY_ATIME,
  65         NAUTILUS_FILE_SORT_BY_EMBLEMS
  66 } NautilusFileSortType;
  67
  68 typedef enum {
  69         NAUTILUS_REQUEST_NOT_STARTED,
  70         NAUTILUS_REQUEST_IN_PROGRESS,
  71         NAUTILUS_REQUEST_DONE
  72 } NautilusRequestStatus;
  73
  74 typedef enum {
  75         NAUTILUS_FILE_ICON_FLAGS_NONE = 0,
  76         NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS = (1<<0),
  77         NAUTILUS_FILE_ICON_FLAGS_IGNORE_VISITING = (1<<1),
  78         NAUTILUS_FILE_ICON_FLAGS_EMBEDDING_TEXT = (1<<2),
  79         NAUTILUS_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT = (1<<3),
  80         NAUTILUS_FILE_ICON_FLAGS_FOR_OPEN_FOLDER = (1<<4)
  81 } NautilusFileIconFlags;
  82
  83 /* Emblems sometimes displayed for NautilusFiles. Do not localize. */
  84 #define NAUTILUS_FILE_EMBLEM_NAME_SYMBOLIC_LINK "symbolic-link"
  85 #define NAUTILUS_FILE_EMBLEM_NAME_CANT_READ "noread"
  86 #define NAUTILUS_FILE_EMBLEM_NAME_CANT_WRITE "nowrite"
  87 #define NAUTILUS_FILE_EMBLEM_NAME_TRASH "trash"
  88 #define NAUTILUS_FILE_EMBLEM_NAME_NOTE "note"
  89 #define NAUTILUS_FILE_EMBLEM_NAME_DESKTOP "desktop"
  90
  91 typedef void (*NautilusFileCallback)          (NautilusFile  *file,
  92                                                gpointer       callback_data);
  93 typedef void (*NautilusFileListCallback)      (GList         *file_list,
  94                                                gpointer       callback_data);
  95 typedef void (*NautilusFileOperationCallback) (NautilusFile  *file,
  96                                                GFile         *result_location,
  97                                                GError        *error,
  98                                                gpointer       callback_data);
  99 typedef int (*NautilusWidthMeasureCallback)   (const char    *string,
 100                                                void          *context);
 101 typedef char * (*NautilusTruncateCallback)    (const char    *string,
 102                                                int            width,
 103                                                void          *context);
 104
 105
 106 #define NAUTILUS_FILE_ATTRIBUTES_FOR_ICON (NAUTILUS_FILE_ATTRIBUTE_INFO | NAUTILUS_FILE_ATTRIBUTE_LINK_INFO |NAUTILUS_FILE_ATTRIBUTE_METADATA | NAUTILUS_FILE_ATTRIBUTE_THUMBNAIL)
 107
 108 typedef void NautilusFileListHandle;
 109
 110 /* GObject requirements. */
 111 GType                   nautilus_file_get_type                          (void);
 112
 113 /* Getting at a single file. */
 114 NautilusFile *          nautilus_file_get                               (GFile                          *location);
 115 NautilusFile *          nautilus_file_get_by_uri                        (const char                     *uri);
 116
 117 /* Get a file only if the nautilus version already exists */
 118 NautilusFile *          nautilus_file_get_existing                      (GFile                          *location);
 119 NautilusFile *          nautilus_file_get_existing_by_uri               (const char                     *uri);
 120
 121 /* Covers for gtk_object_ref and gtk_object_unref that provide two conveniences:
 122  * 1) You don't have to cast to GtkObject *, so using these is type safe.
 123  * 2) You are allowed to call these with NULL,
 124  */
 125 NautilusFile *          nautilus_file_ref                               (NautilusFile                   *file);
 126 void                    nautilus_file_unref                             (NautilusFile                   *file);
 127
 128 /* Monitor the file. */
 129 void                    nautilus_file_monitor_add                       (NautilusFile                   *file,
 130                                                                          gconstpointer                   client,
 131                                                                          NautilusFileAttributes          attributes);
 132 void                    nautilus_file_monitor_remove                    (NautilusFile                   *file,
 133                                                                          gconstpointer                   client);
 134
 135 /* Waiting for data that's read asynchronously.
 136  * This interface currently works only for metadata, but could be expanded
 137  * to other attributes as well.
 138  */
 139 void                    nautilus_file_call_when_ready                   (NautilusFile                   *file,
 140                                                                          NautilusFileAttributes          attributes,
 141                                                                          NautilusFileCallback            callback,
 142                                                                          gpointer                        callback_data);
 143 void                    nautilus_file_cancel_call_when_ready            (NautilusFile                   *file,
 144                                                                          NautilusFileCallback            callback,
 145                                                                          gpointer                        callback_data);
 146 gboolean                nautilus_file_check_if_ready                    (NautilusFile                   *file,
 147                                                                          NautilusFileAttributes          attributes);
 148 void                    nautilus_file_invalidate_attributes             (NautilusFile                   *file,
 149                                                                          NautilusFileAttributes          attributes);
 150 void                    nautilus_file_invalidate_all_attributes         (NautilusFile                   *file);
 151
 152 /* Basic attributes for file objects. */
 153 gboolean                nautilus_file_contains_text                     (NautilusFile                   *file);
 154 char *                  nautilus_file_get_display_name                  (NautilusFile                   *file);
 155 char *                  nautilus_file_get_edit_name                     (NautilusFile                   *file);
 156 char *                  nautilus_file_get_name                          (NautilusFile                   *file);
 157 GFile *                 nautilus_file_get_location                      (NautilusFile                   *file);
 158 char *                  nautilus_file_get_uri                           (NautilusFile                   *file);
 159 char *                  nautilus_file_get_uri_scheme                    (NautilusFile                   *file);
 160 NautilusFile *          nautilus_file_get_parent                        (NautilusFile                   *file);
 161 GFile *                 nautilus_file_get_parent_location               (NautilusFile                   *file);
 162 char *                  nautilus_file_get_parent_uri                    (NautilusFile                   *file);
 163 char *                  nautilus_file_get_parent_uri_for_display        (NautilusFile                   *file);
 164 gboolean                nautilus_file_can_get_size                      (NautilusFile                   *file);
 165 goffset                 nautilus_file_get_size                          (NautilusFile                   *file);
 166 time_t                  nautilus_file_get_mtime                         (NautilusFile                   *file);
 167 GFileType               nautilus_file_get_file_type                     (NautilusFile                   *file);
 168 char *                  nautilus_file_get_mime_type                     (NautilusFile                   *file);
 169 gboolean                nautilus_file_is_mime_type                      (NautilusFile                   *file,
 170                                                                          const char                     *mime_type);
 171 gboolean                nautilus_file_is_launchable                     (NautilusFile                   *file);
 172 gboolean                nautilus_file_is_symbolic_link                  (NautilusFile                   *file);
 173 gboolean                nautilus_file_is_mountpoint                     (NautilusFile                   *file);
 174 GMount *                nautilus_file_get_mount                         (NautilusFile                   *file);
 175 char *                  nautilus_file_get_volume_free_space             (NautilusFile                   *file);
 176 char *                  nautilus_file_get_volume_name                   (NautilusFile                   *file);
 177 char *                  nautilus_file_get_symbolic_link_target_path     (NautilusFile                   *file);
 178 char *                  nautilus_file_get_symbolic_link_target_uri      (NautilusFile                   *file);
 179 gboolean                nautilus_file_is_broken_symbolic_link           (NautilusFile                   *file);
 180 gboolean                nautilus_file_is_nautilus_link                  (NautilusFile                   *file);
 181 gboolean                nautilus_file_is_executable                     (NautilusFile                   *file);
 182 gboolean                nautilus_file_is_directory                      (NautilusFile                   *file);
 183 gboolean                nautilus_file_is_in_trash                       (NautilusFile                   *file);
 184 gboolean                nautilus_file_is_in_desktop                     (NautilusFile                   *file);
 185 gboolean                nautilus_file_is_home                           (NautilusFile                   *file);
 186 gboolean                nautilus_file_is_desktop_directory              (NautilusFile                   *file);
 187 GError *                nautilus_file_get_file_info_error               (NautilusFile                   *file);
 188 gboolean                nautilus_file_get_directory_item_count          (NautilusFile                   *file,
 189                                                                          guint                          *count,
 190                                                                          gboolean                       *count_unreadable);
 191 void                    nautilus_file_recompute_deep_counts             (NautilusFile                   *file);
 192 NautilusRequestStatus   nautilus_file_get_deep_counts                   (NautilusFile                   *file,
 193                                                                          guint                          *directory_count,
 194                                                                          guint                          *file_count,
 195                                                                          guint                          *unreadable_directory_count,
 196                                                                          goffset               *total_size,
 197                                                                          gboolean                        force);
 198 gboolean                nautilus_file_should_show_thumbnail             (NautilusFile                   *file);
 199 gboolean                nautilus_file_should_show_directory_item_count  (NautilusFile                   *file);
 200 gboolean                nautilus_file_should_show_type                  (NautilusFile                   *file);
 201 GList *                 nautilus_file_get_keywords                      (NautilusFile                   *file);
 202 void                    nautilus_file_set_keywords                      (NautilusFile                   *file,
 203                                                                          GList                          *keywords);
 204 GList *                 nautilus_file_get_emblem_icons                  (NautilusFile                   *file,
 205                                                                          char                          **exclude);
 206 GList *                 nautilus_file_get_emblem_pixbufs                (NautilusFile                   *file,
 207                                                                          int                             size,
 208                                                                          gboolean                        force_size,
 209                                                                          char                          **exclude);
 210 char *                  nautilus_file_get_top_left_text                 (NautilusFile                   *file);
 211 char *                  nautilus_file_peek_top_left_text                (NautilusFile                   *file,
 212                                                                          gboolean                        need_large_text,
 213                                                                          gboolean                       *got_top_left_text);
 214 gboolean                nautilus_file_get_directory_item_mime_types     (NautilusFile                   *file,
 215                                                                          GList                         **mime_list);
 216
 217 void                    nautilus_file_set_attributes                    (NautilusFile                   *file,
 218                                                                          GFileInfo                      *attributes,
 219                                                                          NautilusFileOperationCallback   callback,
 220                                                                          gpointer                        callback_data);
 221 GFilesystemPreviewType  nautilus_file_get_filesystem_use_preview        (NautilusFile *file);
 222
 223 /* Permissions. */
 224 gboolean                nautilus_file_can_get_permissions               (NautilusFile                   *file);
 225 gboolean                nautilus_file_can_set_permissions               (NautilusFile                   *file);
 226 guint                   nautilus_file_get_permissions                   (NautilusFile                   *file);
 227 gboolean                nautilus_file_can_get_owner                     (NautilusFile                   *file);
 228 gboolean                nautilus_file_can_set_owner                     (NautilusFile                   *file);
 229 gboolean                nautilus_file_can_get_group                     (NautilusFile                   *file);
 230 gboolean                nautilus_file_can_set_group                     (NautilusFile                   *file);
 231 char *                  nautilus_file_get_owner_name                    (NautilusFile                   *file);
 232 char *                  nautilus_file_get_group_name                    (NautilusFile                   *file);
 233 GList *                 nautilus_get_user_names                         (void);
 234 GList *                 nautilus_get_all_group_names                    (void);
 235 GList *                 nautilus_file_get_settable_group_names          (NautilusFile                   *file);
 236 gboolean                nautilus_file_can_get_selinux_context           (NautilusFile                   *file);
 237 char *                  nautilus_file_get_selinux_context               (NautilusFile                   *file);
 238
 239 /* "Capabilities". */
 240 gboolean                nautilus_file_can_read                          (NautilusFile                   *file);
 241 gboolean                nautilus_file_can_write                         (NautilusFile                   *file);
 242 gboolean                nautilus_file_can_execute                       (NautilusFile                   *file);
 243 gboolean                nautilus_file_can_rename                        (NautilusFile                   *file);
 244 gboolean                nautilus_file_can_delete                        (NautilusFile                   *file);
 245 gboolean                nautilus_file_can_trash                         (NautilusFile                   *file);
 246
 247 gboolean                nautilus_file_can_mount                         (NautilusFile                   *file);
 248 gboolean                nautilus_file_can_unmount                       (NautilusFile                   *file);
 249 gboolean                nautilus_file_can_eject                         (NautilusFile                   *file);
 250
 251 void                    nautilus_file_mount                             (NautilusFile                   *file,
 252                                                                          GMountOperation                *mount_op,
 253                                                                          GCancellable                   *cancellable,
 254                                                                          NautilusFileOperationCallback   callback,
 255                                                                          gpointer                        callback_data);
 256 void                    nautilus_file_unmount                           (NautilusFile                   *file);
 257 void                    nautilus_file_eject                             (NautilusFile                   *file);
 258
 259 /* Basic operations for file objects. */
 260 void                    nautilus_file_set_owner                         (NautilusFile                   *file,
 261                                                                          const char                     *user_name_or_id,
 262                                                                          NautilusFileOperationCallback   callback,
 263                                                                          gpointer                        callback_data);
 264 void                    nautilus_file_set_group                         (NautilusFile                   *file,
 265                                                                          const char                     *group_name_or_id,
 266                                                                          NautilusFileOperationCallback   callback,
 267                                                                          gpointer                        callback_data);
 268 void                    nautilus_file_set_permissions                   (NautilusFile                   *file,
 269                                                                          guint32                         permissions,
 270                                                                          NautilusFileOperationCallback   callback,
 271                                                                          gpointer                        callback_data);
 272 void                    nautilus_file_rename                            (NautilusFile                   *file,
 273                                                                          const char                     *new_name,
 274                                                                          NautilusFileOperationCallback   callback,
 275                                                                          gpointer                        callback_data);
 276 void                    nautilus_file_cancel                            (NautilusFile                   *file,
 277                                                                          NautilusFileOperationCallback   callback,
 278                                                                          gpointer                        callback_data);
 279
 280 /* Return true if this file has already been deleted.
 281  * This object will be unref'd after sending the files_removed signal,
 282  * but it could hang around longer if someone ref'd it.
 283  */
 284 gboolean                nautilus_file_is_gone                           (NautilusFile                   *file);
 285
 286 /* Return true if this file is not confirmed to have ever really
 287  * existed. This is true when the NautilusFile object has been created, but no I/O
 288  * has yet confirmed the existence of a file by that name.
 289  */
 290 gboolean                nautilus_file_is_not_yet_confirmed              (NautilusFile                   *file);
 291
 292 /* Simple getting and setting top-level metadata. */
 293 char *                  nautilus_file_get_metadata                      (NautilusFile                   *file,
 294                                                                          const char                     *key,
 295                                                                          const char                     *default_metadata);
 296 GList *                 nautilus_file_get_metadata_list                 (NautilusFile                   *file,
 297                                                                          const char                     *list_key,
 298                                                                          const char                     *list_subkey);
 299 void                    nautilus_file_set_metadata                      (NautilusFile                   *file,
 300                                                                          const char                     *key,
 301                                                                          const char                     *default_metadata,
 302                                                                          const char                     *metadata);
 303 void                    nautilus_file_set_metadata_list                 (NautilusFile                   *file,
 304                                                                          const char                     *list_key,
 305                                                                          const char                     *list_subkey,
 306                                                                          GList                          *list);
 307
 308 /* Covers for common data types. */
 309 gboolean                nautilus_file_get_boolean_metadata              (NautilusFile                   *file,
 310                                                                          const char                     *key,
 311                                                                          gboolean                        default_metadata);
 312 void                    nautilus_file_set_boolean_metadata              (NautilusFile                   *file,
 313                                                                          const char                     *key,
 314                                                                          gboolean                        default_metadata,
 315                                                                          gboolean                        metadata);
 316 int                     nautilus_file_get_integer_metadata              (NautilusFile                   *file,
 317                                                                          const char                     *key,
 318                                                                          int                             default_metadata);
 319 void                    nautilus_file_set_integer_metadata              (NautilusFile                   *file,
 320                                                                          const char                     *key,
 321                                                                          int                             default_metadata,
 322                                                                          int                             metadata);
 323
 324
 325 /* Attributes for file objects as user-displayable strings. */
 326 char *                  nautilus_file_get_string_attribute              (NautilusFile                   *file,
 327                                                                          const char                     *attribute_name);
 328 char *                  nautilus_file_get_string_attribute_q            (NautilusFile                   *file,
 329                                                                          GQuark                          attribute_q);
 330 char *                  nautilus_file_get_string_attribute_with_default (NautilusFile                   *file,
 331                                                                          const char                     *attribute_name);
 332 char *                  nautilus_file_get_string_attribute_with_default_q (NautilusFile                  *file,
 333                                                                          GQuark                          attribute_q);
 334 char *                  nautilus_file_fit_modified_date_as_string       (NautilusFile                   *file,
 335                                                                          int                             width,
 336                                                                          NautilusWidthMeasureCallback    measure_callback,
 337                                                                          NautilusTruncateCallback        truncate_callback,
 338                                                                          void                           *measure_truncate_context);
 339
 340 /* Matching with another URI. */
 341 gboolean                nautilus_file_matches_uri                       (NautilusFile                   *file,
 342                                                                          const char                     *uri);
 343
 344 /* Is the file local? */
 345 gboolean                nautilus_file_is_local                          (NautilusFile                   *file);
 346
 347 /* Comparing two file objects for sorting */
 348 int                     nautilus_file_compare_for_sort                  (NautilusFile                   *file_1,
 349                                                                          NautilusFile                   *file_2,
 350                                                                          NautilusFileSortType            sort_type,
 351                                                                          gboolean                        directories_first,
 352                                                                          gboolean                        reversed);
 353 int                     nautilus_file_compare_for_sort_by_attribute     (NautilusFile                   *file_1,
 354                                                                          NautilusFile                   *file_2,
 355                                                                          const char                     *attribute,
 356                                                                          gboolean                        directories_first,
 357                                                                          gboolean                        reversed);
 358 int                     nautilus_file_compare_for_sort_by_attribute_q   (NautilusFile                   *file_1,
 359                                                                          NautilusFile                   *file_2,
 360                                                                          GQuark                          attribute,
 361                                                                          gboolean                        directories_first,
 362                                                                          gboolean                        reversed);
 363 int                     nautilus_file_compare_display_name              (NautilusFile                   *file_1,
 364                                                                          const char                     *pattern);
 365
 366 /* filtering functions for use by various directory views */
 367 gboolean                nautilus_file_is_hidden_file                    (NautilusFile                   *file);
 368 gboolean                nautilus_file_is_backup_file                    (NautilusFile                   *file);
 369 gboolean                nautilus_file_should_show                       (NautilusFile                   *file,
 370                                                                          gboolean                        show_hidden,
 371                                                                          gboolean                        show_backup);
 372 GList                  *nautilus_file_list_filter_hidden_and_backup     (GList                          *files,
 373                                                                          gboolean                        show_hidden,
 374                                                                          gboolean                        show_backup);
 375
 376
 377 /* Get the URI that's used when activating the file.
 378  * Getting this can require reading the contents of the file.
 379  */
 380 gboolean                nautilus_file_is_launcher                       (NautilusFile                   *file);
 381 gboolean                nautilus_file_has_activation_uri                (NautilusFile                   *file);
 382 char *                  nautilus_file_get_activation_uri                (NautilusFile                   *file);
 383 GFile *                 nautilus_file_get_activation_location           (NautilusFile                   *file);
 384
 385 char *                  nautilus_file_get_drop_target_uri               (NautilusFile                   *file);
 386
 387 /* Get custom icon (if specified by metadata or link contents) */
 388 char *                  nautilus_file_get_custom_icon                   (NautilusFile                   *file);
 389
 390
 391 GIcon *                 nautilus_file_get_gicon                         (NautilusFile                   *file,
 392                                                                          NautilusFileIconFlags           flags);
 393 NautilusIconInfo *      nautilus_file_get_icon                          (NautilusFile                   *file,
 394                                                                          int                             size,
 395                                                                          NautilusFileIconFlags           flags);
 396 GdkPixbuf *             nautilus_file_get_icon_pixbuf                   (NautilusFile                   *file,
 397                                                                          int                             size,
 398                                                                          gboolean                        force_size,
 399                                                                          NautilusFileIconFlags           flags);
 400
 401 gboolean                nautilus_file_has_open_window                   (NautilusFile                   *file);
 402 void                    nautilus_file_set_has_open_window               (NautilusFile                   *file,
 403                                                                          gboolean                        has_open_window);
 404
 405 /* Thumbnailing handling */
 406 gboolean                nautilus_file_is_thumbnailing                   (NautilusFile                   *file);
 407
 408 /* Convenience functions for dealing with a list of NautilusFile objects that each have a ref.
 409  * These are just convenient names for functions that work on lists of GtkObject *.
 410  */
 411 GList *                 nautilus_file_list_ref                          (GList                          *file_list);
 412 void                    nautilus_file_list_unref                        (GList                          *file_list);
 413 void                    nautilus_file_list_free                         (GList                          *file_list);
 414 GList *                 nautilus_file_list_copy                         (GList                          *file_list);
 415 GList *                 nautilus_file_list_sort_by_display_name         (GList                          *file_list);
 416 void                    nautilus_file_list_call_when_ready              (GList                          *file_list,
 417                                                                          NautilusFileAttributes          attributes,
 418                                                                          NautilusFileListHandle        **handle,
 419                                                                          NautilusFileListCallback        callback,
 420                                                                          gpointer                        callback_data);
 421 void                    nautilus_file_list_cancel_call_when_ready       (NautilusFileListHandle         *handle);
 422
 423 /* Debugging */
 424 void                    nautilus_file_dump                              (NautilusFile                   *file);
 425
 426 typedef struct NautilusFileDetails NautilusFileDetails;
 427
 428 struct NautilusFile {
 429         GObject parent_slot;
 430         NautilusFileDetails *details;
 431 };
 432
 433 /* This is actually a "protected" type, but it must be here so we can
 434  * compile the get_date function pointer declaration below.
 435  */
 436 typedef enum {
 437         NAUTILUS_DATE_TYPE_MODIFIED,
 438         NAUTILUS_DATE_TYPE_CHANGED,
 439         NAUTILUS_DATE_TYPE_ACCESSED,
 440         NAUTILUS_DATE_TYPE_PERMISSIONS_CHANGED
 441 } NautilusDateType;
 442
 443 typedef struct {
 444         GObjectClass parent_slot;
 445
 446         /* Subclasses can set this to something other than G_FILE_TYPE_UNKNOWN and
 447            it will be used as the default file type. This is useful when creating
 448            a "virtual" NautilusFile subclass that you can't actually get real
 449            information about. For exaple NautilusDesktopDirectoryFile. */
 450         GFileType default_file_type;
 451
 452         /* Called when the file notices any change. */
 453         void                  (* changed)                (NautilusFile *file);
 454
 455         /* Called periodically while directory deep count is being computed. */
 456         void                  (* updated_deep_count_in_progress) (NautilusFile *file);
 457
 458         /* Virtual functions (mainly used for trash directory). */
 459         void                  (* monitor_add)            (NautilusFile           *file,
 460                                                           gconstpointer           client,
 461                                                           NautilusFileAttributes  attributes);
 462         void                  (* monitor_remove)         (NautilusFile           *file,
 463                                                           gconstpointer           client);
 464         void                  (* call_when_ready)        (NautilusFile           *file,
 465                                                           NautilusFileAttributes  attributes,
 466                                                           NautilusFileCallback    callback,
 467                                                           gpointer                callback_data);
 468         void                  (* cancel_call_when_ready) (NautilusFile           *file,
 469                                                           NautilusFileCallback    callback,
 470                                                           gpointer                callback_data);
 471         gboolean              (* check_if_ready)         (NautilusFile           *file,
 472                                                           NautilusFileAttributes  attributes);
 473         gboolean              (* get_item_count)         (NautilusFile           *file,
 474                                                           guint                  *count,
 475                                                           gboolean               *count_unreadable);
 476         NautilusRequestStatus (* get_deep_counts)        (NautilusFile           *file,
 477                                                           guint                  *directory_count,
 478                                                           guint                  *file_count,
 479                                                           guint                  *unreadable_directory_count,
 480                                                           goffset       *total_size);
 481         gboolean              (* get_date)               (NautilusFile           *file,
 482                                                           NautilusDateType        type,
 483                                                           time_t                 *date);
 484         char *                (* get_where_string)       (NautilusFile           *file);
 485
 486         void                  (* mount)                  (NautilusFile                   *file,
 487                                                           GMountOperation                *mount_op,
 488                                                           GCancellable                   *cancellable,
 489                                                           NautilusFileOperationCallback   callback,
 490                                                           gpointer                        callback_data);
 491         void                 (* unmount)                 (NautilusFile *file);
 492         void                 (* eject)                   (NautilusFile *file);
 493 } NautilusFileClass;
 494
 495 #endif /* NAUTILUS_FILE_H */