libnautilus-private/nautilus-directory-metafile.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-
   2
   3    nautilus-directory-metafile.c: Nautilus directory model.
   4
   5    Copyright (C) 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    Authors: Darin Adler <darin@bentspoon.com>,
  23             Mike Engber <engber@eazel.com>
  24 */
  25
  26 #include <config.h>
  27 #include "nautilus-directory-metafile.h"
  28
  29 #include "nautilus-directory-private.h"
  30 #include "nautilus-file-private.h"
  31 #include "nautilus-metafile.h"
  32 #include <eel/eel-debug.h>
  33 #include <eel/eel-string.h>
  34 #include <stdio.h>
  35
  36
  37 static NautilusMetafile *
  38 get_metafile (NautilusDirectory *directory)
  39 {
  40         char *uri;
  41
  42         if (directory->details->metafile == NULL) {
  43                 uri = nautilus_directory_get_uri (directory);
  44                 directory->details->metafile = nautilus_metafile_get_for_uri (uri);
  45                 g_free (uri);
  46         }
  47
  48         return directory->details->metafile;
  49 }
  50
  51 gboolean
  52 nautilus_directory_is_metadata_read (NautilusDirectory *directory)
  53 {
  54         NautilusMetafile *metafile;
  55
  56         g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), FALSE);
  57
  58         metafile = get_metafile (directory);
  59
  60         if (metafile == NULL) {
  61                 return TRUE;
  62         }
  63
  64         return nautilus_metafile_is_read (metafile);
  65 }
  66
  67 char *
  68 nautilus_directory_get_file_metadata (NautilusDirectory *directory,
  69                                       const char *file_name,
  70                                       const char *key,
  71                                       const char *default_metadata)
  72 {
  73         NautilusMetafile *metafile;
  74
  75         g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), g_strdup (default_metadata));
  76         g_return_val_if_fail (!eel_str_is_empty (file_name), g_strdup (default_metadata));
  77         g_return_val_if_fail (!eel_str_is_empty (key), g_strdup (default_metadata));
  78
  79         metafile = get_metafile (directory);
  80
  81         return nautilus_metafile_get (metafile, file_name, key, default_metadata);
  82 }
  83
  84 GList *
  85 nautilus_directory_get_file_metadata_list (NautilusDirectory *directory,
  86                                            const char *file_name,
  87                                            const char *list_key,
  88                                            const char *list_subkey)
  89 {
  90         NautilusMetafile *     metafile;
  91
  92         g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), NULL);
  93         g_return_val_if_fail (!eel_str_is_empty (file_name), NULL);
  94         g_return_val_if_fail (!eel_str_is_empty (list_key), NULL);
  95         g_return_val_if_fail (!eel_str_is_empty (list_subkey), NULL);
  96
  97         metafile = get_metafile (directory);
  98         return nautilus_metafile_get_list (metafile, file_name, list_key, list_subkey);
  99 }
 100
 101 void
 102 nautilus_directory_set_file_metadata (NautilusDirectory *directory,
 103                                       const char *file_name,
 104                                       const char *key,
 105                                       const char *default_metadata,
 106                                       const char *metadata)
 107 {
 108         NautilusMetafile *metafile;
 109
 110         g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
 111         g_return_if_fail (!eel_str_is_empty (file_name));
 112         g_return_if_fail (!eel_str_is_empty (key));
 113
 114         metafile = get_metafile (directory);
 115         nautilus_metafile_set (metafile, file_name, key, default_metadata, metadata);
 116 }
 117
 118 void
 119 nautilus_directory_set_file_metadata_list (NautilusDirectory *directory,
 120                                            const char *file_name,
 121                                            const char *list_key,
 122                                            const char *list_subkey,
 123                                            GList *list)
 124 {
 125         NautilusMetafile *metafile;
 126
 127         g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
 128         g_return_if_fail (!eel_str_is_empty (file_name));
 129         g_return_if_fail (!eel_str_is_empty (list_key));
 130         g_return_if_fail (!eel_str_is_empty (list_subkey));
 131
 132         metafile = get_metafile (directory);
 133         nautilus_metafile_set_list (metafile,
 134                                     file_name,
 135                                     list_key,
 136                                     list_subkey,
 137                                     list);
 138 }
 139
 140 gboolean
 141 nautilus_directory_get_boolean_file_metadata (NautilusDirectory *directory,
 142                                               const char *file_name,
 143                                               const char *key,
 144                                               gboolean default_metadata)
 145 {
 146         char *result_as_string;
 147         gboolean result;
 148
 149         result_as_string = nautilus_directory_get_file_metadata
 150                 (directory, file_name, key,
 151                  default_metadata ? "true" : "false");
 152         g_assert (result_as_string != NULL);
 153
 154         if (g_ascii_strcasecmp (result_as_string, "true") == 0) {
 155                 result = TRUE;
 156         } else if (g_ascii_strcasecmp (result_as_string, "false") == 0) {
 157                 result = FALSE;
 158         } else {
 159                 g_error ("boolean metadata with value other than true or false");
 160                 result = default_metadata;
 161         }
 162
 163         g_free (result_as_string);
 164         return result;
 165 }
 166
 167 void
 168 nautilus_directory_set_boolean_file_metadata (NautilusDirectory *directory,
 169                                               const char *file_name,
 170                                               const char *key,
 171                                               gboolean default_metadata,
 172                                               gboolean metadata)
 173 {
 174         nautilus_directory_set_file_metadata
 175                 (directory, file_name, key,
 176                  default_metadata ? "true" : "false",
 177                  metadata ? "true" : "false");
 178 }
 179
 180 int
 181 nautilus_directory_get_integer_file_metadata (NautilusDirectory *directory,
 182                                               const char *file_name,
 183                                               const char *key,
 184                                               int default_metadata)
 185 {
 186         char *result_as_string;
 187         char default_as_string[32];
 188         int result;
 189         char c;
 190
 191         g_snprintf (default_as_string, sizeof (default_as_string), "%d", default_metadata);
 192         result_as_string = nautilus_directory_get_file_metadata
 193                 (directory, file_name, key, default_as_string);
 194
 195         /* Normally we can't get a a NULL, but we check for it here to
 196          * handle the oddball case of a non-existent directory.
 197          */
 198         if (result_as_string == NULL) {
 199                 result = default_metadata;
 200         } else {
 201                 if (sscanf (result_as_string, " %d %c", &result, &c) != 1) {
 202                         result = default_metadata;
 203                 }
 204                 g_free (result_as_string);
 205         }
 206
 207         return result;
 208 }
 209
 210 void
 211 nautilus_directory_set_integer_file_metadata (NautilusDirectory *directory,
 212                                               const char *file_name,
 213                                               const char *key,
 214                                               int default_metadata,
 215                                               int metadata)
 216 {
 217         char value_as_string[32];
 218         char default_as_string[32];
 219
 220         g_snprintf (value_as_string, sizeof (value_as_string), "%d", metadata);
 221         g_snprintf (default_as_string, sizeof (default_as_string), "%d", default_metadata);
 222
 223         nautilus_directory_set_file_metadata
 224                 (directory, file_name, key,
 225                  default_as_string, value_as_string);
 226 }
 227
 228 void
 229 nautilus_directory_copy_file_metadata (NautilusDirectory *source_directory,
 230                                        const char *source_file_name,
 231                                        NautilusDirectory *destination_directory,
 232                                        const char *destination_file_name)
 233 {
 234         char *destination_uri;
 235         NautilusMetafile *metafile;
 236
 237         g_return_if_fail (NAUTILUS_IS_DIRECTORY (source_directory));
 238         g_return_if_fail (source_file_name != NULL);
 239         g_return_if_fail (NAUTILUS_IS_DIRECTORY (destination_directory));
 240         g_return_if_fail (destination_file_name != NULL);
 241
 242         metafile = get_metafile (source_directory);
 243         destination_uri = nautilus_directory_get_uri (destination_directory);
 244
 245         nautilus_metafile_copy (metafile, source_file_name,
 246                                 destination_uri, destination_file_name);
 247
 248         g_free (destination_uri);
 249 }
 250
 251 void
 252 nautilus_directory_remove_file_metadata (NautilusDirectory *directory,
 253                                          const char *file_name)
 254 {
 255         NautilusMetafile *metafile;
 256
 257         g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
 258         g_return_if_fail (file_name != NULL);
 259
 260         metafile = get_metafile (directory);
 261         nautilus_metafile_remove (metafile, file_name);
 262 }
 263
 264 void
 265 nautilus_directory_rename_file_metadata (NautilusDirectory *directory,
 266                                          const char *old_file_name,
 267                                          const char *new_file_name)
 268 {
 269         NautilusMetafile *metafile;
 270
 271         g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
 272         g_return_if_fail (old_file_name != NULL);
 273         g_return_if_fail (new_file_name != NULL);
 274
 275         metafile = get_metafile (directory);
 276         nautilus_metafile_rename (metafile, old_file_name,new_file_name);
 277 }
 278
 279 void
 280 nautilus_directory_rename_directory_metadata (NautilusDirectory *directory,
 281                                               const char *new_directory_uri)
 282 {
 283         NautilusMetafile *metafile;
 284
 285         g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
 286         g_return_if_fail (new_directory_uri != NULL);
 287
 288         metafile = get_metafile (directory);
 289         nautilus_metafile_rename_directory (metafile, new_directory_uri);
 290 }
 291
 292 static void
 293 metafile_changed_cb (NautilusMetafile *metafile,
 294                      GList *file_names,
 295                      NautilusDirectory *directory)
 296 {
 297         GList                   *file_list;
 298         NautilusFile            *file;
 299
 300         file_list = NULL;
 301         while (file_names != NULL) {
 302                 file = nautilus_directory_find_file_by_internal_filename
 303                         (directory, file_names->data);
 304
 305                 if (file != NULL) {
 306                         if (nautilus_file_is_self_owned (file)) {
 307                                 nautilus_file_emit_changed (file);
 308                         } else {
 309                                 file_list = g_list_prepend (file_list, file);
 310                         }
 311                 }
 312                 file_names = file_names->next;
 313         }
 314
 315         if (file_list != NULL) {
 316                 file_list = g_list_reverse (file_list);
 317                 nautilus_directory_emit_change_signals (directory, file_list);
 318                 g_list_free (file_list);
 319         }
 320 }
 321
 322 static void
 323 metafile_ready_cb (NautilusMetafile *metafile,
 324                    NautilusDirectory *directory)
 325 {
 326         emit_change_signals_for_all_files (directory);
 327         nautilus_directory_async_state_changed (directory);
 328 }
 329
 330
 331 void
 332 nautilus_directory_register_metadata_monitor (NautilusDirectory *directory)
 333 {
 334         NautilusMetafile *metafile;
 335
 336         g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
 337
 338         if (directory->details->metafile_monitored) {
 339                 return;
 340         }
 341
 342         metafile = get_metafile (directory);
 343         directory->details->metafile_monitored = TRUE;
 344
 345         g_signal_connect (metafile, "changed", (GCallback)metafile_changed_cb, directory);
 346         g_signal_connect (metafile, "ready", (GCallback)metafile_ready_cb, directory);
 347
 348         nautilus_metafile_load (metafile);
 349 }
 350
 351 void
 352 nautilus_directory_unregister_metadata_monitor (NautilusDirectory *directory)
 353 {
 354         NautilusMetafile *metafile;
 355
 356         g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
 357
 358         directory->details->metafile_monitored = FALSE;
 359
 360         metafile = get_metafile (directory);
 361         g_signal_handlers_disconnect_by_func (metafile, metafile_changed_cb, directory);
 362         g_signal_handlers_disconnect_by_func (metafile, metafile_ready_cb, directory);
 363 }