summaryrefslogtreecommitdiff
path: root/libcaja-private/caja-file.h
blob: f279cbe63f0265080f2c5f734e6d5c2578231097 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-

   caja-file.h: Caja file model.

   Copyright (C) 1999, 2000, 2001 Eazel, Inc.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public
   License along with this program; if not, write to the
   Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
   Boston, MA 02110-1301, USA.

   Author: Darin Adler <darin@bentspoon.com>
*/

#ifndef CAJA_FILE_H
#define CAJA_FILE_H

#include <gtk/gtk.h>
#include <gio/gio.h>
#include <libcaja-private/caja-file-attributes.h>
#include <libcaja-private/caja-icon-info.h>

G_BEGIN_DECLS

/* CajaFile is an object used to represent a single element of a
 * CajaDirectory. It's lightweight and relies on CajaDirectory
 * to do most of the work.
 */

/* CajaFile is defined both here and in caja-directory.h. */
#ifndef CAJA_FILE_DEFINED
#define CAJA_FILE_DEFINED
typedef struct CajaFile CajaFile;
#endif

#define CAJA_TYPE_FILE caja_file_get_type()
#define CAJA_FILE(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), CAJA_TYPE_FILE, CajaFile))
#define CAJA_FILE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_CAST ((klass), CAJA_TYPE_FILE, CajaFileClass))
#define CAJA_IS_FILE(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CAJA_TYPE_FILE))
#define CAJA_IS_FILE_CLASS(klass) \
  (G_TYPE_CHECK_CLASS_TYPE ((klass), CAJA_TYPE_FILE))
#define CAJA_FILE_GET_CLASS(obj) \
  (G_TYPE_INSTANCE_GET_CLASS ((obj), CAJA_TYPE_FILE, CajaFileClass))

typedef enum
{
    CAJA_FILE_SORT_NONE,
    CAJA_FILE_SORT_BY_DISPLAY_NAME,
    CAJA_FILE_SORT_BY_DIRECTORY,
    CAJA_FILE_SORT_BY_SIZE,
    CAJA_FILE_SORT_BY_TYPE,
    CAJA_FILE_SORT_BY_MTIME,
    CAJA_FILE_SORT_BY_ATIME,
    CAJA_FILE_SORT_BY_EMBLEMS,
    CAJA_FILE_SORT_BY_TRASHED_TIME,
    CAJA_FILE_SORT_BY_SIZE_ON_DISK,
    CAJA_FILE_SORT_BY_EXTENSION
} CajaFileSortType;

typedef enum
{
    CAJA_REQUEST_NOT_STARTED,
    CAJA_REQUEST_IN_PROGRESS,
    CAJA_REQUEST_DONE
} CajaRequestStatus;

typedef enum
{
    CAJA_FILE_ICON_FLAGS_NONE = 0,
    CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS = (1<<0),
    CAJA_FILE_ICON_FLAGS_IGNORE_VISITING = (1<<1),
    CAJA_FILE_ICON_FLAGS_EMBEDDING_TEXT = (1<<2),
    CAJA_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT = (1<<3),
    CAJA_FILE_ICON_FLAGS_FOR_OPEN_FOLDER = (1<<4),
    /* whether the thumbnail size must match the display icon size */
    CAJA_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE = (1<<5),
    /* uses the icon of the mount if present */
    CAJA_FILE_ICON_FLAGS_USE_MOUNT_ICON = (1<<6),
    /* render the mount icon as an emblem over the regular one */
    CAJA_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM = (1<<7)
} CajaFileIconFlags;

/* Emblems sometimes displayed for CajaFiles. Do not localize. */
#define CAJA_FILE_EMBLEM_NAME_SYMBOLIC_LINK "symbolic-link"
#define CAJA_FILE_EMBLEM_NAME_CANT_READ "noread"
#define CAJA_FILE_EMBLEM_NAME_CANT_WRITE "nowrite"
#define CAJA_FILE_EMBLEM_NAME_TRASH "trash"
#define CAJA_FILE_EMBLEM_NAME_NOTE "note"
#define CAJA_FILE_EMBLEM_NAME_DESKTOP "desktop"
#define CAJA_FILE_EMBLEM_NAME_SHARED "shared"

typedef void (*CajaFileCallback)          (CajaFile  *file,
        gpointer       callback_data);
typedef void (*CajaFileListCallback)      (GList         *file_list,
        gpointer       callback_data);
