medit/moo/mooedit/mooeditfileops.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4; coding: utf-8 -*-
 *
 *   mooeditfileops.c
 *
 *   Copyright (C) 2004-2005 by Yevgen Muntyan <muntyan@math.tamu.edu>
 *
 *   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.
 *
 *   See COPYING file that comes with this distribution.
 */

#define MOOEDIT_COMPILATION
#include "mooedit/mooedit-private.h"
#include "mooedit/mooeditfileops.h"
#include "mooedit/mooeditdialogs.h"
#include "mooutils/moofileutils.h"
#include "mooutils/moocompat.h"
#include <string.h>


static MooEditLoader *default_loader = NULL;
static MooEditSaver *default_saver = NULL;
static GSList *UNTITLED = NULL;
static GHashTable *UNTITLED_NO = NULL;


static gboolean moo_edit_load_default   (MooEditLoader  *loader,
                                         MooEdit        *edit,
                                         const char     *file,
                                         const char     *encoding,
                                         GError        **error);
static gboolean moo_edit_reload_default (MooEditLoader  *loader,
                                         MooEdit        *edit,
                                         GError        **error);
static gboolean moo_edit_save_default   (MooEditSaver   *saver,
                                         MooEdit        *edit,
                                         const char     *file,
                                         const char     *encoding,
                                         GError        **error);

static void     block_buffer_signals        (MooEdit        *edit);
static void     unblock_buffer_signals      (MooEdit        *edit);
static void     start_file_watch            (MooEdit        *edit);
static void     stop_file_watch             (MooEdit        *edit);
static gboolean file_watch_timeout_func     (MooEdit        *edit);
static gboolean focus_in_cb                 (MooEdit        *edit);
static gboolean check_file_status           (MooEdit        *edit,
                                             gboolean        in_focus_only);
static void     file_modified_on_disk       (MooEdit        *edit);
static void     file_deleted                (MooEdit        *edit);
static void     file_watch_error            (MooEdit        *edit);
static void     file_watch_access_denied    (MooEdit        *edit);
static void     add_status                  (MooEdit        *edit,
                                             MooEditStatus   s);


MooEditLoader   *moo_edit_loader_get_default    (void)
{
    if (!default_loader)
    {
        default_loader = g_new0 (MooEditLoader, 1);
        default_loader->ref_count = 1;
        default_loader->load = moo_edit_load_default;
        default_loader->reload = moo_edit_reload_default;
    }

    return default_loader;
}


MooEditSaver    *moo_edit_saver_get_default     (void)
{
    if (!default_saver)
    {
        default_saver = g_new0 (MooEditSaver, 1);
        default_saver->ref_count = 1;
        default_saver->save = moo_edit_save_default;
    }

    return default_saver;
}


MooEditLoader   *moo_edit_loader_ref            (MooEditLoader  *loader)
{
    g_return_val_if_fail (loader != NULL, NULL);
    loader->ref_count++;
    return loader;
}


MooEditSaver    *moo_edit_saver_ref             (MooEditSaver   *saver)
{
    g_return_val_if_fail (saver != NULL, NULL);
    saver->ref_count++;
    return saver;
}


void             moo_edit_loader_unref          (MooEditLoader  *loader)
{
    if (!loader || --loader->ref_count)
        return;

    g_free (loader);

    if (loader == default_loader)
        default_loader = NULL;
}


void             moo_edit_saver_unref           (MooEditSaver   *saver)
{
    if (!saver || --saver->ref_count)
        return;

    g_free (saver);

    if (saver == default_saver)
        default_saver = NULL;
}


gboolean         moo_edit_load              (MooEditLoader  *loader,
                                             MooEdit        *edit,
                                             const char     *filename,
                                             const char     *encoding,
                                             GError        **error)
{
    char *filename_copy, *encoding_copy;
    gboolean result;

    g_return_val_if_fail (loader != NULL, FALSE);
    g_return_val_if_fail (MOO_IS_EDIT (edit), FALSE);
    g_return_val_if_fail (filename != NULL, FALSE);

    filename_copy = g_strdup (filename);
    encoding_copy = g_strdup (encoding);

    result = loader->load (loader, edit, filename_copy, encoding_copy, error);

    g_free (filename_copy);
    g_free (encoding_copy);
    return result;
}


