path: root/src/nautilus-error-reporting.c

/* nautilus-error-reporting.h - implementation of file manager functions that report
 *                               errors to the user.
 *
 *  Copyright (C) 2000 Eazel, Inc.
 *
 *  The Gnome Library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public License as
 *  published by the Free Software Foundation; either version 2 of the
 *  License, or (at your option) any later version.
 *
 *  The Gnome Library 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
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with the Gnome Library; see the file COPYING.LIB.  If not,
 *  see <http://www.gnu.org/licenses/>.
 *
 *  Authors: John Sullivan <sullivan@eazel.com>
 */

#include <config.h>

#include "nautilus-error-reporting.h"

#include <string.h>
#include <glib/gi18n.h>
#include "nautilus-file.h"
#include <eel/eel-string.h>
#include <eel/eel-stock-dialogs.h>

#define DEBUG_FLAG NAUTILUS_DEBUG_DIRECTORY_VIEW
#include "nautilus-debug.h"

#define NEW_NAME_TAG "Nautilus: new name"
#define MAXIMUM_DISPLAYED_FILE_NAME_LENGTH      50

static void finish_rename (NautilusFile *file,
                           gboolean      stop_timer,
                           GError       *error);

void
nautilus_report_error_loading_directory (NautilusFile *file,
                                         GError       *error,
                                         GtkWindow    *parent_window)
{
    char *file_name;
    char *message;

    if (error == NULL ||
        error->message == NULL)
    {
        return;
    }

    if (error->domain == G_IO_ERROR &&
        error->code == G_IO_ERROR_NOT_MOUNTED)
    {
        /* This case is retried automatically */
        return;
    }

    file_name = nautilus_file_get_display_name (file);

    if (error->domain == G_IO_ERROR)
    {
        switch (error->code)
        {
            case G_IO_ERROR_PERMISSION_DENIED:
            {
                message = g_strdup_printf (_("You do not have the permissions necessary to view the contents of “%s”."),
                                           file_name);
            }
            break;

            case G_IO_ERROR_NOT_FOUND:
            {
                message = g_strdup_printf (_("“%s” could not be found. Perhaps it has recently been deleted."),
                                           file_name);
            }
            break;

            default:
                message = g_strdup_printf (_("Sorry, could not display all the contents of “%s”: %s"), file_name,
                                           error->message);
        }
    }
    else
    {
        message = g_strdup (error->message);
    }

    eel_show_error_dialog (_("This location could not be displayed."), message, parent_window);

    g_free (file_name);
    g_free (message);
}

void
nautilus_report_error_setting_group (NautilusFile *file,
                                     GError       *error,
                                     GtkWindow    *parent_window)
{
    char *file_name;
    char *message;

    if (error == NULL)
    {
        return;
    }

    file_name = nautilus_file_get_display_name (file);

    message = NULL;
    if (error->domain == G_IO_ERROR)
    {
        switch (error->code)
        {
            case G_IO_ERROR_PERMISSION_DENIED:
            {
                message = g_strdup_printf (_("You do not have the permissions necessary to change the group of “%s”."),
                                           file_name);
            }
            break;

            default:
            {
            }
            break;
        }
    }

    if (message == NULL)
    {
        /* We should invent decent error messages for every case we actually experience. */
        g_warning ("Hit unhandled case %s:%d in nautilus_report_error_setting_group",
                   g_quark_to_string (error->domain), error->code);
        /* fall through */
        message = g_strdup_printf (_("Sorry, could not change the group of “%s”: %s"), file_name,
                                   error->message);
    }


    eel_show_error_dialog (_("The group could not be changed."), message, parent_window);

    g_free (file_name);
    g_free (message);
}

void
nautilus_report_error_setting_owner (NautilusFile *file,
                                     GError       *error,
                                     GtkWindow    *parent_window)
{
    char *file_name;
    char *message;

    if (error == NULL)
    {
        return;
    }

    file_name = nautilus_file_get_display_name (file);

    message = g_strdup_printf (_("Sorry, could not change the owner of “%s”: %s"), file_name, error->message);

    eel_show_error_dialog (_("The owner could not be changed."), message, parent_window);

    g_free (file_name);
    g_free (message);
}

void
nautilus_report_error_setting_permissions (NautilusFile *file,
                                           GError       *error,
                                           GtkWindow    *parent_window)
{
    char *file_name;
    char *message;

    if (error == NULL)
    {
        return;
    }

    file_name = nautilus_file_get_display_name (file);

    message = g_strdup_printf (_("Sorry, could not change the permissions of “%s”: %s"), file_name, error->message);

    eel_show_error_dialog (_("The permissions could not be changed."), message, parent_window);

    g_free (file_name);
    g_free (message);
}

typedef struct _NautilusRenameData
{
    char *name;
    NautilusFileOperationCallback callback;
    gpointer callback_data;
} NautilusRenameData;