typedef void (*CajaFileOperationCallback) (CajaFile  *file,
        GFile         *result_location,
        GError        *error,
        gpointer       callback_data);
typedef int (*CajaWidthMeasureCallback)   (const char    *string,
        void	     *context);
typedef char * (*CajaTruncateCallback)    (const char    *string,
        int	      width,
        void	     *context);


#define CAJA_FILE_ATTRIBUTES_FOR_ICON (CAJA_FILE_ATTRIBUTE_INFO | CAJA_FILE_ATTRIBUTE_LINK_INFO | CAJA_FILE_ATTRIBUTE_THUMBNAIL)

typedef void CajaFileListHandle;

/* GObject requirements. */
GType                   caja_file_get_type                          (void);

/* Getting at a single file. */
CajaFile *          caja_file_get                               (GFile                          *location);
CajaFile *          caja_file_get_by_uri                        (const char                     *uri);

/* Get a file only if the caja version already exists */
CajaFile *          caja_file_get_existing                      (GFile                          *location);
CajaFile *          caja_file_get_existing_by_uri               (const char                     *uri);

/* Covers for g_object_ref and g_object_unref that provide two conveniences:
 * 1) Using these is type safe.
 * 2) You are allowed to call these with NULL,
 */
CajaFile *          caja_file_ref                               (CajaFile                   *file);
void                    caja_file_unref                             (CajaFile                   *file);

/* Monitor the file. */
void                    caja_file_monitor_add                       (CajaFile                   *file,
        gconstpointer                   client,
        CajaFileAttributes          attributes);
void                    caja_file_monitor_remove                    (CajaFile                   *file,
        gconstpointer                   client);

/* Synchronously refreshes file info from disk.
 * This can call caja_file_changed, so don't call this function from any
 * of the callbacks for that event.
 */
void                     caja_file_refresh_info                     (CajaFile                   *file);

/* Waiting for data that's read asynchronously.
 * This interface currently works only for metadata, but could be expanded
 * to other attributes as well.
 */
void                    caja_file_call_when_ready                   (CajaFile                   *file,
        CajaFileAttributes          attributes,
        CajaFileCallback            callback,
        gpointer                        callback_data);
void                    caja_file_cancel_call_when_ready            (CajaFile                   *file,
        CajaFileCallback            callback,
        gpointer                        callback_data);
gboolean                caja_file_check_if_ready                    (CajaFile                   *file,
        CajaFileAttributes          attributes);
void                    caja_file_invalidate_attributes             (CajaFile                   *file,
        CajaFileAttributes          attributes);
void                    caja_file_invalidate_all_attributes         (CajaFile                   *file);

/* Basic attributes for file objects. */
gboolean                caja_file_contains_text                     (CajaFile                   *file);
gboolean                caja_file_is_binary                         (CajaFile                   *file);
char *                  caja_file_get_display_name                  (CajaFile                   *file);
char *                  caja_file_get_edit_name                     (CajaFile                   *file);
char *                  caja_file_get_name                          (CajaFile                   *file);
GFile *                 caja_file_get_location                      (CajaFile                   *file);
char *			 caja_file_get_description			 (CajaFile			 *file);
char *                  caja_file_get_uri                           (CajaFile                   *file);
char *                  caja_file_get_uri_scheme                    (CajaFile                   *file);
CajaFile *          caja_file_get_parent                        (CajaFile                   *file);
GFile *                 caja_file_get_parent_location               (CajaFile                   *file);
char *                  caja_file_get_parent_uri                    (CajaFile                   *file);
char *                  caja_file_get_parent_uri_for_display        (CajaFile                   *file);
gboolean                caja_file_can_get_size                      (CajaFile                   *file);
goffset                 caja_file_get_size                          (CajaFile                   *file);
goffset                 caja_file_get_size_on_disk                  (CajaFile                   *file);
time_t                  caja_file_get_mtime                         (CajaFile                   *file);
GFileType               caja_file_get_file_type                     (CajaFile                   *file);
char *                  caja_file_get_mime_type                     (CajaFile                   *file);
gboolean                caja_file_is_mime_type                      (CajaFile                   *file,
        const char                     *mime_type);