gboolean         moo_edit_reload            (MooEditLoader  *loader,
                                             MooEdit        *edit,
                                             GError        **error)
{
    g_return_val_if_fail (loader != NULL, FALSE);
    g_return_val_if_fail (MOO_IS_EDIT (edit), FALSE);

    return loader->reload (loader, edit, error);
}


gboolean         moo_edit_save              (MooEditSaver   *saver,
                                             MooEdit        *edit,
                                             const char     *filename,
                                             const char     *encoding,
                                             GError        **error)
{
    char *filename_copy, *encoding_copy;
    gboolean result;

    g_return_val_if_fail (saver != NULL, FALSE);
    g_return_val_if_fail (MOO_IS_EDIT (edit), FALSE);
    g_return_val_if_fail (filename != NULL, FALSE);

    filename_copy = g_strdup (filename);
    encoding_copy = g_strdup (encoding);

    result = saver->save (saver, edit, filename_copy, encoding_copy, error);

    g_free (filename_copy);
    g_free (encoding_copy);
    return result;
}


/***************************************************************************/
/* File loading
 */

static gboolean do_load                 (MooEdit        *edit,
                                         const char     *file,
                                         const char     *encoding,
                                         GError        **error);


static gboolean moo_edit_load_default   (G_GNUC_UNUSED MooEditLoader *loader,
                                         MooEdit        *edit,
                                         const char     *file,
                                         const char     *encoding,
                                         GError        **error)
{
    GtkTextIter start, end;
    GtkTextBuffer *buffer;
    MooEditFileInfo *info = NULL;
    gboolean undo;

    g_return_val_if_fail (MOO_IS_EDIT (edit), FALSE);
    g_return_val_if_fail (file && file[0], FALSE);

    block_buffer_signals (edit);

    if (moo_edit_is_empty (edit))
        undo = FALSE;
    else
        undo = TRUE;

    buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (edit));

    if (undo)
        gtk_text_buffer_begin_user_action (buffer);
    else
        gtk_source_buffer_begin_not_undoable_action (GTK_SOURCE_BUFFER (buffer));

    gtk_text_buffer_get_bounds (buffer, &start, &end);
    gtk_text_buffer_delete (buffer, &start, &end);

    if (!do_load (edit, file, encoding, error))
    {
        moo_edit_file_info_free (info);
        edit->priv->status = 0;
        stop_file_watch (edit);
        unblock_buffer_signals (edit);

        if (undo)
            gtk_text_buffer_end_user_action (buffer);
        else
            gtk_source_buffer_end_not_undoable_action (GTK_SOURCE_BUFFER (buffer));

        moo_edit_set_modified (edit, FALSE);
        return FALSE;
    }

    gtk_text_buffer_get_start_iter (buffer, &start);
    gtk_text_buffer_place_cursor (buffer, &start);

    unblock_buffer_signals (edit);
    edit->priv->status = 0;
    _moo_edit_set_filename (edit, file, encoding);
    moo_edit_set_modified (edit, FALSE);
    start_file_watch (edit);

    moo_edit_file_info_free (info);

    if (undo)
        gtk_text_buffer_end_user_action (buffer);
    else
        gtk_source_buffer_end_not_undoable_action (GTK_SOURCE_BUFFER (buffer));

    return TRUE;
}