void
nautilus_report_error_renaming_file (NautilusFile *file,
                                     const char   *new_name,
                                     GError       *error,
                                     GtkWindow    *parent_window)
{
    char *original_name, *original_name_truncated;
    char *new_name_truncated;
    char *message;

    /* Truncate names for display since very long file names with no spaces
     * in them won't get wrapped, and can create insanely wide dialog boxes.
     */
    original_name = nautilus_file_get_display_name (file);
    original_name_truncated = eel_str_middle_truncate (original_name, MAXIMUM_DISPLAYED_FILE_NAME_LENGTH);
    g_free (original_name);

    new_name_truncated = eel_str_middle_truncate (new_name, MAXIMUM_DISPLAYED_FILE_NAME_LENGTH);

    message = NULL;
    if (error->domain == G_IO_ERROR)
    {
        switch (error->code)
        {
            case G_IO_ERROR_EXISTS:
            {
                message = g_strdup_printf (_("The name “%s” is already used in this location. "
                                             "Please use a different name."),
                                           new_name_truncated);
            }
            break;

            case G_IO_ERROR_NOT_FOUND:
            {
                message = g_strdup_printf (_("There is no “%s” in this location. "
                                             "Perhaps it was just moved or deleted?"),
                                           original_name_truncated);
            }
            break;

            case G_IO_ERROR_PERMISSION_DENIED:
            {
                message = g_strdup_printf (_("You do not have the permissions necessary to rename “%s”."),
                                           original_name_truncated);
            }
            break;

            case G_IO_ERROR_INVALID_FILENAME:
            {
                if (strchr (new_name, '/') != NULL)
                {
                    message = g_strdup_printf (_("The name “%s” is not valid because it contains the character “/”. "
                                                 "Please use a different name."),
                                               new_name_truncated);
                }
                else
                {
                    message = g_strdup_printf (_("The name “%s” is not valid. "
                                                 "Please use a different name."),
                                               new_name_truncated);
                }
            }
            break;

            case G_IO_ERROR_FILENAME_TOO_LONG:
            {
                message = g_strdup_printf (_("The name “%s” is too long. "
                                             "Please use a different name."),
                                           new_name_truncated);
            }
            break;

            default:
            {
            }
            break;
        }
    }

    if (message == NULL)
    {
        /* We should invent decent error messages for every case we actually experience. */
        g_warning ("Hit unhandled case %s:%d in nautilus_report_error_renaming_file",
                   g_quark_to_string (error->domain), error->code);
        /* fall through */
        message = g_strdup_printf (_("Sorry, could not rename “%s” to “%s”: %s"),
                                   original_name_truncated, new_name_truncated,
                                   error->message);
    }

    g_free (original_name_truncated);
    g_free (new_name_truncated);

    eel_show_error_dialog (_("The item could not be renamed."), message, parent_window);
    g_free (message);
}

static void
nautilus_rename_data_free (NautilusRenameData *data)
{
    g_free (data->name);
    g_free (data);
}

static void
rename_callback (NautilusFile *file,
                 GFile        *result_location,
                 GError       *error,
                 gpointer      callback_data)
{
    NautilusRenameData *data;
    gboolean cancelled = FALSE;

    g_assert (NAUTILUS_IS_FILE (file));
    g_assert (callback_data == NULL);

    data = g_object_get_data (G_OBJECT (file), NEW_NAME_TAG);
    g_assert (data != NULL);

    if (error)
    {
        if (!(error->domain == G_IO_ERROR && error->code == G_IO_ERROR_CANCELLED))
        {
            /* If rename failed, notify the user. */
            nautilus_report_error_renaming_file (file, data->name, error, NULL);
        }
        else
        {
            cancelled = TRUE;
        }
    }

    finish_rename (file, !cancelled, error);
}

static void
cancel_rename_callback (gpointer callback_data)
{
    nautilus_file_cancel (NAUTILUS_FILE (callback_data), rename_callback, NULL);
}

static void
finish_rename (NautilusFile *file,
               gboolean      stop_timer,
               GError       *error)
{
    NautilusRenameData *data;

    data = g_object_get_data (G_OBJECT (file), NEW_NAME_TAG);
    if (data == NULL)
    {
        return;
    }

    /* Cancel both the rename and the timed wait. */
    nautilus_file_cancel (file, rename_callback, NULL);
    if (stop_timer)
    {
        eel_timed_wait_stop (cancel_rename_callback, file);
    }

    if (data->callback != NULL)
    {
        data->callback (file, NULL, error, data->callback_data);
    }

    /* Let go of file name. */
    g_object_set_data (G_OBJECT (file), NEW_NAME_TAG, NULL);
}

void
nautilus_rename_file (NautilusFile                  *file,
                      const char                    *new_name,
                      NautilusFileOperationCallback  callback,
                      gpointer                       callback_data)
{
    char *old_name, *wait_message;
    NautilusRenameData *data;
    char *uri;
    GError *error;

    g_return_if_fail (NAUTILUS_IS_FILE (file));
    g_return_if_fail (new_name != NULL);

    /* Stop any earlier rename that's already in progress. */
    error = g_error_new (G_IO_ERROR, G_IO_ERROR_CANCELLED, "Cancelled");
    finish_rename (file, TRUE, error);
    g_error_free (error);

    data = g_new0 (NautilusRenameData, 1);
    data->name = g_strdup (new_name);
    data->callback = callback;
    data->callback_data = callback_data;

    /* Attach the new name to the file. */
    g_object_set_data_full (G_OBJECT (file),
                            NEW_NAME_TAG,
                            data, (GDestroyNotify) nautilus_rename_data_free);

    /* Start the timed wait to cancel the rename. */
    old_name = nautilus_file_get_display_name (file);
    wait_message = g_strdup_printf (_("Renaming “%s” to “%s”."),
                                    old_name,
                                    new_name);
    g_free (old_name);
    eel_timed_wait_start (cancel_rename_callback, file, wait_message,
                          NULL);     /* FIXME bugzilla.gnome.org 42395: Parent this? */
    g_free (wait_message);

    uri = nautilus_file_get_uri (file);
    DEBUG ("Renaming file %s to %s", uri, new_name);
    g_free (uri);

    /* Start the rename. */
    nautilus_file_rename (file, new_name,
                          rename_callback, NULL);
}