gboolean                caja_file_is_launchable                     (CajaFile                   *file);
gboolean                caja_file_is_symbolic_link                  (CajaFile                   *file);
gboolean                caja_file_is_mountpoint                     (CajaFile                   *file);
GMount *                caja_file_get_mount                         (CajaFile                   *file);
char *                  caja_file_get_volume_free_space             (CajaFile                   *file);
char *                  caja_file_get_volume_name                   (CajaFile                   *file);
char *                  caja_file_get_symbolic_link_target_path     (CajaFile                   *file);
char *                  caja_file_get_symbolic_link_target_uri      (CajaFile                   *file);
gboolean                caja_file_is_broken_symbolic_link           (CajaFile                   *file);
gboolean                caja_file_is_caja_link                  (CajaFile                   *file);
gboolean                caja_file_is_executable                     (CajaFile                   *file);
gboolean                caja_file_is_directory                      (CajaFile                   *file);
gboolean                caja_file_is_user_special_directory         (CajaFile                   *file,
        GUserDirectory                 special_directory);
gboolean		caja_file_is_archive			(CajaFile			*file);
gboolean                caja_file_is_in_trash                       (CajaFile                   *file);
gboolean                caja_file_is_in_desktop                     (CajaFile                   *file);
gboolean		caja_file_is_home				(CajaFile                   *file);
gboolean                caja_file_is_desktop_directory              (CajaFile                   *file);
GError *                caja_file_get_file_info_error               (CajaFile                   *file);
gboolean                caja_file_get_directory_item_count          (CajaFile                   *file,
        guint                          *count,
        gboolean                       *count_unreadable);
void                    caja_file_recompute_deep_counts             (CajaFile                   *file);
CajaRequestStatus   caja_file_get_deep_counts                   (CajaFile                   *file,
        guint                          *directory_count,
        guint                          *file_count,
        guint                          *unreadable_directory_count,
        goffset                        *total_size,
        goffset                        *total_size_on_disk,
        gboolean                        force);
gboolean                caja_file_should_show_thumbnail             (CajaFile                   *file);
gboolean                caja_file_should_show_directory_item_count  (CajaFile                   *file);
gboolean                caja_file_should_show_type                  (CajaFile                   *file);
GList *                 caja_file_get_keywords                      (CajaFile                   *file);
void                    caja_file_set_keywords                      (CajaFile                   *file,
        GList                          *keywords);
GList *                 caja_file_get_emblem_icons                  (CajaFile                   *file,
        char                          **exclude);
GList *                 caja_file_get_emblem_pixbufs                (CajaFile                   *file,
        int                             size,
        gboolean                        force_size,
        char                          **exclude);
char *                  caja_file_get_top_left_text                 (CajaFile                   *file);
char *                  caja_file_peek_top_left_text                (CajaFile                   *file,
        gboolean                        need_large_text,
        gboolean                       *got_top_left_text);

void                    caja_file_set_attributes                    (CajaFile                   *file,
        GFileInfo                      *attributes,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);
GFilesystemPreviewType  caja_file_get_filesystem_use_preview        (CajaFile *file);

char *                  caja_file_get_filesystem_id                 (CajaFile                   *file);

CajaFile *          caja_file_get_trash_original_file           (CajaFile                   *file);

/* Permissions. */
gboolean                caja_file_can_get_permissions               (CajaFile                   *file);
gboolean                caja_file_can_set_permissions               (CajaFile                   *file);
guint                   caja_file_get_permissions                   (CajaFile                   *file);
gboolean                caja_file_can_get_owner                     (CajaFile                   *file);
gboolean                caja_file_can_set_owner                     (CajaFile                   *file);
gboolean                caja_file_can_get_group                     (CajaFile                   *file);
gboolean                caja_file_can_set_group                     (CajaFile                   *file);
char *                  caja_file_get_owner_name                    (CajaFile                   *file);
char *                  caja_file_get_group_name                    (CajaFile                   *file);
GList *                 caja_get_user_names                         (void);
GList *                 caja_get_all_group_names                    (void);
GList *                 caja_file_get_settable_group_names          (CajaFile                   *file);
gboolean                caja_file_can_get_selinux_context           (CajaFile                   *file);
char *                  caja_file_get_selinux_context               (CajaFile                   *file);

/* "Capabilities". */
gboolean                caja_file_can_read                          (CajaFile                   *file);
gboolean                caja_file_can_write                         (CajaFile                   *file);
gboolean                caja_file_can_execute                       (CajaFile                   *file);
gboolean                caja_file_can_rename                        (CajaFile                   *file);
gboolean                caja_file_can_delete                        (CajaFile                   *file);
gboolean                caja_file_can_trash                         (CajaFile                   *file);

