Logo Search packages:      
Sourcecode: nautilus version File versions

nautilus-directory-metafile.c

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-

   nautilus-directory-metafile.c: Nautilus directory model.
 
   Copyright (C) 2000, 2001 Eazel, Inc.
  
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
  
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.
  
   You should have received a copy of the GNU General Public
   License along with this program; if not, write to the
   Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.
  
   Authors: Darin Adler <darin@bentspoon.com>,
            Mike Engber <engber@eazel.com>
*/

#include <config.h>
#include "nautilus-directory-metafile.h"

#include "nautilus-directory-private.h"
#include "nautilus-file-private.h"
#include "nautilus-metafile.h"
#include <eel/eel-debug.h>
#include <eel/eel-string.h>
#include <stdio.h>


static NautilusMetafile *
get_metafile (NautilusDirectory *directory)
{
      char *uri;

      if (directory->details->metafile == NULL) {
            uri = nautilus_directory_get_uri (directory);
            directory->details->metafile = nautilus_metafile_get_for_uri (uri);
            g_free (uri);
      }

      return directory->details->metafile;      
}

gboolean
nautilus_directory_is_metadata_read (NautilusDirectory *directory)
{
      NautilusMetafile *metafile;

      g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), FALSE);
      
      metafile = get_metafile (directory);

      if (metafile == NULL) {
            return TRUE;
      }
            
      return nautilus_metafile_is_read (metafile);
}

char *
nautilus_directory_get_file_metadata (NautilusDirectory *directory,
                              const char *file_name,
                              const char *key,
                              const char *default_metadata)
{
      NautilusMetafile *metafile;

      g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), g_strdup (default_metadata));
      g_return_val_if_fail (!eel_str_is_empty (file_name), g_strdup (default_metadata));
      g_return_val_if_fail (!eel_str_is_empty (key), g_strdup (default_metadata));
      
      metafile = get_metafile (directory);

      return nautilus_metafile_get (metafile, file_name, key, default_metadata);
}

GList *
nautilus_directory_get_file_metadata_list (NautilusDirectory *directory,
                                 const char *file_name,
                                 const char *list_key,
                                 const char *list_subkey)
{
      NautilusMetafile *     metafile;

      g_return_val_if_fail (NAUTILUS_IS_DIRECTORY (directory), NULL);
      g_return_val_if_fail (!eel_str_is_empty (file_name), NULL);
      g_return_val_if_fail (!eel_str_is_empty (list_key), NULL);
      g_return_val_if_fail (!eel_str_is_empty (list_subkey), NULL);
      
      metafile = get_metafile (directory);
      return nautilus_metafile_get_list (metafile, file_name, list_key, list_subkey);
}

void
nautilus_directory_set_file_metadata (NautilusDirectory *directory,
                              const char *file_name,
                              const char *key,
                              const char *default_metadata,
                              const char *metadata)
{
      NautilusMetafile *metafile;

      g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
      g_return_if_fail (!eel_str_is_empty (file_name));
      g_return_if_fail (!eel_str_is_empty (key));
      
      metafile = get_metafile (directory);
      nautilus_metafile_set (metafile, file_name, key, default_metadata, metadata);
}

void
nautilus_directory_set_file_metadata_list (NautilusDirectory *directory,
                                 const char *file_name,
                                 const char *list_key,
                                 const char *list_subkey,
                                 GList *list)
{
      NautilusMetafile *metafile;

      g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
      g_return_if_fail (!eel_str_is_empty (file_name));
      g_return_if_fail (!eel_str_is_empty (list_key));
      g_return_if_fail (!eel_str_is_empty (list_subkey));

      metafile = get_metafile (directory);
      nautilus_metafile_set_list (metafile,
                            file_name,
                            list_key,
                            list_subkey,
                            list);
}

gboolean 
nautilus_directory_get_boolean_file_metadata (NautilusDirectory *directory,
                                    const char *file_name,
                                    const char *key,
                                    gboolean default_metadata)
{
      char *result_as_string;
      gboolean result;

      result_as_string = nautilus_directory_get_file_metadata
            (directory, file_name, key,
             default_metadata ? "true" : "false");
      g_assert (result_as_string != NULL);
      
      if (g_ascii_strcasecmp (result_as_string, "true") == 0) {
            result = TRUE;
      } else if (g_ascii_strcasecmp (result_as_string, "false") == 0) {
            result = FALSE;
      } else {
            g_error ("boolean metadata with value other than true or false");
            result = default_metadata;
      }

      g_free (result_as_string);
      return result;
}

void
nautilus_directory_set_boolean_file_metadata (NautilusDirectory *directory,
                                    const char *file_name,
                                    const char *key,
                                    gboolean default_metadata,
                                    gboolean metadata)
{
      nautilus_directory_set_file_metadata
            (directory, file_name, key,
             default_metadata ? "true" : "false",
             metadata ? "true" : "false");
}