static gboolean do_load                 (MooEdit        *edit,
                                         const char     *filename,
                                         const char     *encoding,
                                         GError        **error)
{
    GIOChannel *file = NULL;
    GIOStatus status;
    GtkTextBuffer *buffer;

    g_return_val_if_fail (filename != NULL, FALSE);

    buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (edit));

    if (!encoding || !strcmp (encoding, "UTF-8") || !strcmp (encoding, "UTF8"))
    {
        char *contents;
        gsize len;
        GMappedFile *mapped_file = g_mapped_file_new (filename, FALSE, error);

        if (mapped_file)
        {
            contents = g_mapped_file_get_contents (mapped_file);
            len = g_mapped_file_get_length (mapped_file);

            if (!g_utf8_validate (contents, len, NULL))
            {
                g_mapped_file_free (mapped_file);
                g_set_error (error, G_CONVERT_ERROR,
                             G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
                             "Invalid UTF8 data read from file");
                return FALSE;
            }

            gtk_text_buffer_insert_at_cursor (buffer, contents, len);
            g_free (edit->priv->encoding);
            edit->priv->encoding = NULL;

            g_mapped_file_free (mapped_file);
            return TRUE;
        }
        else
        {
            g_warning ("%s: could not create mapped file", G_STRLOC);
            g_warning ("%s: %s", G_STRLOC, (*error)->message);
            g_clear_error (error);
        }
    }

    file = g_io_channel_new_file (filename, "r", error);

    if (!file)
        return FALSE;

    if (!encoding)
        encoding = "UTF8";

    if (g_io_channel_set_encoding (file, encoding, error) != G_IO_STATUS_NORMAL)
    {
        g_io_channel_shutdown (file, TRUE, NULL);
        g_io_channel_unref (file);
        return FALSE;
    }

    while (TRUE)
    {
        char *line = NULL;
        gsize len;

        status = g_io_channel_read_line (file, &line, &len, NULL, error);

        if (line)
        {
            if (!g_utf8_validate (line, len, NULL))
            {
                g_io_channel_shutdown (file, TRUE, NULL);
                g_io_channel_unref (file);
                g_set_error (error, G_CONVERT_ERROR,
                             G_CONVERT_ERROR_ILLEGAL_SEQUENCE,
                             "Invalid UTF8 data read from file");
                g_free (line);
                return FALSE;
            }

            gtk_text_buffer_insert_at_cursor (buffer, line, len);
            g_free (line);
        }

        /* XXX */
        if (status != G_IO_STATUS_NORMAL)
        {
            if (status != G_IO_STATUS_EOF)
            {
                g_io_channel_shutdown (file, TRUE, NULL);
                g_io_channel_unref (file);
                return FALSE;
            }
            else
            {
                g_io_channel_shutdown (file, TRUE, NULL);
                g_io_channel_unref (file);
                break;
            }
        }
    }

    g_free (edit->priv->encoding);
    edit->priv->encoding = g_strdup (encoding);
    g_clear_error (error);
    return TRUE;
}


static gboolean moo_edit_reload_default (MooEditLoader  *loader,
                                         MooEdit        *edit,
                                         GError        **error)
{
    GtkTextIter start, end;
    GtkTextBuffer *buffer;

    g_return_val_if_fail (edit->priv->filename != NULL, FALSE);

    buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (edit));

    block_buffer_signals (edit);
    gtk_text_buffer_begin_user_action (buffer);

    gtk_text_buffer_get_bounds (buffer, &start, &end);
    gtk_text_buffer_delete (buffer, &start, &end);

    if (!moo_edit_load (loader, edit, edit->priv->filename,
                        edit->priv->encoding, error))
    {
        gtk_text_buffer_end_user_action (buffer);
        unblock_buffer_signals (edit);
        return FALSE;
    }
    else
    {
        gtk_text_buffer_end_user_action (buffer);
        edit->priv->status = 0;
        unblock_buffer_signals (edit);
        moo_edit_set_modified (edit, FALSE);
        start_file_watch (edit);
        g_clear_error (error);
        return TRUE;
    }
}


/***************************************************************************/
/* File saving
 */

/* XXX */
static const char *line_end[3] = {"\n", "\r\n", "\r"};
static guint line_end_len[3] = {1, 2, 1};

static gboolean do_write                (MooEdit        *edit,
                                         const char     *file,
                                         const char     *encoding,
                                         GError        **error);