gboolean                caja_file_can_mount                         (CajaFile                   *file);
gboolean                caja_file_can_unmount                       (CajaFile                   *file);
gboolean                caja_file_can_eject                         (CajaFile                   *file);
gboolean                caja_file_can_start                         (CajaFile                   *file);
gboolean                caja_file_can_start_degraded                (CajaFile                   *file);
gboolean                caja_file_can_stop                          (CajaFile                   *file);
GDriveStartStopType     caja_file_get_start_stop_type               (CajaFile                   *file);
gboolean                caja_file_can_poll_for_media                (CajaFile                   *file);
gboolean                caja_file_is_media_check_automatic          (CajaFile                   *file);

void                    caja_file_mount                             (CajaFile                   *file,
        GMountOperation                *mount_op,
        GCancellable                   *cancellable,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);
void                    caja_file_unmount                           (CajaFile                   *file,
        GMountOperation                *mount_op,
        GCancellable                   *cancellable,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);
void                    caja_file_eject                             (CajaFile                   *file,
        GMountOperation                *mount_op,
        GCancellable                   *cancellable,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);

void                    caja_file_start                             (CajaFile                   *file,
        GMountOperation                *start_op,
        GCancellable                   *cancellable,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);
void                    caja_file_stop                              (CajaFile                   *file,
        GMountOperation                *mount_op,
        GCancellable                   *cancellable,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);
void                    caja_file_poll_for_media                    (CajaFile                   *file);

/* Basic operations for file objects. */
void                    caja_file_set_owner                         (CajaFile                   *file,
        const char                     *user_name_or_id,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);
void                    caja_file_set_group                         (CajaFile                   *file,
        const char                     *group_name_or_id,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);
void                    caja_file_set_permissions                   (CajaFile                   *file,
        guint32                         permissions,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);
void                    caja_file_rename                            (CajaFile                   *file,
        const char                     *new_name,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);
void                    caja_file_cancel                            (CajaFile                   *file,
        CajaFileOperationCallback   callback,
        gpointer                        callback_data);

/* Return true if this file has already been deleted.
 * This object will be unref'd after sending the files_removed signal,
 * but it could hang around longer if someone ref'd it.
 */
gboolean                caja_file_is_gone                           (CajaFile                   *file);

/* Return true if this file is not confirmed to have ever really
 * existed. This is true when the CajaFile object has been created, but no I/O
 * has yet confirmed the existence of a file by that name.
 */
gboolean                caja_file_is_not_yet_confirmed              (CajaFile                   *file);

/* Simple getting and setting top-level metadata. */
char *                  caja_file_get_metadata                      (CajaFile                   *file,
        const char                     *key,
        const char                     *default_metadata);
GList *                 caja_file_get_metadata_list                 (CajaFile                   *file,
        const char                     *key);
void                    caja_file_set_metadata                      (CajaFile                   *file,
        const char                     *key,
        const char                     *default_metadata,
        const char                     *metadata);
void                    caja_file_set_metadata_list                 (CajaFile                   *file,
        const char                     *key,
        GList                          *list);

/* Covers for common data types. */
gboolean                caja_file_get_boolean_metadata              (CajaFile                   *file,
        const char                     *key,
        gboolean                        default_metadata);
void                    caja_file_set_boolean_metadata              (CajaFile                   *file,
        const char                     *key,
        gboolean                        default_metadata,
        gboolean                        metadata);
int                     caja_file_get_integer_metadata              (CajaFile                   *file,
        const char                     *key,
        int                             default_metadata);
void                    caja_file_set_integer_metadata              (CajaFile                   *file,
        const char                     *key,
        int                             default_metadata,
        int                             metadata);

#define UNDEFINED_TIME ((time_t) (-1))

time_t                  caja_file_get_time_metadata                 (CajaFile                  *file,
        const char                    *key);
void                    caja_file_set_time_metadata                 (CajaFile                  *file,
        const char                    *key,
        time_t                         time);


/* Attributes for file objects as user-displayable strings. */
char *                  caja_file_get_string_attribute              (CajaFile                   *file,
        const char                     *attribute_name);
char *                  caja_file_get_string_attribute_q            (CajaFile                   *file,
        GQuark                          attribute_q);
