libnautilus-private/nautilus-file.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-
   2
   3    nautilus-file.c: 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 #include <config.h>
  26 #include "nautilus-file.h"
  27
  28 #include "nautilus-directory-metafile.h"
  29 #include "nautilus-directory-notify.h"
  30 #include "nautilus-directory-private.h"
  31 #include "nautilus-signaller.h"
  32 #include "nautilus-desktop-directory.h"
  33 #include "nautilus-desktop-directory-file.h"
  34 #include "nautilus-desktop-icon-file.h"
  35 #include "nautilus-file-attributes.h"
  36 #include "nautilus-file-private.h"
  37 #include "nautilus-file-operations.h"
  38 #include "nautilus-file-utilities.h"
  39 #include "nautilus-global-preferences.h"
  40 #include "nautilus-lib-self-check-functions.h"
  41 #include "nautilus-link.h"
  42 #include "nautilus-metadata.h"
  43 #include "nautilus-module.h"
  44 #include "nautilus-search-directory.h"
  45 #include "nautilus-search-directory-file.h"
  46 #include "nautilus-thumbnails.h"
  47 #include "nautilus-users-groups-cache.h"
  48 #include "nautilus-vfs-file.h"
  49 #include "nautilus-saved-search-file.h"
  50 #include <eel/eel-debug.h>
  51 #include <eel/eel-glib-extensions.h>
  52 #include <eel/eel-gtk-extensions.h>
  53 #include <eel/eel-vfs-extensions.h>
  54 #include <eel/eel-gtk-macros.h>
  55 #include <eel/eel-string.h>
  56 #include <grp.h>
  57 #include <gtk/gtksignal.h>
  58 #include <glib/gi18n.h>
  59 #include <gio/gio.h>
  60 #include <glib/gurifuncs.h>
  61 #include <libgnome/gnome-macros.h>
  62 #include <glib/gfileutils.h>
  63 #include <libnautilus-extension/nautilus-file-info.h>
  64 #include <libxml/parser.h>
  65 #include <pwd.h>
  66 #include <stdlib.h>
  67 #include <sys/time.h>
  68 #include <time.h>
  69 #include <unistd.h>
  70
  71 #ifdef HAVE_SELINUX
  72 #include <selinux/selinux.h>
  73 #endif
  74
  75 /* Time in seconds to cache getpwuid results */
  76 #define GETPWUID_CACHE_TIME (5*60)
  77
  78 #define ICON_NAME_THUMBNAIL_LOADING   "image-loading"
  79
  80 #undef NAUTILUS_FILE_DEBUG_REF
  81 #undef NAUTILUS_FILE_DEBUG_REF_VALGRIND
  82
  83 #ifdef NAUTILUS_FILE_DEBUG_REF_VALGRIND
  84 #include <valgrind/valgrind.h>
  85 #define DEBUG_REF_PRINTF VALGRIND_PRINTF_BACKTRACE
  86 #else
  87 #define DEBUG_REF_PRINTF printf
  88 #endif
  89
  90 /* Files that start with these characters sort after files that don't. */
  91 #define SORT_LAST_CHAR1 '.'
  92 #define SORT_LAST_CHAR2 '#'
  93
  94 /* Name to use to tag metadata for the directory itself. */
  95 #define FILE_NAME_FOR_DIRECTORY_METADATA "."
  96
  97 /* Name of Nautilus trash directories */
  98 #define TRASH_DIRECTORY_NAME ".Trash"
  99
 100 typedef enum {
 101         SHOW_HIDDEN = 1 << 0,
 102         SHOW_BACKUP = 1 << 1
 103 } FilterOptions;
 104
 105 typedef void (* ModifyListFunction) (GList **list, NautilusFile *file);
 106
 107 enum {
 108         CHANGED,
 109         UPDATED_DEEP_COUNT_IN_PROGRESS,
 110         LAST_SIGNAL
 111 };
 112
 113 static int date_format_pref;
 114
 115 static guint signals[LAST_SIGNAL];
 116
 117 static GObjectClass *parent_class = NULL;
 118
 119 static GHashTable *symbolic_links;
 120
 121 static GQuark attribute_name_q,
 122         attribute_size_q,
 123         attribute_type_q,
 124         attribute_modification_date_q,
 125         attribute_date_modified_q,
 126         attribute_accessed_date_q,
 127         attribute_date_accessed_q,
 128         attribute_emblems_q,
 129         attribute_mime_type_q,
 130         attribute_size_detail_q,
 131         attribute_deep_size_q,
 132         attribute_deep_file_count_q,
 133         attribute_deep_directory_count_q,
 134         attribute_deep_total_count_q,
 135         attribute_date_changed_q,
 136         attribute_date_permissions_q,
 137         attribute_permissions_q,
 138         attribute_selinux_context_q,
 139         attribute_octal_permissions_q,
 140         attribute_owner_q,
 141         attribute_group_q,
 142         attribute_uri_q,
 143         attribute_where_q,
 144         attribute_link_target_q,
 145         attribute_volume_q,
 146         attribute_free_space_q;
 147
 148
 149 static void     nautilus_file_instance_init                  (NautilusFile          *file);
 150 static void     nautilus_file_class_init                     (NautilusFileClass     *class);
 151 static void     nautilus_file_info_iface_init                (NautilusFileInfoIface *iface);
 152 static char *   nautilus_file_get_owner_as_string            (NautilusFile          *file,
 153                                                               gboolean               include_real_name);
 154 static char *   nautilus_file_get_type_as_string             (NautilusFile          *file);
 155 static gboolean update_info_and_name                         (NautilusFile          *file,
 156                                                               GFileInfo             *info);
 157 static const char * nautilus_file_peek_display_name (NautilusFile *file);
 158 static const char * nautilus_file_peek_display_name_collation_key (NautilusFile *file);
 159
 160 GType
 161 nautilus_file_get_type (void)
 162 {
 163         static GType type = 0;
 164
 165         if (!type) {
 166                 const GTypeInfo info = {
 167                         sizeof (NautilusFileClass),
 168                         NULL,
 169                         NULL,
 170                         (GClassInitFunc) nautilus_file_class_init,
 171                         NULL,
 172                         NULL,
 173                         sizeof (NautilusFile),
 174                         0,
 175                         (GInstanceInitFunc) nautilus_file_instance_init,
 176                 };
 177
 178                 const GInterfaceInfo file_info_iface_info = {
 179                         (GInterfaceInitFunc) nautilus_file_info_iface_init,
 180                         NULL,
 181                         NULL
 182                 };
 183
 184                 type = g_type_register_static (G_TYPE_OBJECT,
 185                                                "NautilusFile",
 186                                                &info, 0);
 187                 g_type_add_interface_static (type,
 188                                              NAUTILUS_TYPE_FILE_INFO,
 189                                              &file_info_iface_info);
 190         }
 191
 192         return type;
 193 }
 194
 195 static void
 196 nautilus_file_instance_init (NautilusFile *file)
 197 {
 198         file->details = G_TYPE_INSTANCE_GET_PRIVATE ((file), NAUTILUS_TYPE_FILE, NautilusFileDetails);
 199
 200         nautilus_file_clear_info (file);
 201         nautilus_file_invalidate_extension_info_internal (file);
 202 }
 203
 204 static GObject*
 205 nautilus_file_constructor (GType                  type,
 206                            guint                  n_construct_properties,
 207                            GObjectConstructParam *construct_params)
 208 {
 209   GObject *object;
 210   NautilusFile *file;
 211
 212   object = (* G_OBJECT_CLASS (parent_class)->constructor) (type,
 213                                                            n_construct_properties,
 214                                                            construct_params);
 215
 216   file = NAUTILUS_FILE (object);
 217
 218   /* Set to default type after full construction */
 219   if (NAUTILUS_FILE_GET_CLASS (file)->default_file_type != G_FILE_TYPE_UNKNOWN) {
 220           file->details->type = NAUTILUS_FILE_GET_CLASS (file)->default_file_type;
 221   }
 222
 223   return object;
 224 }
 225
 226 gboolean
 227 nautilus_file_set_display_name (NautilusFile *file,
 228                                 const char *display_name,
 229                                 const char *edit_name,
 230                                 gboolean custom)
 231 {
 232         gboolean changed;
 233
 234         if (display_name == NULL || *display_name == 0) {
 235                 return FALSE;
 236         }
 237
 238         if (!custom && file->details->got_custom_display_name) {
 239                 return FALSE;
 240         }
 241
 242         if (custom && display_name == NULL) {
 243                 /* We're re-setting a custom display name, invalidate it if
 244                    we already set it so that the old one is re-read */
 245                 if (file->details->got_custom_display_name) {
 246                         file->details->got_custom_display_name = FALSE;
 247                         nautilus_file_invalidate_attributes (file,
 248                                                              NAUTILUS_FILE_ATTRIBUTE_INFO);
 249                 }
 250                 return FALSE;
 251         }
 252
 253         if (edit_name == NULL) {
 254                 edit_name = display_name;
 255         }
 256
 257         changed = FALSE;
 258
 259         if (eel_strcmp (eel_ref_str_peek (file->details->display_name), display_name) != 0) {
 260                 changed = TRUE;
 261
 262                 eel_ref_str_unref (file->details->display_name);
 263
 264                 if (eel_strcmp (eel_ref_str_peek (file->details->name), display_name) == 0) {
 265                         file->details->display_name = eel_ref_str_ref (file->details->name);
 266                 } else {
 267                         file->details->display_name = eel_ref_str_new (display_name);
 268                 }
 269
 270                 g_free (file->details->display_name_collation_key);
 271                 file->details->display_name_collation_key = g_utf8_collate_key_for_filename (display_name, -1);
 272         }
 273
 274         if (eel_strcmp (eel_ref_str_peek (file->details->edit_name), edit_name) != 0) {
 275                 changed = TRUE;
 276
 277                 eel_ref_str_unref (file->details->edit_name);
 278                 if (eel_strcmp (eel_ref_str_peek (file->details->display_name), edit_name) == 0) {
 279                         file->details->edit_name = eel_ref_str_ref (file->details->display_name);
 280                 } else {
 281                         file->details->edit_name = eel_ref_str_new (edit_name);
 282                 }
 283         }
 284
 285         file->details->got_custom_display_name = custom;
 286         return changed;
 287 }
 288
 289 void
 290 nautilus_file_clear_info (NautilusFile *file)
 291 {
 292         file->details->got_file_info = FALSE;
 293         if (file->details->get_info_error) {
 294                 g_error_free (file->details->get_info_error);
 295                 file->details->get_info_error = NULL;
 296         }
 297         /* Reset to default type, which might be other than unknown for
 298            special kinds of files like the desktop or a search directory */
 299         file->details->type = NAUTILUS_FILE_GET_CLASS (file)->default_file_type;
 300
 301         if (!file->details->got_custom_display_name) {
 302                 eel_ref_str_unref (file->details->display_name);
 303                 file->details->display_name = NULL;
 304                 g_free (file->details->display_name_collation_key);
 305                 file->details->display_name_collation_key = NULL;
 306                 eel_ref_str_unref (file->details->edit_name);
 307                 file->details->edit_name = NULL;
 308         }
 309
 310         if (!file->details->got_custom_activation_location &&
 311             file->details->activation_location != NULL) {
 312                 g_object_unref (file->details->activation_location);
 313                 file->details->activation_location = NULL;
 314         }
 315
 316         if (file->details->icon != NULL) {
 317                 g_object_unref (file->details->icon);
 318                 file->details->icon = NULL;
 319         }
 320
 321         g_free (file->details->thumbnail_path);
 322         file->details->thumbnail_path = NULL;
 323         file->details->thumbnailing_failed = FALSE;
 324
 325         file->details->is_launcher = FALSE;
 326         file->details->is_symlink = FALSE;
 327         file->details->is_hidden = FALSE;
 328         file->details->is_backup = FALSE;
 329         file->details->is_mountpoint = FALSE;
 330         file->details->uid = -1;
 331         file->details->gid = -1;
 332         file->details->can_read = TRUE;
 333         file->details->can_write = TRUE;
 334         file->details->can_execute = TRUE;
 335         file->details->can_delete = TRUE;
 336         file->details->can_trash = TRUE;
 337         file->details->can_rename = TRUE;
 338         file->details->can_mount = FALSE;
 339         file->details->can_unmount = FALSE;
 340         file->details->can_eject = FALSE;
 341         file->details->has_permissions = FALSE;
 342         file->details->permissions = 0;
 343         file->details->size = -1;
 344         file->details->sort_order = 0;
 345         file->details->mtime = 0;
 346         file->details->atime = 0;
 347         file->details->ctime = 0;
 348         g_free (file->details->symlink_name);
 349         file->details->symlink_name = NULL;
 350         eel_ref_str_unref (file->details->mime_type);
 351         file->details->mime_type = NULL;
 352         g_free (file->details->selinux_context);
 353         file->details->selinux_context = NULL;
 354 }
 355
 356 static NautilusFile *
 357 nautilus_file_new_from_filename (NautilusDirectory *directory,
 358                                  const char *filename,
 359                                  gboolean self_owned)
 360 {
 361         NautilusFile *file;
 362
 363         g_assert (NAUTILUS_IS_DIRECTORY (directory));
 364         g_assert (filename != NULL);
 365         g_assert (filename[0] != '\0');
 366
 367         if (NAUTILUS_IS_DESKTOP_DIRECTORY (directory)) {
 368                 if (self_owned) {
 369                         file = NAUTILUS_FILE (g_object_new (NAUTILUS_TYPE_DESKTOP_DIRECTORY_FILE, NULL));
 370                 } else {
 371                         /* This doesn't normally happen, unless the user somehow types in a uri
 372                          * that references a file like this. (See #349840) */
 373                         file = NAUTILUS_FILE (g_object_new (NAUTILUS_TYPE_VFS_FILE, NULL));
 374                 }
 375         } else if (NAUTILUS_IS_SEARCH_DIRECTORY (directory)) {
 376                 if (self_owned) {
 377                         file = NAUTILUS_FILE (g_object_new (NAUTILUS_TYPE_SEARCH_DIRECTORY_FILE, NULL));
 378                 } else {
 379                         /* This doesn't normally happen, unless the user somehow types in a uri
 380                          * that references a file like this. (See #349840) */
 381                         file = NAUTILUS_FILE (g_object_new (NAUTILUS_TYPE_VFS_FILE, NULL));
 382                 }
 383         } else if (g_str_has_suffix (filename, NAUTILUS_SAVED_SEARCH_EXTENSION)) {
 384                 file = NAUTILUS_FILE (g_object_new (NAUTILUS_TYPE_SAVED_SEARCH_FILE, NULL));
 385         } else {
 386                 file = NAUTILUS_FILE (g_object_new (NAUTILUS_TYPE_VFS_FILE, NULL));
 387         }
 388
 389         file->details->directory = nautilus_directory_ref (directory);
 390
 391         file->details->name = eel_ref_str_new (filename);
 392
 393 #ifdef NAUTILUS_FILE_DEBUG_REF
 394         DEBUG_REF_PRINTF("%10p ref'd", file);
 395 #endif
 396
 397         return file;
 398 }
 399
 400 static void
 401 modify_link_hash_table (NautilusFile *file,
 402                         ModifyListFunction modify_function)
 403 {
 404         char *target_uri;
 405         gboolean found;
 406         gpointer original_key;
 407         GList **list_ptr;
 408
 409         /* Check if there is a symlink name. If none, we are OK. */
 410         if (file->details->symlink_name == NULL) {
 411                 return;
 412         }
 413
 414         /* Create the hash table first time through. */
 415         if (symbolic_links == NULL) {
 416                 symbolic_links = eel_g_hash_table_new_free_at_exit
 417                         (g_str_hash, g_str_equal, "nautilus-file.c: symbolic_links");
 418         }
 419
 420         target_uri = nautilus_file_get_symbolic_link_target_uri (file);
 421
 422         /* Find the old contents of the hash table. */
 423         found = g_hash_table_lookup_extended
 424                 (symbolic_links, target_uri,
 425                  &original_key, (gpointer *)&list_ptr);
 426         if (!found) {
 427                 list_ptr = g_new0 (GList *, 1);
 428                 original_key = g_strdup (target_uri);
 429                 g_hash_table_insert (symbolic_links, original_key, list_ptr);
 430         }
 431         (* modify_function) (list_ptr, file);
 432         if (*list_ptr == NULL) {
 433                 g_hash_table_remove (symbolic_links, target_uri);
 434                 g_free (list_ptr);
 435                 g_free (original_key);
 436         }
 437         g_free (target_uri);
 438 }
 439
 440 static void
 441 symbolic_link_weak_notify (gpointer      data,
 442                            GObject      *where_the_object_was)
 443 {
 444         GList **list = data;
 445         /* This really shouldn't happen, but we're seeing some strange things in
 446            bug #358172 where the symlink hashtable isn't correctly updated. */
 447         *list = g_list_remove (*list, where_the_object_was);
 448 }
 449
 450 static void
 451 add_to_link_hash_table_list (GList **list, NautilusFile *file)
 452 {
 453         if (g_list_find (*list, file) != NULL) {
 454                 g_warning ("Adding file to symlink_table multiple times. "
 455                            "Please add feedback of what you were doing at http://bugzilla.gnome.org/show_bug.cgi?id=358172\n");
 456                 return;
 457         }
 458         g_object_weak_ref (G_OBJECT (file), symbolic_link_weak_notify, list);
 459         *list = g_list_prepend (*list, file);
 460 }
 461
 462 static void
 463 add_to_link_hash_table (NautilusFile *file)
 464 {
 465         modify_link_hash_table (file, add_to_link_hash_table_list);
 466 }
 467
 468 static void
 469 remove_from_link_hash_table_list (GList **list, NautilusFile *file)
 470 {
 471         if (g_list_find (*list, file) != NULL) {
 472                 g_object_weak_unref (G_OBJECT (file), symbolic_link_weak_notify, list);
 473                 *list = g_list_remove (*list, file);
 474         }
 475 }
 476
 477 static void
 478 remove_from_link_hash_table (NautilusFile *file)
 479 {
 480         modify_link_hash_table (file, remove_from_link_hash_table_list);
 481 }
 482
 483 NautilusFile *
 484 nautilus_file_new_from_info (NautilusDirectory *directory,
 485                              GFileInfo *info)
 486 {
 487         NautilusFile *file;
 488         const char *mime_type;
 489
 490         g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), NULL);
 491         g_return_val_if_fail (info != NULL, NULL);
 492
 493         mime_type = g_file_info_get_content_type (info);
 494         if (mime_type &&
 495             strcmp (mime_type, NAUTILUS_SAVED_SEARCH_MIMETYPE) == 0) {
 496                 g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY);
 497                 file = NAUTILUS_FILE (g_object_new (NAUTILUS_TYPE_SAVED_SEARCH_FILE, NULL));
 498         } else {
 499                 file = NAUTILUS_FILE (g_object_new (NAUTILUS_TYPE_VFS_FILE, NULL));
 500         }
 501
 502         file->details->directory = nautilus_directory_ref (directory);
 503
 504         update_info_and_name (file, info);
 505
 506 #ifdef NAUTILUS_FILE_DEBUG_REF
 507         DEBUG_REF_PRINTF("%10p ref'd", file);
 508 #endif
 509
 510         return file;
 511 }
 512
 513 static NautilusFile *
 514 nautilus_file_get_internal (GFile *location, gboolean create)
 515 {
 516         gboolean self_owned;
 517         NautilusDirectory *directory;
 518         NautilusFile *file;
 519         GFile *parent;
 520         char *basename;
 521
 522         g_assert (location != NULL);
 523
 524         parent = g_file_get_parent (location);
 525
 526         self_owned = FALSE;
 527         if (parent == NULL) {
 528                 self_owned = TRUE;
 529                 parent = g_object_ref (location);
 530         }
 531
 532         /* Get object that represents the directory. */
 533         directory = nautilus_directory_get_internal (parent, create);
 534
 535         g_object_unref (parent);
 536
 537         /* Get the name for the file. */
 538         if (self_owned && directory != NULL) {
 539                 basename = nautilus_directory_get_name_for_self_as_new_file (directory);
 540         } else {
 541                 basename = g_file_get_basename (location);
 542         }
 543         /* Check to see if it's a file that's already known. */
 544         if (directory == NULL) {
 545                 file = NULL;
 546         } else if (self_owned) {
 547                 file = directory->details->as_file;
 548         } else {
 549                 file = nautilus_directory_find_file_by_name (directory, basename);
 550         }
 551
 552         /* Ref or create the file. */
 553         if (file != NULL) {
 554                 nautilus_file_ref (file);
 555         } else if (create) {
 556                 file = nautilus_file_new_from_filename (directory, basename, self_owned);
 557                 if (self_owned) {
 558                         g_assert (directory->details->as_file == NULL);
 559                         directory->details->as_file = file;
 560                 } else {
 561                         nautilus_directory_add_file (directory, file);
 562                 }
 563         }
 564
 565         g_free (basename);
 566         nautilus_directory_unref (directory);
 567
 568         return file;
 569 }
 570
 571 NautilusFile *
 572 nautilus_file_get (GFile *location)
 573 {
 574         return nautilus_file_get_internal (location, TRUE);
 575 }
 576
 577 NautilusFile *
 578 nautilus_file_get_existing (GFile *location)
 579 {
 580         return nautilus_file_get_internal (location, FALSE);
 581 }
 582
 583 NautilusFile *
 584 nautilus_file_get_existing_by_uri (const char *uri)
 585 {
 586         GFile *location;
 587         NautilusFile *file;
 588
 589         location = g_file_new_for_uri (uri);
 590         file = nautilus_file_get_internal (location, FALSE);
 591         g_object_unref (location);
 592
 593         return file;
 594 }
 595
 596 NautilusFile *
 597 nautilus_file_get_by_uri (const char *uri)
 598 {
 599         GFile *location;
 600         NautilusFile *file;
 601
 602         location = g_file_new_for_uri (uri);
 603         file = nautilus_file_get_internal (location, TRUE);
 604         g_object_unref (location);
 605
 606         return file;
 607 }
 608
 609 gboolean
 610 nautilus_file_is_self_owned (NautilusFile *file)
 611 {
 612         return file->details->directory->details->as_file == file;
 613 }
 614
 615 static void
 616 finalize (GObject *object)
 617 {
 618         NautilusDirectory *directory;
 619         NautilusFile *file;
 620         char *uri;
 621
 622         file = NAUTILUS_FILE (object);
 623
 624         g_assert (file->details->operations_in_progress == NULL);
 625
 626         if (file->details->is_thumbnailing) {
 627                 uri = nautilus_file_get_uri (file);
 628                 nautilus_thumbnail_remove_from_queue (uri);
 629                 g_free (uri);
 630         }
 631
 632         nautilus_async_destroying_file (file);
 633
 634         remove_from_link_hash_table (file);
 635
 636         directory = file->details->directory;
 637
 638         if (nautilus_file_is_self_owned (file)) {
 639                 directory->details->as_file = NULL;
 640         } else {
 641                 if (!file->details->is_gone) {
 642                         nautilus_directory_remove_file (directory, file);
 643                 }
 644         }
 645
 646         if (file->details->get_info_error) {
 647                 g_error_free (file->details->get_info_error);
 648         }
 649
 650         nautilus_directory_unref (directory);
 651         eel_ref_str_unref (file->details->name);
 652         eel_ref_str_unref (file->details->display_name);
 653         g_free (file->details->display_name_collation_key);
 654         eel_ref_str_unref (file->details->edit_name);
 655         if (file->details->icon) {
 656                 g_object_unref (file->details->icon);
 657         }
 658         g_free (file->details->thumbnail_path);
 659         g_free (file->details->symlink_name);
 660         eel_ref_str_unref (file->details->mime_type);
 661         g_free (file->details->selinux_context);
 662         g_free (file->details->top_left_text);
 663         g_free (file->details->custom_icon);
 664         if (file->details->activation_location) {
 665                 g_object_unref (file->details->activation_location);
 666         }
 667         g_free (file->details->compare_by_emblem_cache);
 668
 669         if (file->details->thumbnail) {
 670                 g_object_unref (file->details->thumbnail);
 671         }
 672         if (file->details->mount) {
 673                 g_object_unref (file->details->mount);
 674         }
 675
 676         eel_g_list_free_deep (file->details->mime_list);
 677
 678         eel_g_list_free_deep (file->details->pending_extension_emblems);
 679         eel_g_list_free_deep (file->details->extension_emblems);
 680
 681         if (file->details->pending_extension_attributes) {
 682                 g_hash_table_destroy (file->details->pending_extension_attributes);
 683         }
 684
 685         if (file->details->extension_attributes) {
 686                 g_hash_table_destroy (file->details->extension_attributes);
 687         }
 688
 689         G_OBJECT_CLASS (parent_class)->finalize (object);
 690 }
 691
 692 NautilusFile *
 693 nautilus_file_ref (NautilusFile *file)
 694 {
 695         if (file == NULL) {
 696                 return NULL;
 697         }
 698         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
 699
 700 #ifdef NAUTILUS_FILE_DEBUG_REF
 701         DEBUG_REF_PRINTF("%10p ref'd", file);
 702 #endif
 703
 704         return g_object_ref (file);
 705 }
 706
 707 void
 708 nautilus_file_unref (NautilusFile *file)
 709 {
 710         if (file == NULL) {
 711                 return;
 712         }
 713
 714         g_return_if_fail (NAUTILUS_IS_FILE (file));
 715
 716 #ifdef NAUTILUS_FILE_DEBUG_REF
 717         DEBUG_REF_PRINTF("%10p unref'd", file);
 718 #endif
 719
 720         g_object_unref (file);
 721 }
 722
 723 /**
 724  * nautilus_file_get_parent_uri_for_display:
 725  *
 726  * Get the uri for the parent directory.
 727  *
 728  * @file: The file in question.
 729  *
 730  * Return value: A string representing the parent's location,
 731  * formatted for user display (including stripping "file://").
 732  * If the parent is NULL, returns the empty string.
 733  */
 734 char *
 735 nautilus_file_get_parent_uri_for_display (NautilusFile *file)
 736 {
 737         GFile *parent;
 738         char *result;
 739
 740         g_assert (NAUTILUS_IS_FILE (file));
 741
 742         parent = nautilus_file_get_parent_location (file);
 743         if (parent) {
 744                 result = g_file_get_parse_name (parent);
 745                 g_object_unref (parent);
 746         } else {
 747                 result = g_strdup ("");
 748         }
 749
 750         return result;
 751 }
 752
 753 /**
 754  * nautilus_file_get_parent_uri:
 755  *
 756  * Get the uri for the parent directory.
 757  *
 758  * @file: The file in question.
 759  *
 760  * Return value: A string for the parent's location, in "raw URI" form.
 761  * Use nautilus_file_get_parent_uri_for_display instead if the
 762  * result is to be displayed on-screen.
 763  * If the parent is NULL, returns the empty string.
 764  */
 765 char *
 766 nautilus_file_get_parent_uri (NautilusFile *file)
 767 {
 768         g_assert (NAUTILUS_IS_FILE (file));
 769
 770         if (nautilus_file_is_self_owned (file)) {
 771                 /* Callers expect an empty string, not a NULL. */
 772                 return g_strdup ("");
 773         }
 774
 775         return nautilus_directory_get_uri (file->details->directory);
 776 }
 777
 778 GFile *
 779 nautilus_file_get_parent_location (NautilusFile *file)
 780 {
 781         g_assert (NAUTILUS_IS_FILE (file));
 782
 783         if (nautilus_file_is_self_owned (file)) {
 784                 /* Callers expect an empty string, not a NULL. */
 785                 return NULL;
 786         }
 787
 788         return nautilus_directory_get_location (file->details->directory);
 789 }
 790
 791 NautilusFile *
 792 nautilus_file_get_parent (NautilusFile *file)
 793 {
 794         g_assert (NAUTILUS_IS_FILE (file));
 795
 796         if (nautilus_file_is_self_owned (file)) {
 797                 return NULL;
 798         }
 799
 800         return nautilus_directory_get_corresponding_file (file->details->directory);
 801 }
 802
 803 /**
 804  * nautilus_file_can_read:
 805  *
 806  * Check whether the user is allowed to read the contents of this file.
 807  *
 808  * @file: The file to check.
 809  *
 810  * Return value: FALSE if the user is definitely not allowed to read
 811  * the contents of the file. If the user has read permission, or
 812  * the code can't tell whether the user has read permission,
 813  * returns TRUE (so failures must always be handled).
 814  */
 815 gboolean
 816 nautilus_file_can_read (NautilusFile *file)
 817 {
 818         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
 819
 820         return file->details->can_read;
 821 }
 822
 823 /**
 824  * nautilus_file_can_write:
 825  *
 826  * Check whether the user is allowed to write to this file.
 827  *
 828  * @file: The file to check.
 829  *
 830  * Return value: FALSE if the user is definitely not allowed to write
 831  * to the file. If the user has write permission, or
 832  * the code can't tell whether the user has write permission,
 833  * returns TRUE (so failures must always be handled).
 834  */
 835 gboolean
 836 nautilus_file_can_write (NautilusFile *file)
 837 {
 838         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
 839
 840         return file->details->can_write;
 841 }
 842
 843 /**
 844  * nautilus_file_can_execute:
 845  *
 846  * Check whether the user is allowed to execute this file.
 847  *
 848  * @file: The file to check.
 849  *
 850  * Return value: FALSE if the user is definitely not allowed to execute
 851  * the file. If the user has execute permission, or
 852  * the code can't tell whether the user has execute permission,
 853  * returns TRUE (so failures must always be handled).
 854  */
 855 gboolean
 856 nautilus_file_can_execute (NautilusFile *file)
 857 {
 858         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
 859
 860         return file->details->can_execute;
 861 }
 862
 863 gboolean
 864 nautilus_file_can_mount (NautilusFile *file)
 865 {
 866         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
 867
 868         return file->details->can_mount;
 869 }
 870
 871 gboolean
 872 nautilus_file_can_unmount (NautilusFile *file)
 873 {
 874         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
 875
 876         return file->details->can_unmount ||
 877                 (file->details->mount != NULL &&
 878                  g_mount_can_unmount (file->details->mount));
 879 }
 880
 881 gboolean
 882 nautilus_file_can_eject (NautilusFile *file)
 883 {
 884         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
 885
 886         return file->details->can_eject ||
 887                 (file->details->mount != NULL &&
 888                  g_mount_can_eject (file->details->mount));
 889 }
 890
 891 void
 892 nautilus_file_mount (NautilusFile                   *file,
 893                      GMountOperation                *mount_op,
 894                      GCancellable                   *cancellable,
 895                      NautilusFileOperationCallback   callback,
 896                      gpointer                        callback_data)
 897 {
 898         GError *error;
 899
 900         if (NAUTILUS_FILE_GET_CLASS (file)->mount == NULL) {
 901                 if (callback) {
 902                         error = NULL;
 903                         g_set_error (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
 904                                      _("This file cannot be mounted"));
 905                         callback (file, NULL, error, callback_data);
 906                         g_error_free (error);
 907                 }
 908         } else {
 909                 NAUTILUS_FILE_GET_CLASS (file)->mount (file, mount_op, cancellable, callback, callback_data);
 910         }
 911 }
 912
 913 void
 914 nautilus_file_unmount (NautilusFile *file)
 915 {
 916         if (file->details->can_unmount) {
 917                 if (NAUTILUS_FILE_GET_CLASS (file)->unmount != NULL) {
 918                         NAUTILUS_FILE_GET_CLASS (file)->unmount (file);
 919                 }
 920         } else if (file->details->mount != NULL &&
 921                    g_mount_can_unmount (file->details->mount)) {
 922                 nautilus_file_operations_unmount_mount (NULL, file->details->mount, FALSE, TRUE);
 923         }
 924 }
 925
 926 void
 927 nautilus_file_eject (NautilusFile *file)
 928 {
 929         if (file->details->can_eject) {
 930                 if (NAUTILUS_FILE_GET_CLASS (file)->eject != NULL) {
 931                         NAUTILUS_FILE_GET_CLASS (file)->eject (file);
 932                 }
 933         } else if (file->details->mount != NULL &&
 934                    g_mount_can_eject (file->details->mount)) {
 935                 nautilus_file_operations_unmount_mount (NULL, file->details->mount, TRUE, TRUE);
 936         }
 937 }
 938
 939 /**
 940  * nautilus_file_is_desktop_directory:
 941  *
 942  * Check whether this file is the desktop directory.
 943  *
 944  * @file: The file to check.
 945  *
 946  * Return value: TRUE if this is the physical desktop directory.
 947  */
 948 gboolean
 949 nautilus_file_is_desktop_directory (NautilusFile *file)
 950 {
 951         GFile *dir;
 952
 953         dir = file->details->directory->details->location;
 954
 955         if (dir == NULL) {
 956                 return FALSE;
 957         }
 958
 959         return nautilus_is_desktop_directory_file (dir, eel_ref_str_peek (file->details->name));
 960 }
 961
 962 static gboolean
 963 is_desktop_file (NautilusFile *file)
 964 {
 965         return nautilus_file_is_mime_type (file, "application/x-desktop");
 966 }
 967
 968 static gboolean
 969 can_rename_desktop_file (NautilusFile *file)
 970 {
 971         GFile *location;
 972         gboolean res;
 973
 974         location = nautilus_file_get_location (file);
 975         res = g_file_is_native (location);
 976         g_object_unref (location);
 977         return res;
 978 }
 979
 980 /**
 981  * nautilus_file_can_rename:
 982  *
 983  * Check whether the user is allowed to change the name of the file.
 984  *
 985  * @file: The file to check.
 986  *
 987  * Return value: FALSE if the user is definitely not allowed to change
 988  * the name of the file. If the user is allowed to change the name, or
 989  * the code can't tell whether the user is allowed to change the name,
 990  * returns TRUE (so rename failures must always be handled).
 991  */
 992 gboolean
 993 nautilus_file_can_rename (NautilusFile *file)
 994 {
 995         gboolean can_rename;
 996
 997         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
 998
 999         /* Nonexistent files can't be renamed. */
1000         if (nautilus_file_is_gone (file)) {
1001                 return FALSE;
1002         }
1003
1004         /* Self-owned files can't be renamed */
1005         if (nautilus_file_is_self_owned (file)) {
1006                 return FALSE;
1007         }
1008
1009         if ((is_desktop_file (file) && !can_rename_desktop_file (file)) ||
1010              nautilus_file_is_home (file)) {
1011                 return FALSE;
1012         }
1013
1014         can_rename = TRUE;
1015
1016         /* Certain types of links can't be renamed */
1017         if (NAUTILUS_IS_DESKTOP_ICON_FILE (file)) {
1018                 NautilusDesktopLink *link;
1019
1020                 link = nautilus_desktop_icon_file_get_link (NAUTILUS_DESKTOP_ICON_FILE (file));
1021
1022                 if (link != NULL) {
1023                         can_rename = nautilus_desktop_link_can_rename (link);
1024                         g_object_unref (link);
1025                 }
1026         }
1027
1028         if (!can_rename) {
1029                 return FALSE;
1030         }
1031
1032         return file->details->can_rename;
1033 }
1034
1035 gboolean
1036 nautilus_file_can_delete (NautilusFile *file)
1037 {
1038         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
1039
1040         /* Nonexistent files can't be deleted. */
1041         if (nautilus_file_is_gone (file)) {
1042                 return FALSE;
1043         }
1044
1045         /* Self-owned files can't be deleted */
1046         if (nautilus_file_is_self_owned (file)) {
1047                 return FALSE;
1048         }
1049
1050         return file->details->can_delete;
1051 }
1052
1053 gboolean
1054 nautilus_file_can_trash (NautilusFile *file)
1055 {
1056         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
1057
1058         /* Nonexistent files can't be deleted. */
1059         if (nautilus_file_is_gone (file)) {
1060                 return FALSE;
1061         }
1062
1063         /* Self-owned files can't be deleted */
1064         if (nautilus_file_is_self_owned (file)) {
1065                 return FALSE;
1066         }
1067
1068         return file->details->can_trash;
1069 }
1070
1071 GFile *
1072 nautilus_file_get_location (NautilusFile *file)
1073 {
1074         GFile *dir;
1075
1076         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
1077
1078         dir = file->details->directory->details->location;
1079
1080         if (nautilus_file_is_self_owned (file)) {
1081                 return g_object_ref (dir);
1082         }
1083
1084         return g_file_get_child (dir, eel_ref_str_peek (file->details->name));
1085 }
1086
1087 /* Return the actual uri associated with the passed-in file. */
1088 char *
1089 nautilus_file_get_uri (NautilusFile *file)
1090 {
1091         char *uri;
1092         GFile *loc;
1093
1094         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
1095
1096         loc = nautilus_file_get_location (file);
1097         uri = g_file_get_uri (loc);
1098         g_object_unref (loc);
1099
1100         return uri;
1101 }
1102
1103 char *
1104 nautilus_file_get_uri_scheme (NautilusFile *file)
1105 {
1106         GFile *loc;
1107         char *scheme;
1108
1109         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
1110
1111         if (file->details->directory == NULL ||
1112             file->details->directory->details->location == NULL) {
1113                 return NULL;
1114         }
1115
1116         loc = nautilus_directory_get_location (file->details->directory);
1117         scheme = g_file_get_uri_scheme (loc);
1118         g_object_unref (loc);
1119
1120         return scheme;
1121 }
1122
1123 NautilusFileOperation *
1124 nautilus_file_operation_new (NautilusFile *file,
1125                              NautilusFileOperationCallback callback,
1126                              gpointer callback_data)
1127 {
1128         NautilusFileOperation *op;
1129
1130         op = g_new0 (NautilusFileOperation, 1);
1131         op->file = nautilus_file_ref (file);
1132         op->callback = callback;
1133         op->callback_data = callback_data;
1134         op->cancellable = g_cancellable_new ();
1135
1136         op->file->details->operations_in_progress = g_list_prepend
1137                 (op->file->details->operations_in_progress, op);
1138
1139         return op;
1140 }
1141
1142 static void
1143 nautilus_file_operation_remove (NautilusFileOperation *op)
1144 {
1145         op->file->details->operations_in_progress = g_list_remove
1146                 (op->file->details->operations_in_progress, op);
1147 }
1148
1149 void
1150 nautilus_file_operation_free (NautilusFileOperation *op)
1151 {
1152         nautilus_file_operation_remove (op);
1153         nautilus_file_unref (op->file);
1154         g_object_unref (op->cancellable);
1155         if (op->free_data) {
1156                 op->free_data (op->data);
1157         }
1158         g_free (op);
1159 }
1160
1161 void
1162 nautilus_file_operation_complete (NautilusFileOperation *op, GFile *result_file, GError *error)
1163 {
1164         /* Claim that something changed even if the operation failed.
1165          * This makes it easier for some clients who see the "reverting"
1166          * as "changing back".
1167          */
1168         nautilus_file_operation_remove (op);
1169         nautilus_file_changed (op->file);
1170         if (op->callback) {
1171                 (* op->callback) (op->file, result_file, error, op->callback_data);
1172         }
1173         nautilus_file_operation_free (op);
1174 }
1175
1176 void
1177 nautilus_file_operation_cancel (NautilusFileOperation *op)
1178 {
1179         /* Cancel the operation if it's still in progress. */
1180         g_cancellable_cancel (op->cancellable);
1181 }
1182
1183 static void
1184 rename_get_info_callback (GObject *source_object,
1185                           GAsyncResult *res,
1186                           gpointer callback_data)
1187 {
1188         NautilusFileOperation *op;
1189         NautilusDirectory *directory;
1190         NautilusFile *existing_file;
1191         char *old_name;
1192         char *old_uri;
1193         char *new_uri;
1194         const char *new_name;
1195         GFileInfo *new_info;
1196         GError *error;
1197
1198         op = callback_data;
1199
1200         error = NULL;
1201         new_info = g_file_query_info_finish (G_FILE (source_object), res, &error);
1202         if (new_info != NULL) {
1203                 directory = op->file->details->directory;
1204
1205                 new_name = g_file_info_get_name (new_info);
1206
1207                 /* If there was another file by the same name in this
1208                  * directory, mark it gone.
1209                  */
1210                 existing_file = nautilus_directory_find_file_by_name (directory, new_name);
1211                 if (existing_file != NULL) {
1212                         nautilus_file_mark_gone (existing_file);
1213                         nautilus_file_changed (existing_file);
1214                 }
1215
1216                 old_uri = nautilus_file_get_uri (op->file);
1217                 old_name = g_strdup (eel_ref_str_peek (op->file->details->name));
1218
1219                 update_info_and_name (op->file, new_info);
1220
1221                 /* Self-owned files store their metadata under the
1222                  * hard-code name "."  so there's no need to rename
1223                  * their metadata when they are renamed.
1224                  */
1225                 if (!nautilus_file_is_self_owned (op->file)) {
1226                         nautilus_directory_rename_file_metadata
1227                                 (directory, old_name, eel_ref_str_peek (op->file->details->name));
1228                 }
1229
1230                 g_free (old_name);
1231
1232                 new_uri = nautilus_file_get_uri (op->file);
1233                 nautilus_directory_moved (old_uri, new_uri);
1234                 g_free (new_uri);
1235                 g_free (old_uri);
1236
1237                 /* the rename could have affected the display name if e.g.
1238                  * we're in a vfolder where the name comes from a desktop file
1239                  * and a rename affects the contents of the desktop file.
1240                  */
1241                 if (op->file->details->got_custom_display_name) {
1242                         nautilus_file_invalidate_attributes (op->file,
1243                                                              NAUTILUS_FILE_ATTRIBUTE_INFO |
1244                                                              NAUTILUS_FILE_ATTRIBUTE_LINK_INFO);
1245                 }
1246
1247                 g_object_unref (new_info);
1248         }
1249         nautilus_file_operation_complete (op, NULL, error);
1250         if (error) {
1251                 g_error_free (error);
1252         }
1253 }
1254
1255 static void
1256 rename_callback (GObject *source_object,
1257                  GAsyncResult *res,
1258                  gpointer callback_data)
1259 {
1260         NautilusFileOperation *op;
1261         GFile *new_file;
1262         GError *error;
1263
1264         op = callback_data;
1265
1266         error = NULL;
1267         new_file = g_file_set_display_name_finish (G_FILE (source_object),
1268                                                    res, &error);
1269
1270         if (new_file != NULL) {
1271                 g_file_query_info_async (new_file,
1272                                          NAUTILUS_FILE_DEFAULT_ATTRIBUTES,
1273                                          0,
1274                                          G_PRIORITY_DEFAULT,
1275                                          op->cancellable,
1276                                          rename_get_info_callback, op);
1277         } else {
1278                 nautilus_file_operation_complete (op, NULL, error);
1279                 g_error_free (error);
1280         }
1281 }
1282
1283 static gboolean
1284 name_is (NautilusFile *file, const char *new_name)
1285 {
1286         const char *old_name;
1287         old_name = eel_ref_str_peek (file->details->name);
1288         return strcmp (new_name, old_name) == 0;
1289 }
1290
1291 void
1292 nautilus_file_rename (NautilusFile *file,
1293                       const char *new_name,
1294                       NautilusFileOperationCallback callback,
1295                       gpointer callback_data)
1296 {
1297         NautilusFileOperation *op;
1298         char *uri;
1299         char *old_name;
1300         gboolean success;
1301         gboolean is_renameable_desktop_file;
1302         GFile *location;
1303         GError *error;
1304
1305         g_return_if_fail (NAUTILUS_IS_FILE (file));
1306         g_return_if_fail (new_name != NULL);
1307         g_return_if_fail (callback != NULL);
1308
1309         is_renameable_desktop_file =
1310                 is_desktop_file (file) && can_rename_desktop_file (file);
1311
1312         /* Return an error for incoming names containing path separators.
1313          * But not for .desktop files as '/' are allowed for them */
1314         if (strstr (new_name, "/") != NULL && !is_renameable_desktop_file) {
1315                 error = g_error_new (G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
1316                                      _("Slashes are not allowed in filenames"));
1317                 (* callback) (file, NULL, error, callback_data);
1318                 g_error_free (error);
1319                 return;
1320         }
1321
1322         /* Can't rename a file that's already gone.
1323          * We need to check this here because there may be a new
1324          * file with the same name.
1325          */
1326         if (nautilus_file_is_gone (file)) {
1327                 /* Claim that something changed even if the rename
1328                  * failed. This makes it easier for some clients who
1329                  * see the "reverting" to the old name as "changing
1330                  * back".
1331                  */
1332                 nautilus_file_changed (file);
1333                 error = g_error_new (G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
1334                                      _("File not found"));
1335                 (* callback) (file, NULL, error, callback_data);
1336                 g_error_free (error);
1337                 return;
1338         }
1339
1340         /* Test the name-hasn't-changed case explicitly, for two reasons.
1341          * (1) rename returns an error if new & old are same.
1342          * (2) We don't want to send file-changed signal if nothing changed.
1343          */
1344         if (name_is (file, new_name)) {
1345                 (* callback) (file, NULL, NULL, callback_data);
1346                 return;
1347         }
1348
1349         /* Self-owned files can't be renamed. Test the name-not-actually-changing
1350          * case before this case.
1351          */
1352         if (nautilus_file_is_self_owned (file)) {
1353                 /* Claim that something changed even if the rename
1354                  * failed. This makes it easier for some clients who
1355                  * see the "reverting" to the old name as "changing
1356                  * back".
1357                  */
1358                 nautilus_file_changed (file);
1359                 error = g_error_new (G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
1360                                      _("Toplevel files cannot be renamed"));
1361
1362                 (* callback) (file, NULL, error, callback_data);
1363                 g_error_free (error);
1364                 return;
1365         }
1366
1367         if (NAUTILUS_IS_DESKTOP_ICON_FILE (file)) {
1368                 NautilusDesktopLink *link;
1369
1370                 link = nautilus_desktop_icon_file_get_link (NAUTILUS_DESKTOP_ICON_FILE (file));
1371
1372                 if (link != NULL &&
1373                     nautilus_desktop_link_rename (link, new_name)) {
1374                         (* callback) (file, NULL, NULL, callback_data);
1375                 } else {
1376                         error = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED,
1377                                              _("Unable to rename desktop icon"));
1378                         (* callback) (file, NULL, error, callback_data);
1379                         g_error_free (error);
1380                 }
1381
1382                 g_object_unref (link);
1383                 return;
1384         }
1385
1386         if (is_renameable_desktop_file) {
1387                 /* Don't actually change the name if the new name is the same.
1388                  * This helps for the vfolder method where this can happen and
1389                  * we want to minimize actual changes
1390                  */
1391                 uri = nautilus_file_get_uri (file);
1392                 old_name = nautilus_link_local_get_text (uri);
1393                 if (old_name != NULL && strcmp (new_name, old_name) == 0) {
1394                         success = TRUE;
1395                 } else {
1396                         success = nautilus_link_local_set_text (uri, new_name);
1397                 }
1398                 g_free (old_name);
1399                 g_free (uri);
1400
1401                 if (success) {
1402                         nautilus_file_invalidate_attributes (file,
1403                                                              NAUTILUS_FILE_ATTRIBUTE_INFO |
1404                                                              NAUTILUS_FILE_ATTRIBUTE_LINK_INFO);
1405                         (* callback) (file, NULL, NULL, callback_data);
1406                         return;
1407                 } else {
1408                         error = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED,
1409                                              _("Unable to rename desktop file"));
1410                         (* callback) (file, NULL, error, callback_data);
1411                         g_error_free (error);
1412                         return;
1413                 }
1414         }
1415
1416         /* Set up a renaming operation. */
1417         op = nautilus_file_operation_new (file, callback, callback_data);
1418         op->is_rename = TRUE;
1419
1420         /* Do the renaming. */
1421
1422         location = nautilus_file_get_location (file);
1423         g_file_set_display_name_async (location,
1424                                        new_name,
1425                                        G_PRIORITY_DEFAULT,
1426                                        op->cancellable,
1427                                        rename_callback,
1428                                        op);
1429         g_object_unref (location);
1430 }
1431
1432 gboolean
1433 nautilus_file_rename_in_progress (NautilusFile *file)
1434 {
1435         GList *node;
1436         NautilusFileOperation *op;
1437
1438         for (node = file->details->operations_in_progress; node != NULL; node = node->next) {
1439                 op = node->data;
1440                 if (op->is_rename) {
1441                         return TRUE;
1442                 }
1443         }
1444         return FALSE;
1445 }
1446
1447 void
1448 nautilus_file_cancel (NautilusFile *file,
1449                       NautilusFileOperationCallback callback,
1450                       gpointer callback_data)
1451 {
1452         GList *node, *next;
1453         NautilusFileOperation *op;
1454
1455         for (node = file->details->operations_in_progress; node != NULL; node = next) {
1456                 next = node->next;
1457                 op = node->data;
1458
1459                 g_assert (op->file == file);
1460                 if (op->callback == callback && op->callback_data == callback_data) {
1461                         nautilus_file_operation_cancel (op);
1462                 }
1463         }
1464 }
1465
1466 gboolean
1467 nautilus_file_matches_uri (NautilusFile *file, const char *match_uri)
1468 {
1469         GFile *match_file, *location;
1470         gboolean result;
1471
1472         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
1473         g_return_val_if_fail (match_uri != NULL, FALSE);
1474
1475         location = nautilus_file_get_location (file);
1476         match_file = g_file_new_for_uri (match_uri);
1477         result = g_file_equal (location, match_file);
1478         g_object_unref (location);
1479         g_object_unref (match_file);
1480
1481         return result;
1482 }
1483
1484 gboolean
1485 nautilus_file_is_local (NautilusFile *file)
1486 {
1487         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
1488
1489         return nautilus_directory_is_local (file->details->directory);
1490 }
1491
1492 static void
1493 update_link (NautilusFile *link_file, NautilusFile *target_file)
1494 {
1495         g_assert (NAUTILUS_IS_FILE (link_file));
1496         g_assert (NAUTILUS_IS_FILE (target_file));
1497
1498         /* FIXME bugzilla.gnome.org 42044: If we don't put any code
1499          * here then the hash table is a waste of time.
1500          */
1501 }
1502
1503 static GList *
1504 get_link_files (NautilusFile *target_file)
1505 {
1506         char *uri;
1507         GList **link_files;
1508
1509         if (symbolic_links == NULL) {
1510                 link_files = NULL;
1511         } else {
1512                 uri = nautilus_file_get_uri (target_file);
1513                 link_files = g_hash_table_lookup (symbolic_links, uri);
1514                 g_free (uri);
1515         }
1516         if (link_files) {
1517                 return nautilus_file_list_copy (*link_files);
1518         }
1519         return NULL;
1520 }
1521
1522 static void
1523 update_links_if_target (NautilusFile *target_file)
1524 {
1525         GList *link_files, *p;
1526
1527         link_files = get_link_files (target_file);
1528         for (p = link_files; p != NULL; p = p->next) {
1529                 update_link (NAUTILUS_FILE (p->data), target_file);
1530         }
1531         nautilus_file_list_free (link_files);
1532 }
1533
1534 static gboolean
1535 update_info_internal (NautilusFile *file,
1536                       GFileInfo *info,
1537                       gboolean update_name)
1538 {
1539         GList *node;
1540         gboolean changed;
1541         gboolean is_symlink, is_hidden, is_backup, is_mountpoint;
1542         gboolean has_permissions;
1543         guint32 permissions;
1544         gboolean can_read, can_write, can_execute, can_delete, can_trash, can_rename, can_mount, can_unmount, can_eject;
1545         gboolean thumbnailing_failed;
1546         int uid, gid;
1547         goffset size;
1548         int sort_order;
1549         time_t atime, mtime, ctime;
1550         const char *symlink_name, *mime_type, *selinux_context, *name, *thumbnail_path;
1551         GFileType file_type;
1552         GIcon *icon;
1553         GFile *old_activation_location;
1554         const char *activation_uri;
1555         const char *description;
1556
1557         if (file->details->is_gone) {
1558                 return FALSE;
1559         }
1560
1561         if (info == NULL) {
1562                 nautilus_file_mark_gone (file);
1563                 return TRUE;
1564         }
1565
1566         file->details->file_info_is_up_to_date = TRUE;
1567
1568         /* FIXME bugzilla.gnome.org 42044: Need to let links that
1569          * point to the old name know that the file has been renamed.
1570          */
1571
1572         remove_from_link_hash_table (file);
1573
1574         changed = FALSE;
1575
1576         if (!file->details->got_file_info) {
1577                 changed = TRUE;
1578         }
1579         file->details->got_file_info = TRUE;
1580
1581         changed |= nautilus_file_set_display_name (file,
1582                                                   g_file_info_get_display_name (info),
1583                                                   g_file_info_get_edit_name (info),
1584                                                   FALSE);
1585
1586         file_type = g_file_info_get_file_type (info);
1587         if (file->details->type != file_type) {
1588                 changed = TRUE;
1589         }
1590         file->details->type = file_type;
1591
1592         if (!file->details->got_custom_activation_location) {
1593                 activation_uri = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI);
1594                 if (activation_uri == NULL) {
1595                         if (file->details->activation_location) {
1596                                 g_object_unref (file->details->activation_location);
1597                                 file->details->activation_location = NULL;
1598                                 changed = TRUE;
1599                         }
1600                 } else {
1601                         old_activation_location = file->details->activation_location;
1602                         file->details->activation_location = g_file_new_for_uri (activation_uri);
1603
1604                         if (old_activation_location) {
1605                                 if (!g_file_equal (old_activation_location,
1606                                                    file->details->activation_location)) {
1607                                         changed = TRUE;
1608                                 }
1609                                 g_object_unref (old_activation_location);
1610                         } else {
1611                                 changed = TRUE;
1612                         }
1613                 }
1614         }
1615
1616         is_symlink = g_file_info_get_is_symlink (info);
1617         if (file->details->is_symlink != is_symlink) {
1618                 changed = TRUE;
1619         }
1620         file->details->is_symlink = is_symlink;
1621
1622         is_hidden = g_file_info_get_is_hidden (info);
1623         if (file->details->is_hidden != is_hidden) {
1624                 changed = TRUE;
1625         }
1626         file->details->is_hidden = is_hidden;
1627
1628         is_backup = g_file_info_get_is_backup (info);
1629         if (file->details->is_backup != is_backup) {
1630                 changed = TRUE;
1631         }
1632         file->details->is_backup = is_backup;
1633
1634         is_mountpoint = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT);
1635         if (file->details->is_mountpoint != is_mountpoint) {
1636                 changed = TRUE;
1637         }
1638         file->details->is_mountpoint = is_mountpoint;
1639
1640         has_permissions = g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_MODE);
1641         permissions = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE);;
1642         if (file->details->has_permissions != has_permissions ||
1643             file->details->permissions != permissions) {
1644                 changed = TRUE;
1645         }
1646         file->details->has_permissions = has_permissions;
1647         file->details->permissions = permissions;
1648
1649         /* We default to TRUE for this if we can't know */
1650         can_read = TRUE;
1651         can_write = TRUE;
1652         can_execute = TRUE;
1653         can_delete = TRUE;
1654         can_trash = TRUE;
1655         can_rename = TRUE;
1656         can_mount = FALSE;
1657         can_unmount = FALSE;
1658         can_eject = FALSE;
1659         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ)) {
1660                 can_read = g_file_info_get_attribute_boolean (info,
1661                                                               G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
1662         }
1663         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) {
1664                 can_write = g_file_info_get_attribute_boolean (info,
1665                                                                G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
1666         }
1667         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE)) {
1668                 can_execute = g_file_info_get_attribute_boolean (info,
1669                                                                 G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE);
1670         }
1671         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE)) {
1672                 can_delete = g_file_info_get_attribute_boolean (info,
1673                                                                 G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE);
1674         }
1675         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH)) {
1676                 can_trash = g_file_info_get_attribute_boolean (info,
1677                                                                G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH);
1678         }
1679         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME)) {
1680                 can_rename = g_file_info_get_attribute_boolean (info,
1681                                                                 G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME);
1682         }
1683         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT)) {
1684                 can_mount = g_file_info_get_attribute_boolean (info,
1685                                                                G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT);
1686         }
1687         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT)) {
1688                 can_unmount = g_file_info_get_attribute_boolean (info,
1689                                                                  G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT);
1690         }
1691         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT)) {
1692                 can_eject = g_file_info_get_attribute_boolean (info,
1693                                                                G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT);
1694         }
1695         if (file->details->can_read != can_read ||
1696             file->details->can_write != can_write ||
1697             file->details->can_execute != can_execute ||
1698             file->details->can_delete != can_delete ||
1699             file->details->can_trash != can_trash ||
1700             file->details->can_rename != can_rename ||
1701             file->details->can_mount != can_mount ||
1702             file->details->can_unmount != can_unmount ||
1703             file->details->can_eject != can_eject) {
1704                 changed = TRUE;
1705         }
1706
1707         file->details->can_read = can_read;
1708         file->details->can_write = can_write;
1709         file->details->can_execute = can_execute;
1710         file->details->can_delete = can_delete;
1711         file->details->can_trash = can_trash;
1712         file->details->can_rename = can_rename;
1713         file->details->can_mount = can_mount;
1714         file->details->can_unmount = can_unmount;
1715         file->details->can_eject = can_eject;
1716
1717         uid = -1;
1718         gid = -1;
1719         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_UID)) {
1720                 uid = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_UID);
1721         }
1722         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_GID)) {
1723                 gid = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_GID);
1724         }
1725         if (file->details->uid != uid ||
1726             file->details->gid != gid) {
1727                 changed = TRUE;
1728         }
1729         file->details->uid = uid;
1730         file->details->gid = gid;
1731
1732         size = -1;
1733         if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE)) {
1734                 size = g_file_info_get_size (info);
1735         }
1736         if (file->details->size != size) {
1737                 changed = TRUE;
1738         }
1739         file->details->size = size;
1740
1741         sort_order = g_file_info_get_sort_order (info);
1742         if (file->details->sort_order != sort_order) {
1743                 changed = TRUE;
1744         }
1745         file->details->sort_order = sort_order;
1746
1747         atime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_ACCESS);
1748         ctime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_CHANGED);
1749         mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
1750         if (file->details->atime != atime ||
1751             file->details->mtime != mtime ||
1752             file->details->ctime != ctime) {
1753                 changed = TRUE;
1754         }
1755         file->details->atime = atime;
1756         file->details->ctime = ctime;
1757         file->details->mtime = mtime;
1758
1759         if (file->details->thumbnail != NULL &&
1760             file->details->thumbnail_mtime != 0 &&
1761             file->details->thumbnail_mtime != mtime) {
1762                 file->details->thumbnail_is_up_to_date = FALSE;
1763                 changed = TRUE;
1764         }
1765
1766         icon = g_file_info_get_icon (info);
1767         if (!g_icon_equal (icon, file->details->icon)) {
1768                 changed = TRUE;
1769
1770                 if (file->details->icon) {
1771                         g_object_unref (file->details->icon);
1772                 }
1773                 file->details->icon = g_object_ref (icon);
1774         }
1775
1776         thumbnail_path =  g_file_info_get_attribute_byte_string (info, G_FILE_ATTRIBUTE_THUMBNAIL_PATH);
1777         if (eel_strcmp (file->details->thumbnail_path, thumbnail_path) != 0) {
1778                 changed = TRUE;
1779                 g_free (file->details->thumbnail_path);
1780                 file->details->thumbnail_path = g_strdup (thumbnail_path);
1781         }
1782
1783         thumbnailing_failed =  g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_THUMBNAILING_FAILED);
1784         if (file->details->thumbnailing_failed != thumbnailing_failed) {
1785                 changed = TRUE;
1786                 file->details->thumbnailing_failed = thumbnailing_failed;
1787         }
1788
1789         symlink_name = g_file_info_get_symlink_target (info);
1790         if (eel_strcmp (file->details->symlink_name, symlink_name) != 0) {
1791                 changed = TRUE;
1792                 g_free (file->details->symlink_name);
1793                 file->details->symlink_name = g_strdup (symlink_name);
1794         }
1795
1796         mime_type = g_file_info_get_content_type (info);
1797         if (eel_strcmp (eel_ref_str_peek (file->details->mime_type), mime_type) != 0) {
1798                 changed = TRUE;
1799         }
1800         eel_ref_str_unref (file->details->mime_type);
1801         file->details->mime_type = eel_ref_str_get_unique (mime_type);
1802
1803         selinux_context = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_SELINUX_CONTEXT);
1804         if (eel_strcmp (file->details->selinux_context, selinux_context) != 0) {
1805                 changed = TRUE;
1806                 g_free (file->details->selinux_context);
1807                 file->details->selinux_context = g_strdup (selinux_context);
1808         }
1809
1810         description = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION);
1811         if (eel_strcmp (file->details->description, description) != 0) {
1812                 changed = TRUE;
1813                 g_free (file->details->description);
1814                 file->details->description = g_strdup (description);
1815         }
1816
1817         if (update_name) {
1818                 name = g_file_info_get_name (info);
1819                 if (file->details->name == NULL ||
1820                     strcmp (eel_ref_str_peek (file->details->name), name) != 0) {
1821                         node = nautilus_directory_begin_file_name_change
1822                                 (file->details->directory, file);
1823
1824                         eel_ref_str_unref (file->details->name);
1825                         if (eel_strcmp (eel_ref_str_peek (file->details->display_name),
1826                                         name) == 0) {
1827                                 file->details->name = eel_ref_str_ref (file->details->display_name);
1828                         } else {
1829                                 file->details->name = eel_ref_str_new (name);
1830                         }
1831
1832                         nautilus_directory_end_file_name_change
1833                                 (file->details->directory, file, node);
1834                 }
1835         }
1836
1837         if (changed) {
1838                 add_to_link_hash_table (file);
1839
1840                 update_links_if_target (file);
1841         }
1842
1843         return changed;
1844 }
1845
1846 static gboolean
1847 update_info_and_name (NautilusFile *file,
1848                       GFileInfo *info)
1849 {
1850         return update_info_internal (file, info, TRUE);
1851 }
1852
1853 gboolean
1854 nautilus_file_update_info (NautilusFile *file,
1855                            GFileInfo *info)
1856 {
1857         return update_info_internal (file, info, FALSE);
1858 }
1859
1860 static gboolean
1861 update_name_internal (NautilusFile *file,
1862                       const char *name,
1863                       gboolean in_directory)
1864 {
1865         GList *node;
1866
1867         g_assert (name != NULL);
1868
1869         if (file->details->is_gone) {
1870                 return FALSE;
1871         }
1872
1873         if (name_is (file, name)) {
1874                 return FALSE;
1875         }
1876
1877         node = NULL;
1878         if (in_directory) {
1879                 node = nautilus_directory_begin_file_name_change
1880                         (file->details->directory, file);
1881         }
1882
1883         eel_ref_str_unref (file->details->name);
1884         file->details->name = eel_ref_str_new (name);
1885
1886         if (in_directory) {
1887                 nautilus_directory_end_file_name_change
1888                         (file->details->directory, file, node);
1889         }
1890
1891         return TRUE;
1892 }
1893
1894 gboolean
1895 nautilus_file_update_name (NautilusFile *file, const char *name)
1896 {
1897         gboolean ret;
1898
1899         ret = update_name_internal (file, name, TRUE);
1900
1901         if (ret) {
1902                 update_links_if_target (file);
1903         }
1904
1905         return ret;
1906 }
1907
1908 gboolean
1909 nautilus_file_update_name_and_directory (NautilusFile *file,
1910                                          const char *name,
1911                                          NautilusDirectory *new_directory)
1912 {
1913         NautilusDirectory *old_directory;
1914         FileMonitors *monitors;
1915
1916         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
1917         g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (file->details->directory), FALSE);
1918         g_return_val_if_fail (!file->details->is_gone, FALSE);
1919         g_return_val_if_fail (!nautilus_file_is_self_owned (file), FALSE);
1920         g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (new_directory), FALSE);
1921
1922         old_directory = file->details->directory;
1923         if (old_directory == new_directory) {
1924                 if (name) {
1925                         return update_name_internal (file, name, TRUE);
1926                 } else {
1927                         return FALSE;
1928                 }
1929         }
1930
1931         nautilus_file_ref (file);
1932
1933         /* FIXME bugzilla.gnome.org 42044: Need to let links that
1934          * point to the old name know that the file has been moved.
1935          */
1936
1937         remove_from_link_hash_table (file);
1938
1939         monitors = nautilus_directory_remove_file_monitors (old_directory, file);
1940         nautilus_directory_remove_file (old_directory, file);
1941
1942         file->details->directory = nautilus_directory_ref (new_directory);
1943         nautilus_directory_unref (old_directory);
1944
1945         if (name) {
1946                 update_name_internal (file, name, FALSE);
1947         }
1948
1949         nautilus_directory_add_file (new_directory, file);
1950         nautilus_directory_add_file_monitors (new_directory, file, monitors);
1951
1952         add_to_link_hash_table (file);
1953
1954         update_links_if_target (file);
1955
1956         nautilus_file_unref (file);
1957
1958         return TRUE;
1959 }
1960
1961 void
1962 nautilus_file_set_directory (NautilusFile *file,
1963                              NautilusDirectory *new_directory)
1964 {
1965         nautilus_file_update_name_and_directory (file, NULL, new_directory);
1966 }
1967
1968 static Knowledge
1969 get_item_count (NautilusFile *file,
1970                 guint *count)
1971 {
1972         gboolean known, unreadable;
1973
1974         known = nautilus_file_get_directory_item_count
1975                 (file, count, &unreadable);
1976         if (!known) {
1977                 return UNKNOWN;
1978         }
1979         if (unreadable) {
1980                 return UNKNOWABLE;
1981         }
1982         return KNOWN;
1983 }
1984
1985 static Knowledge
1986 get_size (NautilusFile *file,
1987           goffset *size)
1988 {
1989         /* If we tried and failed, then treat it like there is no size
1990          * to know.
1991          */
1992         if (file->details->get_info_failed) {
1993                 return UNKNOWABLE;
1994         }
1995
1996         /* If the info is NULL that means we haven't even tried yet,
1997          * so it's just unknown, not unknowable.
1998          */
1999         if (!file->details->got_file_info) {
2000                 return UNKNOWN;
2001         }
2002
2003         /* If we got info with no size in it, it means there is no
2004          * such thing as a size as far as gnome-vfs is concerned,
2005          * so "unknowable".
2006          */
2007         if (file->details->size == -1) {
2008                 return UNKNOWABLE;
2009         }
2010
2011         /* We have a size! */
2012         *size = file->details->size;
2013         return KNOWN;
2014 }
2015
2016 static Knowledge
2017 get_time (NautilusFile *file,
2018           time_t *time_out,
2019           NautilusDateType type)
2020 {
2021         time_t time;
2022
2023         /* If we tried and failed, then treat it like there is no size
2024          * to know.
2025          */
2026         if (file->details->get_info_failed) {
2027                 return UNKNOWABLE;
2028         }
2029
2030         /* If the info is NULL that means we haven't even tried yet,
2031          * so it's just unknown, not unknowable.
2032          */
2033         if (!file->details->got_file_info) {
2034                 return UNKNOWN;
2035         }
2036
2037         time = 0;
2038         switch (type) {
2039         case NAUTILUS_DATE_TYPE_MODIFIED:
2040                 time = file->details->mtime;
2041                 break;
2042         case NAUTILUS_DATE_TYPE_ACCESSED:
2043                 time = file->details->atime;
2044                 break;
2045         default:
2046                 g_assert_not_reached ();
2047                 break;
2048         }
2049
2050         *time_out = time;
2051
2052         /* If we got info with no modification time in it, it means
2053          * there is no such thing as a modification time as far as
2054          * gnome-vfs is concerned, so "unknowable".
2055          */
2056         if (time == 0) {
2057                 return UNKNOWABLE;
2058         }
2059         return KNOWN;
2060 }
2061
2062 static int
2063 compare_directories_by_count (NautilusFile *file_1, NautilusFile *file_2)
2064 {
2065         /* Sort order:
2066          *   Directories with unknown # of items
2067          *   Directories with "unknowable" # of items
2068          *   Directories with 0 items
2069          *   Directories with n items
2070          */
2071
2072         Knowledge count_known_1, count_known_2;
2073         guint count_1, count_2;
2074
2075         count_known_1 = get_item_count (file_1, &count_1);
2076         count_known_2 = get_item_count (file_2, &count_2);
2077
2078         if (count_known_1 > count_known_2) {
2079                 return -1;
2080         }
2081         if (count_known_1 < count_known_2) {
2082                 return +1;
2083         }
2084
2085         /* count_known_1 and count_known_2 are equal now. Check if count
2086          * details are UNKNOWABLE or UNKNOWN.
2087          */
2088         if (count_known_1 == UNKNOWABLE || count_known_1 == UNKNOWN) {
2089                 return 0;
2090         }
2091
2092         if (count_1 < count_2) {
2093                 return -1;
2094         }
2095         if (count_1 > count_2) {
2096                 return +1;
2097         }
2098
2099         return 0;
2100 }
2101
2102 static int
2103 compare_files_by_size (NautilusFile *file_1, NautilusFile *file_2)
2104 {
2105         /* Sort order:
2106          *   Files with unknown size.
2107          *   Files with "unknowable" size.
2108          *   Files with smaller sizes.
2109          *   Files with large sizes.
2110          */
2111
2112         Knowledge size_known_1, size_known_2;
2113         goffset size_1, size_2;
2114
2115         size_known_1 = get_size (file_1, &size_1);
2116         size_known_2 = get_size (file_2, &size_2);
2117
2118         if (size_known_1 > size_known_2) {
2119                 return -1;
2120         }
2121         if (size_known_1 < size_known_2) {
2122                 return +1;
2123         }
2124
2125         /* size_known_1 and size_known_2 are equal now. Check if size
2126          * details are UNKNOWABLE or UNKNOWN
2127          */
2128         if (size_known_1 == UNKNOWABLE || size_known_1 == UNKNOWN) {
2129                 return 0;
2130         }
2131
2132         if (size_1 < size_2) {
2133                 return -1;
2134         }
2135         if (size_1 > size_2) {
2136                 return +1;
2137         }
2138
2139         return 0;
2140 }
2141
2142 static int
2143 compare_by_size (NautilusFile *file_1, NautilusFile *file_2)
2144 {
2145         /* Sort order:
2146          *   Directories with n items
2147          *   Directories with 0 items
2148          *   Directories with "unknowable" # of items
2149          *   Directories with unknown # of items
2150          *   Files with large sizes.
2151          *   Files with smaller sizes.
2152          *   Files with "unknowable" size.
2153          *   Files with unknown size.
2154          */
2155
2156         gboolean is_directory_1, is_directory_2;
2157
2158         is_directory_1 = nautilus_file_is_directory (file_1);
2159         is_directory_2 = nautilus_file_is_directory (file_2);
2160
2161         if (is_directory_1 && !is_directory_2) {
2162                 return -1;
2163         }
2164         if (is_directory_2 && !is_directory_1) {
2165                 return +1;
2166         }
2167
2168         if (is_directory_1) {
2169                 return compare_directories_by_count (file_1, file_2);
2170         } else {
2171                 return compare_files_by_size (file_1, file_2);
2172         }
2173 }
2174
2175 static int
2176 compare_by_display_name (NautilusFile *file_1, NautilusFile *file_2)
2177 {
2178         const char *name_1, *name_2;
2179         const char *key_1, *key_2;
2180         gboolean sort_last_1, sort_last_2;
2181         int compare;
2182
2183         name_1 = nautilus_file_peek_display_name (file_1);
2184         name_2 = nautilus_file_peek_display_name (file_2);
2185
2186         sort_last_1 = name_1[0] == SORT_LAST_CHAR1 || name_1[0] == SORT_LAST_CHAR2;
2187         sort_last_2 = name_2[0] == SORT_LAST_CHAR1 || name_2[0] == SORT_LAST_CHAR2;
2188
2189         if (sort_last_1 && !sort_last_2) {
2190                 compare = +1;
2191         } else if (!sort_last_1 && sort_last_2) {
2192                 compare = -1;
2193         } else {
2194                 key_1 = nautilus_file_peek_display_name_collation_key (file_1);
2195                 key_2 = nautilus_file_peek_display_name_collation_key (file_2);
2196                 compare = strcmp (key_1, key_2);
2197         }
2198
2199         return compare;
2200 }
2201
2202 static int
2203 compare_by_directory_name (NautilusFile *file_1, NautilusFile *file_2)
2204 {
2205         char *directory_1, *directory_2;
2206         int compare;
2207
2208         if (file_1->details->directory == file_2->details->directory) {
2209                 return 0;
2210         }
2211
2212         directory_1 = nautilus_file_get_parent_uri_for_display (file_1);
2213         directory_2 = nautilus_file_get_parent_uri_for_display (file_2);
2214
2215         compare = g_utf8_collate (directory_1, directory_2);
2216
2217         g_free (directory_1);
2218         g_free (directory_2);
2219
2220         return compare;
2221 }
2222
2223 static gboolean
2224 file_has_note (NautilusFile *file)
2225 {
2226         char *note;
2227         gboolean res;
2228
2229         note = nautilus_file_get_metadata (file, NAUTILUS_METADATA_KEY_ANNOTATION, NULL);
2230         res = note != NULL && note[0] != 0;
2231         g_free (note);
2232
2233         return res;
2234 }
2235
2236 static GList *
2237 prepend_automatic_keywords (NautilusFile *file,
2238                             GList *names)
2239 {
2240         /* Prepend in reverse order. */
2241         NautilusFile *parent;
2242
2243         parent = nautilus_file_get_parent (file);
2244
2245 #ifdef TRASH_IS_FAST_ENOUGH
2246         if (nautilus_file_is_in_trash (file)) {
2247                 names = g_list_prepend
2248                         (names, g_strdup (NAUTILUS_FILE_EMBLEM_NAME_TRASH));
2249         }
2250 #endif
2251         if (nautilus_file_is_desktop_directory (file)) {
2252                 names = g_list_prepend
2253                         (names, g_strdup (NAUTILUS_FILE_EMBLEM_NAME_DESKTOP));
2254         }
2255         if (file_has_note (file)) {
2256                 names = g_list_prepend
2257                         (names, g_strdup (NAUTILUS_FILE_EMBLEM_NAME_NOTE));
2258         }
2259         if (!nautilus_file_can_write (file) &&
2260             (parent == NULL || nautilus_file_can_write (parent))) {
2261                 names = g_list_prepend
2262                         (names, g_strdup (NAUTILUS_FILE_EMBLEM_NAME_CANT_WRITE));
2263         }
2264         if (!nautilus_file_can_read (file)) {
2265                 names = g_list_prepend
2266                         (names, g_strdup (NAUTILUS_FILE_EMBLEM_NAME_CANT_READ));
2267         }
2268         if (nautilus_file_is_symbolic_link (file)) {
2269                 names = g_list_prepend
2270                         (names, g_strdup (NAUTILUS_FILE_EMBLEM_NAME_SYMBOLIC_LINK));
2271         }
2272
2273         if (parent) {
2274                 nautilus_file_unref (parent);
2275         }
2276
2277
2278         return names;
2279 }
2280
2281 static void
2282 fill_emblem_cache_if_needed (NautilusFile *file)
2283 {
2284         GList *node, *keywords;
2285         char *scanner;
2286         size_t length;
2287
2288         if (file->details->compare_by_emblem_cache != NULL) {
2289                 /* Got a cache already. */
2290                 return;
2291         }
2292
2293         keywords = nautilus_file_get_keywords (file);
2294
2295         /* Add up the keyword string lengths */
2296         length = 1;
2297         for (node = keywords; node != NULL; node = node->next) {
2298                 length += strlen ((const char *) node->data) + 1;
2299         }
2300
2301         /* Now that we know how large the cache struct needs to be, allocate it. */
2302         file->details->compare_by_emblem_cache = g_malloc (sizeof(NautilusFileSortByEmblemCache) + length);
2303
2304         /* Copy them into the cache. */
2305         scanner = file->details->compare_by_emblem_cache->emblem_keywords;
2306         for (node = keywords; node != NULL; node = node->next) {
2307                 length = strlen ((const char *) node->data) + 1;
2308                 memcpy (scanner, (const char *) node->data, length);
2309                 scanner += length;
2310         }
2311
2312         /* Zero-terminate so we can tell where the list ends. */
2313         *scanner = 0;
2314
2315         eel_g_list_free_deep (keywords);
2316 }
2317
2318 static int
2319 compare_by_emblems (NautilusFile *file_1, NautilusFile *file_2)
2320 {
2321         const char *keyword_cache_1, *keyword_cache_2;
2322         size_t length;
2323         int compare_result;
2324
2325         fill_emblem_cache_if_needed (file_1);
2326         fill_emblem_cache_if_needed (file_2);
2327
2328         /* We ignore automatic emblems, and only sort by user-added keywords. */
2329         compare_result = 0;
2330         keyword_cache_1 = file_1->details->compare_by_emblem_cache->emblem_keywords;
2331         keyword_cache_2 = file_2->details->compare_by_emblem_cache->emblem_keywords;
2332         for (; *keyword_cache_1 != '\0' && *keyword_cache_2 != '\0';) {
2333                 compare_result = g_utf8_collate (keyword_cache_1, keyword_cache_2);
2334                 if (compare_result != 0) {
2335                         return compare_result;
2336                 }
2337
2338                 /* Advance to the next keyword */
2339                 length = strlen (keyword_cache_1);
2340                 keyword_cache_1 += length + 1;
2341                 keyword_cache_2 += length + 1;
2342         }
2343
2344
2345         /* One or both is now NULL. */
2346         if (*keyword_cache_1 != '\0') {
2347                 g_assert (*keyword_cache_2 == '\0');
2348                 return -1;
2349         } else if (*keyword_cache_2 != '\0') {
2350                 return +1;
2351         }
2352
2353         return 0;
2354 }
2355
2356 static int
2357 compare_by_type (NautilusFile *file_1, NautilusFile *file_2)
2358 {
2359         gboolean is_directory_1;
2360         gboolean is_directory_2;
2361         char *type_string_1;
2362         char *type_string_2;
2363         int result;
2364
2365         /* Directories go first. Then, if mime types are identical,
2366          * don't bother getting strings (for speed). This assumes
2367          * that the string is dependent entirely on the mime type,
2368          * which is true now but might not be later.
2369          */
2370         is_directory_1 = nautilus_file_is_directory (file_1);
2371         is_directory_2 = nautilus_file_is_directory (file_2);
2372
2373         if (is_directory_1 && is_directory_2) {
2374                 return 0;
2375         }
2376
2377         if (is_directory_1) {
2378                 return -1;
2379         }
2380
2381         if (is_directory_2) {
2382                 return +1;
2383         }
2384
2385         if (file_1->details->mime_type != NULL &&
2386             file_2->details->mime_type != NULL &&
2387             strcmp (eel_ref_str_peek (file_1->details->mime_type),
2388                     eel_ref_str_peek (file_2->details->mime_type)) == 0) {
2389                 return 0;
2390         }
2391
2392         type_string_1 = nautilus_file_get_type_as_string (file_1);
2393         type_string_2 = nautilus_file_get_type_as_string (file_2);
2394
2395         result = g_utf8_collate (type_string_1, type_string_2);
2396
2397         g_free (type_string_1);
2398         g_free (type_string_2);
2399
2400         return result;
2401 }
2402
2403 static int
2404 compare_by_time (NautilusFile *file_1, NautilusFile *file_2, NautilusDateType type)
2405 {
2406         /* Sort order:
2407          *   Files with unknown times.
2408          *   Files with "unknowable" times.
2409          *   Files with older times.
2410          *   Files with newer times.
2411          */
2412
2413         Knowledge time_known_1, time_known_2;
2414         time_t time_1, time_2;
2415
2416         time_1 = 0;
2417         time_2 = 0;
2418
2419         time_known_1 = get_time (file_1, &time_1, type);
2420         time_known_2 = get_time (file_2, &time_2, type);
2421
2422         if (time_known_1 > time_known_2) {
2423                 return -1;
2424         }
2425         if (time_known_1 < time_known_2) {
2426                 return +1;
2427         }
2428
2429         /* Now time_known_1 is equal to time_known_2. Check whether
2430          * we failed to get modification times for files
2431          */
2432         if(time_known_1 == UNKNOWABLE || time_known_1 == UNKNOWN) {
2433                 return 0;
2434         }
2435
2436         if (time_1 < time_2) {
2437                 return -1;
2438         }
2439         if (time_1 > time_2) {
2440                 return +1;
2441         }
2442
2443         return 0;
2444 }
2445
2446 static int
2447 compare_by_full_path (NautilusFile *file_1, NautilusFile *file_2)
2448 {
2449         int compare;
2450
2451         compare = compare_by_directory_name (file_1, file_2);
2452         if (compare != 0) {
2453                 return compare;
2454         }
2455         return compare_by_display_name (file_1, file_2);
2456 }
2457
2458 static int
2459 nautilus_file_compare_for_sort_internal (NautilusFile *file_1,
2460                                          NautilusFile *file_2,
2461                                          gboolean directories_first)
2462 {
2463         gboolean is_directory_1, is_directory_2;
2464
2465         if (directories_first) {
2466                 is_directory_1 = nautilus_file_is_directory (file_1);
2467                 is_directory_2 = nautilus_file_is_directory (file_2);
2468
2469                 if (is_directory_1 && !is_directory_2) {
2470                         return -1;
2471                 }
2472
2473                 if (is_directory_2 && !is_directory_1) {
2474                         return +1;
2475                 }
2476         }
2477
2478         if (file_1->details->sort_order < file_2->details->sort_order) {
2479                 return -1;
2480         } else if (file_1->details->sort_order > file_2->details->sort_order) {
2481                 return 1;
2482         }
2483
2484         return 0;
2485 }
2486
2487 /**
2488  * nautilus_file_compare_for_sort:
2489  * @file_1: A file object
2490  * @file_2: Another file object
2491  * @sort_type: Sort criterion
2492  * @directories_first: Put all directories before any non-directories
2493  * @reversed: Reverse the order of the items, except that
2494  * the directories_first flag is still respected.
2495  *
2496  * Return value: int < 0 if @file_1 should come before file_2 in a
2497  * sorted list; int > 0 if @file_2 should come before file_1 in a
2498  * sorted list; 0 if @file_1 and @file_2 are equal for this sort criterion. Note
2499  * that each named sort type may actually break ties several ways, with the name
2500  * of the sort criterion being the primary but not only differentiator.
2501  **/
2502 int
2503 nautilus_file_compare_for_sort (NautilusFile *file_1,
2504                                 NautilusFile *file_2,
2505                                 NautilusFileSortType sort_type,
2506                                 gboolean directories_first,
2507                                 gboolean reversed)
2508 {
2509         int result;
2510
2511         if (file_1 == file_2) {
2512                 return 0;
2513         }
2514
2515         result = nautilus_file_compare_for_sort_internal (file_1, file_2, directories_first);
2516
2517         if (result == 0) {
2518                 switch (sort_type) {
2519                 case NAUTILUS_FILE_SORT_BY_DISPLAY_NAME:
2520                         result = compare_by_display_name (file_1, file_2);
2521                         if (result == 0) {
2522                                 result = compare_by_directory_name (file_1, file_2);
2523                         }
2524                         break;
2525                 case NAUTILUS_FILE_SORT_BY_DIRECTORY:
2526                         result = compare_by_full_path (file_1, file_2);
2527                         break;
2528                 case NAUTILUS_FILE_SORT_BY_SIZE:
2529                         /* Compare directory sizes ourselves, then if necessary
2530                          * use GnomeVFS to compare file sizes.
2531                          */
2532                         result = compare_by_size (file_1, file_2);
2533                         if (result == 0) {
2534                                 result = compare_by_full_path (file_1, file_2);
2535                         }
2536                         break;
2537                 case NAUTILUS_FILE_SORT_BY_TYPE:
2538                         /* GnomeVFS doesn't know about our special text for certain
2539                          * mime types, so we handle the mime-type sorting ourselves.
2540                          */
2541                         result = compare_by_type (file_1, file_2);
2542                         if (result == 0) {
2543                                 result = compare_by_full_path (file_1, file_2);
2544                         }
2545                         break;
2546                 case NAUTILUS_FILE_SORT_BY_MTIME:
2547                         result = compare_by_time (file_1, file_2, NAUTILUS_DATE_TYPE_MODIFIED);
2548                         if (result == 0) {
2549                                 result = compare_by_full_path (file_1, file_2);
2550                         }
2551                         break;
2552                 case NAUTILUS_FILE_SORT_BY_ATIME:
2553                         result = compare_by_time (file_1, file_2, NAUTILUS_DATE_TYPE_ACCESSED);
2554                         if (result == 0) {
2555                                 result = compare_by_full_path (file_1, file_2);
2556                         }
2557                         break;
2558                 case NAUTILUS_FILE_SORT_BY_EMBLEMS:
2559                         /* GnomeVFS doesn't know squat about our emblems, so
2560                          * we handle comparing them here, before falling back
2561                          * to tie-breakers.
2562                          */
2563                         result = compare_by_emblems (file_1, file_2);
2564                         if (result == 0) {
2565                                 result = compare_by_full_path (file_1, file_2);
2566                         }
2567                         break;
2568                 default:
2569                         g_return_val_if_reached (0);
2570                 }
2571         }
2572
2573         if (reversed) {
2574                 result = -result;
2575         }
2576
2577         return result;
2578 }
2579
2580 int
2581 nautilus_file_compare_for_sort_by_attribute_q   (NautilusFile                   *file_1,
2582                                                  NautilusFile                   *file_2,
2583                                                  GQuark                          attribute,
2584                                                  gboolean                        directories_first,
2585                                                  gboolean                        reversed)
2586 {
2587         int result;
2588
2589         if (file_1 == file_2) {
2590                 return 0;
2591         }
2592
2593         /* Convert certain attributes into NautilusFileSortTypes and use
2594          * nautilus_file_compare_for_sort()
2595          */
2596         if (attribute == 0 || attribute == attribute_name_q) {
2597                 return nautilus_file_compare_for_sort (file_1, file_2,
2598                                                        NAUTILUS_FILE_SORT_BY_DISPLAY_NAME,
2599                                                        directories_first,
2600                                                        reversed);
2601         } else if (attribute == attribute_size_q) {
2602                 return nautilus_file_compare_for_sort (file_1, file_2,
2603                                                        NAUTILUS_FILE_SORT_BY_SIZE,
2604                                                        directories_first,
2605                                                        reversed);
2606         } else if (attribute == attribute_type_q) {
2607                 return nautilus_file_compare_for_sort (file_1, file_2,
2608                                                        NAUTILUS_FILE_SORT_BY_TYPE,
2609                                                        directories_first,
2610                                                        reversed);
2611         } else if (attribute == attribute_modification_date_q || attribute == attribute_date_modified_q) {
2612                 return nautilus_file_compare_for_sort (file_1, file_2,
2613                                                        NAUTILUS_FILE_SORT_BY_MTIME,
2614                                                        directories_first,
2615                                                        reversed);
2616         } else if (attribute == attribute_accessed_date_q || attribute == attribute_date_accessed_q) {
2617                 return nautilus_file_compare_for_sort (file_1, file_2,
2618                                                        NAUTILUS_FILE_SORT_BY_ATIME,
2619                                                        directories_first,
2620                                                        reversed);
2621         } else if (attribute == attribute_emblems_q) {
2622                 return nautilus_file_compare_for_sort (file_1, file_2,
2623                                                        NAUTILUS_FILE_SORT_BY_EMBLEMS,
2624                                                        directories_first,
2625                                                        reversed);
2626         }
2627
2628         /* it is a normal attribute, compare by strings */
2629
2630         result = nautilus_file_compare_for_sort_internal (file_1, file_2, directories_first);
2631
2632         if (result == 0) {
2633                 char *value_1;
2634                 char *value_2;
2635
2636                 value_1 = nautilus_file_get_string_attribute_q (file_1,
2637                                                                 attribute);
2638                 value_2 = nautilus_file_get_string_attribute_q (file_2,
2639                                                                 attribute);
2640
2641                 if (value_1 != NULL && value_2 != NULL) {
2642                         result = strcmp (value_1, value_2);
2643                 }
2644
2645                 g_free (value_1);
2646                 g_free (value_2);
2647         }
2648
2649         if (reversed) {
2650                 result = -result;
2651         }
2652
2653         return result;
2654 }
2655
2656 int
2657 nautilus_file_compare_for_sort_by_attribute     (NautilusFile                   *file_1,
2658                                                  NautilusFile                   *file_2,
2659                                                  const char                     *attribute,
2660                                                  gboolean                        directories_first,
2661                                                  gboolean                        reversed)
2662 {
2663         return nautilus_file_compare_for_sort_by_attribute_q (file_1, file_2,
2664                                                               g_quark_from_string (attribute),
2665                                                               directories_first,
2666                                                               reversed);
2667 }
2668
2669
2670 /**
2671  * nautilus_file_compare_name:
2672  * @file: A file object
2673  * @pattern: A string we are comparing it with
2674  *
2675  * Return value: result of a comparison of the file name and the given pattern,
2676  * using the same sorting order as sort by name.
2677  **/
2678 int
2679 nautilus_file_compare_display_name (NautilusFile *file,
2680                                     const char *pattern)
2681 {
2682         const char *name;
2683         int result;
2684
2685         g_return_val_if_fail (pattern != NULL, -1);
2686
2687         name = nautilus_file_peek_display_name (file);
2688         result = g_utf8_collate (name, pattern);
2689         return result;
2690 }
2691
2692
2693 gboolean
2694 nautilus_file_is_hidden_file (NautilusFile *file)
2695 {
2696         return file->details->is_hidden;
2697 }
2698
2699 gboolean
2700 nautilus_file_is_backup_file (NautilusFile *file)
2701 {
2702         return file->details->is_backup;
2703 }
2704
2705 static gboolean
2706 is_file_hidden (NautilusFile *file)
2707 {
2708         return file->details->directory->details->hidden_file_hash != NULL &&
2709                 g_hash_table_lookup (file->details->directory->details->hidden_file_hash,
2710                                      eel_ref_str_peek (file->details->name)) != NULL;
2711
2712 }
2713
2714 gboolean
2715 nautilus_file_should_show (NautilusFile *file,
2716                            gboolean show_hidden,
2717                            gboolean show_backup)
2718 {
2719         return (show_hidden || (!nautilus_file_is_hidden_file (file) && !is_file_hidden (file))) &&
2720                 (show_backup || !nautilus_file_is_backup_file (file));
2721
2722 }
2723
2724 gboolean
2725 nautilus_file_is_home (NautilusFile *file)
2726 {
2727         GFile *dir;
2728
2729         dir = file->details->directory->details->location;
2730         if (dir == NULL) {
2731                 return FALSE;
2732         }
2733
2734         return nautilus_is_home_directory_file (dir,
2735                                                 eel_ref_str_peek (file->details->name));
2736 }
2737
2738 gboolean
2739 nautilus_file_is_in_desktop (NautilusFile *file)
2740 {
2741         if (file->details->directory->details->location) {
2742                 return nautilus_is_desktop_directory (file->details->directory->details->location);
2743         }
2744         return FALSE;
2745
2746 }
2747
2748 static gboolean
2749 filter_hidden_and_backup_partition_callback (gpointer data,
2750                                              gpointer callback_data)
2751 {
2752         NautilusFile *file;
2753         FilterOptions options;
2754
2755         file = NAUTILUS_FILE (data);
2756         options = GPOINTER_TO_INT (callback_data);
2757
2758         return nautilus_file_should_show (file,
2759                                           options & SHOW_HIDDEN,
2760                                           options & SHOW_BACKUP);
2761 }
2762
2763 GList *
2764 nautilus_file_list_filter_hidden_and_backup (GList    *files,
2765                                              gboolean  show_hidden,
2766                                              gboolean  show_backup)
2767 {
2768         GList *filtered_files;
2769         GList *removed_files;
2770
2771         /* FIXME bugzilla.gnome.org 40653:
2772          * Eventually this should become a generic filtering thingy.
2773          */
2774
2775         filtered_files = nautilus_file_list_copy (files);
2776         filtered_files = eel_g_list_partition (filtered_files,
2777                                                filter_hidden_and_backup_partition_callback,
2778                                                GINT_TO_POINTER ((show_hidden ? SHOW_HIDDEN : 0) |
2779                                                                 (show_backup ? SHOW_BACKUP : 0)),
2780                                                &removed_files);
2781         nautilus_file_list_free (removed_files);
2782
2783         return filtered_files;
2784 }
2785
2786
2787
2788
2789 /* We use the file's URI for the metadata for files in a directory,
2790  * but we use a hard-coded string for the metadata for the directory
2791  * itself.
2792  */
2793 static const char *
2794 get_metadata_name (NautilusFile *file)
2795 {
2796         if (nautilus_file_is_self_owned (file)) {
2797                 return FILE_NAME_FOR_DIRECTORY_METADATA;
2798         }
2799         return eel_ref_str_peek (file->details->name);
2800 }
2801
2802 char *
2803 nautilus_file_get_metadata (NautilusFile *file,
2804                             const char *key,
2805                             const char *default_metadata)
2806 {
2807         g_return_val_if_fail (key != NULL, g_strdup (default_metadata));
2808         g_return_val_if_fail (key[0] != '\0', g_strdup (default_metadata));
2809         if (file == NULL) {
2810                 return g_strdup (default_metadata);
2811         }
2812         g_return_val_if_fail (NAUTILUS_IS_FILE (file), g_strdup (default_metadata));
2813
2814         return nautilus_directory_get_file_metadata
2815                 (file->details->directory,
2816                  get_metadata_name (file),
2817                  key,
2818                  default_metadata);
2819 }
2820
2821 GList *
2822 nautilus_file_get_metadata_list (NautilusFile *file,
2823                                  const char *list_key,
2824                                  const char *list_subkey)
2825 {
2826         g_return_val_if_fail (list_key != NULL, NULL);
2827         g_return_val_if_fail (list_key[0] != '\0', NULL);
2828         g_return_val_if_fail (list_subkey != NULL, NULL);
2829         g_return_val_if_fail (list_subkey[0] != '\0', NULL);
2830         if (file == NULL) {
2831                 return NULL;
2832         }
2833         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
2834
2835         return nautilus_directory_get_file_metadata_list
2836                 (file->details->directory,
2837                  get_metadata_name (file),
2838                  list_key,
2839                  list_subkey);
2840 }
2841
2842 void
2843 nautilus_file_set_metadata (NautilusFile *file,
2844                             const char *key,
2845                             const char *default_metadata,
2846                             const char *metadata)
2847 {
2848         g_return_if_fail (NAUTILUS_IS_FILE (file));
2849         g_return_if_fail (key != NULL);
2850         g_return_if_fail (key[0] != '\0');
2851
2852         nautilus_directory_set_file_metadata
2853                 (file->details->directory,
2854                  get_metadata_name (file),
2855                  key,
2856                  default_metadata,
2857                  metadata);
2858 }
2859
2860 void
2861 nautilus_file_set_metadata_list (NautilusFile *file,
2862                                  const char *list_key,
2863                                  const char *list_subkey,
2864                                  GList *list)
2865 {
2866         g_return_if_fail (NAUTILUS_IS_FILE (file));
2867         g_return_if_fail (list_key != NULL);
2868         g_return_if_fail (list_key[0] != '\0');
2869         g_return_if_fail (list_subkey != NULL);
2870         g_return_if_fail (list_subkey[0] != '\0');
2871
2872         nautilus_directory_set_file_metadata_list
2873                 (file->details->directory,
2874                  get_metadata_name (file),
2875                  list_key,
2876                  list_subkey,
2877                  list);
2878 }
2879
2880
2881 gboolean
2882 nautilus_file_get_boolean_metadata (NautilusFile *file,
2883                                     const char   *key,
2884                                     gboolean      default_metadata)
2885 {
2886         g_return_val_if_fail (key != NULL, default_metadata);
2887         g_return_val_if_fail (key[0] != '\0', default_metadata);
2888         if (file == NULL) {
2889                 return default_metadata;
2890         }
2891         g_return_val_if_fail (NAUTILUS_IS_FILE (file), default_metadata);
2892
2893         return nautilus_directory_get_boolean_file_metadata
2894                 (file->details->directory,
2895                  get_metadata_name (file),
2896                  key,
2897                  default_metadata);
2898 }
2899
2900 int
2901 nautilus_file_get_integer_metadata (NautilusFile *file,
2902                                     const char   *key,
2903                                     int           default_metadata)
2904 {
2905         g_return_val_if_fail (key != NULL, default_metadata);
2906         g_return_val_if_fail (key[0] != '\0', default_metadata);
2907         if (file == NULL) {
2908                 return default_metadata;
2909         }
2910         g_return_val_if_fail (NAUTILUS_IS_FILE (file), default_metadata);
2911
2912         return nautilus_directory_get_integer_file_metadata
2913                 (file->details->directory,
2914                  get_metadata_name (file),
2915                  key,
2916                  default_metadata);
2917 }
2918
2919
2920 void
2921 nautilus_file_set_boolean_metadata (NautilusFile *file,
2922                                     const char   *key,
2923                                     gboolean      default_metadata,
2924                                     gboolean      metadata)
2925 {
2926         g_return_if_fail (NAUTILUS_IS_FILE (file));
2927         g_return_if_fail (key != NULL);
2928         g_return_if_fail (key[0] != '\0');
2929
2930         nautilus_directory_set_boolean_file_metadata
2931                 (file->details->directory,
2932                  get_metadata_name (file),
2933                  key,
2934                  default_metadata,
2935                  metadata);
2936 }
2937
2938 void
2939 nautilus_file_set_integer_metadata (NautilusFile *file,
2940                                     const char   *key,
2941                                     int           default_metadata,
2942                                     int           metadata)
2943 {
2944         g_return_if_fail (NAUTILUS_IS_FILE (file));
2945         g_return_if_fail (key != NULL);
2946         g_return_if_fail (key[0] != '\0');
2947
2948         nautilus_directory_set_integer_file_metadata
2949                 (file->details->directory,
2950                  get_metadata_name (file),
2951                  key,
2952                  default_metadata,
2953                  metadata);
2954 }
2955
2956 static const char *
2957 nautilus_file_peek_display_name_collation_key (NautilusFile *file)
2958 {
2959         const char *res;
2960
2961         res = file->details->display_name_collation_key;
2962         if (res == NULL)
2963                 res = "";
2964
2965         return res;
2966 }
2967
2968 static const char *
2969 nautilus_file_peek_display_name (NautilusFile *file)
2970 {
2971         const char *name;
2972         char *escaped_name;
2973
2974         /* Default to display name based on filename if its not set yet */
2975
2976         if (file->details->display_name == NULL) {
2977                 name = eel_ref_str_peek (file->details->name);
2978                 if (g_utf8_validate (name, -1, NULL)) {
2979                         nautilus_file_set_display_name (file,
2980                                                         name,
2981                                                         NULL,
2982                                                         FALSE);
2983                 } else {
2984                         escaped_name = g_uri_escape_string (name, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, TRUE);
2985                         nautilus_file_set_display_name (file,
2986                                                         escaped_name,
2987                                                         NULL,
2988                                                         FALSE);
2989                         g_free (escaped_name);
2990                 }
2991         }
2992
2993         return eel_ref_str_peek (file->details->display_name);
2994 }
2995
2996 char *
2997 nautilus_file_get_display_name (NautilusFile *file)
2998 {
2999         return g_strdup (nautilus_file_peek_display_name (file));
3000 }
3001
3002 char *
3003 nautilus_file_get_edit_name (NautilusFile *file)
3004 {
3005         const char *res;
3006
3007         res = eel_ref_str_peek (file->details->edit_name);
3008         if (res == NULL)
3009                 res = "";
3010
3011         return g_strdup (res);
3012 }
3013
3014 char *
3015 nautilus_file_get_name (NautilusFile *file)
3016 {
3017         return g_strdup (eel_ref_str_peek (file->details->name));
3018 }
3019
3020 /**
3021  * nautilus_file_get_description:
3022  * @file: a #NautilusFile.
3023  *
3024  * Gets the standard::description key from @file, if
3025  * it has been cached.
3026  *
3027  * Returns: a string containing the value of the standard::description
3028  *      key, or %NULL.
3029  */
3030 char *
3031 nautilus_file_get_description (NautilusFile *file)
3032 {
3033         return g_strdup (file->details->description);
3034 }
3035
3036 void
3037 nautilus_file_monitor_add (NautilusFile *file,
3038                            gconstpointer client,
3039                            NautilusFileAttributes attributes)
3040 {
3041         g_return_if_fail (NAUTILUS_IS_FILE (file));
3042         g_return_if_fail (client != NULL);
3043
3044         EEL_CALL_METHOD
3045                 (NAUTILUS_FILE_CLASS, file,
3046                  monitor_add, (file, client, attributes));
3047 }
3048
3049 void
3050 nautilus_file_monitor_remove (NautilusFile *file,
3051                               gconstpointer client)
3052 {
3053         g_return_if_fail (NAUTILUS_IS_FILE (file));
3054         g_return_if_fail (client != NULL);
3055
3056         EEL_CALL_METHOD
3057                 (NAUTILUS_FILE_CLASS, file,
3058                  monitor_remove, (file, client));
3059 }
3060
3061 gboolean
3062 nautilus_file_is_launcher (NautilusFile *file)
3063 {
3064         return file->details->is_launcher;
3065 }
3066
3067 gboolean
3068 nautilus_file_has_activation_uri (NautilusFile *file)
3069 {
3070         return file->details->activation_location != NULL;
3071 }
3072
3073
3074 /* Return the uri associated with the passed-in file, which may not be
3075  * the actual uri if the file is an desktop file or a nautilus
3076  * xml link file.
3077  */
3078 char *
3079 nautilus_file_get_activation_uri (NautilusFile *file)
3080 {
3081         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
3082
3083         if (file->details->activation_location != NULL) {
3084                 return g_file_get_uri (file->details->activation_location);
3085         }
3086
3087         return nautilus_file_get_uri (file);
3088 }
3089
3090 GFile *
3091 nautilus_file_get_activation_location (NautilusFile *file)
3092 {
3093         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
3094
3095         if (file->details->activation_location != NULL) {
3096                 return g_object_ref (file->details->activation_location);
3097         }
3098
3099         return nautilus_file_get_location (file);
3100 }
3101
3102
3103 char *
3104 nautilus_file_get_drop_target_uri (NautilusFile *file)
3105 {
3106         char *uri, *target_uri;
3107         GFile *location;
3108         NautilusDesktopLink *link;
3109
3110         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
3111
3112         if (NAUTILUS_IS_DESKTOP_ICON_FILE (file)) {
3113                 link = nautilus_desktop_icon_file_get_link (NAUTILUS_DESKTOP_ICON_FILE (file));
3114
3115                 if (link != NULL) {
3116                         location = nautilus_desktop_link_get_activation_location (link);
3117                         g_object_unref (link);
3118                         if (location != NULL) {
3119                                 uri = g_file_get_uri (location);
3120                                 g_object_unref (location);
3121                                 return uri;
3122                         }
3123                 }
3124         }
3125
3126         uri = nautilus_file_get_uri (file);
3127
3128         /* Check for Nautilus link */
3129         if (nautilus_file_is_nautilus_link (file)) {
3130                 location = nautilus_file_get_location (file);
3131                 /* FIXME bugzilla.gnome.org 43020: This does sync. I/O and works only locally. */
3132                 if (g_file_is_native (location)) {
3133                         target_uri = nautilus_link_local_get_link_uri (uri);
3134                         if (target_uri != NULL) {
3135                                 g_free (uri);
3136                                 uri = target_uri;
3137                         }
3138                 }
3139                 g_object_unref (location);
3140         }
3141
3142         return uri;
3143 }
3144
3145 static gboolean
3146 is_uri_relative (const char *uri)
3147 {
3148         char *scheme;
3149
3150         scheme = g_uri_parse_scheme (uri);
3151         g_free (scheme);
3152         return scheme == NULL;
3153 }
3154
3155 static char *
3156 get_custom_icon_metadata_uri (NautilusFile *file)
3157 {
3158         char *custom_icon_uri;
3159         char *uri;
3160         char *dir_uri;
3161
3162         uri = nautilus_file_get_metadata (file, NAUTILUS_METADATA_KEY_CUSTOM_ICON, NULL);
3163         if (uri != NULL &&
3164             nautilus_file_is_directory (file) &&
3165             is_uri_relative (uri)) {
3166                 dir_uri = nautilus_file_get_uri (file);
3167                 custom_icon_uri = g_build_filename (dir_uri, uri, NULL);
3168                 g_free (dir_uri);
3169                 g_free (uri);
3170         } else {
3171                 custom_icon_uri = uri;
3172         }
3173         return custom_icon_uri;
3174 }
3175
3176 static GIcon *
3177 get_custom_icon (NautilusFile *file)
3178 {
3179         char *custom_icon_uri;
3180         GFile *icon_file;
3181         GIcon *icon;
3182
3183         if (file == NULL) {
3184                 return NULL;
3185         }
3186
3187         icon = NULL;
3188
3189         /* Metadata takes precedence */
3190         custom_icon_uri = get_custom_icon_metadata_uri (file);
3191
3192         if (custom_icon_uri) {
3193                 icon_file = g_file_new_for_uri (custom_icon_uri);
3194                 icon = g_file_icon_new (icon_file);
3195                 g_object_unref (icon_file);
3196         }
3197
3198         if (icon == NULL && file->details->got_link_info && file->details->custom_icon != NULL) {
3199                 if (g_path_is_absolute (file->details->custom_icon)) {
3200                         icon_file = g_file_new_for_path (file->details->custom_icon);
3201                         icon = g_file_icon_new (icon_file);
3202                         g_object_unref (icon_file);
3203                 } else {
3204                         icon = g_themed_icon_new (file->details->custom_icon);
3205                 }
3206         }
3207
3208         return icon;
3209 }
3210
3211
3212 static int cached_thumbnail_limit;
3213 static int cached_thumbnail_size;
3214 static int show_image_thumbs;
3215
3216 GFilesystemPreviewType
3217 nautilus_file_get_filesystem_use_preview (NautilusFile *file)
3218 {
3219         GFilesystemPreviewType use_preview;
3220         NautilusFile *parent;
3221
3222         parent = nautilus_file_get_parent (file);
3223         if (parent != NULL) {
3224                 use_preview = parent->details->filesystem_use_preview;
3225                 g_object_unref (parent);
3226         } else {
3227                 use_preview = 0;
3228         }
3229
3230         return use_preview;
3231 }
3232
3233 gboolean
3234 nautilus_file_should_show_thumbnail (NautilusFile *file)
3235 {
3236         const char *mime_type;
3237         GFilesystemPreviewType use_preview;
3238
3239         use_preview = nautilus_file_get_filesystem_use_preview (file);
3240
3241         mime_type = eel_ref_str_peek (file->details->mime_type);
3242         if (mime_type == NULL) {
3243                 mime_type = "application/octet-stream";
3244         }
3245
3246         /* If the thumbnail has already been created, don't care about the size
3247          * of the original file.
3248          */
3249         if (nautilus_thumbnail_is_mimetype_limited_by_size (mime_type) &&
3250             file->details->thumbnail_path == NULL &&
3251             nautilus_file_get_size (file) > (unsigned int)cached_thumbnail_limit) {
3252                 return FALSE;
3253         }
3254
3255         if (show_image_thumbs == NAUTILUS_SPEED_TRADEOFF_ALWAYS) {
3256                 if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) {
3257                         return FALSE;
3258                 } else {
3259                         return TRUE;
3260                 }
3261         } else if (show_image_thumbs == NAUTILUS_SPEED_TRADEOFF_NEVER) {
3262                 return FALSE;
3263         } else {
3264                 if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) {
3265                         /* file system says to never thumbnail anything */
3266                         return FALSE;
3267                 } else if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL) {
3268                         /* file system says we should treat file as if it's local */
3269                         return TRUE;
3270                 } else {
3271                         /* only local files */
3272                         return nautilus_file_is_local (file);
3273                 }
3274         }
3275
3276         return FALSE;
3277 }
3278
3279 GIcon *
3280 nautilus_file_get_gicon (NautilusFile *file,
3281                          NautilusFileIconFlags flags)
3282 {
3283         const char * const * names;
3284         const char *name;
3285         GPtrArray *array;
3286         GIcon *icon;
3287         int i;
3288         gboolean changed;
3289
3290         if (file == NULL) {
3291                 return NULL;
3292         }
3293
3294         if (file->details->icon) {
3295                 icon = NULL;
3296
3297                 if (((flags & NAUTILUS_FILE_ICON_FLAGS_EMBEDDING_TEXT) ||
3298                      (flags & NAUTILUS_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT) ||
3299                      (flags & NAUTILUS_FILE_ICON_FLAGS_FOR_OPEN_FOLDER) ||
3300                      ((flags & NAUTILUS_FILE_ICON_FLAGS_IGNORE_VISITING) == 0 &&
3301                       nautilus_file_has_open_window (file))) &&
3302                     G_IS_THEMED_ICON (file->details->icon)) {
3303                         names = g_themed_icon_get_names (G_THEMED_ICON (file->details->icon));
3304                         array = g_ptr_array_new ();
3305
3306                         changed = TRUE;
3307                         for (i = 0; names[i] != NULL; i++) {
3308                                 name = names[i];
3309
3310                                 if (strcmp (name, "folder") == 0 &&
3311                                     (flags & NAUTILUS_FILE_ICON_FLAGS_IGNORE_VISITING) == 0 &&
3312                                     nautilus_file_has_open_window (file)) {
3313                                         changed = TRUE;
3314                                         g_ptr_array_add (array, "folder-visiting");
3315                                 }
3316                                 if (strcmp (name, "folder") == 0 &&
3317                                     (flags & NAUTILUS_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT)) {
3318                                         changed = TRUE;
3319                                         g_ptr_array_add (array, "folder-drag-accept");
3320                                 }
3321                                 if (strcmp (name, "folder") == 0 &&
3322                                     (flags & NAUTILUS_FILE_ICON_FLAGS_FOR_OPEN_FOLDER)) {
3323                                         changed = TRUE;
3324                                         g_ptr_array_add (array, "folder-open");
3325                                 }
3326                                 if (strcmp (name, "text-x-generic") == 0 &&
3327                                     (flags & NAUTILUS_FILE_ICON_FLAGS_EMBEDDING_TEXT)) {
3328                                         changed = TRUE;
3329                                         g_ptr_array_add (array, "text-x-preview");
3330                                 }
3331                                 g_ptr_array_add (array, (char *)name);
3332                         }
3333
3334                         if (changed) {
3335                                 icon = g_themed_icon_new_from_names ((char **)array->pdata, array->len);
3336                         }
3337
3338                         g_ptr_array_free (array, TRUE);
3339                 }
3340
3341                 if (icon == NULL) {
3342                         icon = g_object_ref (file->details->icon);
3343                 }
3344
3345                 return icon;
3346         }
3347
3348         return g_themed_icon_new ("text-x-generic");
3349 }
3350
3351 NautilusIconInfo *
3352 nautilus_file_get_icon (NautilusFile *file,
3353                         int size,
3354                         NautilusFileIconFlags flags)
3355 {
3356         NautilusIconInfo *icon;
3357         GIcon *gicon;
3358         GdkPixbuf *raw_pixbuf, *scaled_pixbuf;
3359         int modified_size;
3360
3361         if (file == NULL) {
3362                 return NULL;
3363         }
3364
3365         gicon = get_custom_icon (file);
3366         if (gicon) {
3367                 icon = nautilus_icon_info_lookup (gicon, size);
3368                 g_object_unref (gicon);
3369                 return icon;
3370         }
3371
3372         modified_size = size * cached_thumbnail_size / NAUTILUS_ICON_SIZE_STANDARD;
3373
3374         if (flags & NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS &&
3375             nautilus_file_should_show_thumbnail (file)) {
3376                 if (file->details->thumbnail) {
3377                         if (file->details->thumbnail_size == modified_size) {
3378                                 scaled_pixbuf = g_object_ref (file->details->thumbnail);
3379                         } else {
3380                                 int w, h, s;
3381                                 double scale;
3382
3383                                 if (file->details->thumbnail_size == 0) {
3384                                         raw_pixbuf = g_object_ref (file->details->thumbnail);
3385                                 } else {
3386                                         raw_pixbuf = nautilus_thumbnail_unframe_image (file->details->thumbnail);
3387                                 }
3388
3389                                 w = gdk_pixbuf_get_width (raw_pixbuf);
3390                                 h = gdk_pixbuf_get_height (raw_pixbuf);
3391
3392                                 /* These compensates for frame size which will be added on the raw image */
3393                                 s = MAX (NAUTILUS_THUMBNAIL_FRAME_LEFT + w + NAUTILUS_THUMBNAIL_FRAME_RIGHT,
3394                                          NAUTILUS_THUMBNAIL_FRAME_TOP + h + NAUTILUS_THUMBNAIL_FRAME_BOTTOM);
3395
3396                                 scale = (double)modified_size / s;
3397
3398                                 scaled_pixbuf = gdk_pixbuf_scale_simple (raw_pixbuf,
3399                                                                          w * scale, h * scale,
3400                                                                          GDK_INTERP_HYPER);
3401                                 nautilus_thumbnail_frame_image (&scaled_pixbuf);
3402
3403                                 g_object_unref (raw_pixbuf);
3404
3405                                 if (modified_size > file->details->thumbnail_size) {
3406                                         /* Invalidate if we resize upward (and the
3407                                            loaded was not the original raw version, w/ size 0).
3408                                         */
3409                                         if (file->details->thumbnail_size != 0 ||
3410                                             (modified_size > 128 && !file->details->thumbnail_tried_original)) {
3411                                                 nautilus_file_invalidate_attributes (file, NAUTILUS_FILE_ATTRIBUTE_THUMBNAIL);
3412                                         }
3413                                         file->details->thumbnail_size = modified_size;
3414                                         g_object_unref (file->details->thumbnail);
3415                                         file->details->thumbnail = g_object_ref (scaled_pixbuf);
3416                                 }
3417                         }
3418
3419                         icon = nautilus_icon_info_new_for_pixbuf (scaled_pixbuf);
3420                         g_object_unref (scaled_pixbuf);
3421                         return icon;
3422                 } else if (file->details->thumbnail_path == NULL &&
3423                            file->details->can_read &&
3424                            !file->details->thumbnailing_failed &&
3425                            !file->details->is_thumbnailing) {
3426                         if (nautilus_can_thumbnail (file)) {
3427                                 nautilus_create_thumbnail (file);
3428                         }
3429                 }
3430         }
3431
3432         if (file->details->is_thumbnailing &&
3433             flags & NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS)
3434                 gicon = g_themed_icon_new (ICON_NAME_THUMBNAIL_LOADING);
3435         else
3436                 gicon = nautilus_file_get_gicon (file, flags);
3437
3438         if (gicon) {
3439                 icon = nautilus_icon_info_lookup (gicon, size);
3440                 g_object_unref (gicon);
3441                 return icon;
3442         }
3443
3444         return nautilus_icon_info_new_for_pixbuf (NULL);
3445 }
3446
3447 GdkPixbuf *
3448 nautilus_file_get_icon_pixbuf (NautilusFile *file,
3449                                int size,
3450                                gboolean force_size,
3451                                NautilusFileIconFlags flags)
3452 {
3453         NautilusIconInfo *info;
3454         GdkPixbuf *pixbuf;
3455
3456         info = nautilus_file_get_icon (file, size, flags);
3457         if (force_size) {
3458                 pixbuf =  nautilus_icon_info_get_pixbuf_at_size (info, size);
3459         } else {
3460                 pixbuf = nautilus_icon_info_get_pixbuf (info);
3461         }
3462         g_object_unref (info);
3463
3464         return pixbuf;
3465 }
3466
3467 char *
3468 nautilus_file_get_custom_icon (NautilusFile *file)
3469 {
3470         char *custom_icon;
3471
3472         if (file == NULL) {
3473                 return NULL;
3474         }
3475
3476         /* Metadata takes precedence */
3477         custom_icon = get_custom_icon_metadata_uri (file);
3478
3479         if (custom_icon == NULL && file->details->got_link_info) {
3480                 custom_icon = g_strdup (file->details->custom_icon);
3481         }
3482
3483         return custom_icon;
3484 }
3485
3486
3487 gboolean
3488 nautilus_file_get_date (NautilusFile *file,
3489                         NautilusDateType date_type,
3490                         time_t *date)
3491 {
3492         if (date != NULL) {
3493                 *date = 0;
3494         }
3495
3496         g_return_val_if_fail (date_type == NAUTILUS_DATE_TYPE_CHANGED
3497                               || date_type == NAUTILUS_DATE_TYPE_ACCESSED
3498                               || date_type == NAUTILUS_DATE_TYPE_MODIFIED
3499                               || date_type == NAUTILUS_DATE_TYPE_PERMISSIONS_CHANGED, FALSE);
3500
3501         if (file == NULL) {
3502                 return FALSE;
3503         }
3504
3505         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
3506
3507         return EEL_CALL_METHOD_WITH_RETURN_VALUE
3508                 (NAUTILUS_FILE_CLASS, file,
3509                  get_date, (file, date_type, date));
3510 }
3511
3512 static char *
3513 nautilus_file_get_where_string (NautilusFile *file)
3514 {
3515         if (file == NULL) {
3516                 return NULL;
3517         }
3518
3519         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
3520
3521         return EEL_CALL_METHOD_WITH_RETURN_VALUE
3522                 (NAUTILUS_FILE_CLASS, file,
3523                  get_where_string, (file));
3524 }
3525
3526 static const char *TODAY_TIME_FORMATS [] = {
3527         /* Today, use special word.
3528          * strftime patterns preceeded with the widest
3529          * possible resulting string for that pattern.
3530          *
3531          * Note to localizers: You can look at man strftime
3532          * for details on the format, but you should only use
3533          * the specifiers from the C standard, not extensions.
3534          * These include "%" followed by one of
3535          * "aAbBcdHIjmMpSUwWxXyYZ". There are two extensions
3536          * in the Nautilus version of strftime that can be
3537          * used (and match GNU extensions). Putting a "-"
3538          * between the "%" and any numeric directive will turn
3539          * off zero padding, and putting a "_" there will use
3540          * space padding instead of zero padding.
3541          */
3542         N_("today at 00:00:00 PM"),
3543         N_("today at %-I:%M:%S %p"),
3544
3545         N_("today at 00:00 PM"),
3546         N_("today at %-I:%M %p"),
3547
3548         N_("today, 00:00 PM"),
3549         N_("today, %-I:%M %p"),
3550
3551         N_("today"),
3552         N_("today"),
3553
3554         NULL
3555 };
3556
3557 static const char *YESTERDAY_TIME_FORMATS [] = {
3558         /* Yesterday, use special word.
3559          * Note to localizers: Same issues as "today" string.
3560          */
3561         N_("yesterday at 00:00:00 PM"),
3562         N_("yesterday at %-I:%M:%S %p"),
3563
3564         N_("yesterday at 00:00 PM"),
3565         N_("yesterday at %-I:%M %p"),
3566
3567         N_("yesterday, 00:00 PM"),
3568         N_("yesterday, %-I:%M %p"),
3569
3570         N_("yesterday"),
3571         N_("yesterday"),
3572
3573         NULL
3574 };
3575
3576 static const char *CURRENT_WEEK_TIME_FORMATS [] = {
3577         /* Current week, include day of week.
3578          * Note to localizers: Same issues as "today" string.
3579          * The width measurement templates correspond to
3580          * the day/month name with the most letters.
3581          */
3582         N_("Wednesday, September 00 0000 at 00:00:00 PM"),
3583         N_("%A, %B %-d %Y at %-I:%M:%S %p"),
3584
3585         N_("Mon, Oct 00 0000 at 00:00:00 PM"),
3586         N_("%a, %b %-d %Y at %-I:%M:%S %p"),
3587
3588         N_("Mon, Oct 00 0000 at 00:00 PM"),
3589         N_("%a, %b %-d %Y at %-I:%M %p"),
3590
3591         N_("Oct 00 0000 at 00:00 PM"),
3592         N_("%b %-d %Y at %-I:%M %p"),
3593
3594         N_("Oct 00 0000, 00:00 PM"),
3595         N_("%b %-d %Y, %-I:%M %p"),
3596
3597         N_("00/00/00, 00:00 PM"),
3598         N_("%m/%-d/%y, %-I:%M %p"),
3599
3600         N_("00/00/00"),
3601         N_("%m/%d/%y"),
3602
3603         NULL
3604 };
3605
3606 static char *
3607 nautilus_file_fit_date_as_string (NautilusFile *file,
3608                                   NautilusDateType date_type,
3609                                   int width,
3610                                   NautilusWidthMeasureCallback measure_callback,
3611                                   NautilusTruncateCallback truncate_callback,
3612                                   void *measure_context)
3613 {
3614         time_t file_time_raw;
3615         struct tm *file_time;
3616         const char **formats;
3617         const char *width_template;
3618         const char *format;
3619         char *date_string;
3620         char *result;
3621         GDate *today;
3622         GDate *file_date;
3623         guint32 file_date_age;
3624         int i;
3625
3626         if (!nautilus_file_get_date (file, date_type, &file_time_raw)) {
3627                 return NULL;
3628         }
3629
3630         file_time = localtime (&file_time_raw);
3631
3632         if (date_format_pref == NAUTILUS_DATE_FORMAT_LOCALE) {
3633                 return eel_strdup_strftime ("%c", file_time);
3634         } else if (date_format_pref == NAUTILUS_DATE_FORMAT_ISO) {
3635                 return eel_strdup_strftime ("%Y-%m-%d %H:%M:%S", file_time);
3636         }
3637
3638         file_date = eel_g_date_new_tm (file_time);
3639
3640         today = g_date_new ();
3641         g_date_set_time_t (today, time (NULL));
3642
3643         /* Overflow results in a large number; fine for our purposes. */
3644         file_date_age = (g_date_get_julian (today) -
3645                          g_date_get_julian (file_date));
3646
3647         g_date_free (file_date);
3648         g_date_free (today);
3649
3650         /* Format varies depending on how old the date is. This minimizes
3651          * the length (and thus clutter & complication) of typical dates
3652          * while providing sufficient detail for recent dates to make
3653          * them maximally understandable at a glance. Keep all format
3654          * strings separate rather than combining bits & pieces for
3655          * internationalization's sake.
3656          */
3657
3658         if (file_date_age == 0) {
3659                 formats = TODAY_TIME_FORMATS;
3660         } else if (file_date_age == 1) {
3661                 formats = YESTERDAY_TIME_FORMATS;
3662         } else if (file_date_age < 7) {
3663                 formats = CURRENT_WEEK_TIME_FORMATS;
3664         } else {
3665                 formats = CURRENT_WEEK_TIME_FORMATS;
3666         }
3667
3668         /* Find the date format that just fits the required width. Instead of measuring
3669          * the resulting string width directly, measure the width of a template that represents
3670          * the widest possible version of a date in a given format. This is done by using M, m
3671          * and 0 for the variable letters/digits respectively.
3672          */
3673         format = NULL;
3674
3675         for (i = 0; ; i += 2) {
3676                 width_template = (formats [i] ? _(formats [i]) : NULL);
3677                 if (width_template == NULL) {
3678                         /* no more formats left */
3679                         g_assert (format != NULL);
3680
3681                         /* Can't fit even the shortest format -- return an ellipsized form in the
3682                          * shortest format
3683                          */
3684
3685                         date_string = eel_strdup_strftime (format, file_time);
3686
3687                         if (truncate_callback == NULL) {
3688                                 return date_string;
3689                         }
3690
3691                         result = (* truncate_callback) (date_string, width, measure_context);
3692                         g_free (date_string);
3693                         return result;
3694                 }
3695
3696                 format = _(formats [i + 1]);
3697
3698                 if (measure_callback == NULL) {
3699                         /* don't care about fitting the width */
3700                         break;
3701                 }
3702
3703                 if ((* measure_callback) (width_template, measure_context) <= width) {
3704                         /* The template fits, this is the format we can fit. */
3705                         break;
3706                 }
3707         }
3708
3709         return eel_strdup_strftime (format, file_time);
3710
3711 }
3712
3713 /**
3714  * nautilus_file_fit_modified_date_as_string:
3715  *
3716  * Get a user-displayable string representing a file modification date,
3717  * truncated to @width using the measuring and truncating callbacks.
3718  * @file: NautilusFile representing the file in question.
3719  * @width: The desired resulting string width.
3720  * @measure_callback: The callback used to measure the string width.
3721  * @truncate_callback: The callback used to truncate the string to a desired width.
3722  * @measure_context: Data neede when measuring and truncating.
3723  *
3724  * Returns: Newly allocated string ready to display to the user.
3725  *
3726  **/
3727 char *
3728 nautilus_file_fit_modified_date_as_string (NautilusFile *file,
3729                                            int width,
3730                                            NautilusWidthMeasureCallback measure_callback,
3731                                            NautilusTruncateCallback truncate_callback,
3732                                            void *measure_context)
3733 {
3734         return nautilus_file_fit_date_as_string (file, NAUTILUS_DATE_TYPE_MODIFIED,
3735                 width, measure_callback, truncate_callback, measure_context);
3736 }
3737
3738 /**
3739  * nautilus_file_get_date_as_string:
3740  *
3741  * Get a user-displayable string representing a file modification date.
3742  * The caller is responsible for g_free-ing this string.
3743  * @file: NautilusFile representing the file in question.
3744  *
3745  * Returns: Newly allocated string ready to display to the user.
3746  *
3747  **/
3748 static char *
3749 nautilus_file_get_date_as_string (NautilusFile *file, NautilusDateType date_type)
3750 {
3751         return nautilus_file_fit_date_as_string (file, date_type,
3752                 0, NULL, NULL, NULL);
3753 }
3754
3755 static NautilusSpeedTradeoffValue show_directory_item_count;
3756 static NautilusSpeedTradeoffValue show_text_in_icons;
3757
3758 static void
3759 show_text_in_icons_changed_callback (gpointer callback_data)
3760 {
3761         show_text_in_icons = eel_preferences_get_enum (NAUTILUS_PREFERENCES_SHOW_TEXT_IN_ICONS);
3762 }
3763
3764 static void
3765 show_directory_item_count_changed_callback (gpointer callback_data)
3766 {
3767         show_directory_item_count = eel_preferences_get_enum (NAUTILUS_PREFERENCES_SHOW_DIRECTORY_ITEM_COUNTS);
3768 }
3769
3770 static gboolean
3771 get_speed_tradeoff_preference_for_file (NautilusFile *file, NautilusSpeedTradeoffValue value)
3772 {
3773         GFilesystemPreviewType use_preview;
3774
3775         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
3776
3777         use_preview = nautilus_file_get_filesystem_use_preview (file);
3778
3779         if (value == NAUTILUS_SPEED_TRADEOFF_ALWAYS) {
3780                 if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) {
3781                         return FALSE;
3782                 } else {
3783                         return TRUE;
3784                 }
3785         }
3786
3787         if (value == NAUTILUS_SPEED_TRADEOFF_NEVER) {
3788                 return FALSE;
3789         }
3790
3791         g_assert (value == NAUTILUS_SPEED_TRADEOFF_LOCAL_ONLY);
3792
3793         if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) {
3794                 /* file system says to never preview anything */
3795                 return FALSE;
3796         } else if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL) {
3797                 /* file system says we should treat file as if it's local */
3798                 return TRUE;
3799         } else {
3800                 /* only local files */
3801                 return nautilus_file_is_local (file);
3802         }
3803 }
3804
3805 gboolean
3806 nautilus_file_should_show_directory_item_count (NautilusFile *file)
3807 {
3808         static gboolean show_directory_item_count_callback_added = FALSE;
3809
3810         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
3811
3812         if (file->details->mime_type &&
3813             strcmp (eel_ref_str_peek (file->details->mime_type), "x-directory/smb-share") == 0) {
3814                 return FALSE;
3815         }
3816
3817         /* Add the callback once for the life of our process */
3818         if (!show_directory_item_count_callback_added) {
3819                 eel_preferences_add_callback (NAUTILUS_PREFERENCES_SHOW_DIRECTORY_ITEM_COUNTS,
3820                                                    show_directory_item_count_changed_callback,
3821                                                    NULL);
3822                 show_directory_item_count_callback_added = TRUE;
3823
3824                 /* Peek for the first time */
3825                 show_directory_item_count_changed_callback (NULL);
3826         }
3827
3828         return get_speed_tradeoff_preference_for_file (file, show_directory_item_count);
3829 }
3830
3831 gboolean
3832 nautilus_file_should_show_type (NautilusFile *file)
3833 {
3834         char *uri;
3835         gboolean ret;
3836
3837         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
3838
3839         uri = nautilus_file_get_uri (file);
3840         ret = ((strcmp (uri, "computer:///") != 0) &&
3841                (strcmp (uri, "network:///") != 0) &&
3842                (strcmp (uri, "smb:///") != 0));
3843         g_free (uri);
3844
3845         return ret;
3846 }
3847
3848 gboolean
3849 nautilus_file_should_get_top_left_text (NautilusFile *file)
3850 {
3851         static gboolean show_text_in_icons_callback_added = FALSE;
3852
3853         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
3854
3855         /* Add the callback once for the life of our process */
3856         if (!show_text_in_icons_callback_added) {
3857                 eel_preferences_add_callback (NAUTILUS_PREFERENCES_SHOW_TEXT_IN_ICONS,
3858                                                    show_text_in_icons_changed_callback,
3859                                                    NULL);
3860                 show_text_in_icons_callback_added = TRUE;
3861
3862                 /* Peek for the first time */
3863                 show_text_in_icons_changed_callback (NULL);
3864         }
3865
3866         if (show_text_in_icons == NAUTILUS_SPEED_TRADEOFF_ALWAYS) {
3867                 return TRUE;
3868         }
3869
3870         if (show_text_in_icons == NAUTILUS_SPEED_TRADEOFF_NEVER) {
3871                 return FALSE;
3872         }
3873
3874         return get_speed_tradeoff_preference_for_file (file, show_text_in_icons);
3875 }
3876
3877 /**
3878  * nautilus_file_get_directory_item_count
3879  *
3880  * Get the number of items in a directory.
3881  * @file: NautilusFile representing a directory.
3882  * @count: Place to put count.
3883  * @count_unreadable: Set to TRUE (if non-NULL) if permissions prevent
3884  * the item count from being read on this directory. Otherwise set to FALSE.
3885  *
3886  * Returns: TRUE if count is available.
3887  *
3888  **/
3889 gboolean
3890 nautilus_file_get_directory_item_count (NautilusFile *file,
3891                                         guint *count,
3892                                         gboolean *count_unreadable)
3893 {
3894         if (count != NULL) {
3895                 *count = 0;
3896         }
3897         if (count_unreadable != NULL) {
3898                 *count_unreadable = FALSE;
3899         }
3900
3901         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
3902
3903         if (!nautilus_file_is_directory (file)) {
3904                 return FALSE;
3905         }
3906
3907         if (!nautilus_file_should_show_directory_item_count (file)) {
3908                 return FALSE;
3909         }
3910
3911         return EEL_CALL_METHOD_WITH_RETURN_VALUE
3912                 (NAUTILUS_FILE_CLASS, file,
3913                  get_item_count, (file, count, count_unreadable));
3914 }
3915
3916 /**
3917  * nautilus_file_get_deep_counts
3918  *
3919  * Get the statistics about items inside a directory.
3920  * @file: NautilusFile representing a directory or file.
3921  * @directory_count: Place to put count of directories inside.
3922  * @files_count: Place to put count of files inside.
3923  * @unreadable_directory_count: Number of directories encountered
3924  * that were unreadable.
3925  * @total_size: Total size of all files and directories visited.
3926  * @force: Whether the deep counts should even be collected if
3927  * nautilus_file_should_show_directory_item_count returns FALSE
3928  * for this file.
3929  *
3930  * Returns: Status to indicate whether sizes are available.
3931  *
3932  **/
3933 NautilusRequestStatus
3934 nautilus_file_get_deep_counts (NautilusFile *file,
3935                                guint *directory_count,
3936                                guint *file_count,
3937                                guint *unreadable_directory_count,
3938                                goffset *total_size,
3939                                gboolean force)
3940 {
3941         if (directory_count != NULL) {
3942                 *directory_count = 0;
3943         }
3944         if (file_count != NULL) {
3945                 *file_count = 0;
3946         }
3947         if (unreadable_directory_count != NULL) {
3948                 *unreadable_directory_count = 0;
3949         }
3950         if (total_size != NULL) {
3951                 *total_size = 0;
3952         }
3953
3954         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NAUTILUS_REQUEST_DONE);
3955
3956         if (!force && !nautilus_file_should_show_directory_item_count (file)) {
3957                 /* Set field so an existing value isn't treated as up-to-date
3958                  * when preference changes later.
3959                  */
3960                 file->details->deep_counts_status = NAUTILUS_REQUEST_NOT_STARTED;
3961                 return file->details->deep_counts_status;
3962         }
3963
3964         return EEL_CALL_METHOD_WITH_RETURN_VALUE
3965                 (NAUTILUS_FILE_CLASS, file,
3966                  get_deep_counts, (file,
3967                                    directory_count,
3968                                    file_count,
3969                                    unreadable_directory_count,
3970                                    total_size));
3971 }
3972
3973 void
3974 nautilus_file_recompute_deep_counts (NautilusFile *file)
3975 {
3976         if (file->details->deep_counts_status != NAUTILUS_REQUEST_IN_PROGRESS) {
3977                 file->details->deep_counts_status = NAUTILUS_REQUEST_NOT_STARTED;
3978                 if (file->details->directory != NULL) {
3979                         nautilus_directory_add_file_to_work_queue (file->details->directory, file);
3980                         nautilus_directory_async_state_changed (file->details->directory);
3981                 }
3982         }
3983 }
3984
3985
3986 /**
3987  * nautilus_file_get_directory_item_mime_types
3988  *
3989  * Get the list of mime-types present in a directory.
3990  * @file: NautilusFile representing a directory. It is an error to
3991  * call this function on a file that is not a directory.
3992  * @mime_list: Place to put the list of mime-types.
3993  *
3994  * Returns: TRUE if mime-type list is available.
3995  *
3996  **/
3997 gboolean
3998 nautilus_file_get_directory_item_mime_types (NautilusFile *file,
3999                                              GList **mime_list)
4000 {
4001         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
4002         g_return_val_if_fail (mime_list != NULL, FALSE);
4003
4004         if (!nautilus_file_is_directory (file)
4005             || !file->details->got_mime_list) {
4006                 *mime_list = NULL;
4007                 return FALSE;
4008         }
4009
4010         *mime_list = eel_g_str_list_copy (file->details->mime_list);
4011         return TRUE;
4012 }
4013
4014 gboolean
4015 nautilus_file_can_get_size (NautilusFile *file)
4016 {
4017         return file->details->size == -1;
4018 }
4019
4020
4021 /**
4022  * nautilus_file_get_size
4023  *
4024  * Get the file size.
4025  * @file: NautilusFile representing the file in question.
4026  *
4027  * Returns: Size in bytes.
4028  *
4029  **/
4030 goffset
4031 nautilus_file_get_size (NautilusFile *file)
4032 {
4033         /* Before we have info on the file, we don't know the size. */
4034         if (file->details->size == -1)
4035                 return 0;
4036         return file->details->size;
4037 }
4038
4039 time_t
4040 nautilus_file_get_mtime (NautilusFile *file)
4041 {
4042         return file->details->mtime;
4043 }
4044
4045
4046 static void
4047 set_attributes_get_info_callback (GObject *source_object,
4048                                   GAsyncResult *res,
4049                                   gpointer callback_data)
4050 {
4051         NautilusFileOperation *op;
4052         GFileInfo *new_info;
4053         GError *error;
4054
4055         op = callback_data;
4056
4057         error = NULL;
4058         new_info = g_file_query_info_finish (G_FILE (source_object), res, &error);
4059         if (new_info != NULL) {
4060                 nautilus_file_update_info (op->file, new_info);
4061                 g_object_unref (new_info);
4062         }
4063         nautilus_file_operation_complete (op, NULL, error);
4064         if (error) {
4065                 g_error_free (error);
4066         }
4067 }
4068
4069
4070 static void
4071 set_attributes_callback (GObject *source_object,
4072                          GAsyncResult *result,
4073                          gpointer callback_data)
4074 {
4075         NautilusFileOperation *op;
4076         GError *error;
4077         gboolean res;
4078
4079         op = callback_data;
4080
4081         error = NULL;
4082         res = g_file_set_attributes_finish (G_FILE (source_object),
4083                                             result,
4084                                             NULL,
4085                                             &error);
4086
4087         if (res) {
4088                 g_file_query_info_async (G_FILE (source_object),
4089                                          NAUTILUS_FILE_DEFAULT_ATTRIBUTES,
4090                                          0,
4091                                          G_PRIORITY_DEFAULT,
4092                                          op->cancellable,
4093                                          set_attributes_get_info_callback, op);
4094         } else {
4095                 nautilus_file_operation_complete (op, NULL, error);
4096                 g_error_free (error);
4097         }
4098 }
4099
4100 void
4101 nautilus_file_set_attributes (NautilusFile *file,
4102                               GFileInfo *attributes,
4103                               NautilusFileOperationCallback callback,
4104                               gpointer callback_data)
4105 {
4106         NautilusFileOperation *op;
4107         GFile *location;
4108
4109         op = nautilus_file_operation_new (file, callback, callback_data);
4110
4111         location = nautilus_file_get_location (file);
4112         g_file_set_attributes_async (location,
4113                                      attributes,
4114                                      0,
4115                                      G_PRIORITY_DEFAULT,
4116                                      op->cancellable,
4117                                      set_attributes_callback,
4118                                      op);
4119         g_object_unref (location);
4120 }
4121
4122
4123 /**
4124  * nautilus_file_can_get_permissions:
4125  *
4126  * Check whether the permissions for a file are determinable.
4127  * This might not be the case for files on non-UNIX file systems.
4128  *
4129  * @file: The file in question.
4130  *
4131  * Return value: TRUE if the permissions are valid.
4132  */
4133 gboolean
4134 nautilus_file_can_get_permissions (NautilusFile *file)
4135 {
4136         return file->details->has_permissions;
4137 }
4138
4139 /**
4140  * nautilus_file_can_set_permissions:
4141  *
4142  * Check whether the current user is allowed to change
4143  * the permissions of a file.
4144  *
4145  * @file: The file in question.
4146  *
4147  * Return value: TRUE if the current user can change the
4148  * permissions of @file, FALSE otherwise. It's always possible
4149  * that when you actually try to do it, you will fail.
4150  */
4151 gboolean
4152 nautilus_file_can_set_permissions (NautilusFile *file)
4153 {
4154         uid_t user_id;
4155
4156         if (file->details->uid != -1 &&
4157             nautilus_file_is_local (file)) {
4158                 /* Check the user. */
4159                 user_id = geteuid();
4160
4161                 /* Owner is allowed to set permissions. */
4162                 if (user_id == (uid_t) file->details->uid) {
4163                         return TRUE;
4164                 }
4165
4166                 /* Root is also allowed to set permissions. */
4167                 if (user_id == 0) {
4168                         return TRUE;
4169                 }
4170
4171                 /* Nobody else is allowed. */
4172                 return FALSE;
4173         }
4174
4175         /* pretend to have full chmod rights when no info is available, relevant when
4176          * the FS can't provide ownership info, for instance for FTP */
4177         return TRUE;
4178 }
4179
4180 guint
4181 nautilus_file_get_permissions (NautilusFile *file)
4182 {
4183         g_return_val_if_fail (nautilus_file_can_get_permissions (file), 0);
4184
4185         return file->details->permissions;
4186 }
4187
4188 /**
4189  * nautilus_file_set_permissions:
4190  *
4191  * Change a file's permissions. This should only be called if
4192  * nautilus_file_can_set_permissions returned TRUE.
4193  *
4194  * @file: NautilusFile representing the file in question.
4195  * @new_permissions: New permissions value. This is the whole
4196  * set of permissions, not a delta.
4197  **/
4198 void
4199 nautilus_file_set_permissions (NautilusFile *file,
4200                                guint32 new_permissions,
4201                                NautilusFileOperationCallback callback,
4202                                gpointer callback_data)
4203 {
4204         GFileInfo *info;
4205         GError *error;
4206
4207         if (!nautilus_file_can_set_permissions (file)) {
4208                 /* Claim that something changed even if the permission change failed.
4209                  * This makes it easier for some clients who see the "reverting"
4210                  * to the old permissions as "changing back".
4211                  */
4212                 nautilus_file_changed (file);
4213                 error = g_error_new (G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
4214                                      _("Not allowed to set permissions"));
4215                 (* callback) (file, NULL, error, callback_data);
4216                 g_error_free (error);
4217                 return;
4218         }
4219
4220         /* Test the permissions-haven't-changed case explicitly
4221          * because we don't want to send the file-changed signal if
4222          * nothing changed.
4223          */
4224         if (new_permissions == file->details->permissions) {
4225                 (* callback) (file, NULL, NULL, callback_data);
4226                 return;
4227         }
4228
4229         info = g_file_info_new ();
4230         g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE, new_permissions);
4231         nautilus_file_set_attributes (file, info, callback, callback_data);
4232         g_object_unref (info);
4233 }
4234
4235 /**
4236  * nautilus_file_can_get_selinux_context:
4237  *
4238  * Check whether the selinux context for a file are determinable.
4239  * This might not be the case for files on non-UNIX file systems,
4240  * files without a context or systems that don't support selinux.
4241  *
4242  * @file: The file in question.
4243  *
4244  * Return value: TRUE if the permissions are valid.
4245  */
4246 gboolean
4247 nautilus_file_can_get_selinux_context (NautilusFile *file)
4248 {
4249         return file->details->selinux_context != NULL;
4250 }
4251
4252
4253 /**
4254  * nautilus_file_get_selinux_context:
4255  *
4256  * Get a user-displayable string representing a file's selinux
4257  * context
4258  * @file: NautilusFile representing the file in question.
4259  *
4260  * Returns: Newly allocated string ready to display to the user.
4261  *
4262  **/
4263 char *
4264 nautilus_file_get_selinux_context (NautilusFile *file)
4265 {
4266         char *translated;
4267         char *raw;
4268
4269         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
4270
4271         if (!nautilus_file_can_get_selinux_context (file)) {
4272                 return NULL;
4273         }
4274
4275         raw = file->details->selinux_context;
4276
4277 #ifdef HAVE_SELINUX
4278         if (selinux_raw_to_trans_context (raw, &translated) == 0) {
4279                 char *tmp;
4280                 tmp = g_strdup (translated);
4281                 freecon (translated);
4282                 translated = tmp;
4283         }
4284         else
4285 #endif
4286         {
4287                 translated = g_strdup (raw);
4288         }
4289
4290         return translated;
4291 }
4292
4293 static char *
4294 get_real_name (const char *name, const char *gecos)
4295 {
4296         char *locale_string, *part_before_comma, *capitalized_login_name, *real_name;
4297
4298         if (gecos == NULL) {
4299                 return NULL;
4300         }
4301
4302         locale_string = eel_str_strip_substring_and_after (gecos, ",");
4303         if (!g_utf8_validate (locale_string, -1, NULL)) {
4304                 part_before_comma = g_locale_to_utf8 (locale_string, -1, NULL, NULL, NULL);
4305                 g_free (locale_string);
4306         } else {
4307                 part_before_comma = locale_string;
4308         }
4309
4310         if (!g_utf8_validate (name, -1, NULL)) {
4311                 locale_string = g_locale_to_utf8 (name, -1, NULL, NULL, NULL);
4312         } else {
4313                 locale_string = g_strdup (name);
4314         }
4315
4316         capitalized_login_name = eel_str_capitalize (locale_string);
4317         g_free (locale_string);
4318
4319         if (capitalized_login_name == NULL) {
4320                 real_name = part_before_comma;
4321         } else {
4322                 real_name = eel_str_replace_substring
4323                         (part_before_comma, "&", capitalized_login_name);
4324                 g_free (part_before_comma);
4325         }
4326
4327
4328         if (eel_str_is_empty (real_name)
4329             || eel_strcmp (name, real_name) == 0
4330             || eel_strcmp (capitalized_login_name, real_name) == 0) {
4331                 g_free (real_name);
4332                 real_name = NULL;
4333         }
4334
4335         g_free (capitalized_login_name);
4336
4337         return real_name;
4338 }
4339
4340 static char *
4341 get_user_and_real_name_from_id (uid_t uid)
4342 {
4343         char *name, *gecos;
4344         char *real_name, *user_and_real_name;
4345
4346         name = nautilus_users_cache_get_name (uid);
4347         gecos = nautilus_users_cache_get_gecos (uid);
4348
4349         real_name = get_real_name (name, gecos);
4350         if (real_name != NULL) {
4351                 user_and_real_name = g_strdup_printf ("%s - %s", name, real_name);
4352         } else {
4353                 user_and_real_name = g_strdup (name);
4354         }
4355         g_free (real_name);
4356
4357         g_free (name);
4358         g_free (gecos);
4359
4360         return user_and_real_name;
4361 }
4362
4363 static gboolean
4364 get_group_id_from_group_name (const char *group_name, uid_t *gid)
4365 {
4366         struct group *group;
4367
4368         g_assert (gid != NULL);
4369
4370         group = getgrnam (group_name);
4371
4372         if (group == NULL) {
4373                 return FALSE;
4374         }
4375
4376         *gid = group->gr_gid;
4377
4378         return TRUE;
4379 }
4380
4381 static gboolean
4382 get_ids_from_user_name (const char *user_name, uid_t *uid, uid_t *gid)
4383 {
4384         struct passwd *password_info;
4385
4386         g_assert (uid != NULL || gid != NULL);
4387
4388         password_info = getpwnam (user_name);
4389
4390         if (password_info == NULL) {
4391                 return FALSE;
4392         }
4393
4394         if (uid != NULL) {
4395                 *uid = password_info->pw_uid;
4396         }
4397
4398         if (gid != NULL) {
4399                 *gid = password_info->pw_gid;
4400         }
4401
4402         return TRUE;
4403 }
4404
4405 static gboolean
4406 get_user_id_from_user_name (const char *user_name, uid_t *id)
4407 {
4408         return get_ids_from_user_name (user_name, id, NULL);
4409 }
4410
4411 static gboolean
4412 get_id_from_digit_string (const char *digit_string, uid_t *id)
4413 {
4414         long scanned_id;
4415         char c;
4416
4417         g_assert (id != NULL);
4418
4419         /* Only accept string if it has one integer with nothing
4420          * afterwards.
4421          */
4422         if (sscanf (digit_string, "%ld%c", &scanned_id, &c) != 1) {
4423                 return FALSE;
4424         }
4425         *id = scanned_id;
4426         return TRUE;
4427 }
4428
4429 /**
4430  * nautilus_file_can_get_owner:
4431  *
4432  * Check whether the owner a file is determinable.
4433  * This might not be the case for files on non-UNIX file systems.
4434  *
4435  * @file: The file in question.
4436  *
4437  * Return value: TRUE if the owner is valid.
4438  */
4439 gboolean
4440 nautilus_file_can_get_owner (NautilusFile *file)
4441 {
4442         /* Before we have info on a file, the owner is unknown. */
4443         return file->details->uid != -1;
4444 }
4445
4446 /**
4447  * nautilus_file_get_owner_name:
4448  *
4449  * Get the user name of the file's owner. If the owner has no
4450  * name, returns the userid as a string. The caller is responsible
4451  * for g_free-ing this string.
4452  *
4453  * @file: The file in question.
4454  *
4455  * Return value: A newly-allocated string.
4456  */
4457 char *
4458 nautilus_file_get_owner_name (NautilusFile *file)
4459 {
4460         return nautilus_file_get_owner_as_string (file, FALSE);
4461 }
4462
4463 /**
4464  * nautilus_file_can_set_owner:
4465  *
4466  * Check whether the current user is allowed to change
4467  * the owner of a file.
4468  *
4469  * @file: The file in question.
4470  *
4471  * Return value: TRUE if the current user can change the
4472  * owner of @file, FALSE otherwise. It's always possible
4473  * that when you actually try to do it, you will fail.
4474  */
4475 gboolean
4476 nautilus_file_can_set_owner (NautilusFile *file)
4477 {
4478         /* Not allowed to set the owner if we can't
4479          * even read it. This can happen on non-UNIX file
4480          * systems.
4481          */
4482         if (!nautilus_file_can_get_owner (file)) {
4483                 return FALSE;
4484         }
4485
4486         /* Only root is also allowed to set the owner. */
4487         return geteuid() == 0;
4488 }
4489
4490 /**
4491  * nautilus_file_set_owner:
4492  *
4493  * Set the owner of a file. This will only have any effect if
4494  * nautilus_file_can_set_owner returns TRUE.
4495  *
4496  * @file: The file in question.
4497  * @user_name_or_id: The user name to set the owner to.
4498  * If the string does not match any user name, and the
4499  * string is an integer, the owner will be set to the
4500  * userid represented by that integer.
4501  * @callback: Function called when asynch owner change succeeds or fails.
4502  * @callback_data: Parameter passed back with callback function.
4503  */
4504 void
4505 nautilus_file_set_owner (NautilusFile *file,
4506                          const char *user_name_or_id,
4507                          NautilusFileOperationCallback callback,
4508                          gpointer callback_data)
4509 {
4510         GError *error;
4511         GFileInfo *info;
4512         uid_t new_id;
4513
4514         if (!nautilus_file_can_set_owner (file)) {
4515                 /* Claim that something changed even if the permission
4516                  * change failed. This makes it easier for some
4517                  * clients who see the "reverting" to the old owner as
4518                  * "changing back".
4519                  */
4520                 nautilus_file_changed (file);
4521                 error = g_error_new (G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
4522                                      _("Not allowed to set owner"));
4523                 (* callback) (file, NULL, error, callback_data);
4524                 g_error_free (error);
4525                 return;
4526         }
4527
4528         /* If no match treating user_name_or_id as name, try treating
4529          * it as id.
4530          */
4531         if (!get_user_id_from_user_name (user_name_or_id, &new_id)
4532             && !get_id_from_digit_string (user_name_or_id, &new_id)) {
4533                 /* Claim that something changed even if the permission
4534                  * change failed. This makes it easier for some
4535                  * clients who see the "reverting" to the old owner as
4536                  * "changing back".
4537                  */
4538                 nautilus_file_changed (file);
4539                 error = g_error_new (G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
4540                                      _("Specified owner '%s' doesn't exist"), user_name_or_id);
4541                 (* callback) (file, NULL, error, callback_data);
4542                 g_error_free (error);
4543                 return;
4544         }
4545
4546         /* Test the owner-hasn't-changed case explicitly because we
4547          * don't want to send the file-changed signal if nothing
4548          * changed.
4549          */
4550         if (new_id == (uid_t) file->details->uid) {
4551                 (* callback) (file, NULL, NULL, callback_data);
4552                 return;
4553         }
4554
4555         info = g_file_info_new ();
4556         g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_UID, new_id);
4557         nautilus_file_set_attributes (file, info, callback, callback_data);
4558         g_object_unref (info);
4559 }
4560
4561 /**
4562  * nautilus_get_user_names:
4563  *
4564  * Get a list of user names. For users with a different associated
4565  * "real name", the real name follows the standard user name, separated
4566  * by a carriage return. The caller is responsible for freeing this list
4567  * and its contents.
4568  */
4569 GList *
4570 nautilus_get_user_names (void)
4571 {
4572         GList *list;
4573         char *real_name, *name;
4574         struct passwd *user;
4575
4576         list = NULL;
4577
4578         setpwent ();
4579
4580         while ((user = getpwent ()) != NULL) {
4581                 real_name = get_real_name (user->pw_name, user->pw_gecos);
4582                 if (real_name != NULL) {
4583                         name = g_strconcat (user->pw_name, "\n", real_name, NULL);
4584                 } else {
4585                         name = g_strdup (user->pw_name);
4586                 }
4587                 g_free (real_name);
4588                 list = g_list_prepend (list, name);
4589         }
4590
4591         endpwent ();
4592
4593         return eel_g_str_list_alphabetize (list);
4594 }
4595
4596 /**
4597  * nautilus_file_can_get_group:
4598  *
4599  * Check whether the group a file is determinable.
4600  * This might not be the case for files on non-UNIX file systems.
4601  *
4602  * @file: The file in question.
4603  *
4604  * Return value: TRUE if the group is valid.
4605  */
4606 gboolean
4607 nautilus_file_can_get_group (NautilusFile *file)
4608 {
4609         /* Before we have info on a file, the group is unknown. */
4610         return file->details->gid != -1;
4611 }
4612
4613 /**
4614  * nautilus_file_get_group_name:
4615  *
4616  * Get the name of the file's group. If the group has no
4617  * name, returns the groupid as a string. The caller is responsible
4618  * for g_free-ing this string.
4619  *
4620  * @file: The file in question.
4621  *
4622  * Return value: A newly-allocated string.
4623  **/
4624 char *
4625 nautilus_file_get_group_name (NautilusFile *file)
4626 {
4627         char *group_name;
4628
4629         /* Before we have info on a file, the owner is unknown. */
4630         if (file->details->gid == -1) {
4631                 return NULL;
4632         }
4633
4634         group_name = nautilus_groups_cache_get_name ((gid_t) file->details->gid);
4635         if (group_name == NULL) {
4636                 /* In the oddball case that the group name has been set to an id for which
4637                  * there is no defined group, return the id in string form.
4638                  */
4639                 group_name = g_strdup_printf ("%d", file->details->gid);
4640         }
4641
4642         return group_name;
4643 }
4644
4645 /**
4646  * nautilus_file_can_set_group:
4647  *
4648  * Check whether the current user is allowed to change
4649  * the group of a file.
4650  *
4651  * @file: The file in question.
4652  *
4653  * Return value: TRUE if the current user can change the
4654  * group of @file, FALSE otherwise. It's always possible
4655  * that when you actually try to do it, you will fail.
4656  */
4657 gboolean
4658 nautilus_file_can_set_group (NautilusFile *file)
4659 {
4660         uid_t user_id;
4661
4662         /* Not allowed to set the permissions if we can't
4663          * even read them. This can happen on non-UNIX file
4664          * systems.
4665          */
4666         if (!nautilus_file_can_get_group (file)) {
4667                 return FALSE;
4668         }
4669
4670         /* Check the user. */
4671         user_id = geteuid();
4672
4673         /* Owner is allowed to set group (with restrictions). */
4674         if (user_id == (uid_t) file->details->uid) {
4675                 return TRUE;
4676         }
4677
4678         /* Root is also allowed to set group. */
4679         if (user_id == 0) {
4680                 return TRUE;
4681         }
4682
4683         /* Nobody else is allowed. */
4684         return FALSE;
4685 }
4686
4687 /* Get a list of group names, filtered to only the ones
4688  * that contain the given username. If the username is
4689  * NULL, returns a list of all group names.
4690  */
4691 static GList *
4692 nautilus_get_group_names_for_user (void)
4693 {
4694         GList *list;
4695         struct group *group;
4696         int count, i;
4697         gid_t gid_list[NGROUPS_MAX + 1];
4698
4699
4700         list = NULL;
4701
4702         count = getgroups (NGROUPS_MAX + 1, gid_list);
4703         for (i = 0; i < count; i++) {
4704                 group = getgrgid (gid_list[i]);
4705                 if (group == NULL)
4706                         break;
4707
4708                 list = g_list_prepend (list, g_strdup (group->gr_name));
4709         }
4710
4711         return eel_g_str_list_alphabetize (list);
4712 }
4713
4714 /**
4715  * nautilus_get_group_names:
4716  *
4717  * Get a list of all group names.
4718  */
4719 GList *
4720 nautilus_get_all_group_names (void)
4721 {
4722         GList *list;
4723         struct group *group;
4724
4725         list = NULL;
4726
4727         setgrent ();
4728
4729         while ((group = getgrent ()) != NULL)
4730                 list = g_list_prepend (list, g_strdup (group->gr_name));
4731
4732         endgrent ();
4733
4734         return eel_g_str_list_alphabetize (list);
4735 }
4736
4737 /**
4738  * nautilus_file_get_settable_group_names:
4739  *
4740  * Get a list of all group names that the current user
4741  * can set the group of a specific file to.
4742  *
4743  * @file: The NautilusFile in question.
4744  */
4745 GList *
4746 nautilus_file_get_settable_group_names (NautilusFile *file)
4747 {
4748         uid_t user_id;
4749         GList *result;
4750
4751         if (!nautilus_file_can_set_group (file)) {
4752                 return NULL;
4753         }
4754
4755         /* Check the user. */
4756         user_id = geteuid();
4757
4758         if (user_id == 0) {
4759                 /* Root is allowed to set group to anything. */
4760                 result = nautilus_get_all_group_names ();
4761         } else if (user_id == (uid_t) file->details->uid) {
4762                 /* Owner is allowed to set group to any that owner is member of. */
4763                 result = nautilus_get_group_names_for_user ();
4764         } else {
4765                 g_warning ("unhandled case in nautilus_get_settable_group_names");
4766                 result = NULL;
4767         }
4768
4769         return result;
4770 }
4771
4772 /**
4773  * nautilus_file_set_group:
4774  *
4775  * Set the group of a file. This will only have any effect if
4776  * nautilus_file_can_set_group returns TRUE.
4777  *
4778  * @file: The file in question.
4779  * @group_name_or_id: The group name to set the owner to.
4780  * If the string does not match any group name, and the
4781  * string is an integer, the group will be set to the
4782  * group id represented by that integer.
4783  * @callback: Function called when asynch group change succeeds or fails.
4784  * @callback_data: Parameter passed back with callback function.
4785  */
4786 void
4787 nautilus_file_set_group (NautilusFile *file,
4788                          const char *group_name_or_id,
4789                          NautilusFileOperationCallback callback,
4790                          gpointer callback_data)
4791 {
4792         GError *error;
4793         GFileInfo *info;
4794         uid_t new_id;
4795
4796         if (!nautilus_file_can_set_group (file)) {
4797                 /* Claim that something changed even if the group
4798                  * change failed. This makes it easier for some
4799                  * clients who see the "reverting" to the old group as
4800                  * "changing back".
4801                  */
4802                 nautilus_file_changed (file);
4803                 error = g_error_new (G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
4804                                      _("Not allowed to set group"));
4805                 (* callback) (file, NULL, error, callback_data);
4806                 g_error_free (error);
4807                 return;
4808         }
4809
4810         /* If no match treating group_name_or_id as name, try treating
4811          * it as id.
4812          */
4813         if (!get_group_id_from_group_name (group_name_or_id, &new_id)
4814             && !get_id_from_digit_string (group_name_or_id, &new_id)) {
4815                 /* Claim that something changed even if the group
4816                  * change failed. This makes it easier for some
4817                  * clients who see the "reverting" to the old group as
4818                  * "changing back".
4819                  */
4820                 nautilus_file_changed (file);
4821                 error = g_error_new (G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
4822                                      _("Specified group '%s' doesn't exist"), group_name_or_id);
4823                 (* callback) (file, NULL, error, callback_data);
4824                 g_error_free (error);
4825                 return;
4826         }
4827
4828         if (new_id == (gid_t) file->details->gid) {
4829                 (* callback) (file, NULL, NULL, callback_data);
4830                 return;
4831         }
4832
4833
4834         info = g_file_info_new ();
4835         g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_GID, new_id);
4836         nautilus_file_set_attributes (file, info, callback, callback_data);
4837         g_object_unref (info);
4838 }
4839
4840 /**
4841  * nautilus_file_get_octal_permissions_as_string:
4842  *
4843  * Get a user-displayable string representing a file's permissions
4844  * as an octal number. The caller
4845  * is responsible for g_free-ing this string.
4846  * @file: NautilusFile representing the file in question.
4847  *
4848  * Returns: Newly allocated string ready to display to the user.
4849  *
4850  **/
4851 static char *
4852 nautilus_file_get_octal_permissions_as_string (NautilusFile *file)
4853 {
4854         guint32 permissions;
4855
4856         g_assert (NAUTILUS_IS_FILE (file));
4857
4858         if (!nautilus_file_can_get_permissions (file)) {
4859                 return NULL;
4860         }
4861
4862         permissions = file->details->permissions;
4863         return g_strdup_printf ("%03o", permissions);
4864 }
4865
4866 /**
4867  * nautilus_file_get_permissions_as_string:
4868  *
4869  * Get a user-displayable string representing a file's permissions. The caller
4870  * is responsible for g_free-ing this string.
4871  * @file: NautilusFile representing the file in question.
4872  *
4873  * Returns: Newly allocated string ready to display to the user.
4874  *
4875  **/
4876 static char *
4877 nautilus_file_get_permissions_as_string (NautilusFile *file)
4878 {
4879         guint32 permissions;
4880         gboolean is_directory;
4881         gboolean is_link;
4882         gboolean suid, sgid, sticky;
4883
4884         if (!nautilus_file_can_get_permissions (file)) {
4885                 return NULL;
4886         }
4887
4888         g_assert (NAUTILUS_IS_FILE (file));
4889
4890         permissions = file->details->permissions;
4891         is_directory = nautilus_file_is_directory (file);
4892         is_link = nautilus_file_is_symbolic_link (file);
4893
4894         /* We use ls conventions for displaying these three obscure flags */
4895         suid = permissions & S_ISGID;
4896         sgid = permissions & S_ISGID;
4897         sticky = permissions & S_ISVTX;
4898
4899         return g_strdup_printf ("%c%c%c%c%c%c%c%c%c%c",
4900                                  is_link ? 'l' : is_directory ? 'd' : '-',
4901                                  permissions & S_IRUSR ? 'r' : '-',
4902                                  permissions & S_IWUSR ? 'w' : '-',
4903                                  permissions & S_IXUSR
4904                                         ? (suid ? 's' : 'x')
4905                                         : (suid ? 'S' : '-'),
4906                                  permissions & S_IRGRP ? 'r' : '-',
4907                                  permissions & S_IWGRP ? 'w' : '-',
4908                                  permissions & S_IXGRP
4909                                         ? (sgid ? 's' : 'x')
4910                                         : (sgid ? 'S' : '-'),
4911                                  permissions & S_IROTH ? 'r' : '-',
4912                                  permissions & S_IWOTH ? 'w' : '-',
4913                                  permissions & S_IXOTH
4914                                         ? (sticky ? 't' : 'x')
4915                                         : (sticky ? 'T' : '-'));
4916 }
4917
4918 /**
4919  * nautilus_file_get_owner_as_string:
4920  *
4921  * Get a user-displayable string representing a file's owner. The caller
4922  * is responsible for g_free-ing this string.
4923  * @file: NautilusFile representing the file in question.
4924  * @include_real_name: Whether or not to append the real name (if any)
4925  * for this user after the user name.
4926  *
4927  * Returns: Newly allocated string ready to display to the user.
4928  *
4929  **/
4930 static char *
4931 nautilus_file_get_owner_as_string (NautilusFile *file, gboolean include_real_name)
4932 {
4933         char *user_name;
4934
4935         /* Before we have info on a file, the owner is unknown. */
4936         if (file->details->uid == -1) {
4937                 return NULL;
4938         }
4939
4940         if (include_real_name) {
4941                 user_name = get_user_and_real_name_from_id (file->details->uid);
4942         } else {
4943                 user_name = nautilus_users_cache_get_name (file->details->uid);
4944         }
4945
4946         if (user_name == NULL) {
4947                 /* In the oddball case that the user name has been set to an id for which
4948                  * there is no defined user, return the id in string form.
4949                  */
4950                 user_name = g_strdup_printf ("%d", file->details->uid);
4951         }
4952
4953         return user_name;
4954 }
4955
4956 static char *
4957 format_item_count_for_display (guint item_count,
4958                                gboolean includes_directories,
4959                                gboolean includes_files)
4960 {
4961         g_assert (includes_directories || includes_files);
4962
4963         return g_strdup_printf (includes_directories
4964                         ? (includes_files
4965                            ? ngettext ("%'u item", "%'u items", item_count)
4966                            : ngettext ("%'u folder", "%'u folders", item_count))
4967                         : ngettext ("%'u file", "%'u files", item_count), item_count);
4968 }
4969
4970 /**
4971  * nautilus_file_get_size_as_string:
4972  *
4973  * Get a user-displayable string representing a file size. The caller
4974  * is responsible for g_free-ing this string. The string is an item
4975  * count for directories.
4976  * @file: NautilusFile representing the file in question.
4977  *
4978  * Returns: Newly allocated string ready to display to the user.
4979  *
4980  **/
4981 static char *
4982 nautilus_file_get_size_as_string (NautilusFile *file)
4983 {
4984         guint item_count;
4985         gboolean count_unreadable;
4986
4987         if (file == NULL) {
4988                 return NULL;
4989         }
4990
4991         g_assert (NAUTILUS_IS_FILE (file));
4992
4993         if (nautilus_file_is_directory (file)) {
4994                 if (!nautilus_file_get_directory_item_count (file, &item_count, &count_unreadable)) {
4995                         return NULL;
4996                 }
4997                 return format_item_count_for_display (item_count, TRUE, TRUE);
4998         }
4999
5000         if (file->details->size == -1) {
5001                 return NULL;
5002         }
5003         return g_format_size_for_display (file->details->size);
5004 }
5005
5006 /**
5007  * nautilus_file_get_size_as_string_with_real_size:
5008  *
5009  * Get a user-displayable string representing a file size. The caller
5010  * is responsible for g_free-ing this string. The string is an item
5011  * count for directories.
5012  * This function adds the real size in the string.
5013  * @file: NautilusFile representing the file in question.
5014  *
5015  * Returns: Newly allocated string ready to display to the user.
5016  *
5017  **/
5018 static char *
5019 nautilus_file_get_size_as_string_with_real_size (NautilusFile *file)
5020 {
5021         guint item_count;
5022         gboolean count_unreadable;
5023         char * formated;
5024         char * formated_plus_real;
5025         char * real_size;
5026
5027         if (file == NULL) {
5028                 return NULL;
5029         }
5030
5031         g_assert (NAUTILUS_IS_FILE (file));
5032
5033         if (nautilus_file_is_directory (file)) {
5034                 if (!nautilus_file_get_directory_item_count (file, &item_count, &count_unreadable)) {
5035                         return NULL;
5036                 }
5037                 return format_item_count_for_display (item_count, TRUE, TRUE);
5038         }
5039
5040         if (file->details->size == -1) {
5041                 return NULL;
5042         }
5043
5044         formated = g_format_size_for_display (file->details->size);
5045         /* Do this in a separate stage so that we don't have to put G_GUINT64_FORMAT in the translated string */
5046         real_size = g_strdup_printf (_("%"G_GUINT64_FORMAT), (guint64) file->details->size);
5047         formated_plus_real = g_strdup_printf (_("%s (%s bytes)"), formated, real_size);
5048         g_free (real_size);
5049         g_free (formated);
5050         return formated_plus_real;
5051 }
5052
5053
5054 static char *
5055 nautilus_file_get_deep_count_as_string_internal (NautilusFile *file,
5056                                                  gboolean report_size,
5057                                                  gboolean report_directory_count,
5058                                                  gboolean report_file_count)
5059 {
5060         NautilusRequestStatus status;
5061         guint directory_count;
5062         guint file_count;
5063         guint unreadable_count;
5064         guint total_count;
5065         goffset total_size;
5066
5067         /* Must ask for size or some kind of count, but not both. */
5068         g_assert (!report_size || (!report_directory_count && !report_file_count));
5069         g_assert (report_size || report_directory_count || report_file_count);
5070
5071         if (file == NULL) {
5072                 return NULL;
5073         }
5074
5075         g_assert (NAUTILUS_IS_FILE (file));
5076         g_assert (nautilus_file_is_directory (file));
5077
5078         status = nautilus_file_get_deep_counts
5079                 (file, &directory_count, &file_count, &unreadable_count, &total_size, FALSE);
5080
5081         /* Check whether any info is available. */
5082         if (status == NAUTILUS_REQUEST_NOT_STARTED) {
5083                 return NULL;
5084         }
5085
5086         total_count = file_count + directory_count;
5087
5088         if (total_count == 0) {
5089                 switch (status) {
5090                 case NAUTILUS_REQUEST_IN_PROGRESS:
5091                         /* Don't return confident "zero" until we're finished looking,
5092                          * because of next case.
5093                          */
5094                         return NULL;
5095                 case NAUTILUS_REQUEST_DONE:
5096                         /* Don't return "zero" if we there were contents but we couldn't read them. */
5097                         if (unreadable_count != 0) {
5098                                 return NULL;
5099                         }
5100                 default: break;
5101                 }
5102         }
5103
5104         /* Note that we don't distinguish the "everything was readable" case
5105          * from the "some things but not everything was readable" case here.
5106          * Callers can distinguish them using nautilus_file_get_deep_counts
5107          * directly if desired.
5108          */
5109         if (report_size) {
5110                 return g_format_size_for_display (total_size);
5111         }
5112
5113         return format_item_count_for_display (report_directory_count
5114                 ? (report_file_count ? total_count : directory_count)
5115                 : file_count,
5116                 report_directory_count, report_file_count);
5117 }
5118
5119 /**
5120  * nautilus_file_get_deep_size_as_string:
5121  *
5122  * Get a user-displayable string representing the size of all contained
5123  * items (only makes sense for directories). The caller
5124  * is responsible for g_free-ing this string.
5125  * @file: NautilusFile representing the file in question.
5126  *
5127  * Returns: Newly allocated string ready to display to the user.
5128  *
5129  **/
5130 static char *
5131 nautilus_file_get_deep_size_as_string (NautilusFile *file)
5132 {
5133         return nautilus_file_get_deep_count_as_string_internal (file, TRUE, FALSE, FALSE);
5134 }
5135
5136 /**
5137  * nautilus_file_get_deep_total_count_as_string:
5138  *
5139  * Get a user-displayable string representing the count of all contained
5140  * items (only makes sense for directories). The caller
5141  * is responsible for g_free-ing this string.
5142  * @file: NautilusFile representing the file in question.
5143  *
5144  * Returns: Newly allocated string ready to display to the user.
5145  *
5146  **/
5147 static char *
5148 nautilus_file_get_deep_total_count_as_string (NautilusFile *file)
5149 {
5150         return nautilus_file_get_deep_count_as_string_internal (file, FALSE, TRUE, TRUE);
5151 }
5152
5153 /**
5154  * nautilus_file_get_deep_file_count_as_string:
5155  *
5156  * Get a user-displayable string representing the count of all contained
5157  * items, not including directories. It only makes sense to call this
5158  * function on a directory. The caller
5159  * is responsible for g_free-ing this string.
5160  * @file: NautilusFile representing the file in question.
5161  *
5162  * Returns: Newly allocated string ready to display to the user.
5163  *
5164  **/
5165 static char *
5166 nautilus_file_get_deep_file_count_as_string (NautilusFile *file)
5167 {
5168         return nautilus_file_get_deep_count_as_string_internal (file, FALSE, FALSE, TRUE);
5169 }
5170
5171 /**
5172  * nautilus_file_get_deep_directory_count_as_string:
5173  *
5174  * Get a user-displayable string representing the count of all contained
5175  * directories. It only makes sense to call this
5176  * function on a directory. The caller
5177  * is responsible for g_free-ing this string.
5178  * @file: NautilusFile representing the file in question.
5179  *
5180  * Returns: Newly allocated string ready to display to the user.
5181  *
5182  **/
5183 static char *
5184 nautilus_file_get_deep_directory_count_as_string (NautilusFile *file)
5185 {
5186         return nautilus_file_get_deep_count_as_string_internal (file, FALSE, TRUE, FALSE);
5187 }
5188
5189 /**
5190  * nautilus_file_get_string_attribute:
5191  *
5192  * Get a user-displayable string from a named attribute. Use g_free to
5193  * free this string. If the value is unknown, returns NULL. You can call
5194  * nautilus_file_get_string_attribute_with_default if you want a non-NULL
5195  * default.
5196  *
5197  * @file: NautilusFile representing the file in question.
5198  * @attribute_name: The name of the desired attribute. The currently supported
5199  * set includes "name", "type", "mime_type", "size", "deep_size", "deep_directory_count",
5200  * "deep_file_count", "deep_total_count", "date_modified", "date_changed", "date_accessed",
5201  * "date_permissions", "owner", "group", "permissions", "octal_permissions", "uri", "where",
5202  * "link_target", "volume", "free_space", "selinux_context"
5203  *
5204  * Returns: Newly allocated string ready to display to the user, or NULL
5205  * if the value is unknown or @attribute_name is not supported.
5206  *
5207  **/
5208 char *
5209 nautilus_file_get_string_attribute_q (NautilusFile *file, GQuark attribute_q)
5210 {
5211         char *extension_attribute;
5212
5213         if (attribute_q == attribute_name_q) {
5214                 return nautilus_file_get_display_name (file);
5215         }
5216         if (attribute_q == attribute_type_q) {
5217                 return nautilus_file_get_type_as_string (file);
5218         }
5219         if (attribute_q == attribute_mime_type_q) {
5220                 return nautilus_file_get_mime_type (file);
5221         }
5222         if (attribute_q == attribute_size_q) {
5223                 return nautilus_file_get_size_as_string (file);
5224         }
5225         if (attribute_q == attribute_size_detail_q) {
5226                 return nautilus_file_get_size_as_string_with_real_size (file);
5227         }
5228         if (attribute_q == attribute_deep_size_q) {
5229                 return nautilus_file_get_deep_size_as_string (file);
5230         }
5231         if (attribute_q == attribute_deep_file_count_q) {
5232                 return nautilus_file_get_deep_file_count_as_string (file);
5233         }
5234         if (attribute_q == attribute_deep_directory_count_q) {
5235                 return nautilus_file_get_deep_directory_count_as_string (file);
5236         }
5237         if (attribute_q == attribute_deep_total_count_q) {
5238                 return nautilus_file_get_deep_total_count_as_string (file);
5239         }
5240         if (attribute_q == attribute_date_modified_q) {
5241                 return nautilus_file_get_date_as_string (file,
5242                                                          NAUTILUS_DATE_TYPE_MODIFIED);
5243         }
5244         if (attribute_q == attribute_date_changed_q) {
5245                 return nautilus_file_get_date_as_string (file,
5246                                                          NAUTILUS_DATE_TYPE_CHANGED);
5247         }
5248         if (attribute_q == attribute_date_accessed_q) {
5249                 return nautilus_file_get_date_as_string (file,
5250                                                          NAUTILUS_DATE_TYPE_ACCESSED);
5251         }
5252         if (attribute_q == attribute_date_permissions_q) {
5253                 return nautilus_file_get_date_as_string (file,
5254                                                          NAUTILUS_DATE_TYPE_PERMISSIONS_CHANGED);
5255         }
5256         if (attribute_q == attribute_permissions_q) {
5257                 return nautilus_file_get_permissions_as_string (file);
5258         }
5259         if (attribute_q == attribute_selinux_context_q) {
5260                 return nautilus_file_get_selinux_context (file);
5261         }
5262         if (attribute_q == attribute_octal_permissions_q) {
5263                 return nautilus_file_get_octal_permissions_as_string (file);
5264         }
5265         if (attribute_q == attribute_owner_q) {
5266                 return nautilus_file_get_owner_as_string (file, TRUE);
5267         }
5268         if (attribute_q == attribute_group_q) {
5269                 return nautilus_file_get_group_name (file);
5270         }
5271         if (attribute_q == attribute_uri_q) {
5272                 return nautilus_file_get_uri (file);
5273         }
5274         if (attribute_q == attribute_where_q) {
5275                 return nautilus_file_get_where_string (file);
5276         }
5277         if (attribute_q == attribute_link_target_q) {
5278                 return nautilus_file_get_symbolic_link_target_path (file);
5279         }
5280         if (attribute_q == attribute_volume_q) {
5281                 return nautilus_file_get_volume_name (file);
5282         }
5283         if (attribute_q == attribute_free_space_q) {
5284                 return nautilus_file_get_volume_free_space (file);
5285         }
5286
5287         extension_attribute = NULL;
5288
5289         if (file->details->pending_extension_attributes) {
5290                 extension_attribute = g_hash_table_lookup (file->details->pending_extension_attributes,
5291                                                            GINT_TO_POINTER (attribute_q));
5292         }
5293
5294         if (extension_attribute == NULL && file->details->extension_attributes) {
5295                 extension_attribute = g_hash_table_lookup (file->details->extension_attributes,
5296                                                            GINT_TO_POINTER (attribute_q));
5297         }
5298
5299         return g_strdup (extension_attribute);
5300 }
5301
5302 char *
5303 nautilus_file_get_string_attribute (NautilusFile *file, const char *attribute_name)
5304 {
5305         return nautilus_file_get_string_attribute_q (file, g_quark_from_string (attribute_name));
5306 }
5307
5308
5309 /**
5310  * nautilus_file_get_string_attribute_with_default:
5311  *
5312  * Get a user-displayable string from a named attribute. Use g_free to
5313  * free this string. If the value is unknown, returns a string representing
5314  * the unknown value, which varies with attribute. You can call
5315  * nautilus_file_get_string_attribute if you want NULL instead of a default
5316  * result.
5317  *
5318  * @file: NautilusFile representing the file in question.
5319  * @attribute_name: The name of the desired attribute. See the description of
5320  * nautilus_file_get_string for the set of available attributes.
5321  *
5322  * Returns: Newly allocated string ready to display to the user, or a string
5323  * such as "unknown" if the value is unknown or @attribute_name is not supported.
5324  *
5325  **/
5326 char *
5327 nautilus_file_get_string_attribute_with_default_q (NautilusFile *file, GQuark attribute_q)
5328 {
5329         char *result;
5330         guint item_count;
5331         gboolean count_unreadable;
5332         NautilusRequestStatus status;
5333
5334         result = nautilus_file_get_string_attribute_q (file, attribute_q);
5335         if (result != NULL) {
5336                 return result;
5337         }
5338
5339         /* Supply default values for the ones we know about. */
5340         /* FIXME bugzilla.gnome.org 40646:
5341          * Use hash table and switch statement or function pointers for speed?
5342          */
5343         if (attribute_q == attribute_size_q) {
5344                 if (!nautilus_file_should_show_directory_item_count (file)) {
5345                         return g_strdup ("--");
5346                 }
5347                 count_unreadable = FALSE;
5348                 if (nautilus_file_is_directory (file)) {
5349                         nautilus_file_get_directory_item_count (file, &item_count, &count_unreadable);
5350                 }
5351                 return g_strdup (count_unreadable ? _("? items") : "...");
5352         }
5353         if (attribute_q == attribute_deep_size_q) {
5354                 status = nautilus_file_get_deep_counts (file, NULL, NULL, NULL, NULL, FALSE);
5355                 if (status == NAUTILUS_REQUEST_DONE) {
5356                         /* This means no contents at all were readable */
5357                         return g_strdup (_("? bytes"));
5358                 }
5359                 return g_strdup ("...");
5360         }
5361         if (attribute_q == attribute_deep_file_count_q
5362             || attribute_q == attribute_deep_directory_count_q
5363             || attribute_q == attribute_deep_total_count_q) {
5364                 status = nautilus_file_get_deep_counts (file, NULL, NULL, NULL, NULL, FALSE);
5365                 if (status == NAUTILUS_REQUEST_DONE) {
5366                         /* This means no contents at all were readable */
5367                         return g_strdup (_("? items"));
5368                 }
5369                 return g_strdup ("...");
5370         }
5371         if (attribute_q == attribute_type_q) {
5372                 return g_strdup (_("unknown type"));
5373         }
5374         if (attribute_q == attribute_mime_type_q) {
5375                 return g_strdup (_("unknown MIME type"));
5376         }
5377
5378         /* Fallback, use for both unknown attributes and attributes
5379          * for which we have no more appropriate default.
5380          */
5381         return g_strdup (_("unknown"));
5382 }
5383
5384 char *
5385 nautilus_file_get_string_attribute_with_default (NautilusFile *file, const char *attribute_name)
5386 {
5387         return nautilus_file_get_string_attribute_with_default_q (file, g_quark_from_string (attribute_name));
5388 }
5389
5390 /**
5391  * get_description:
5392  *
5393  * Get a user-displayable string representing a file type. The caller
5394  * is responsible for g_free-ing this string.
5395  * @file: NautilusFile representing the file in question.
5396  *
5397  * Returns: Newly allocated string ready to display to the user.
5398  *
5399  **/
5400 static char *
5401 get_description (NautilusFile *file)
5402 {
5403         const char *mime_type;
5404         char *description;
5405
5406         g_assert (NAUTILUS_IS_FILE (file));
5407
5408         mime_type = eel_ref_str_peek (file->details->mime_type);
5409         if (eel_str_is_empty (mime_type)) {
5410                 return NULL;
5411         }
5412
5413         if (g_content_type_is_unknown (mime_type) &&
5414             nautilus_file_is_executable (file)) {
5415                 return g_strdup (_("program"));
5416         }
5417
5418         description = g_content_type_get_description (mime_type);
5419         if (!eel_str_is_empty (description)) {
5420                 return description;
5421         }
5422
5423         return g_strdup (mime_type);
5424 }
5425
5426 /* Takes ownership of string */
5427 static char *
5428 update_description_for_link (NautilusFile *file, char *string)
5429 {
5430         char *res;
5431
5432         if (nautilus_file_is_symbolic_link (file)) {
5433                 g_assert (!nautilus_file_is_broken_symbolic_link (file));
5434                 if (string == NULL) {
5435                         return g_strdup (_("link"));
5436                 }
5437                 /* Note to localizers: convert file type string for file
5438                  * (e.g. "folder", "plain text") to file type for symbolic link
5439                  * to that kind of file (e.g. "link to folder").
5440                  */
5441                 res = g_strdup_printf (_("Link to %s"), string);
5442                 g_free (string);
5443                 return res;
5444         }
5445
5446         return string;
5447 }
5448
5449 static char *
5450 nautilus_file_get_type_as_string (NautilusFile *file)
5451 {
5452         if (file == NULL) {
5453                 return NULL;
5454         }
5455
5456         if (nautilus_file_is_broken_symbolic_link (file)) {
5457                 return g_strdup (_("link (broken)"));
5458         }
5459
5460         return update_description_for_link (file, get_description (file));
5461 }
5462
5463 /**
5464  * nautilus_file_get_file_type
5465  *
5466  * Return this file's type.
5467  * @file: NautilusFile representing the file in question.
5468  *
5469  * Returns: The type.
5470  *
5471  **/
5472 GFileType
5473 nautilus_file_get_file_type (NautilusFile *file)
5474 {
5475         if (file == NULL) {
5476                 return G_FILE_TYPE_UNKNOWN;
5477         }
5478
5479         return file->details->type;
5480 }
5481
5482 /**
5483  * nautilus_file_get_mime_type
5484  *
5485  * Return this file's default mime type.
5486  * @file: NautilusFile representing the file in question.
5487  *
5488  * Returns: The mime type.
5489  *
5490  **/
5491 char *
5492 nautilus_file_get_mime_type (NautilusFile *file)
5493 {
5494         if (file != NULL) {
5495                 g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
5496                 if (file->details->mime_type != NULL) {
5497                         return g_strdup (eel_ref_str_peek (file->details->mime_type));
5498                 }
5499         }
5500         return g_strdup ("application/octet-stream");
5501 }
5502
5503 /**
5504  * nautilus_file_is_mime_type
5505  *
5506  * Check whether a file is of a particular MIME type, or inherited
5507  * from it.
5508  * @file: NautilusFile representing the file in question.
5509  * @mime_type: The MIME-type string to test (e.g. "text/plain")
5510  *
5511  * Return value: TRUE if @mime_type exactly matches the
5512  * file's MIME type.
5513  *
5514  **/
5515 gboolean
5516 nautilus_file_is_mime_type (NautilusFile *file, const char *mime_type)
5517 {
5518         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
5519         g_return_val_if_fail (mime_type != NULL, FALSE);
5520
5521         if (file->details->mime_type == NULL) {
5522                 return FALSE;
5523         }
5524         return g_content_type_is_a (eel_ref_str_peek (file->details->mime_type),
5525                                     mime_type);
5526 }
5527
5528 gboolean
5529 nautilus_file_is_launchable (NautilusFile *file)
5530 {
5531         gboolean type_can_be_executable;
5532
5533         type_can_be_executable = FALSE;
5534         if (file->details->mime_type != NULL) {
5535                 type_can_be_executable =
5536                         g_content_type_can_be_executable (eel_ref_str_peek (file->details->mime_type));
5537         }
5538
5539         return type_can_be_executable &&
5540                 nautilus_file_can_get_permissions (file) &&
5541                 nautilus_file_can_execute (file) &&
5542                 nautilus_file_is_executable (file) &&
5543                 !nautilus_file_is_directory (file);
5544 }
5545
5546
5547 /**
5548  * nautilus_file_get_emblem_icons
5549  *
5550  * Return the list of names of emblems that this file should display,
5551  * in canonical order.
5552  * @file: NautilusFile representing the file in question.
5553  *
5554  * Returns: A list of emblem names.
5555  *
5556  **/
5557 GList *
5558 nautilus_file_get_emblem_icons (NautilusFile *file,
5559                                 char **exclude)
5560 {
5561         GList *keywords, *l;
5562         GList *icons;
5563         char *icon_name;
5564         char *keyword;
5565         int i;
5566         GIcon *icon;
5567
5568         if (file == NULL) {
5569                 return NULL;
5570         }
5571
5572         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
5573
5574         keywords = nautilus_file_get_keywords (file);
5575         keywords = prepend_automatic_keywords (file, keywords);
5576
5577         icons = NULL;
5578         for (l = keywords; l != NULL; l = l->next) {
5579                 keyword = l->data;
5580
5581 #ifdef TRASH_IS_FAST_ENOUGH
5582                 if (strcmp (keyword, NAUTILUS_FILE_EMBLEM_NAME_TRASH) == 0) {
5583                         char *uri;
5584                         gboolean file_is_trash;
5585                         /* Leave out the trash emblem for the trash itself, since
5586                          * putting a trash emblem on a trash icon is gilding the
5587                          * lily.
5588                          */
5589                         uri = nautilus_file_get_uri (file);
5590                         file_is_trash = strcmp (uri, EEL_TRASH_URI) == 0;
5591                         g_free (uri);
5592                         if (file_is_trash) {
5593                                 continue;
5594                         }
5595                 }
5596 #endif
5597                 if (exclude) {
5598                         for (i = 0; exclude[i] != NULL; i++) {
5599                                 if (strcmp (exclude[i], keyword) == 0) {
5600                                         continue;
5601                                 }
5602                         }
5603                 }
5604
5605                 icon_name = nautilus_icon_get_emblem_icon_by_name (keyword);
5606                 icon = g_themed_icon_new (icon_name);
5607                 g_free (icon_name);
5608                 icons = g_list_prepend (icons, icon);
5609         }
5610
5611         eel_g_list_free_deep (keywords);
5612
5613         return icons;
5614 }
5615
5616 GList *
5617 nautilus_file_get_emblem_pixbufs (NautilusFile *file,
5618                                   int size,
5619                                   gboolean force_size,
5620                                   char **exclude)
5621 {
5622         GList *icons, *l;
5623         GList *pixbufs;
5624         GIcon *icon;
5625         GdkPixbuf *pixbuf;
5626         NautilusIconInfo *icon_info;
5627
5628         icons = nautilus_file_get_emblem_icons (file, exclude);
5629         pixbufs = NULL;
5630
5631         for (l = icons; l != NULL; l = l->next) {
5632                 icon = l->data;
5633
5634                 icon_info = nautilus_icon_info_lookup (icon, size);
5635                 if (force_size) {
5636                         pixbuf = nautilus_icon_info_get_pixbuf_nodefault_at_size (icon_info, size);
5637                 } else {
5638                         pixbuf = nautilus_icon_info_get_pixbuf_nodefault (icon_info);
5639                 }
5640
5641                 if (pixbuf) {
5642                         pixbufs = g_list_prepend (pixbufs, pixbuf);
5643                 }
5644
5645
5646                 g_object_unref (icon_info);
5647                 g_object_unref (icon);
5648         }
5649         g_list_free (icons);
5650
5651         return g_list_reverse (pixbufs);
5652
5653
5654 }
5655
5656 static GList *
5657 sort_keyword_list_and_remove_duplicates (GList *keywords)
5658 {
5659         GList *p;
5660         GList *duplicate_link;
5661
5662         if (keywords != NULL) {
5663                 keywords = eel_g_str_list_alphabetize (keywords);
5664
5665                 p = keywords;
5666                 while (p->next != NULL) {
5667                         if (strcmp ((const char *) p->data, (const char *) p->next->data) == 0) {
5668                                 duplicate_link = p->next;
5669                                 keywords = g_list_remove_link (keywords, duplicate_link);
5670                                 eel_g_list_free_deep (duplicate_link);
5671                         } else {
5672                                 p = p->next;
5673                         }
5674                 }
5675         }
5676
5677         return keywords;
5678 }
5679
5680 /**
5681  * nautilus_file_get_keywords
5682  *
5683  * Return this file's keywords.
5684  * @file: NautilusFile representing the file in question.
5685  *
5686  * Returns: A list of keywords.
5687  *
5688  **/
5689 GList *
5690 nautilus_file_get_keywords (NautilusFile *file)
5691 {
5692         GList *keywords;
5693
5694         if (file == NULL) {
5695                 return NULL;
5696         }
5697
5698         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
5699
5700         /* Put all the keywords into a list. */
5701         keywords = nautilus_file_get_metadata_list
5702                 (file, "keyword", "name");
5703
5704         keywords = g_list_concat (keywords, eel_g_str_list_copy (file->details->extension_emblems));
5705         keywords = g_list_concat (keywords, eel_g_str_list_copy (file->details->pending_extension_emblems));
5706
5707         return sort_keyword_list_and_remove_duplicates (keywords);
5708 }
5709
5710 /**
5711  * nautilus_file_set_keywords
5712  *
5713  * Change this file's keywords.
5714  * @file: NautilusFile representing the file in question.
5715  * @keywords: New set of keywords (a GList of strings).
5716  *
5717  **/
5718 void
5719 nautilus_file_set_keywords (NautilusFile *file, GList *keywords)
5720 {
5721         GList *canonical_keywords;
5722
5723         /* Invalidate the emblem compare cache */
5724         g_free (file->details->compare_by_emblem_cache);
5725         file->details->compare_by_emblem_cache = NULL;
5726
5727         g_return_if_fail (NAUTILUS_IS_FILE (file));
5728
5729         canonical_keywords = sort_keyword_list_and_remove_duplicates
5730                 (g_list_copy (keywords));
5731         nautilus_file_set_metadata_list
5732                 (file, "keyword", "name", canonical_keywords);
5733         g_list_free (canonical_keywords);
5734 }
5735
5736 /**
5737  * nautilus_file_is_symbolic_link
5738  *
5739  * Check if this file is a symbolic link.
5740  * @file: NautilusFile representing the file in question.
5741  *
5742  * Returns: True if the file is a symbolic link.
5743  *
5744  **/
5745 gboolean
5746 nautilus_file_is_symbolic_link (NautilusFile *file)
5747 {
5748         return file->details->is_symlink;
5749 }
5750
5751 gboolean
5752 nautilus_file_is_mountpoint (NautilusFile *file)
5753 {
5754         return file->details->is_mountpoint;
5755 }
5756
5757 GMount *
5758 nautilus_file_get_mount (NautilusFile *file)
5759 {
5760         if (file->details->mount) {
5761                 return g_object_ref (file->details->mount);
5762         }
5763         return NULL;
5764 }
5765
5766 /**
5767  * nautilus_file_is_broken_symbolic_link
5768  *
5769  * Check if this file is a symbolic link with a missing target.
5770  * @file: NautilusFile representing the file in question.
5771  *
5772  * Returns: True if the file is a symbolic link with a missing target.
5773  *
5774  **/
5775 gboolean
5776 nautilus_file_is_broken_symbolic_link (NautilusFile *file)
5777 {
5778         if (file == NULL) {
5779                 return FALSE;
5780         }
5781
5782         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
5783
5784         /* Non-broken symbolic links return the target's type for get_file_type. */
5785         return nautilus_file_get_file_type (file) == G_FILE_TYPE_SYMBOLIC_LINK;
5786 }
5787
5788 /**
5789  * nautilus_file_get_volume_free_space
5790  * Get a nicely formatted char with free space on the file's volume
5791  * @file: NautilusFile representing the file in question.
5792  *
5793  * Returns: newly-allocated copy of file size in a formatted string
5794  */
5795 char *
5796 nautilus_file_get_volume_free_space (NautilusFile *file)
5797 {
5798         goffset free_space;
5799         GFileInfo *info;
5800         GFile *location;
5801         char *res;
5802
5803         res = NULL;
5804
5805         location = nautilus_file_get_location (file);
5806         info = g_file_query_filesystem_info (location, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, NULL, NULL);
5807         if (info) {
5808                 if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE)) {
5809                         free_space = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
5810                         res = g_format_size_for_display (free_space);
5811                 }
5812                 g_object_unref (info);
5813         }
5814         g_object_unref (location);
5815
5816         return res;
5817 }
5818
5819 /**
5820  * nautilus_file_get_volume_name
5821  * Get the path of the volume the file resides on
5822  * @file: NautilusFile representing the file in question.
5823  *
5824  * Returns: newly-allocated copy of the volume name of the target file,
5825  * if the volume name isn't set, it returns the mount path of the volume
5826  */
5827 char *
5828 nautilus_file_get_volume_name (NautilusFile *file)
5829 {
5830         GFile *location;
5831         char *res;
5832         GMount *mount;
5833
5834         res = NULL;
5835
5836         location = nautilus_file_get_location (file);
5837         mount = g_file_find_enclosing_mount (location, NULL, NULL);
5838         if (mount) {
5839                 res = g_strdup (g_mount_get_name (mount));
5840                 g_object_unref (mount);
5841         }
5842         g_object_unref (location);
5843
5844         return res;
5845 }
5846
5847 /**
5848  * nautilus_file_get_symbolic_link_target_path
5849  *
5850  * Get the file path of the target of a symbolic link. It is an error
5851  * to call this function on a file that isn't a symbolic link.
5852  * @file: NautilusFile representing the symbolic link in question.
5853  *
5854  * Returns: newly-allocated copy of the file path of the target of the symbolic link.
5855  */
5856 char *
5857 nautilus_file_get_symbolic_link_target_path (NautilusFile *file)
5858 {
5859         g_return_val_if_fail (nautilus_file_is_symbolic_link (file), NULL);
5860
5861         return g_strdup (file->details->symlink_name);
5862 }
5863
5864 /**
5865  * nautilus_file_get_symbolic_link_target_uri
5866  *
5867  * Get the uri of the target of a symbolic link. It is an error
5868  * to call this function on a file that isn't a symbolic link.
5869  * @file: NautilusFile representing the symbolic link in question.
5870  *
5871  * Returns: newly-allocated copy of the uri of the target of the symbolic link.
5872  */
5873 char *
5874 nautilus_file_get_symbolic_link_target_uri (NautilusFile *file)
5875 {
5876         GFile *location, *parent, *target;
5877         char *target_uri;
5878
5879         g_return_val_if_fail (nautilus_file_is_symbolic_link (file), NULL);
5880
5881         if (file->details->symlink_name == NULL) {
5882                 return NULL;
5883         } else {
5884                 target = NULL;
5885
5886                 location = nautilus_file_get_location (file);
5887                 parent = g_file_get_parent (location);
5888                 g_object_unref (location);
5889                 if (parent) {
5890                         target = g_file_resolve_relative_path (parent, file->details->symlink_name);
5891                         g_object_unref (parent);
5892                 }
5893
5894                 target_uri = NULL;
5895                 if (target) {
5896                         target_uri = g_file_get_uri (target);
5897                         g_object_unref (target);
5898                 }
5899                 return target_uri;
5900         }
5901 }
5902
5903 /**
5904  * nautilus_file_is_nautilus_link
5905  *
5906  * Check if this file is a "nautilus link", meaning a historical
5907  * nautilus xml link file or a desktop file.
5908  * @file: NautilusFile representing the file in question.
5909  *
5910  * Returns: True if the file is a nautilus link.
5911  *
5912  **/
5913 gboolean
5914 nautilus_file_is_nautilus_link (NautilusFile *file)
5915 {
5916         /* NOTE: I removed the historical link here, because i don't think we
5917            even detect that mimetype anymore */
5918         return nautilus_file_is_mime_type (file, "application/x-desktop");
5919 }
5920
5921 /**
5922  * nautilus_file_is_directory
5923  *
5924  * Check if this file is a directory.
5925  * @file: NautilusFile representing the file in question.
5926  *
5927  * Returns: TRUE if @file is a directory.
5928  *
5929  **/
5930 gboolean
5931 nautilus_file_is_directory (NautilusFile *file)
5932 {
5933         return nautilus_file_get_file_type (file) == G_FILE_TYPE_DIRECTORY;
5934 }
5935
5936 /**
5937  * nautilus_file_is_in_trash
5938  *
5939  * Check if this file is a file in trash.
5940  * @file: NautilusFile representing the file in question.
5941  *
5942  * Returns: TRUE if @file is in a trash.
5943  *
5944  **/
5945 gboolean
5946 nautilus_file_is_in_trash (NautilusFile *file)
5947 {
5948         g_assert (NAUTILUS_IS_FILE (file));
5949
5950         return nautilus_directory_is_in_trash (file->details->directory);
5951 }
5952
5953 GError *
5954 nautilus_file_get_file_info_error (NautilusFile *file)
5955 {
5956         if (!file->details->get_info_failed) {
5957                 return NULL;
5958         }
5959
5960         return file->details->get_info_error;
5961 }
5962
5963 /**
5964  * nautilus_file_contains_text
5965  *
5966  * Check if this file contains text.
5967  * This is private and is used to decide whether or not to read the top left text.
5968  * @file: NautilusFile representing the file in question.
5969  *
5970  * Returns: TRUE if @file has a text MIME type.
5971  *
5972  **/
5973 gboolean
5974 nautilus_file_contains_text (NautilusFile *file)
5975 {
5976         if (file == NULL) {
5977                 return FALSE;
5978         }
5979
5980         /* All text files inherit from text/plain */
5981         return nautilus_file_is_mime_type (file, "text/plain");
5982 }
5983
5984 /**
5985  * nautilus_file_is_executable
5986  *
5987  * Check if this file is executable at all.
5988  * @file: NautilusFile representing the file in question.
5989  *
5990  * Returns: TRUE if any of the execute bits are set. FALSE if
5991  * not, or if the permissions are unknown.
5992  *
5993  **/
5994 gboolean
5995 nautilus_file_is_executable (NautilusFile *file)
5996 {
5997         if (!file->details->has_permissions) {
5998                 /* File's permissions field is not valid.
5999                  * Can't access specific permissions, so return FALSE.
6000                  */
6001                 return FALSE;
6002         }
6003
6004         return file->details->can_execute;
6005 }
6006
6007 /**
6008  * nautilus_file_peek_top_left_text
6009  *
6010  * Peek at the text from the top left of the file.
6011  * @file: NautilusFile representing the file in question.
6012  *
6013  * Returns: NULL if there is no text readable, otherwise, the text.
6014  *          This string is owned by the file object and should not
6015  *          be kept around or freed.
6016  *
6017  **/
6018 char *
6019 nautilus_file_peek_top_left_text (NautilusFile *file,
6020                                   gboolean  need_large_text,
6021                                   gboolean *needs_loading)
6022 {
6023         g_return_val_if_fail (NAUTILUS_IS_FILE (file), NULL);
6024
6025         if (!nautilus_file_should_get_top_left_text (file)) {
6026                 if (needs_loading) {
6027                         *needs_loading = FALSE;
6028                 }
6029                 return NULL;
6030         }
6031
6032         if (needs_loading) {
6033                 *needs_loading = !file->details->top_left_text_is_up_to_date;
6034                 if (need_large_text) {
6035                         *needs_loading |= file->details->got_top_left_text != file->details->got_large_top_left_text;
6036                 }
6037         }
6038
6039         /* Show " ..." in the file until we read the contents in. */
6040         if (!file->details->got_top_left_text) {
6041
6042                 if (nautilus_file_contains_text (file)) {
6043                         return " ...";
6044                 }
6045                 return NULL;
6046         }
6047
6048         /* Show what we read in. */
6049         return file->details->top_left_text;
6050 }
6051
6052 /**
6053  * nautilus_file_get_top_left_text
6054  *
6055  * Get the text from the top left of the file.
6056  * @file: NautilusFile representing the file in question.
6057  *
6058  * Returns: NULL if there is no text readable, otherwise, the text.
6059  *
6060  **/
6061 char *
6062 nautilus_file_get_top_left_text (NautilusFile *file)
6063 {
6064         return g_strdup (nautilus_file_peek_top_left_text (file, FALSE, NULL));
6065 }
6066
6067
6068 void
6069 nautilus_file_mark_gone (NautilusFile *file)
6070 {
6071         NautilusDirectory *directory;
6072
6073         if (file->details->is_gone)
6074                 return;
6075
6076         file->details->is_gone = TRUE;
6077
6078         update_links_if_target (file);
6079
6080         /* Drop it from the symlink hash ! */
6081         remove_from_link_hash_table (file);
6082
6083         /* Let the directory know it's gone. */
6084         directory = file->details->directory;
6085         if (!nautilus_file_is_self_owned (file)) {
6086                 nautilus_directory_remove_file (directory, file);
6087         }
6088
6089         nautilus_file_clear_info (file);
6090
6091         /* FIXME bugzilla.gnome.org 42429:
6092          * Maybe we can get rid of the name too eventually, but
6093          * for now that would probably require too many if statements
6094          * everywhere anyone deals with the name. Maybe we can give it
6095          * a hard-coded "<deleted>" name or something.
6096          */
6097 }
6098
6099 /**
6100  * nautilus_file_changed
6101  *
6102  * Notify the user that this file has changed.
6103  * @file: NautilusFile representing the file in question.
6104  **/
6105 void
6106 nautilus_file_changed (NautilusFile *file)
6107 {
6108         GList fake_list;
6109
6110         g_return_if_fail (NAUTILUS_IS_FILE (file));
6111
6112         if (nautilus_file_is_self_owned (file)) {
6113                 nautilus_file_emit_changed (file);
6114         } else {
6115                 fake_list.data = file;
6116                 fake_list.next = NULL;
6117                 fake_list.prev = NULL;
6118                 nautilus_directory_emit_change_signals
6119                         (file->details->directory, &fake_list);
6120         }
6121 }
6122
6123 /**
6124  * nautilus_file_updated_deep_count_in_progress
6125  *
6126  * Notify clients that a newer deep count is available for
6127  * the directory in question.
6128  */
6129 void
6130 nautilus_file_updated_deep_count_in_progress (NautilusFile *file) {
6131         GList *link_files, *node;
6132
6133         g_assert (NAUTILUS_IS_FILE (file));
6134         g_assert (nautilus_file_is_directory (file));
6135
6136         /* Send out a signal. */
6137         g_signal_emit (file, signals[UPDATED_DEEP_COUNT_IN_PROGRESS], 0, file);
6138
6139         /* Tell link files pointing to this object about the change. */
6140         link_files = get_link_files (file);
6141         for (node = link_files; node != NULL; node = node->next) {
6142                 nautilus_file_updated_deep_count_in_progress (NAUTILUS_FILE (node->data));
6143         }
6144         nautilus_file_list_free (link_files);
6145 }
6146
6147 /**
6148  * nautilus_file_emit_changed
6149  *
6150  * Emit a file changed signal.
6151  * This can only be called by the directory, since the directory
6152  * also has to emit a files_changed signal.
6153  *
6154  * @file: NautilusFile representing the file in question.
6155  **/
6156 void
6157 nautilus_file_emit_changed (NautilusFile *file)
6158 {
6159         GList *link_files, *p;
6160
6161         g_assert (NAUTILUS_IS_FILE (file));
6162
6163
6164         /* Invalidate the emblem compare cache. -- This is not the cleanest
6165          * place to do it but it is the one guaranteed bottleneck through
6166          * which all change notifications pass.
6167          */
6168         g_free (file->details->compare_by_emblem_cache);
6169         file->details->compare_by_emblem_cache = NULL;
6170
6171         /* Send out a signal. */
6172         g_signal_emit (file, signals[CHANGED], 0, file);
6173
6174         /* Tell link files pointing to this object about the change. */
6175         link_files = get_link_files (file);
6176         for (p = link_files; p != NULL; p = p->next) {
6177                 if (p->data != file) {
6178                         nautilus_file_changed (NAUTILUS_FILE (p->data));
6179                 }
6180         }
6181         nautilus_file_list_free (link_files);
6182 }
6183
6184 /**
6185  * nautilus_file_is_gone
6186  *
6187  * Check if a file has already been deleted.
6188  * @file: NautilusFile representing the file in question.
6189  *
6190  * Returns: TRUE if the file is already gone.
6191  **/
6192 gboolean
6193 nautilus_file_is_gone (NautilusFile *file)
6194 {
6195         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
6196
6197         return file->details->is_gone;
6198 }
6199
6200 /**
6201  * nautilus_file_is_not_yet_confirmed
6202  *
6203  * Check if we're in a state where we don't know if a file really
6204  * exists or not, before the initial I/O is complete.
6205  * @file: NautilusFile representing the file in question.
6206  *
6207  * Returns: TRUE if the file is already gone.
6208  **/
6209 gboolean
6210 nautilus_file_is_not_yet_confirmed (NautilusFile *file)
6211 {
6212         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
6213
6214         return !file->details->got_file_info;
6215 }
6216
6217 /**
6218  * nautilus_file_check_if_ready
6219  *
6220  * Check whether the values for a set of file attributes are
6221  * currently available, without doing any additional work. This
6222  * is useful for callers that want to reflect updated information
6223  * when it is ready but don't want to force the work required to
6224  * obtain the information, which might be slow network calls, e.g.
6225  *
6226  * @file: The file being queried.
6227  * @file_attributes: A bit-mask with the desired information.
6228  *
6229  * Return value: TRUE if all of the specified attributes are currently readable.
6230  */
6231 gboolean
6232 nautilus_file_check_if_ready (NautilusFile *file,
6233                               NautilusFileAttributes file_attributes)
6234 {
6235         /* To be parallel with call_when_ready, return
6236          * TRUE for NULL file.
6237          */
6238         if (file == NULL) {
6239                 return TRUE;
6240         }
6241
6242         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
6243
6244         return EEL_CALL_METHOD_WITH_RETURN_VALUE
6245                 (NAUTILUS_FILE_CLASS, file,
6246                  check_if_ready, (file, file_attributes));
6247 }
6248
6249 void
6250 nautilus_file_call_when_ready (NautilusFile *file,
6251                                NautilusFileAttributes file_attributes,
6252                                NautilusFileCallback callback,
6253                                gpointer callback_data)
6254
6255 {
6256         if (file == NULL) {
6257                 (* callback) (file, callback_data);
6258                 return;
6259         }
6260
6261         g_return_if_fail (NAUTILUS_IS_FILE (file));
6262
6263         EEL_CALL_METHOD
6264                 (NAUTILUS_FILE_CLASS, file,
6265                  call_when_ready, (file, file_attributes,
6266                                    callback, callback_data));
6267 }
6268
6269 void
6270 nautilus_file_cancel_call_when_ready (NautilusFile *file,
6271                                       NautilusFileCallback callback,
6272                                       gpointer callback_data)
6273 {
6274         g_return_if_fail (callback != NULL);
6275
6276         if (file == NULL) {
6277                 return;
6278         }
6279
6280         g_return_if_fail (NAUTILUS_IS_FILE (file));
6281
6282         EEL_CALL_METHOD
6283                 (NAUTILUS_FILE_CLASS, file,
6284                  cancel_call_when_ready, (file, callback, callback_data));
6285 }
6286
6287 static void
6288 invalidate_directory_count (NautilusFile *file)
6289 {
6290         file->details->directory_count_is_up_to_date = FALSE;
6291 }
6292
6293 static void
6294 invalidate_deep_counts (NautilusFile *file)
6295 {
6296         file->details->deep_counts_status = NAUTILUS_REQUEST_NOT_STARTED;
6297 }
6298
6299 static void
6300 invalidate_mime_list (NautilusFile *file)
6301 {
6302         file->details->mime_list_is_up_to_date = FALSE;
6303 }
6304
6305 static void
6306 invalidate_top_left_text (NautilusFile *file)
6307 {
6308         file->details->top_left_text_is_up_to_date = FALSE;
6309 }
6310
6311 static void
6312 invalidate_file_info (NautilusFile *file)
6313 {
6314         file->details->file_info_is_up_to_date = FALSE;
6315 }
6316
6317 static void
6318 invalidate_link_info (NautilusFile *file)
6319 {
6320         file->details->link_info_is_up_to_date = FALSE;
6321 }
6322
6323 static void
6324 invalidate_thumbnail (NautilusFile *file)
6325 {
6326         file->details->thumbnail_is_up_to_date = FALSE;
6327 }
6328
6329 void
6330 nautilus_file_invalidate_extension_info_internal (NautilusFile *file)
6331 {
6332         file->details->pending_info_providers =
6333                 nautilus_module_get_extensions_for_type (NAUTILUS_TYPE_INFO_PROVIDER);
6334 }
6335
6336 void
6337 nautilus_file_invalidate_attributes_internal (NautilusFile *file,
6338                                               NautilusFileAttributes file_attributes)
6339 {
6340         Request request;
6341
6342         if (file == NULL) {
6343                 return;
6344         }
6345
6346         if (NAUTILUS_IS_DESKTOP_ICON_FILE (file)) {
6347                 /* Desktop icon files are always up to date.
6348                  * If we invalidate their attributes they
6349                  * will lose data, so we just ignore them.
6350                  */
6351                 return;
6352         }
6353
6354         nautilus_directory_set_up_request (&request, file_attributes);
6355
6356         if (request.directory_count) {
6357                 invalidate_directory_count (file);
6358         }
6359         if (request.deep_count) {
6360                 invalidate_deep_counts (file);
6361         }
6362         if (request.mime_list) {
6363                 invalidate_mime_list (file);
6364         }
6365         if (request.file_info) {
6366                 invalidate_file_info (file);
6367         }
6368         if (request.top_left_text) {
6369                 invalidate_top_left_text (file);
6370         }
6371         if (request.link_info) {
6372                 invalidate_link_info (file);
6373         }
6374         if (request.extension_info) {
6375                 nautilus_file_invalidate_extension_info_internal (file);
6376         }
6377         if (request.thumbnail) {
6378                 invalidate_thumbnail (file);
6379         }
6380
6381         /* FIXME bugzilla.gnome.org 45075: implement invalidating metadata */
6382 }
6383
6384 gboolean
6385 nautilus_file_has_open_window (NautilusFile *file)
6386 {
6387         return file->details->has_open_window;
6388 }
6389
6390 void
6391 nautilus_file_set_has_open_window (NautilusFile *file,
6392                                    gboolean has_open_window)
6393 {
6394         has_open_window = (has_open_window != FALSE);
6395
6396         if (file->details->has_open_window != has_open_window) {
6397                 file->details->has_open_window = has_open_window;
6398                 nautilus_file_changed (file);
6399         }
6400 }
6401
6402
6403 gboolean
6404 nautilus_file_is_thumbnailing (NautilusFile *file)
6405 {
6406         g_return_val_if_fail (NAUTILUS_IS_FILE (file), FALSE);
6407
6408         return file->details->is_thumbnailing;
6409 }
6410
6411 void
6412 nautilus_file_set_is_thumbnailing (NautilusFile *file,
6413                                    gboolean is_thumbnailing)
6414 {
6415         g_return_if_fail (NAUTILUS_IS_FILE (file));
6416
6417         file->details->is_thumbnailing = is_thumbnailing;
6418 }
6419
6420
6421 /**
6422  * nautilus_file_invalidate_attributes
6423  *
6424  * Invalidate the specified attributes and force a reload.
6425  * @file: NautilusFile representing the file in question.
6426  * @file_attributes: attributes to froget.
6427  **/
6428
6429 void
6430 nautilus_file_invalidate_attributes (NautilusFile *file,
6431                                      NautilusFileAttributes file_attributes)
6432 {
6433         /* Cancel possible in-progress loads of any of these attributes */
6434         nautilus_directory_cancel_loading_file_attributes (file->details->directory,
6435                                                            file,
6436                                                            file_attributes);
6437
6438         /* Actually invalidate the values */
6439         nautilus_file_invalidate_attributes_internal (file, file_attributes);
6440
6441         nautilus_directory_add_file_to_work_queue (file->details->directory, file);
6442
6443         /* Kick off I/O if necessary */
6444         nautilus_directory_async_state_changed (file->details->directory);
6445 }
6446
6447 NautilusFileAttributes
6448 nautilus_file_get_all_attributes (void)
6449 {
6450         return  NAUTILUS_FILE_ATTRIBUTE_INFO |
6451                 NAUTILUS_FILE_ATTRIBUTE_LINK_INFO |
6452                 NAUTILUS_FILE_ATTRIBUTE_DEEP_COUNTS |
6453                 NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT |
6454                 NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_MIME_TYPES |
6455                 NAUTILUS_FILE_ATTRIBUTE_METADATA |
6456                 NAUTILUS_FILE_ATTRIBUTE_TOP_LEFT_TEXT |
6457                 NAUTILUS_FILE_ATTRIBUTE_LARGE_TOP_LEFT_TEXT |
6458                 NAUTILUS_FILE_ATTRIBUTE_EXTENSION_INFO |
6459                 NAUTILUS_FILE_ATTRIBUTE_THUMBNAIL |
6460                 NAUTILUS_FILE_ATTRIBUTE_MOUNT;
6461 }
6462
6463 void
6464 nautilus_file_invalidate_all_attributes (NautilusFile *file)
6465 {
6466         NautilusFileAttributes all_attributes;
6467
6468         all_attributes = nautilus_file_get_all_attributes ();
6469         nautilus_file_invalidate_attributes (file, all_attributes);
6470 }
6471
6472
6473 /**
6474  * nautilus_file_dump
6475  *
6476  * Debugging call, prints out the contents of the file
6477  * fields.
6478  *
6479  * @file: file to dump.
6480  **/
6481 void
6482 nautilus_file_dump (NautilusFile *file)
6483 {
6484         long size = file->details->deep_size;
6485         char *uri;
6486         const char *file_kind;
6487
6488         uri = nautilus_file_get_uri (file);
6489         g_print ("uri: %s \n", uri);
6490         if (!file->details->got_file_info) {
6491                 g_print ("no file info \n");
6492         } else if (file->details->get_info_failed) {
6493                 g_print ("failed to get file info \n");
6494         } else {
6495                 g_print ("size: %ld \n", size);
6496                 switch (file->details->type) {
6497                 case G_FILE_TYPE_REGULAR:
6498                         file_kind = "regular file";
6499                         break;
6500                 case G_FILE_TYPE_DIRECTORY:
6501                         file_kind = "folder";
6502                         break;
6503                 case G_FILE_TYPE_SPECIAL:
6504                         file_kind = "special";
6505                         break;
6506                 case G_FILE_TYPE_SYMBOLIC_LINK:
6507                         file_kind = "symbolic link";
6508                         break;
6509                 case G_FILE_TYPE_UNKNOWN:
6510                 default:
6511                         file_kind = "unknown";
6512                         break;
6513                 }
6514                 g_print ("kind: %s \n", file_kind);
6515                 if (file->details->type == G_FILE_TYPE_SYMBOLIC_LINK) {
6516                         g_print ("link to %s \n", file->details->symlink_name);
6517                         /* FIXME bugzilla.gnome.org 42430: add following of symlinks here */
6518                 }
6519                 /* FIXME bugzilla.gnome.org 42431: add permissions and other useful stuff here */
6520         }
6521         g_free (uri);
6522 }
6523
6524 /**
6525  * nautilus_file_list_ref
6526  *
6527  * Ref all the files in a list.
6528  * @list: GList of files.
6529  **/
6530 GList *
6531 nautilus_file_list_ref (GList *list)
6532 {
6533         g_list_foreach (list, (GFunc) nautilus_file_ref, NULL);
6534         return list;
6535 }
6536
6537 /**
6538  * nautilus_file_list_unref
6539  *
6540  * Unref all the files in a list.
6541  * @list: GList of files.
6542  **/
6543 void
6544 nautilus_file_list_unref (GList *list)
6545 {
6546         g_list_foreach (list, (GFunc) nautilus_file_unref, NULL);
6547 }
6548
6549 /**
6550  * nautilus_file_list_free
6551  *
6552  * Free a list of files after unrefing them.
6553  * @list: GList of files.
6554  **/
6555 void
6556 nautilus_file_list_free (GList *list)
6557 {
6558         nautilus_file_list_unref (list);
6559         g_list_free (list);
6560 }
6561
6562 /**
6563  * nautilus_file_list_copy
6564  *
6565  * Copy the list of files, making a new ref of each,
6566  * @list: GList of files.
6567  **/
6568 GList *
6569 nautilus_file_list_copy (GList *list)
6570 {
6571         return g_list_copy (nautilus_file_list_ref (list));
6572 }
6573
6574 static int
6575 compare_by_display_name_cover (gconstpointer a, gconstpointer b)
6576 {
6577         return compare_by_display_name (NAUTILUS_FILE (a), NAUTILUS_FILE (b));
6578 }
6579
6580 /**
6581  * nautilus_file_list_sort_by_display_name
6582  *
6583  * Sort the list of files by file name.
6584  * @list: GList of files.
6585  **/
6586 GList *
6587 nautilus_file_list_sort_by_display_name (GList *list)
6588 {
6589         return g_list_sort (list, compare_by_display_name_cover);
6590 }
6591
6592 static GList *ready_data_list = NULL;
6593
6594 typedef struct
6595 {
6596         GList *file_list;
6597         GList *remaining_files;
6598         NautilusFileListCallback callback;
6599         gpointer callback_data;
6600 } FileListReadyData;
6601
6602 static void
6603 file_list_ready_data_free (FileListReadyData *data)
6604 {
6605         GList *l;
6606
6607         l = g_list_find (ready_data_list, data);
6608         if (l != NULL) {
6609                 ready_data_list = g_list_delete_link (ready_data_list, l);
6610
6611                 nautilus_file_list_free (data->file_list);
6612                 g_list_free (data->remaining_files);
6613                 g_free (data);
6614         }
6615 }
6616
6617 static FileListReadyData *
6618 file_list_ready_data_new (GList *file_list,
6619                           NautilusFileListCallback callback,
6620                           gpointer callback_data)
6621 {
6622         FileListReadyData *data;
6623
6624         data = g_new0 (FileListReadyData, 1);
6625         data->file_list = nautilus_file_list_copy (file_list);
6626         data->remaining_files = g_list_copy (file_list);
6627         data->callback = callback;
6628         data->callback_data = callback_data;
6629
6630         ready_data_list = g_list_prepend (ready_data_list, data);
6631
6632         return data;
6633 }
6634
6635 static void
6636 file_list_file_ready_callback (NautilusFile *file,
6637                                gpointer user_data)
6638 {
6639         FileListReadyData *data;
6640
6641         data = user_data;
6642         data->remaining_files = g_list_remove (data->remaining_files, file);
6643
6644         if (data->remaining_files == NULL) {
6645                 if (data->callback) {
6646                         (*data->callback) (data->file_list, data->callback_data);
6647                 }
6648
6649                 file_list_ready_data_free (data);
6650         }
6651 }
6652
6653 void
6654 nautilus_file_list_call_when_ready (GList *file_list,
6655                                     NautilusFileAttributes attributes,
6656                                     NautilusFileListHandle **handle,
6657                                     NautilusFileListCallback callback,
6658                                     gpointer callback_data)
6659 {
6660         GList *l;
6661         FileListReadyData *data;
6662         NautilusFile *file;
6663
6664         g_return_if_fail (file_list != NULL);
6665
6666         data = file_list_ready_data_new
6667                 (file_list, callback, callback_data);
6668
6669         if (handle) {
6670                 *handle = (NautilusFileListHandle *) data;
6671         }
6672
6673
6674         l = file_list;
6675         while (l != NULL) {
6676                 file = NAUTILUS_FILE (l->data);
6677                 /* Need to do this here, as the list can be modified by this call */
6678                 l = l->next;
6679                 nautilus_file_call_when_ready (file,
6680                                                attributes,
6681                                                file_list_file_ready_callback,
6682                                                data);
6683         }
6684 }
6685
6686 void
6687 nautilus_file_list_cancel_call_when_ready (NautilusFileListHandle *handle)
6688 {
6689         GList *l;
6690         NautilusFile *file;
6691         FileListReadyData *data;
6692
6693         g_return_if_fail (handle != NULL);
6694
6695         data = (FileListReadyData *) handle;
6696
6697         l = g_list_find (ready_data_list, data);
6698         if (l != NULL) {
6699                 for (l = data->remaining_files; l != NULL; l = l->next) {
6700                         file = NAUTILUS_FILE (l->data);
6701
6702                         EEL_CALL_METHOD
6703                                 (NAUTILUS_FILE_CLASS, file,
6704                                  cancel_call_when_ready, (file, file_list_file_ready_callback, data));
6705                 }
6706
6707                 file_list_ready_data_free (data);
6708         }
6709 }
6710
6711 static char *
6712 try_to_make_utf8 (const char *text, int *length)
6713 {
6714         static const char *encodings_to_try[2];
6715         static int n_encodings_to_try = 0;
6716         gsize converted_length;
6717         GError *conversion_error;
6718         char *utf8_text;
6719         int i;
6720
6721         if (n_encodings_to_try == 0) {
6722                 const char *charset;
6723                 gboolean charset_is_utf8;
6724
6725                 charset_is_utf8 = g_get_charset (&charset);
6726                 if (!charset_is_utf8) {
6727                         encodings_to_try[n_encodings_to_try++] = charset;
6728                 }
6729
6730                 if (g_ascii_strcasecmp (charset, "ISO-8859-1") != 0) {
6731                         encodings_to_try[n_encodings_to_try++] = "ISO-8859-1";
6732                 }
6733         }
6734
6735         utf8_text = NULL;
6736         for (i = 0; i < n_encodings_to_try; i++) {
6737                 conversion_error = NULL;
6738                 utf8_text = g_convert (text, *length,
6739                                            "UTF-8", encodings_to_try[i],
6740                                            NULL, &converted_length, &conversion_error);
6741                 if (utf8_text != NULL) {
6742                         *length = converted_length;
6743                         break;
6744                 }
6745                 g_error_free (conversion_error);
6746         }
6747
6748         return utf8_text;
6749 }
6750
6751
6752
6753 /* Extract the top left part of the read-in text. */
6754 char *
6755 nautilus_extract_top_left_text (const char *text,
6756                                 gboolean large,
6757                                 int length)
6758 {
6759         GString* buffer;
6760         const gchar *in;
6761         const gchar *end;
6762         int line, i;
6763         gunichar c;
6764         char *text_copy;
6765         const char *utf8_end;
6766         gboolean validated;
6767         int max_bytes, max_lines, max_cols;
6768
6769         if (large) {
6770                 max_bytes = NAUTILUS_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_BYTES;
6771                 max_lines = NAUTILUS_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_LINES;
6772                 max_cols = NAUTILUS_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_CHARACTERS_PER_LINE;
6773         } else {
6774                 max_bytes = NAUTILUS_FILE_TOP_LEFT_TEXT_MAXIMUM_BYTES;
6775                 max_lines = NAUTILUS_FILE_TOP_LEFT_TEXT_MAXIMUM_LINES;
6776                 max_cols = NAUTILUS_FILE_TOP_LEFT_TEXT_MAXIMUM_CHARACTERS_PER_LINE;
6777         }
6778
6779
6780
6781         text_copy = NULL;
6782         if (text != NULL) {
6783                 /* Might be a partial utf8 character at the end if we didn't read whole file */
6784                 validated = g_utf8_validate (text, length, &utf8_end);
6785                 if (!validated &&
6786                     !(length >= max_bytes &&
6787                       text + length - utf8_end < 6)) {
6788                         text_copy = try_to_make_utf8 (text, &length);
6789                         text = text_copy;
6790                 } else if (!validated) {
6791                         length = utf8_end - text;
6792                 }
6793         }
6794
6795         if (text == NULL || length == 0) {
6796                 return NULL;
6797         }
6798
6799         buffer = g_string_new ("");
6800         end = text + length; in = text;
6801
6802         for (line = 0; line < max_lines; line++) {
6803                 /* Extract one line. */
6804                 for (i = 0; i < max_cols; ) {
6805                         if (*in == '\n') {
6806                                 break;
6807                         }
6808
6809                         c = g_utf8_get_char (in);
6810
6811                         if (g_unichar_isprint (c)) {
6812                                 g_string_append_unichar (buffer, c);
6813                                 i++;
6814                         }
6815
6816                         in = g_utf8_next_char (in);
6817                         if (in == end) {
6818                                 goto done;
6819                         }
6820                 }
6821
6822                 /* Skip the rest of the line. */
6823                 while (*in != '\n') {
6824                         if (++in == end) {
6825                                 goto done;
6826                         }
6827                 }
6828                 if (++in == end) {
6829                         goto done;
6830                 }
6831
6832                 /* Put a new-line separator in. */
6833                 g_string_append_c(buffer, '\n');
6834         }
6835  done:
6836         g_free (text_copy);
6837
6838         return g_string_free(buffer, FALSE);
6839 }
6840
6841 static void
6842 thumbnail_limit_changed_callback (gpointer user_data)
6843 {
6844         cached_thumbnail_limit = eel_preferences_get_integer (NAUTILUS_PREFERENCES_IMAGE_FILE_THUMBNAIL_LIMIT);
6845
6846         /* Tell the world that icons might have changed. We could invent a narrower-scope
6847          * signal to mean only "thumbnails might have changed" if this ends up being slow
6848          * for some reason.
6849          */
6850         emit_change_signals_for_all_files_in_all_directories ();
6851 }
6852
6853 static void
6854 thumbnail_size_changed_callback (gpointer user_data)
6855 {
6856         cached_thumbnail_size = eel_preferences_get_integer (NAUTILUS_PREFERENCES_ICON_VIEW_THUMBNAIL_SIZE);
6857
6858         /* Tell the world that icons might have changed. We could invent a narrower-scope
6859          * signal to mean only "thumbnails might have changed" if this ends up being slow
6860          * for some reason.
6861          */
6862         emit_change_signals_for_all_files_in_all_directories ();
6863 }
6864
6865 static void
6866 show_thumbnails_changed_callback (gpointer user_data)
6867 {
6868         show_image_thumbs = eel_preferences_get_enum (NAUTILUS_PREFERENCES_SHOW_IMAGE_FILE_THUMBNAILS);
6869
6870         /* Tell the world that icons might have changed. We could invent a narrower-scope
6871          * signal to mean only "thumbnails might have changed" if this ends up being slow
6872          * for some reason.
6873          */
6874         emit_change_signals_for_all_files_in_all_directories ();
6875 }
6876
6877 static void
6878 mime_type_data_changed_callback (GObject *signaller, gpointer user_data)
6879 {
6880         /* Tell the world that icons might have changed. We could invent a narrower-scope
6881          * signal to mean only "thumbnails might have changed" if this ends up being slow
6882          * for some reason.
6883          */
6884         emit_change_signals_for_all_files_in_all_directories ();
6885 }
6886
6887 static void
6888 icon_theme_changed_callback (GtkIconTheme *icon_theme,
6889                              gpointer user_data)
6890 {
6891         /* Clear all pixmap caches as the icon => pixmap lookup changed */
6892         nautilus_icon_info_clear_caches ();
6893
6894         /* Tell the world that icons might have changed. We could invent a narrower-scope
6895          * signal to mean only "thumbnails might have changed" if this ends up being slow
6896          * for some reason.
6897          */
6898         emit_change_signals_for_all_files_in_all_directories ();
6899 }
6900
6901 static void
6902 nautilus_file_class_init (NautilusFileClass *class)
6903 {
6904         GtkIconTheme *icon_theme;
6905
6906         parent_class = g_type_class_peek_parent (class);
6907
6908         attribute_name_q = g_quark_from_static_string ("name");
6909         attribute_size_q = g_quark_from_static_string ("size");
6910         attribute_type_q = g_quark_from_static_string ("type");
6911         attribute_modification_date_q = g_quark_from_static_string ("modification_date");
6912         attribute_date_modified_q = g_quark_from_static_string ("date_modified");
6913         attribute_accessed_date_q = g_quark_from_static_string ("accessed_date");
6914         attribute_date_accessed_q = g_quark_from_static_string ("date_accessed");
6915         attribute_emblems_q = g_quark_from_static_string ("emblems");
6916         attribute_mime_type_q = g_quark_from_static_string ("mime_type");
6917         attribute_size_detail_q = g_quark_from_static_string ("size_detail");
6918         attribute_deep_size_q = g_quark_from_static_string ("deep_size");
6919         attribute_deep_file_count_q = g_quark_from_static_string ("deep_file_count");
6920         attribute_deep_directory_count_q = g_quark_from_static_string ("deep_directory_count");
6921         attribute_deep_total_count_q = g_quark_from_static_string ("deep_total_count");
6922         attribute_date_changed_q = g_quark_from_static_string ("date_changed");
6923         attribute_date_permissions_q = g_quark_from_static_string ("date_permissions");
6924         attribute_permissions_q = g_quark_from_static_string ("permissions");
6925         attribute_selinux_context_q = g_quark_from_static_string ("selinux_context");
6926         attribute_octal_permissions_q = g_quark_from_static_string ("octal_permissions");
6927         attribute_owner_q = g_quark_from_static_string ("owner");
6928         attribute_group_q = g_quark_from_static_string ("group");
6929         attribute_uri_q = g_quark_from_static_string ("uri");
6930         attribute_where_q = g_quark_from_static_string ("where");
6931         attribute_link_target_q = g_quark_from_static_string ("link_target");
6932         attribute_volume_q = g_quark_from_static_string ("volume");
6933         attribute_free_space_q = g_quark_from_static_string ("free_space");
6934
6935         G_OBJECT_CLASS (class)->finalize = finalize;
6936         G_OBJECT_CLASS (class)->constructor = nautilus_file_constructor;
6937
6938         signals[CHANGED] =
6939                 g_signal_new ("changed",
6940                               G_TYPE_FROM_CLASS (class),
6941                               G_SIGNAL_RUN_LAST,
6942                               G_STRUCT_OFFSET (NautilusFileClass, changed),
6943                               NULL, NULL,
6944                               g_cclosure_marshal_VOID__VOID,
6945                               G_TYPE_NONE, 0);
6946
6947         signals[UPDATED_DEEP_COUNT_IN_PROGRESS] =
6948                 g_signal_new ("updated_deep_count_in_progress",
6949                               G_TYPE_FROM_CLASS (class),
6950                               G_SIGNAL_RUN_LAST,
6951                               G_STRUCT_OFFSET (NautilusFileClass, updated_deep_count_in_progress),
6952                               NULL, NULL,
6953                               g_cclosure_marshal_VOID__VOID,
6954                               G_TYPE_NONE, 0);
6955
6956         g_type_class_add_private (class, sizeof (NautilusFileDetails));
6957
6958
6959         eel_preferences_add_auto_enum (NAUTILUS_PREFERENCES_DATE_FORMAT,
6960                                        &date_format_pref);
6961
6962         thumbnail_limit_changed_callback (NULL);
6963         eel_preferences_add_callback (NAUTILUS_PREFERENCES_IMAGE_FILE_THUMBNAIL_LIMIT,
6964                                       thumbnail_limit_changed_callback,
6965                                       NULL);
6966         thumbnail_size_changed_callback (NULL);
6967         eel_preferences_add_callback (NAUTILUS_PREFERENCES_ICON_VIEW_THUMBNAIL_SIZE,
6968                                       thumbnail_size_changed_callback,
6969                                       NULL);
6970         show_thumbnails_changed_callback (NULL);
6971         eel_preferences_add_callback (NAUTILUS_PREFERENCES_SHOW_IMAGE_FILE_THUMBNAILS,
6972                                       show_thumbnails_changed_callback,
6973                                       NULL);
6974
6975         icon_theme = gtk_icon_theme_get_default ();
6976         g_signal_connect_object (icon_theme,
6977                                  "changed",
6978                                  G_CALLBACK (icon_theme_changed_callback),
6979                                  NULL, 0);
6980
6981         g_signal_connect (nautilus_signaller_get_current (),
6982                           "mime_data_changed",
6983                           G_CALLBACK (mime_type_data_changed_callback),
6984                           NULL);
6985 }
6986
6987 static void
6988 nautilus_file_add_emblem (NautilusFile *file,
6989                           const char *emblem_name)
6990 {
6991         if (file->details->pending_info_providers) {
6992                 file->details->pending_extension_emblems = g_list_prepend (file->details->pending_extension_emblems,
6993                                                                            g_strdup (emblem_name));
6994         } else {
6995                 file->details->extension_emblems = g_list_prepend (file->details->extension_emblems,
6996                                                                    g_strdup (emblem_name));
6997         }
6998
6999         nautilus_file_changed (file);
7000 }
7001
7002 static void
7003 nautilus_file_add_string_attribute (NautilusFile *file,
7004                                     const char *attribute_name,
7005                                     const char *value)
7006 {
7007         if (file->details->pending_info_providers) {
7008                 /* Lazily create hashtable */
7009                 if (!file->details->pending_extension_attributes) {
7010                         file->details->pending_extension_attributes =
7011                                 g_hash_table_new_full (g_direct_hash, g_direct_equal,
7012                                                        NULL,
7013                                                        (GDestroyNotify)g_free);
7014                 }
7015                 g_hash_table_insert (file->details->pending_extension_attributes,
7016                                      GINT_TO_POINTER (g_quark_from_string (attribute_name)),
7017                                      g_strdup (value));
7018         } else {
7019                 if (!file->details->extension_attributes) {
7020                         file->details->extension_attributes =
7021                                 g_hash_table_new_full (g_direct_hash, g_direct_equal,
7022                                                        NULL,
7023                                                        (GDestroyNotify)g_free);
7024                 }
7025                 g_hash_table_insert (file->details->extension_attributes,
7026                                      GINT_TO_POINTER (g_quark_from_string (attribute_name)),
7027                                      g_strdup (value));
7028         }
7029
7030         nautilus_file_changed (file);
7031 }
7032
7033 static void
7034 nautilus_file_invalidate_extension_info (NautilusFile *file)
7035 {
7036         nautilus_file_invalidate_attributes (file, NAUTILUS_FILE_ATTRIBUTE_EXTENSION_INFO);
7037 }
7038
7039 void
7040 nautilus_file_info_providers_done (NautilusFile *file)
7041 {
7042         eel_g_list_free_deep (file->details->extension_emblems);
7043         file->details->extension_emblems = file->details->pending_extension_emblems;
7044         file->details->pending_extension_emblems = NULL;
7045
7046         if (file->details->extension_attributes) {
7047                 g_hash_table_destroy (file->details->extension_attributes);
7048         }
7049
7050         file->details->extension_attributes = file->details->pending_extension_attributes;
7051         file->details->pending_extension_attributes = NULL;
7052
7053         nautilus_file_changed (file);
7054 }
7055
7056 static void
7057 nautilus_file_info_iface_init (NautilusFileInfoIface *iface)
7058 {
7059         iface->is_gone = nautilus_file_is_gone;
7060         iface->get_name = nautilus_file_get_name;
7061         iface->get_file_type = nautilus_file_get_file_type;
7062         iface->get_location = nautilus_file_get_location;
7063         iface->get_uri = nautilus_file_get_uri;
7064         iface->get_parent_location = nautilus_file_get_parent_location;
7065         iface->get_parent_uri = nautilus_file_get_parent_uri;
7066         iface->get_parent_info = nautilus_file_get_parent;
7067         iface->get_mount = nautilus_file_get_mount;
7068         iface->get_uri_scheme = nautilus_file_get_uri_scheme;
7069         iface->get_activation_uri = nautilus_file_get_activation_uri;
7070         iface->get_mime_type = nautilus_file_get_mime_type;
7071         iface->is_mime_type = nautilus_file_is_mime_type;
7072         iface->is_directory = nautilus_file_is_directory;
7073         iface->can_write = nautilus_file_can_write;
7074         iface->add_emblem = nautilus_file_add_emblem;
7075         iface->get_string_attribute = nautilus_file_get_string_attribute;
7076         iface->add_string_attribute = nautilus_file_add_string_attribute;
7077         iface->invalidate_extension_info = nautilus_file_invalidate_extension_info;
7078 }
7079
7080 #if !defined (NAUTILUS_OMIT_SELF_CHECK)
7081
7082 void
7083 nautilus_self_check_file (void)
7084 {
7085         NautilusFile *file_1;
7086         NautilusFile *file_2;
7087         GList *list;
7088
7089         /* refcount checks */
7090
7091         EEL_CHECK_INTEGER_RESULT (nautilus_directory_number_outstanding (), 0);
7092
7093         file_1 = nautilus_file_get_by_uri ("file:///home/");
7094
7095         EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 1);
7096         EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1->details->directory)->ref_count, 1);
7097         EEL_CHECK_INTEGER_RESULT (nautilus_directory_number_outstanding (), 1);
7098
7099         nautilus_file_unref (file_1);
7100
7101         EEL_CHECK_INTEGER_RESULT (nautilus_directory_number_outstanding (), 0);
7102
7103         file_1 = nautilus_file_get_by_uri ("file:///etc");
7104         file_2 = nautilus_file_get_by_uri ("file:///usr");
7105
7106         list = NULL;
7107         list = g_list_prepend (list, file_1);
7108         list = g_list_prepend (list, file_2);
7109
7110         nautilus_file_list_ref (list);
7111
7112         EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 2);
7113         EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_2)->ref_count, 2);
7114
7115         nautilus_file_list_unref (list);
7116
7117         EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 1);
7118         EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_2)->ref_count, 1);
7119
7120         nautilus_file_list_free (list);
7121
7122         EEL_CHECK_INTEGER_RESULT (nautilus_directory_number_outstanding (), 0);
7123
7124
7125         /* name checks */
7126         file_1 = nautilus_file_get_by_uri ("file:///home/");
7127
7128         EEL_CHECK_STRING_RESULT (nautilus_file_get_name (file_1), "home");
7129
7130         EEL_CHECK_BOOLEAN_RESULT (nautilus_file_get_by_uri ("file:///home/") == file_1, TRUE);
7131         nautilus_file_unref (file_1);
7132
7133         EEL_CHECK_BOOLEAN_RESULT (nautilus_file_get_by_uri ("file:///home") == file_1, TRUE);
7134         nautilus_file_unref (file_1);
7135
7136         nautilus_file_unref (file_1);
7137
7138         file_1 = nautilus_file_get_by_uri ("file:///home");
7139         EEL_CHECK_STRING_RESULT (nautilus_file_get_name (file_1), "home");
7140         nautilus_file_unref (file_1);
7141
7142 #if 0
7143         /* ALEX: I removed this, because it was breaking distchecks.
7144          * It used to work, but when canonical uris changed from
7145          * foo: to foo:/// it broke. I don't expect it to matter
7146          * in real life */
7147         file_1 = nautilus_file_get_by_uri (":");
7148         EEL_CHECK_STRING_RESULT (nautilus_file_get_name (file_1), ":");
7149         nautilus_file_unref (file_1);
7150 #endif
7151
7152         file_1 = nautilus_file_get_by_uri ("eazel:");
7153         EEL_CHECK_STRING_RESULT (nautilus_file_get_name (file_1), "eazel");
7154         nautilus_file_unref (file_1);
7155
7156         /* sorting */
7157         file_1 = nautilus_file_get_by_uri ("file:///etc");
7158         file_2 = nautilus_file_get_by_uri ("file:///usr");
7159
7160         EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 1);
7161         EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_2)->ref_count, 1);
7162
7163         EEL_CHECK_BOOLEAN_RESULT (nautilus_file_compare_for_sort (file_1, file_2, NAUTILUS_FILE_SORT_BY_DISPLAY_NAME, FALSE, FALSE) < 0, TRUE);
7164         EEL_CHECK_BOOLEAN_RESULT (nautilus_file_compare_for_sort (file_1, file_2, NAUTILUS_FILE_SORT_BY_DISPLAY_NAME, FALSE, TRUE) > 0, TRUE);
7165         EEL_CHECK_BOOLEAN_RESULT (nautilus_file_compare_for_sort (file_1, file_1, NAUTILUS_FILE_SORT_BY_DISPLAY_NAME, FALSE, FALSE) == 0, TRUE);
7166         EEL_CHECK_BOOLEAN_RESULT (nautilus_file_compare_for_sort (file_1, file_1, NAUTILUS_FILE_SORT_BY_DISPLAY_NAME, TRUE, FALSE) == 0, TRUE);
7167         EEL_CHECK_BOOLEAN_RESULT (nautilus_file_compare_for_sort (file_1, file_1, NAUTILUS_FILE_SORT_BY_DISPLAY_NAME, FALSE, TRUE) == 0, TRUE);
7168         EEL_CHECK_BOOLEAN_RESULT (nautilus_file_compare_for_sort (file_1, file_1, NAUTILUS_FILE_SORT_BY_DISPLAY_NAME, TRUE, TRUE) == 0, TRUE);
7169
7170         nautilus_file_unref (file_1);
7171         nautilus_file_unref (file_2);
7172 }
7173
7174 #endif /* !NAUTILUS_OMIT_SELF_CHECK */