static gboolean moo_edit_save_default   (G_GNUC_UNUSED MooEditSaver *saver,
                                         MooEdit        *edit,
                                         const char     *filename,
                                         const char     *encoding,
                                         GError        **error)
{
    g_return_val_if_fail (MOO_IS_EDIT (edit), FALSE);
    g_return_val_if_fail (filename && filename[0], FALSE);

    if (!do_write (edit, filename, encoding, error))
        return FALSE;

    edit->priv->status = 0;
    _moo_edit_set_filename (edit, filename, encoding);
    moo_edit_set_modified (edit, FALSE);
    start_file_watch (edit);

    return TRUE;
}


static gboolean do_write                (MooEdit        *edit,
                                         const char     *filename,
                                         const char     *encoding,
                                         GError        **error)
{
    GIOChannel *file;
    GIOStatus status;
    GtkTextIter line_start;
    const char *le = line_end[edit->priv->line_end_type];
    gssize le_len = line_end_len[edit->priv->line_end_type];
    GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (edit));

    g_return_val_if_fail (filename != NULL, FALSE);

    if (encoding && (!strcmp (encoding, "UTF-8") || !strcmp (encoding, "UTF8")))
        encoding = NULL;

    file = g_io_channel_new_file (filename, "w", error);

    if (!file)
        return FALSE;

    if (encoding && g_io_channel_set_encoding (file, encoding, error) != G_IO_STATUS_NORMAL)
    {
        g_io_channel_shutdown (file, TRUE, NULL);
        g_io_channel_unref (file);
        return FALSE;
    }

    gtk_text_buffer_get_start_iter (buffer, &line_start);

    do
    {
        gsize written;
        GtkTextIter line_end = line_start;
        gboolean write_line_end = FALSE;

        if (!gtk_text_iter_ends_line (&line_start))
        {
            char *line;
            gssize len = -1;

            gtk_text_iter_forward_to_line_end (&line_end);
            line = gtk_text_buffer_get_text (buffer, &line_start, &line_end, FALSE);

            status = g_io_channel_write_chars (file, line, len, &written, error);
            g_free (line);

            /* XXX */
            if (status != G_IO_STATUS_NORMAL)
            {
                g_io_channel_shutdown (file, TRUE, NULL);
                g_io_channel_unref (file);
                return FALSE;
            }
        }

        if (gtk_text_iter_ends_line (&line_start))
            write_line_end = !gtk_text_iter_is_end (&line_start);
        else
            write_line_end = !gtk_text_iter_is_end (&line_end);

        if (write_line_end)
        {
            status = g_io_channel_write_chars (file, le, le_len, &written, error);

            if (written < (gsize)le_len || status != G_IO_STATUS_NORMAL)
            {
                g_io_channel_shutdown (file, TRUE, NULL);
                g_io_channel_unref (file);
                return FALSE;
            }
        }
    }
    while (gtk_text_iter_forward_line (&line_start));

    status = g_io_channel_shutdown (file, TRUE, error);

    if (status != G_IO_STATUS_NORMAL)
    {
        g_io_channel_unref (file);
        return FALSE;
    }

    g_io_channel_unref (file);
    g_clear_error (error);
    return TRUE;
}


/***************************************************************************/
/* Aux stuff
 */

static void     block_buffer_signals        (MooEdit        *edit)
{
    MooTextView *view = MOO_TEXT_VIEW (edit);
    GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (edit));
    g_signal_handler_block (buffer, view->priv->can_undo_handler_id);
    g_signal_handler_block (buffer, view->priv->can_redo_handler_id);
    g_signal_handler_block (buffer, edit->priv->modified_changed_handler_id);
}


static void     unblock_buffer_signals      (MooEdit        *edit)
{
    MooTextView *view = MOO_TEXT_VIEW (edit);
    GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (edit));
    g_signal_handler_unblock (buffer, view->priv->can_undo_handler_id);
    g_signal_handler_unblock (buffer, view->priv->can_redo_handler_id);
    g_signal_handler_unblock (buffer, edit->priv->modified_changed_handler_id);
}