char *                  caja_file_get_string_attribute_with_default (CajaFile                   *file,
        const char                     *attribute_name);
char *                  caja_file_get_string_attribute_with_default_q (CajaFile                  *file,
        GQuark                          attribute_q);
char *			caja_file_fit_modified_date_as_string	(CajaFile 			*file,
        int				 width,
        CajaWidthMeasureCallback    measure_callback,
        CajaTruncateCallback	 truncate_callback,
        void				*measure_truncate_context);

/* Matching with another URI. */
gboolean                caja_file_matches_uri                       (CajaFile                   *file,
        const char                     *uri);

/* Is the file local? */
gboolean                caja_file_is_local                          (CajaFile                   *file);

/* Comparing two file objects for sorting */
CajaFileSortType    caja_file_get_default_sort_type             (CajaFile                   *file,
        gboolean                       *reversed);
const gchar *           caja_file_get_default_sort_attribute        (CajaFile                   *file,
        gboolean                       *reversed);

int                     caja_file_compare_for_sort                  (CajaFile                   *file_1,
        CajaFile                   *file_2,
        CajaFileSortType            sort_type,
        gboolean			 directories_first,
        gboolean		  	 reversed);
int                     caja_file_compare_for_sort_by_attribute     (CajaFile                   *file_1,
        CajaFile                   *file_2,
        const char                     *attribute,
        gboolean                        directories_first,
        gboolean                        reversed);
int                     caja_file_compare_for_sort_by_attribute_q   (CajaFile                   *file_1,
        CajaFile                   *file_2,
        GQuark                          attribute,
        gboolean                        directories_first,
        gboolean                        reversed);
gboolean                caja_file_is_date_sort_attribute_q          (GQuark                          attribute);

int                     caja_file_compare_display_name              (CajaFile                   *file_1,
        const char                     *pattern);
int                     caja_file_compare_location                  (CajaFile                    *file_1,
        CajaFile                    *file_2);

/* filtering functions for use by various directory views */
gboolean                caja_file_is_hidden_file                    (CajaFile                   *file);
gboolean                caja_file_should_show                       (CajaFile                   *file,
        gboolean                        show_hidden,
        gboolean                        show_foreign,
        gboolean                        show_backup);
GList                  *caja_file_list_filter_hidden                (GList                          *files,
        gboolean                        show_hidden);


/* Get the URI that's used when activating the file.
 * Getting this can require reading the contents of the file.
 */
gboolean                caja_file_is_launcher                       (CajaFile                   *file);
gboolean                caja_file_is_foreign_link                   (CajaFile                   *file);
gboolean                caja_file_is_trusted_link                   (CajaFile                   *file);
gboolean                caja_file_has_activation_uri                (CajaFile                   *file);
char *                  caja_file_get_activation_uri                (CajaFile                   *file);
GFile *                 caja_file_get_activation_location           (CajaFile                   *file);

char *                  caja_file_get_drop_target_uri               (CajaFile                   *file);

/* Get custom icon (if specified by metadata or link contents) */
char *                  caja_file_get_custom_icon                   (CajaFile                   *file);


GIcon           *caja_file_get_gicon        (CajaFile         *file,
                                             CajaFileIconFlags flags);
CajaIconInfo    *caja_file_get_icon         (CajaFile         *file,
                                             int               size,
                                             int               scale,
                                             CajaFileIconFlags flags);
GdkPixbuf       *caja_file_get_icon_pixbuf  (CajaFile         *file,
                                             int               size,
                                             gboolean          force_size,
                                             int               scale,
                                             CajaFileIconFlags flags);
cairo_surface_t *caja_file_get_icon_surface (CajaFile         *file,
                                             int               size,
                                             gboolean          force_size,
                                             int               scale,
                                             CajaFileIconFlags flags);

gboolean                caja_file_has_open_window                   (CajaFile                   *file);
void                    caja_file_set_has_open_window               (CajaFile                   *file,
        gboolean                        has_open_window);

/* Thumbnailing handling */
gboolean                caja_file_is_thumbnailing                   (CajaFile                   *file);

/* Convenience functions for dealing with a list of CajaFile objects that each have a ref.
 * These are just convenient names for functions that work on lists of GtkObject *.
 */