int 
nautilus_directory_get_integer_file_metadata (NautilusDirectory *directory,
                                    const char *file_name,
                                    const char *key,
                                    int default_metadata)
{
      char *result_as_string;
      char default_as_string[32];
      int result;
      char c;

      g_snprintf (default_as_string, sizeof (default_as_string), "%d", default_metadata);
      result_as_string = nautilus_directory_get_file_metadata
            (directory, file_name, key, default_as_string);

      /* Normally we can't get a a NULL, but we check for it here to
       * handle the oddball case of a non-existent directory.
       */
      if (result_as_string == NULL) {
            result = default_metadata;
      } else {
            if (sscanf (result_as_string, " %d %c", &result, &c) != 1) {
                  result = default_metadata;
            }
            g_free (result_as_string);
      }

      return result;
}

void
nautilus_directory_set_integer_file_metadata (NautilusDirectory *directory,
                                    const char *file_name,
                                    const char *key,
                                    int default_metadata,
                                    int metadata)
{
      char value_as_string[32];
      char default_as_string[32];

      g_snprintf (value_as_string, sizeof (value_as_string), "%d", metadata);
      g_snprintf (default_as_string, sizeof (default_as_string), "%d", default_metadata);

      nautilus_directory_set_file_metadata
            (directory, file_name, key,
             default_as_string, value_as_string);
}

void
nautilus_directory_copy_file_metadata (NautilusDirectory *source_directory,
                               const char *source_file_name,
                               NautilusDirectory *destination_directory,
                               const char *destination_file_name)
{
      char *destination_uri;
      NautilusMetafile *metafile;

      g_return_if_fail (NAUTILUS_IS_DIRECTORY (source_directory));
      g_return_if_fail (source_file_name != NULL);
      g_return_if_fail (NAUTILUS_IS_DIRECTORY (destination_directory));
      g_return_if_fail (destination_file_name != NULL);

      metafile = get_metafile (source_directory);
      destination_uri = nautilus_directory_get_uri (destination_directory);

      nautilus_metafile_copy (metafile, source_file_name,
                        destination_uri, destination_file_name);

      g_free (destination_uri);
}

void
nautilus_directory_remove_file_metadata (NautilusDirectory *directory,
                               const char *file_name)
{
      NautilusMetafile *metafile;

      g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
      g_return_if_fail (file_name != NULL);

      metafile = get_metafile (directory);
      nautilus_metafile_remove (metafile, file_name);
}

void
nautilus_directory_rename_file_metadata (NautilusDirectory *directory,
                               const char *old_file_name,
                               const char *new_file_name)
{
      NautilusMetafile *metafile;

      g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
      g_return_if_fail (old_file_name != NULL);
      g_return_if_fail (new_file_name != NULL);

      metafile = get_metafile (directory);
      nautilus_metafile_rename (metafile, old_file_name,new_file_name);
}

void
nautilus_directory_rename_directory_metadata (NautilusDirectory *directory,
                                    const char *new_directory_uri)
{
      NautilusMetafile *metafile;

      g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));
      g_return_if_fail (new_directory_uri != NULL);

      metafile = get_metafile (directory);
      nautilus_metafile_rename_directory (metafile, new_directory_uri);
}

static void
metafile_changed_cb (NautilusMetafile *metafile,
                 GList *file_names,
                 NautilusDirectory *directory)
{
      GList                   *file_list;
      NautilusFile            *file;
      
      file_list = NULL;
      while (file_names != NULL) {
            file = nautilus_directory_find_file_by_internal_filename
                  (directory, file_names->data);

            if (file != NULL) {
                  if (nautilus_file_is_self_owned (file)) {
                        nautilus_file_emit_changed (file);
                  } else {
                        file_list = g_list_prepend (file_list, file);
                  }
            }
            file_names = file_names->next;
      }
      
      if (file_list != NULL) {
            file_list = g_list_reverse (file_list);
            nautilus_directory_emit_change_signals (directory, file_list);
            g_list_free (file_list);
      }
}

static void
metafile_ready_cb (NautilusMetafile *metafile,
               NautilusDirectory *directory)
{
      emit_change_signals_for_all_files (directory);
      nautilus_directory_async_state_changed (directory);
}


void
nautilus_directory_register_metadata_monitor (NautilusDirectory *directory)
{
      NautilusMetafile *metafile;

      g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory));

      if (directory->details->metafile_monitored) {
            return;
      }

      metafile = get_metafile (directory);
      directory->details->metafile_monitored = TRUE;

      g_signal_connect (metafile, "changed", (GCallback)metafile_changed_cb, directory);
      g_signal_connect (metafile, "ready", (GCallback)metafile_ready_cb, directory);
      
      nautilus_metafile_load (metafile);
}

void
nautilus_directory_unregister_metadata_monitor (NautilusDirectory *directory)
{
      NautilusMetafile *metafile;

      g_return_if_fail (NAUTILUS_IS_DIRECTORY (directory)); 

      directory->details->metafile_monitored = FALSE;

      metafile = get_metafile (directory);
      g_signal_handlers_disconnect_by_func (metafile, metafile_changed_cb, directory);
      g_signal_handlers_disconnect_by_func (metafile, metafile_ready_cb, directory);
}

Generated by  Doxygen 1.6.0   Back to index