/* XXX use MooFileWatch */
static void     start_file_watch            (MooEdit        *edit)
{
    GTime timestamp;

    if (edit->priv->file_watch_id)
        g_source_remove (edit->priv->file_watch_id);
    edit->priv->file_watch_id = 0;

    g_return_if_fail ((edit->priv->status & MOO_EDIT_CHANGED_ON_DISK) == 0);
    g_return_if_fail (edit->priv->filename != NULL);

    timestamp = moo_get_file_mtime (edit->priv->filename);
    g_return_if_fail (timestamp > 0); /* TODO TODO */
    edit->priv->timestamp = timestamp;

    if (edit->priv->file_watch_timeout)
        edit->priv->file_watch_id =
                g_timeout_add (edit->priv->file_watch_timeout,
                               (GSourceFunc) file_watch_timeout_func,
                               edit);
    if (!edit->priv->focus_in_handler_id)
        edit->priv->focus_in_handler_id =
                g_signal_connect (edit, "focus-in-event",
                                  G_CALLBACK (focus_in_cb),
                                  NULL);
}


static void     stop_file_watch             (MooEdit        *edit)
{
    if (edit->priv->file_watch_id)
        g_source_remove (edit->priv->file_watch_id);

    edit->priv->file_watch_id = 0;

    if (edit->priv->focus_in_handler_id)
    {
        g_signal_handler_disconnect (edit, edit->priv->focus_in_handler_id);
        edit->priv->focus_in_handler_id = 0;
    }
}


static gboolean file_watch_timeout_func     (MooEdit        *edit)
{
    return check_file_status (edit, TRUE);
}


static gboolean focus_in_cb                 (MooEdit        *edit)
{
    check_file_status (edit, TRUE);
    return FALSE;
}


static gboolean check_file_status           (MooEdit        *edit,
                                             gboolean        in_focus_only)
{
    GTime stamp;

    if (in_focus_only && !GTK_WIDGET_HAS_FOCUS (edit))
        return TRUE;

    g_return_val_if_fail (edit->priv->filename != NULL, FALSE);

    g_return_val_if_fail (!(edit->priv->status & MOO_EDIT_CHANGED_ON_DISK), FALSE);
    g_return_val_if_fail (edit->priv->timestamp > 0, FALSE);
    g_return_val_if_fail (edit->priv->filename != NULL, FALSE);

    stamp = moo_get_file_mtime (edit->priv->filename);

    if (stamp < 0)
    {
        switch (stamp)
        {
            case MOO_EACCESS:
                file_watch_access_denied (edit);
                return FALSE;

            case MOO_ENOENT:
                file_deleted (edit);
                return FALSE;

            case MOO_EIO:
            default:
                g_critical ("%s: error in moo_get_file_mtime", G_STRLOC);
                file_watch_error (edit);
                return FALSE;
        }
    }

    if (stamp == edit->priv->timestamp)
        return TRUE;

    if (stamp < edit->priv->timestamp)
    {
        g_warning ("%s: mtime of file on disk is less than timestamp", G_STRLOC);
        file_watch_error (edit);
        return FALSE;
    }

    file_modified_on_disk (edit);
    return FALSE;
}


static void     file_modified_on_disk       (MooEdit        *edit)
{
    g_return_if_fail (edit->priv->filename != NULL);
    stop_file_watch (edit);
    add_status (edit, MOO_EDIT_MODIFIED_ON_DISK);
}


static void     file_deleted                (MooEdit        *edit)
{
    g_return_if_fail (edit->priv->filename != NULL);
    stop_file_watch (edit);
    add_status (edit, MOO_EDIT_DELETED);
}


static void     file_watch_error            (MooEdit        *edit)
{
    g_critical ("%s", G_STRLOC);
    stop_file_watch (edit);
    add_status (edit, MOO_EDIT_DELETED);
}


static void     file_watch_access_denied    (MooEdit        *edit)
{
    g_critical ("%s", G_STRLOC);
    stop_file_watch (edit);
    /* XXX */
    add_status (edit, MOO_EDIT_DELETED);
}