GList *                 caja_file_list_ref                          (GList                          *file_list);
void                    caja_file_list_unref                        (GList                          *file_list);
void                    caja_file_list_free                         (GList                          *file_list);
GList *                 caja_file_list_copy                         (GList                          *file_list);
GList *			caja_file_list_sort_by_display_name		(GList				*file_list);
void                    caja_file_list_call_when_ready              (GList                          *file_list,
        CajaFileAttributes          attributes,
        CajaFileListHandle        **handle,
        CajaFileListCallback        callback,
        gpointer                        callback_data);
void                    caja_file_list_cancel_call_when_ready       (CajaFileListHandle         *handle);

/* Debugging */
void                    caja_file_dump                              (CajaFile                   *file);

typedef struct _CajaFilePrivate CajaFilePrivate;

struct CajaFile
{
    GObject parent_slot;
    CajaFilePrivate *details;
};

/* This is actually a "protected" type, but it must be here so we can
 * compile the get_date function pointer declaration below.
 */
typedef enum
{
    CAJA_DATE_TYPE_MODIFIED,
    CAJA_DATE_TYPE_CHANGED,
    CAJA_DATE_TYPE_ACCESSED,
    CAJA_DATE_TYPE_PERMISSIONS_CHANGED,
    CAJA_DATE_TYPE_TRASHED
} CajaDateType;

typedef struct
{
    GObjectClass parent_slot;

    /* Subclasses can set this to something other than G_FILE_TYPE_UNKNOWN and
       it will be used as the default file type. This is useful when creating
       a "virtual" CajaFile subclass that you can't actually get real
       information about. For exaple CajaDesktopDirectoryFile. */
    GFileType default_file_type;

    /* Called when the file notices any change. */
    void                  (* changed)                (CajaFile *file);

    /* Called periodically while directory deep count is being computed. */
    void                  (* updated_deep_count_in_progress) (CajaFile *file);

    /* Virtual functions (mainly used for trash directory). */
    void                  (* monitor_add)            (CajaFile           *file,
            gconstpointer           client,
            CajaFileAttributes  attributes);
    void                  (* monitor_remove)         (CajaFile           *file,
            gconstpointer           client);
    void                  (* call_when_ready)        (CajaFile           *file,
            CajaFileAttributes  attributes,
            CajaFileCallback    callback,
            gpointer                callback_data);
    void                  (* cancel_call_when_ready) (CajaFile           *file,
            CajaFileCallback    callback,
            gpointer                callback_data);
    gboolean              (* check_if_ready)         (CajaFile           *file,
            CajaFileAttributes  attributes);
    gboolean              (* get_item_count)         (CajaFile           *file,
            guint                  *count,
            gboolean               *count_unreadable);
    CajaRequestStatus (* get_deep_counts)        (CajaFile           *file,
            guint                  *directory_count,
            guint                  *file_count,
            guint                  *unreadable_directory_count,
            goffset                *total_size,
            goffset                *total_size_on_disk);
    gboolean              (* get_date)               (CajaFile           *file,
            CajaDateType        type,
            time_t                 *date);
    char *                (* get_where_string)       (CajaFile           *file);

    void                  (* set_metadata)           (CajaFile           *file,
            const char             *key,
            const char             *value);
    void                  (* set_metadata_as_list)   (CajaFile           *file,
            const char             *key,
            char                  **value);

    void                  (* mount)                  (CajaFile                   *file,
            GMountOperation                *mount_op,
            GCancellable                   *cancellable,
            CajaFileOperationCallback   callback,
            gpointer                        callback_data);
    void                 (* unmount)                 (CajaFile                   *file,
            GMountOperation                *mount_op,
            GCancellable                   *cancellable,
            CajaFileOperationCallback   callback,
            gpointer                        callback_data);
    void                 (* eject)                   (CajaFile                   *file,
            GMountOperation                *mount_op,
            GCancellable                   *cancellable,
            CajaFileOperationCallback   callback,
            gpointer                        callback_data);

    void                  (* start)                  (CajaFile                   *file,
            GMountOperation                *start_op,
            GCancellable                   *cancellable,
            CajaFileOperationCallback   callback,
            gpointer                        callback_data);
    void                 (* stop)                    (CajaFile                   *file,
            GMountOperation                *mount_op,
            GCancellable                   *cancellable,
            CajaFileOperationCallback   callback,
            gpointer                        callback_data);

    void                 (* poll_for_media)          (CajaFile                   *file);
} CajaFileClass;

G_END_DECLS

#endif /* CAJA_FILE_H */