static void     add_status                  (MooEdit        *edit,
                                             MooEditStatus   s)
{
    edit->priv->status |= s;
    g_signal_emit_by_name (edit, "doc-status-changed", NULL);
}


static void remove_untitled             (gpointer    destroyed,
                                         MooEdit    *edit)
{
    gpointer n = g_hash_table_lookup (UNTITLED_NO, edit);

    if (n)
    {
        UNTITLED = g_slist_remove (UNTITLED, n);
        g_hash_table_remove (UNTITLED_NO, edit);
        if (!destroyed)
            g_object_weak_unref (G_OBJECT (edit),
                                 (GWeakNotify) remove_untitled,
                                 GINT_TO_POINTER (TRUE));
    }
}


static int  add_untitled                (MooEdit    *edit)
{
    int n;

    if (!(n = GPOINTER_TO_INT (g_hash_table_lookup (UNTITLED_NO, edit))))
    {
        for (n = 1; ; ++n)
        {
            if (!g_slist_find (UNTITLED, GINT_TO_POINTER (n)))
            {
                UNTITLED = g_slist_prepend (UNTITLED, GINT_TO_POINTER (n));
                break;
            }
        }

        g_hash_table_insert (UNTITLED_NO, edit, GINT_TO_POINTER (n));
        g_object_weak_ref (G_OBJECT (edit),
                           (GWeakNotify) remove_untitled,
                           GINT_TO_POINTER (TRUE));
    }

    return n;
}


void        _moo_edit_set_filename      (MooEdit    *edit,
                                         const char *file,
                                         const char *encoding)
{
    MooEditLang *lang;

    g_free (edit->priv->filename);
    g_free (edit->priv->basename);
    g_free (edit->priv->display_filename);
    g_free (edit->priv->display_basename);

    if (!UNTITLED_NO)
        UNTITLED_NO = g_hash_table_new (g_direct_hash, g_direct_equal);

    if (!file)
    {
        int n = add_untitled (edit);

        edit->priv->filename = NULL;
        edit->priv->basename = NULL;

        if (n == 1)
            edit->priv->display_filename = g_strdup ("Untitled");
        else
            edit->priv->display_filename = g_strdup_printf ("Untitled %d", n);

        edit->priv->display_basename = g_strdup (edit->priv->display_filename);
    }
    else
    {
        remove_untitled (NULL, edit);

        edit->priv->filename = g_strdup (file);
        edit->priv->basename = g_path_get_basename (file);

        edit->priv->display_filename =
                _moo_edit_filename_to_utf8 (file);
        edit->priv->display_basename =
                _moo_edit_filename_to_utf8 (edit->priv->basename);
    }

    if (!edit->priv->lang_custom)
    {
        if (file)
            lang = moo_edit_lang_mgr_get_language_for_file (_moo_edit_get_lang_mgr (edit), file);
        else
            lang = moo_edit_lang_mgr_get_default_language (_moo_edit_get_lang_mgr (edit));
        moo_edit_set_lang (edit, lang);
    }

    g_free (edit->priv->encoding);
    edit->priv->encoding = g_strdup (encoding);

    _moo_edit_choose_indenter (edit);

    g_signal_emit_by_name (edit, "filename-changed", edit->priv->filename, NULL);
    g_signal_emit_by_name (edit, "doc-status-changed", NULL);
}


char       *_moo_edit_filename_to_utf8      (const char         *filename)
{
    GError *err = NULL;
    char *utf_filename;

    g_return_val_if_fail (filename != NULL, NULL);

    utf_filename = g_filename_to_utf8 (filename, -1, NULL, NULL, &err);

    if (!utf_filename)
    {
        g_critical ("%s: could not convert filename to utf8", G_STRLOC);

        if (err)
        {
            g_critical ("%s: %s", G_STRLOC, err->message);
            g_error_free (err);
            err = NULL;
        }

        utf_filename = g_strdup ("<Unknown>");
    }

    return utf_filename;
}