medit/moo/mooedit/mooeditor.cpp

/*
 *   mooeditor.cpp
 *
 *   Copyright (C) 2004-2016 by Yevgen Muntyan <emuntyan@users.sourceforge.net>
 *   Copyright (C) 2014 by Ulrich Eckhardt <ulrich.eckhardt@base-42.de>
 *
 *   This file is part of medit.  medit is free software; you can
 *   redistribute it and/or modify it under the terms of the
 *   GNU Lesser General Public License as published by the
 *   Free Software Foundation; either version 2.1 of the License,
 *   or (at your option) any later version.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with medit.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * class:MooEditor: (parent GObject): editor object
 **/

#include "mooedit/mooeditor-private.h"
#include "mooedit/mooeditwindow-impl.h"
#include "mooedit/mooeditdialogs.h"
#include "mooedit/mooedit-fileops.h"
#include "mooedit/mooplugin.h"
#include "mooedit/mooeditprefs.h"
#include "mooedit/mooedit-impl.h"
#include "mooedit/mooeditview-impl.h"
#include "mooedit/mooedit-accels.h"
#include "mooedit/mooeditfiltersettings.h"
#include "mooedit/mooeditfileinfo-impl.h"
#include "mooedit/mooedithistoryitem.h"
#include "mooedit/mooedit-ui.h"
#include "mooedit/medit-ui.h"
#include "moocpp/moocpp.h"
#include "moocpp/gutil.h"
#include "mooutils/moomenuaction.h"
#include "marshals.h"
#include "mooutils/mooutils-misc.h"
#include "mooutils/mooaction-private.h"
#include "mooutils/mooutils-gobject.h"
#include "mooutils/mooutils-enums.h"
#include "mooutils/mooutils-fs.h"
#include "mooutils/moostock.h"
#include "mooutils/mooi18n.h"
#include "mooutils/mooencodings.h"
#include "mooutils/moolist.h"
#include "mooutils/moofilewatch.h"
#include <mooglib/moo-glib.h>
#include <string.h>
#include <stdlib.h>

using namespace moo;

#define RECENT_ACTION_ID "OpenRecent"
#define RECENT_DIALOG_ACTION_ID "OpenRecentDialog"

#define CURRENT_SESSION_VERSION "2.0"

MOO_DEFINE_QUARK (moo-edit-reload-error, moo_edit_reload_error_quark)
MOO_DEFINE_QUARK (moo-edit-save-error, moo_edit_save_error_quark)

static MooEditor* editor_instance = NULL;

static void          set_single_window          (MooEditor      *editor,
                                                 gboolean        single);

static GtkAction    *create_open_recent_action  (MooWindow      *window,
                                                 gpointer        user_data);
static void          action_recent_dialog       (MooEditWindow  *window);

static MooEditWindow *create_window             (MooEditor      *editor);
static MooSaveResponse moo_editor_before_save   (MooEditor    *editor,
                                                 MooEdit        *doc,
                                                 GFile          *file);
static void          moo_editor_will_save       (MooEditor    *editor,
                                                 MooEdit        *doc,
                                                 GFile          *file);
static MooCloseResponse moo_editor_before_close_window
                                                (MooEditor      *editor,
                                                 MooEditWindow  *window);
static void          do_close_window            (MooEditor      *editor,
                                                 MooEditWindow  *window);
static void          do_close_doc               (MooEditor      *editor,
                                                 MooEdit        *doc);
static gboolean      close_docs_real            (MooEditor      *editor,
                                                 MooEditArray   *docs);
static MooEditArray *find_modified              (MooEditArray   *docs);

static void          add_new_window_action      (void);
static void          remove_new_window_action   (void);

static GObject      *moo_editor_constructor     (GType           type,
                                                 guint           n_props,
                                                 GObjectConstructParam *props);
static void          moo_editor_finalize        (GObject        *object);
static void          moo_editor_set_property    (GObject        *object,
                                                 guint           prop_id,
                                                 const GValue   *value,
                                                 GParamSpec     *pspec);
static void          moo_editor_get_property    (GObject        *object,
                                                 guint           prop_id,
                                                 GValue         *value,
                                                 GParamSpec     *pspec);


enum {
    PROP_0,
    PROP_OPEN_SINGLE_FILE_INSTANCE,
    PROP_ALLOW_EMPTY_WINDOW,
    PROP_SINGLE_WINDOW,
    PROP_SAVE_BACKUPS,
    PROP_STRIP_WHITESPACE,
};

enum {
    BEFORE_CLOSE_WINDOW,
    WILL_CLOSE_WINDOW,
    AFTER_CLOSE_WINDOW,
    WILL_CLOSE_DOC,
    BEFORE_SAVE,
    WILL_SAVE,
    AFTER_SAVE,
    LAST_SIGNAL
};

static guint signals[LAST_SIGNAL];


/* MOO_TYPE_EDITOR */
G_DEFINE_TYPE (MooEditor, moo_editor, G_TYPE_OBJECT)


inline static gboolean test_flag(MooEditor *editor, MooEditorOptions flag)
{
    return (editor->priv->opts & flag) != MOO_EDITOR_OPTIONS_NONE;
}

inline static void set_flag(MooEditor *editor, MooEditorOptions flag, gboolean set_or_not)
{
    if (set_or_not)
        editor->priv->opts |= flag;
    else
        editor->priv->opts &= ~flag;
}

static void
moo_editor_class_init (MooEditorClass *klass)
{
    GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
    MooWindowClass *edit_window_class;

    gobject_class->constructor = moo_editor_constructor;
    gobject_class->finalize = moo_editor_finalize;
    gobject_class->set_property = moo_editor_set_property;
    gobject_class->get_property = moo_editor_get_property;

    klass->before_close_window = moo_editor_before_close_window;
    klass->before_save = moo_editor_before_save;
    klass->will_save = moo_editor_will_save;

    _moo_edit_init_config ();
    g_type_class_unref (g_type_class_ref (MOO_TYPE_EDIT));
    g_type_class_unref (g_type_class_ref (MOO_TYPE_EDIT_WINDOW));
    g_type_class_unref (g_type_class_ref (MOO_TYPE_INDENTER));

    g_type_class_add_private (klass, sizeof (MooEditorPrivate));

    g_object_class_install_property (gobject_class, PROP_OPEN_SINGLE_FILE_INSTANCE,
        g_param_spec_boolean ("open-single-file-instance", "open-single-file-instance", "open-single-file-instance",
                              TRUE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT)));

    g_object_class_install_property (gobject_class, PROP_ALLOW_EMPTY_WINDOW,
        g_param_spec_boolean ("allow-empty-window", "allow-empty-window", "allow-empty-window",
                              FALSE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT)));

    g_object_class_install_property (gobject_class, PROP_SINGLE_WINDOW,
        g_param_spec_boolean ("single-window", "single-window", "single-window",
                              FALSE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT)));

    g_object_class_install_property (gobject_class, PROP_SAVE_BACKUPS,
        g_param_spec_boolean ("save-backups", "save-backups", "save-backups",
                              FALSE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT)));

    g_object_class_install_property (gobject_class, PROP_STRIP_WHITESPACE,
        g_param_spec_boolean ("strip-whitespace", "strip-whitespace", "strip-whitespace",
                              FALSE, (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT)));

    signals[BEFORE_CLOSE_WINDOW] =
            g_signal_new ("before-close-window",
                          G_OBJECT_CLASS_TYPE (klass),
                          G_SIGNAL_RUN_LAST,
                          G_STRUCT_OFFSET (MooEditorClass, before_close_window),
                          moo_signal_accumulator_continue_cancel,
                          GINT_TO_POINTER (MOO_CLOSE_RESPONSE_CONTINUE),
                          _moo_marshal_ENUM__OBJECT,
                          MOO_TYPE_CLOSE_RESPONSE, 1,
                          MOO_TYPE_EDIT_WINDOW);

    /**
     * MooEditor::will-close-window:
     *
     * @editor: the object which received the signal
     * @window: the window which is about to be closed
     *
     * This signal is emitted before the window is closed.
     **/
    signals[WILL_CLOSE_WINDOW] =
            g_signal_new ("will-close-window",
                          G_OBJECT_CLASS_TYPE (klass),
                          G_SIGNAL_RUN_LAST,
                          G_STRUCT_OFFSET (MooEditorClass, will_close_window),
                          NULL, NULL,
                          _moo_marshal_VOID__OBJECT,
                          G_TYPE_NONE, 1,
                          MOO_TYPE_EDIT_WINDOW);

    signals[AFTER_CLOSE_WINDOW] =
            g_signal_new ("after-close-window",
                          G_OBJECT_CLASS_TYPE (klass),
                          G_SIGNAL_RUN_LAST,
                          G_STRUCT_OFFSET (MooEditorClass, after_close_window),
                          NULL, NULL,
                          _moo_marshal_VOID__VOID,
                          G_TYPE_NONE, 0);

    /**
     * MooEditor::will-close-doc:
     *
     * @editor: the object which received the signal
     * @doc: the document which is about to be closed
     *
     * This signal is emitted before the document is closed.
     **/
    signals[WILL_CLOSE_DOC] =
            g_signal_new ("will-close-doc",
                          G_OBJECT_CLASS_TYPE (klass),
                          G_SIGNAL_RUN_LAST,
                          G_STRUCT_OFFSET (MooEditorClass, will_close_doc),
                          NULL, NULL,
                          _moo_marshal_VOID__OBJECT,
                          G_TYPE_NONE, 1,
                          MOO_TYPE_EDIT);

    /**
     * MooEditor::before-save:
     *
     * @editor: the object which received the signal
     * @doc: the document which is about to be saved on disk
     * @file: the #GFile object which represents saved file
     *
     * This signal is emitted when the document is going to be saved on disk.
     * Callbacks must return #MOO_SAVE_RESPONSE_CANCEL if document
     * should not be saved, and #MOO_SAVE_RESPONSE_CONTINUE otherwise.
     *
     * For example, if before saving the file must be checked out from a version
     * control system, a callback can do that and return #MOO_SAVE_RESPONSE_CANCEL
     * if checkout failed.
     *
     * Callbacks must not modify document content. If you need to modify
     * it before saving, use MooEditor::will-save signal instead.
     *
     * Returns: #MOO_SAVE_RESPONSE_CANCEL to cancel saving,
     * #MOO_SAVE_RESPONSE_CONTINUE otherwise.
     **/
    signals[BEFORE_SAVE] =
            g_signal_new ("before-save",
                          G_OBJECT_CLASS_TYPE (klass),
                          G_SIGNAL_RUN_LAST,
                          G_STRUCT_OFFSET (MooEditorClass, before_save),
                          moo_signal_accumulator_continue_cancel,
                          GINT_TO_POINTER (MOO_SAVE_RESPONSE_CONTINUE),
                          _moo_marshal_ENUM__OBJECT_OBJECT,
                          MOO_TYPE_SAVE_RESPONSE, 2,
                          MOO_TYPE_EDIT,
                          G_TYPE_FILE);

    /**
     * MooEditor::will-save:
     *
     * @editor: the object which received the signal
     * @doc: the document which is about to be saved on disk
     * @file: the #GFile object which represents saved file
     *
     * This signal is emitted when the document is going to be saved on disk,
     * after MooEditor::before-save signal. Callbacks may modify document
     * content at this point.
     **/
    signals[WILL_SAVE] =
            g_signal_new ("will-save",
                          G_OBJECT_CLASS_TYPE (klass),
                          G_SIGNAL_RUN_LAST,
                          G_STRUCT_OFFSET (MooEditorClass, will_save),
                          NULL, NULL,
                          _moo_marshal_VOID__OBJECT_OBJECT,
                          G_TYPE_NONE, 2,
                          MOO_TYPE_EDIT,
                          G_TYPE_FILE);

    /**
     * MooEditor::after-save:
     *
     * @editor: the object which received the signal
     * @doc: the document which was saved on disk
     *
     * This signal is emitted after the document has been successfully saved on disk.
     **/
    signals[AFTER_SAVE] =
            g_signal_new ("after-save",
                          G_OBJECT_CLASS_TYPE (klass),
                          G_SIGNAL_RUN_LAST,
                          G_STRUCT_OFFSET (MooEditorClass, after_save),
                          NULL, NULL,
                          _moo_marshal_VOID__OBJECT,
                          G_TYPE_NONE, 1,
                          MOO_TYPE_EDIT);

    edit_window_class = MOO_WINDOW_CLASS (g_type_class_ref (MOO_TYPE_EDIT_WINDOW));
    moo_window_class_new_action_custom (edit_window_class, RECENT_ACTION_ID, NULL,
                                        create_open_recent_action,
                                        NULL, NULL);
    moo_window_class_new_action (edit_window_class, RECENT_DIALOG_ACTION_ID, NULL,
                                 "display-name", _("Open Recent Files Dialog"),
                                 /* Translators: remove the part before and including | */
                                 "label", Q_("Open Recent|_More..."),
                                 "default-accel", MOO_EDIT_ACCEL_OPEN_RECENT_DIALOG,
                                 "closure-callback", action_recent_dialog,
                                 NULL);
    g_type_class_unref (edit_window_class);

    add_new_window_action ();
}

MooEditorPrivate::MooEditorPrivate()
{
    // zero-initialized when allocated with the GObject
}

MooEditorPrivate::~MooEditorPrivate()
{
    if (file_watch)
    {
        GError *error = NULL;

        if (!file_watch->close (&error))
        {
            g_warning ("error in moo_file_watch_close: %s", moo_error_message (error));
            g_error_free (error);
            error = NULL;
        }

        file_watch.reset();
    }

    if (!windows.empty())
        g_critical ("finalizing editor while some windows are open");
}


static void
moo_editor_init (MooEditor *editor)
{
    init_cpp_private(editor, editor->priv, MOO_TYPE_EDITOR);
}

static GObject *
moo_editor_constructor (GType                  type,
                        guint                  n_props,
                        GObjectConstructParam *props)
{
    MooEditor *editor;
    GObject *object;

    object = G_OBJECT_CLASS (moo_editor_parent_class)->constructor (type, n_props, props);
    editor = MOO_EDITOR (object);

    _moo_stock_init ();

    editor->priv->doc_ui_xml.set_new(moo_ui_xml_new());
    moo_ui_xml_add_ui_from_string (editor->priv->doc_ui_xml.gobj(),
                                   mooedit_ui_xml, -1);

    editor->priv->lang_mgr.ref(moo_lang_mgr_default());
    g_signal_connect_swapped (editor->priv->lang_mgr.gobj(), "loaded",
                              G_CALLBACK (_moo_editor_apply_prefs),
                              editor);

    editor->priv->history.set_new(MOO_HISTORY_MGR (
        g_object_new (MOO_TYPE_HISTORY_MGR,
                        "name", "Editor",
                        (const char*) NULL)));

    _moo_edit_filter_settings_load ();
    _moo_editor_apply_prefs (editor);

    return object;
}


static void
moo_editor_set_property (GObject        *object,
                         guint           prop_id,
                         const GValue   *value,
                         GParamSpec     *pspec)
{
    MooEditor *editor = MOO_EDITOR (object);

    switch (prop_id) {
        case PROP_OPEN_SINGLE_FILE_INSTANCE:
            set_flag (editor, OPEN_SINGLE, g_value_get_boolean (value));
            break;

        case PROP_ALLOW_EMPTY_WINDOW:
            set_flag (editor, ALLOW_EMPTY_WINDOW, g_value_get_boolean (value));
            break;

        case PROP_SINGLE_WINDOW:
            set_single_window (editor, g_value_get_boolean (value));
            break;

        case PROP_SAVE_BACKUPS:
            set_flag (editor, SAVE_BACKUPS, g_value_get_boolean (value));
            break;

        case PROP_STRIP_WHITESPACE:
            set_flag (editor, STRIP_WHITESPACE, g_value_get_boolean (value));
            break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
            break;
    }
}


static void
moo_editor_get_property (GObject        *object,
                         guint           prop_id,
                         GValue         *value,
                         GParamSpec     *pspec)
{
    MooEditor *editor = MOO_EDITOR (object);

    switch (prop_id) {
        case PROP_OPEN_SINGLE_FILE_INSTANCE:
            g_value_set_boolean (value, test_flag (editor, OPEN_SINGLE));
            break;

        case PROP_ALLOW_EMPTY_WINDOW:
            g_value_set_boolean (value, test_flag (editor, ALLOW_EMPTY_WINDOW));
            break;

        case PROP_SINGLE_WINDOW:
            g_value_set_boolean (value, test_flag (editor, SINGLE_WINDOW));
            break;

        case PROP_SAVE_BACKUPS:
            g_value_set_boolean (value, test_flag (editor, SAVE_BACKUPS));
            break;

        case PROP_STRIP_WHITESPACE:
            g_value_set_boolean (value, test_flag (editor, STRIP_WHITESPACE));
            break;

        default:
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
            break;
    }
}


static void
moo_editor_finalize (GObject *object)
{
    MooEditor *editor = MOO_EDITOR (object);

    if (editor_instance == editor)
        editor_instance = NULL;

    finalize_cpp_private(editor, editor->priv);

    G_OBJECT_CLASS (moo_editor_parent_class)->finalize (object);
}


MooFileWatch *
_moo_editor_get_file_watch (MooEditor *editor)
{
    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);

    if (!editor->priv->file_watch)
        editor->priv->file_watch = MooFileWatch::create(nullptr);

    return editor->priv->file_watch.gobj();
}


/**
 * moo_editor_create_instance: (static-method-of MooEditor) (moo.lua 0)
 *
 * Returns: (transfer full)
 */
MooEditor *
moo_editor_create_instance ()
{
    if (!editor_instance)
    {
        editor_instance = MOO_EDITOR (g_object_new (MOO_TYPE_EDITOR,
                                                    (const char*) NULL));
        g_object_add_weak_pointer (G_OBJECT (editor_instance), reinterpret_cast<gpointer*> (&editor_instance));
    }
    else
    {
        g_object_ref (editor_instance);
    }

    return editor_instance;
}


/**
 * moo_editor_instance: (static-method-of MooEditor)
 **/
MooEditor *
moo_editor_instance (void)
{
    return editor_instance;
}


static GType
get_window_type (MooEditor *editor)
{
    return editor->priv->window_type ?
            editor->priv->window_type : MOO_TYPE_EDIT_WINDOW;
}


static GType
get_doc_type (MooEditor *editor)
{
    return editor->priv->doc_type ?
            editor->priv->doc_type : MOO_TYPE_EDIT;
}


static void
set_single_window (MooEditor      *editor,
                   gboolean        single)
{
    /* XXX move documents to some window if several windows open? */
    set_flag (editor, SINGLE_WINDOW, single);

    if (single)
        remove_new_window_action ();
    else
        add_new_window_action ();

    g_object_notify (G_OBJECT (editor), "single-window");
}


static void
add_new_window_action (void)
{
    MooWindowClass *klass;

    klass = MOO_WINDOW_CLASS (g_type_class_peek (MOO_TYPE_EDIT_WINDOW));

    if (!moo_window_class_find_action (klass, "NewWindow"))
        moo_window_class_new_action (klass, "NewWindow", NULL,
                                     "display-name", MOO_STOCK_NEW_WINDOW,
                                     "label", MOO_STOCK_NEW_WINDOW,
                                     "tooltip", _("Open new editor window"),
                                     "stock-id", MOO_STOCK_NEW_WINDOW,
                                     "default-accel", MOO_EDIT_ACCEL_NEW_WINDOW,
                                     "closure-callback", moo_editor_new_window,
                                     "closure-proxy-func", moo_edit_window_get_editor,
                                     NULL);
}


static void
remove_new_window_action (void)
{
    MooWindowClass *klass;
    klass = MOO_WINDOW_CLASS (g_type_class_peek (MOO_TYPE_EDIT_WINDOW));
    moo_window_class_remove_action (klass, "NewWindow");
}


static MooEditWindow *
get_top_window (MooEditor *editor)
{
    GtkWindow *window;

    if (editor->priv->windows.empty())
        return NULL;

    GSList *window_list = nullptr;
    for (const auto& w: editor->priv->windows)
        window_list = g_slist_prepend (window_list, w);
    window_list = g_slist_reverse (window_list);

    window = _moo_get_top_window (window_list);

    if (!window)
        window = GTK_WINDOW (editor->priv->windows[0]);

    g_slist_free (window_list);

    return MOO_EDIT_WINDOW (window);
}


/**
 * moo_editor_get_ui_xml: (moo.private 1)
 */
MooUiXml *
moo_editor_get_ui_xml (MooEditor *editor)
{
    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);

    if (!editor->priv->ui_xml)
    {
        editor->priv->ui_xml.set_new(moo_ui_xml_new ());
        moo_ui_xml_add_ui_from_string (editor->priv->ui_xml.gobj(), medit_ui_xml, -1);
    }

    return editor->priv->ui_xml.gobj();
}


/**
 * moo_editor_get_doc_ui_xml: (moo.private 1)
 */
MooUiXml *
moo_editor_get_doc_ui_xml (MooEditor *editor)
{
    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
    return editor->priv->doc_ui_xml.gobj();
}


/**
 * moo_editor_set_ui_xml: (moo.private 1)
 */
void
moo_editor_set_ui_xml (MooEditor      *editor,
                       MooUiXml       *xml)
{
    g_return_if_fail (MOO_IS_EDITOR (editor));
    g_return_if_fail (MOO_IS_UI_XML (xml));

    if (editor->priv->ui_xml == xml)
        return;

    editor->priv->ui_xml.ref(xml);

    for (const auto& window: editor->priv->windows)
        moo_window_set_ui_xml (MOO_WINDOW (window), editor->priv->ui_xml.gobj());
}


MooHistoryMgr *
_moo_editor_get_history_mgr (MooEditor *editor)
{
    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
    return editor->priv->history.gobj();
}

// static void
// add_recent_uri (MooEditor  *editor,
//                 const char *uri)
// {
//     moo_history_mgr_add_uri (editor->priv->history, uri);
// }

static void
recent_item_activated (GSList   *items,
                       gpointer  data)
{
    MooEditWindow *window = MOO_EDIT_WINDOW (data);
    MooEditor *editor = moo_editor_instance ();

    g_return_if_fail (MOO_IS_EDIT_WINDOW (window));
    g_return_if_fail (MOO_IS_EDITOR (editor));

    while (items)
    {
        const char *encoding;
        const char *uri;
        char *filename;
        MooHistoryItem *item = static_cast<MooHistoryItem*>(items->data);

        uri = moo_history_item_get_uri (item);
        filename = g_filename_from_uri (uri, NULL, NULL);
        g_return_if_fail (filename != NULL);

        encoding = _moo_edit_history_item_get_encoding (item);
        if (!moo_editor_open_uri (editor, uri, encoding, -1, window))
            moo_history_mgr_remove_uri (editor->priv->history.gobj(), uri);

        g_free (filename);

        items = items->next;
    }
}

static GtkWidget *
create_recent_menu (GtkAction *action)
{
    GtkWidget *menu, *item;
    GtkAction *action_more;
    MooWindow *window;
    MooEditor *editor;

    window = MOO_WINDOW (_moo_action_get_window (action));
    g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), NULL);

    editor = moo_editor_instance ();
    menu = moo_history_mgr_create_menu (editor->priv->history.gobj(),
                                        recent_item_activated,
                                        window, NULL);
    moo_bind_bool_property (action,
                            "sensitive", editor->priv->history.gobj(),
                            "empty", TRUE);

    item = gtk_separator_menu_item_new ();
    gtk_widget_show (item);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

    action_more = moo_window_get_action (window, RECENT_DIALOG_ACTION_ID);
    item = gtk_action_create_menu_item (action_more);
    gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

    item = gtk_menu_item_new ();
    gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu);

    return item;
}

static GtkAction *
create_open_recent_action (G_GNUC_UNUSED MooWindow *window,
                           G_GNUC_UNUSED gpointer   user_data)
{
    GtkAction *action;

    action = moo_menu_action_new ("OpenRecent", _("Open Recent"));
    moo_menu_action_set_func (MOO_MENU_ACTION (action), create_recent_menu);

    return action;
}

static void
action_recent_dialog (MooEditWindow *window)
{
    GtkWidget *dialog;
    MooEditor *editor;

    editor = moo_editor_instance ();
    g_return_if_fail (MOO_IS_EDITOR (editor));

    dialog = moo_history_mgr_create_dialog (editor->priv->history.gobj(),
                                            recent_item_activated,
                                            window, NULL);
    gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (window));
    _moo_window_set_remember_size (GTK_WINDOW (dialog),
                                   moo_edit_setting (MOO_EDIT_PREFS_DIALOGS "/recent-files"),
                                   400, 350,
                                   FALSE);

    gtk_dialog_run (GTK_DIALOG (dialog));
    gtk_widget_destroy (dialog);
}


/*****************************************************************************/

static MooEditWindow *
create_window (MooEditor *editor)
{
    MooEditWindow *window = MOO_EDIT_WINDOW (
        g_object_new (get_window_type (editor),
                      "editor", editor,
                      "ui-xml", moo_editor_get_ui_xml (editor),
                      (const char*) NULL));

    editor->priv->windows.emplace_back(window);
    _moo_window_attach_plugins (window);
    gtk_widget_show (GTK_WIDGET (window));
    return window;
}


/**
 * moo_editor_new_window:
 */
MooEditWindow *
moo_editor_new_window (MooEditor *editor)
{
    MooEditWindow *window;
    MooEdit *doc;

    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);

    window = create_window (editor);

    if (!test_flag (editor, ALLOW_EMPTY_WINDOW))
    {
        doc = MOO_EDIT (g_object_new (get_doc_type (editor), "editor", editor, (const char*) NULL));
        _moo_edit_window_insert_doc (window, doc, NULL);
        g_object_unref (doc);
    }

    return window;
}


/**
 * moo_editor_new_doc:
 *
 * @editor:
 * @window: (allow-none) (default NULL)
 */
MooEdit *
moo_editor_new_doc (MooEditor      *editor,
                    MooEditWindow  *window)
{
    MooEdit *doc;

    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
    g_return_val_if_fail (!window || MOO_IS_EDIT_WINDOW (window), NULL);

    if (!window)
        window = get_top_window (editor);

    if (!window)
        window = moo_editor_new_window (editor);

    g_return_val_if_fail (window != NULL, NULL);

    doc = MOO_EDIT (g_object_new (get_doc_type (editor), "editor", editor, (const char*) NULL));
    _moo_edit_window_insert_doc (window, doc, NULL);
    g_object_unref (doc);

    if (moo_prefs_get_bool (moo_edit_setting (MOO_EDIT_PREFS_AUTO_SYNC)))
    {
        // After creating the new document, prompt the user for a path to save
        // it to. If the user aborts, delete the document, too.
        if (!moo_editor_save_as (editor, doc, NULL, NULL))
        {
            moo_editor_close_doc (editor, doc);
            return NULL;
        }
    }

    return doc;
}


void
_moo_editor_move_doc (MooEditor     *editor,
                      MooEdit       *doc,
                      MooEditWindow *dest,
                      MooEditView   *dest_view,
                      gboolean       focus)
{
    MooEditWindow *old_window;
    MooEdit *dest_doc = NULL;
    MooEditTab *tab;

    g_return_if_fail (MOO_IS_EDITOR (editor));
    g_return_if_fail (MOO_IS_EDIT (doc) && moo_edit_get_editor (doc) == editor);
    g_return_if_fail (!dest || (MOO_IS_EDIT_WINDOW (dest) && moo_edit_window_get_editor (dest) == editor));

    if (!dest)
    {
        dest = moo_editor_new_window (editor);
        dest_view = moo_edit_window_get_active_view (dest);
    }

    tab = moo_edit_view_get_tab (moo_edit_get_view (doc));

    g_object_ref (tab);
    g_object_ref (doc);

    if ((old_window = moo_edit_get_window (doc)))
    {
        _moo_edit_window_remove_doc (old_window, doc);

        if (!moo_edit_window_get_active_doc (old_window))
            moo_editor_close_window (editor, old_window);
    }

    _moo_edit_window_insert_tab (dest, tab, dest_view);

    dest_doc = dest_view ? moo_edit_view_get_doc (dest_view) : NULL;
    if (dest_doc && moo_edit_is_empty (dest_doc))
        moo_editor_close_doc (editor, dest_doc);

    if (focus)
        moo_editor_set_active_doc (editor, doc);

    g_object_unref (doc);
    g_object_unref (tab);
}


static void
update_history_item_for_doc (MooEditor *editor,
                             MooEdit   *doc,
                             gboolean   add)
{
    char *uri;
    MooHistoryItem *item;
    int line;
    const char *enc;
    MooEditView *view;

    if (!(uri = moo_edit_get_uri (doc)))
        return;

    item = moo_history_item_new (uri, NULL);

    view = moo_edit_get_view (doc);
    line = moo_text_view_get_cursor_line (GTK_TEXT_VIEW (view));
    if (line != 0)
        _moo_edit_history_item_set_line (item, line);

    enc = moo_edit_get_encoding (doc);
    if (enc && strcmp (enc, MOO_ENCODING_UTF8) != 0)
        _moo_edit_history_item_set_encoding (item, enc);

    if (add)
        moo_history_mgr_add_file (editor->priv->history.gobj(), item);
    else
        moo_history_mgr_update_file (editor->priv->history.gobj(), item);

    moo_history_item_free (item);
    g_free (uri);
}


static EditPtr
moo_editor_load_file(MooEditor       *editor,
                     MooOpenInfo     *info,
                     MooEditWindow   *window,
                     GtkWidget       *parent,
                     gboolean         silent,
                     gboolean         add_history,
                     gerrp&           error)
{
    MooEditView *view = NULL;
    gboolean new_doc = FALSE;
    gboolean new_object = FALSE;
    const char *recent_encoding = NULL;
    gerrp error_here;
    gboolean success = TRUE;

    moo_return_error_if_fail_p(MOO_IS_EDITOR(editor));
    moo_return_error_if_fail_p(info != NULL && info->file != nullptr);

    gstr uri = info->file->get_uri();
    gstr filename = info->file->get_path();
    int line = info->line;
    EditPtr doc = wrap(moo_editor_get_doc_for_file(editor, info->file.gobj()));

    if (filename.empty())
    {
        g_set_error (&error_here, MOO_EDIT_FILE_ERROR,
                     MOO_EDIT_FILE_ERROR_NOT_IMPLEMENTED,
                     "Loading remote files is not implemented");
        success = FALSE;
    }

    if (success && !doc)
    {
        new_doc = TRUE;

        if (!window)
            window = moo_editor_get_active_window (editor);

        if (window)
        {
            doc = wrap (moo_edit_window_get_active_doc (window));

            if (doc && !moo_edit_is_empty (doc.gobj()))
                doc = NULL;
        }
    }

    if (success && !doc)
    {
        new_object = TRUE;
        doc = wrap_new(MOO_EDIT(g_object_new(get_doc_type(editor), "editor", editor, nullptr)));
    }

    if (success)
    {
        view = moo_edit_get_view (doc.gobj());

        if (!new_doc && line < 0 && (info->flags & MOO_OPEN_FLAG_RELOAD) != MOO_OPEN_FLAGS_NONE)
            line = moo_text_view_get_cursor_line (GTK_TEXT_VIEW (view));

        if (info->encoding.empty())
        {
            MooHistoryItem *hist_item = moo_history_mgr_find_uri (editor->priv->history.gobj(), uri);
            if (hist_item)
                recent_encoding = _moo_edit_history_item_get_encoding (hist_item);
        }
    }

    if (success && new_doc)
    {
        if ((info->flags & MOO_OPEN_FLAG_CREATE_NEW) && _moo_edit_file_is_new(*info->file))
        {
            doc->_set_status(MOO_EDIT_STATUS_NEW);
            doc->_set_file(info->file.gobj(), info->encoding);
        }
        else
        {
            // XXX
            success = _moo_edit_load_file(*doc, *info->file,
                                          info->encoding,
                                          gstr::wrap(recent_encoding),
                                          error_here);
        }
    }

    if (!success)
    {
        if (!silent && !_moo_is_file_error_cancelled (error_here))
        {
            if (!parent && !window)
                window = moo_editor_get_active_window (editor);
            if (!parent && window)
                parent = GTK_WIDGET (window);
            _moo_edit_open_error_dialog(parent, info->file, error_here.get());
        }

        error = std::move (error_here);
    }
    else if (!new_doc && (info->flags & MOO_OPEN_FLAG_RELOAD))
    {
        success = _moo_edit_reload_file(*doc, info->encoding, error_here);

        if (!success)
        {
            if (!silent && !_moo_is_file_error_cancelled (error_here))
                _moo_edit_reload_error_dialog (doc.gobj(), error_here.get());
            error = std::move (error_here);
        }
    }

    if (success && new_object)
    {
        if (!window || (info->flags & MOO_OPEN_FLAG_NEW_WINDOW))
            window = create_window (editor);

        _moo_edit_window_insert_doc (window, doc.gobj(), NULL);
    }

    if (success)
    {
        MooHistoryItem *hist_item;

        if (line < 0 && new_doc)
        {
            hist_item = moo_history_mgr_find_uri (editor->priv->history.gobj(), uri);
            if (hist_item)
                line = _moo_edit_history_item_get_line (hist_item);
        }

        if (line >= 0)
            moo_text_view_move_cursor (MOO_TEXT_VIEW (view), line, 0, FALSE, TRUE);
    }

    if (success && add_history)
        update_history_item_for_doc (editor, doc.gobj(), TRUE);

    if (success)
    {
        moo_editor_set_active_doc (editor, doc.gobj());
        gtk_widget_grab_focus (GTK_WIDGET (view));
    }

    return success ? std::move(doc) : nullptr;
}

// static MooEdit *
// moo_editor_load_file (MooEditor       *editor,
//                       MooOpenInfo *info,
//                       MooEditWindow   *window,
//                       GtkWidget       *parent,
//                       gboolean         silent,
//                       gboolean         add_history,
//                       GError         **error)
// {
//     GError *error = NULL;
//     gboolean new_doc = FALSE;
//     MooEdit *doc = NULL;
//     char *uri;
//     gboolean result = TRUE;
//     const char *recent_encoding = NULL;
//
//     *docp = NULL;
//     uri = g_file_get_uri (info->file);
//     g_return_val_if_fail (uri != NULL, FALSE);
//
//     if ((doc = moo_editor_get_doc_for_uri (editor, uri)))
//     {
//         *docp = doc;
//         if (add_history)
//             add_recent_uri (editor, uri);
//         g_free (uri);
//         return FALSE;
//     }
//
//     if (window)
//     {
//         doc = moo_edit_window_get_active_doc (window);
//
//         if (doc && moo_edit_is_empty (doc))
//             g_object_ref (doc);
//         else
//             doc = NULL;
//     }
//
//     if (!doc)
//     {
//         doc = MOO_EDIT (g_object_new (get_doc_type (editor), "editor", editor, (const char*) NULL));
//         g_object_ref_sink (doc);
//         new_doc = TRUE;
//     }
//
//     if (!info->encoding)
//     {
//         MooHistoryItem *hist_item = moo_history_mgr_find_uri (editor->priv->history, uri);
//         if (hist_item)
//             recent_encoding = _moo_edit_history_item_get_encoding (hist_item);
//     }
//
//     /* XXX open_single */
//     if (!_moo_edit_load_file (doc, info->file, info->encoding, recent_encoding, &error))
//     {
//         if (!silent)
//         {
//             if (!parent && !window)
//                 window = moo_editor_get_active_window (editor);
//             if (!parent && window)
//                 parent = GTK_WIDGET (window);
//             _moo_edit_open_error_dialog (parent, info->file, info->encoding, error);
//         }
//         g_error_free (error);
//         result = FALSE;
//     }
//     else
//     {
//         MooHistoryItem *hist_item;
//         int line = info->line;
//
//         if (line < 0)
//         {
//             hist_item = moo_history_mgr_find_uri (editor->priv->history, uri);
//             if (hist_item)
//                 line = _moo_edit_history_item_get_line (hist_item);
//         }
//
//         if (line >= 0)
//             moo_text_view_move_cursor (MOO_TEXT_VIEW (doc), line, 0, FALSE, TRUE);
//
//         if (!window)
//             window = moo_editor_get_active_window (editor);
//         if (!window)
//             window = create_window (editor);
//
//         if (new_doc)
//         {
//             _moo_edit_window_insert_doc (window, doc, NULL);
//             moo_editor_add_doc (editor, window, doc);
//         }
//
//         if (add_history)
//             update_history_item_for_doc (editor, doc, TRUE);
//     }
//
//     if (result)
//         *docp = doc;
//
//     g_free (uri);
//     g_object_unref (doc);
//     return result;
// }

static MooEditArray *
_moo_editor_open_files (MooEditor*        editor,
                        MooOpenInfoArray* files,
                        GtkWidget*        parent,
                        gerrp&            error)
{
    guint i;
    MooEdit *bring_to_front = NULL;
    gboolean result = TRUE;
    MooEditWindow *window = NULL;
    MooEditArray *docs;

    moo_return_error_if_fail_p (MOO_IS_EDITOR (editor));
    moo_return_error_if_fail_p (!parent || GTK_IS_WIDGET (parent));
    moo_return_error_if_fail_p (!moo_open_info_array_is_empty (files));

    if (parent)
    {
        GtkWidget *top = gtk_widget_get_toplevel (parent);
        if (MOO_IS_EDIT_WINDOW (top))
            window = MOO_EDIT_WINDOW (top);
    }

    docs = moo_edit_array_new ();

    for (i = 0; i < files->n_elms; ++i)
    {
        MooOpenInfo *info = files->elms[i];

        if (!window)
            window = moo_editor_get_active_window (editor);

        EditPtr doc = moo_editor_load_file(editor, info, window, parent,
                                           FALSE, TRUE, error);

        if (doc)
        {
            parent = GTK_WIDGET (moo_edit_get_view (doc.gobj()));
            bring_to_front = doc.gobj();
            moo_edit_array_append (docs, doc.gobj());
        }
        else
        {
            result = FALSE;
            break;
        }
    }

    if (bring_to_front)
    {
        moo_editor_set_active_doc (editor, bring_to_front);
        gtk_widget_grab_focus (GTK_WIDGET (moo_edit_get_view (bring_to_front)));
    }

    if (!result)
    {
        moo_edit_array_free (docs);
        docs = NULL;
    }

    return docs;
}


/**
 * moo_editor_get_active_doc:
 */
MooEdit *
moo_editor_get_active_doc (MooEditor *editor)
{
    MooEditWindow *window = moo_editor_get_active_window (editor);
    return window ? moo_edit_window_get_active_doc (window) : NULL;
}

/**
 * moo_editor_get_active_view:
 */
MooEditView *
moo_editor_get_active_view (MooEditor *editor)
{
    MooEditWindow *window = moo_editor_get_active_window (editor);
    return window ? moo_edit_window_get_active_view (window) : NULL;
}

/**
 * moo_editor_get_active_window:
 */
MooEditWindow *
moo_editor_get_active_window (MooEditor *editor)
{
    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
    return get_top_window (editor);
}


void
moo_editor_present (MooEditor *editor,
                    guint32    stamp)
{
    MooEditWindow *window;

    g_return_if_fail (MOO_IS_EDITOR (editor));

    window = moo_editor_get_active_window (editor);

    if (!window)
        window = moo_editor_new_window (editor);

    g_return_if_fail (window != NULL);
    moo_window_present (GTK_WINDOW (window), stamp);
}


/**
 * moo_editor_set_active_window:
 */
void
moo_editor_set_active_window (MooEditor      *editor,
                              MooEditWindow  *window)
{
    g_return_if_fail (MOO_IS_EDITOR (editor));
    g_return_if_fail (MOO_IS_EDIT_WINDOW (window));
    gtk_window_present (GTK_WINDOW (window));
}

/**
 * moo_editor_set_active_view:
 */
void
moo_editor_set_active_view (MooEditor   *editor,
                            MooEditView *view)
{
    MooEditWindow *window;

    g_return_if_fail (MOO_IS_EDITOR (editor));
    g_return_if_fail (MOO_IS_EDIT_VIEW (view));

    window = moo_edit_view_get_window (view);
    g_return_if_fail (MOO_IS_EDIT_WINDOW (window));

    moo_window_present (GTK_WINDOW (window), 0);
    moo_edit_window_set_active_view (window, view);
}

/**
 * moo_editor_set_active_doc:
 */
void
moo_editor_set_active_doc (MooEditor      *editor,
                           MooEdit        *doc)
{
    moo_editor_set_active_view (editor, moo_edit_get_view (doc));
}


static MooEdit *
find_busy (MooEditArray *docs)
{
    guint i;
    for (i = 0; i < docs->n_elms; ++i)
        if (Edit(*docs->elms[i])._is_busy())
            return docs->elms[i];
    return NULL;
}

static MooCloseResponse
moo_editor_before_close_window (MooEditor     *editor,
                                MooEditWindow *window)
{
    MooSaveChangesResponse response;
    MooEditArray *modified;
    MooEditArray *docs;
    gboolean do_close = FALSE;
    MooEdit *busy = NULL;

    g_return_val_if_fail (MOO_IS_EDITOR (editor), MOO_CLOSE_RESPONSE_CANCEL);
    g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), MOO_CLOSE_RESPONSE_CANCEL);

    docs = moo_edit_window_get_docs (window);
    busy = find_busy (docs);

    if (busy)
    {
        moo_editor_set_active_doc (editor, busy);
        moo_edit_array_free (docs);
        return MOO_CLOSE_RESPONSE_CANCEL;
    }

    modified = find_modified (docs);

    if (moo_edit_array_is_empty (modified))
    {
        do_close = TRUE;
    }
    else if (modified->n_elms == 1)
    {
        if (window)
            moo_edit_window_set_active_doc (window, modified->elms[0]);

        response = _moo_edit_save_changes_dialog (modified->elms[0]);

        switch (response)
        {
            case MOO_SAVE_CHANGES_RESPONSE_SAVE:
                if (moo_editor_save (editor, modified->elms[0], NULL))
                    do_close = TRUE;
                break;

            case MOO_SAVE_CHANGES_RESPONSE_CANCEL:
                break;

            default:
                do_close = TRUE;
                break;
        }
    }
    else
    {
        guint i;
        MooEditArray *to_save;
        gboolean saved = TRUE;

        to_save = moo_edit_array_new ();
        response = _moo_edit_save_multiple_changes_dialog (modified, to_save);

        switch (response)
        {
            case MOO_SAVE_CHANGES_RESPONSE_SAVE:
                for (i = 0; i < to_save->n_elms; ++i)
                    if (!moo_editor_save (editor, to_save->elms[i], NULL))
                    {
                        saved = FALSE;
                        break;
                    }
                if (saved)
                    do_close = TRUE;
                break;

            case MOO_SAVE_CHANGES_RESPONSE_CANCEL:
                break;

            default:
                do_close = TRUE;
                break;
        }

        moo_edit_array_free (to_save);
    }

    moo_edit_array_free (modified);
    moo_edit_array_free (docs);
    return do_close ? MOO_CLOSE_RESPONSE_CONTINUE : MOO_CLOSE_RESPONSE_CANCEL;
}


/**
 * moo_editor_close_window:
 */
gboolean
moo_editor_close_window (MooEditor      *editor,
                         MooEditWindow  *window)
{
    MooCloseResponse response = MOO_CLOSE_RESPONSE_CONTINUE;

    g_return_val_if_fail (MOO_IS_EDITOR (editor), FALSE);
    g_return_val_if_fail (MOO_IS_EDIT_WINDOW (window), FALSE);

    if (!contains(editor->priv->windows, window))
        return TRUE;

    g_object_ref (window);

    g_signal_emit_by_name (window, "before-close", &response);

    if (response != MOO_CLOSE_RESPONSE_CANCEL && contains(editor->priv->windows, window))
        g_signal_emit (editor, signals[BEFORE_CLOSE_WINDOW], 0, window, &response);

    if (response != MOO_CLOSE_RESPONSE_CANCEL && contains(editor->priv->windows, window))
        do_close_window (editor, window);

    g_object_unref (window);

    return response != MOO_CLOSE_RESPONSE_CANCEL;
}


static void
do_close_window (MooEditor      *editor,
                 MooEditWindow  *window)
{
    MooEditArray *docs;
    guint i;

    g_signal_emit (editor, signals[WILL_CLOSE_WINDOW], 0, window);
    g_signal_emit_by_name (window, "will-close");

    docs = moo_edit_window_get_docs (window);

    for (i = 0; i < docs->n_elms; ++i)
        do_close_doc (editor, docs->elms[i]);

    remove(editor->priv->windows, window);

    _moo_window_detach_plugins (window);
    gtk_widget_destroy (GTK_WIDGET (window));

    g_signal_emit (editor, signals[AFTER_CLOSE_WINDOW], 0);

    moo_edit_array_free (docs);
}


static void
do_close_doc (MooEditor *editor,
              MooEdit   *doc)
{
    MooEditWindow *window;

    EditPtr docp = wrap(doc); // get a reference so it doesn't get destroyed below

    g_signal_emit(editor, signals[WILL_CLOSE_DOC], 0, doc);
    g_signal_emit_by_name(doc, "will-close");

    window = moo_edit_get_window(doc);
    g_assert(window);

    update_history_item_for_doc(editor, doc, TRUE);

    if (window)
        _moo_edit_window_remove_doc(window, doc);
    else
        _moo_doc_detach_plugins(NULL, doc);

    docp->_closed();
}


/**
 * moo_editor_close_doc:
 */
gboolean
moo_editor_close_doc (MooEditor *editor,
                      MooEdit   *doc)
{
    gboolean result;
    MooEditArray *docs;

    docs = moo_edit_array_new ();
    moo_edit_array_append (docs, doc);
    result = moo_editor_close_docs (editor, docs);
    moo_edit_array_free (docs);
    return result;
}


/**
 * moo_editor_close_docs:
 */
gboolean
moo_editor_close_docs (MooEditor    *editor,
                       MooEditArray *docs)
{
    guint i;
    MooEditWindow *window;

    g_return_val_if_fail (MOO_IS_EDITOR (editor), FALSE);

    if (moo_edit_array_is_empty (docs))
        return TRUE;

    for (i = 0; i < docs->n_elms; ++i)
    {
        MooEdit *doc = docs->elms[i];

        g_return_val_if_fail (MOO_IS_EDIT (doc), FALSE);

        if (Edit(*doc)._is_busy())
        {
            moo_editor_set_active_doc (editor, doc);
            return FALSE;
        }
    }

    window = moo_edit_get_window (docs->elms[0]);

    if (close_docs_real (editor, docs))
    {
        if (window &&
            !moo_edit_window_get_n_tabs (window) &&
            !test_flag (editor, ALLOW_EMPTY_WINDOW))
        {
            MooEdit *doc = MOO_EDIT (g_object_new (get_doc_type (editor),
                                                   "editor", editor,
                                                   (const char*) NULL));
            _moo_edit_window_insert_doc (window, doc, NULL);
            g_object_unref (doc);
        }

        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


static gboolean
close_docs_real (MooEditor    *editor,
                 MooEditArray *docs)
{
    MooSaveChangesResponse response;
    MooEditArray *modified;
    gboolean do_close = FALSE;

    modified = find_modified (docs);

    if (moo_edit_array_is_empty (modified))
    {
        do_close = TRUE;
    }
    else if (modified->n_elms == 1)
    {
        MooEditWindow *window = moo_edit_get_window (modified->elms[0]);

        if (window)
            moo_edit_window_set_active_doc (window, modified->elms[0]);

        response = _moo_edit_save_changes_dialog (modified->elms[0]);

        switch (response)
        {
            case MOO_SAVE_CHANGES_RESPONSE_SAVE:
                if (moo_editor_save (editor, modified->elms[0], NULL))
                    do_close = TRUE;
                break;

            case MOO_SAVE_CHANGES_RESPONSE_CANCEL:
                break;

            default:
                do_close = TRUE;
                break;
        }
    }
    else
    {
        guint i;
        MooEditArray *to_save;
        gboolean saved = TRUE;

        to_save = moo_edit_array_new ();
        response = _moo_edit_save_multiple_changes_dialog (modified, to_save);

        switch (response)
        {
            case MOO_SAVE_CHANGES_RESPONSE_SAVE:
                for (i = 0; i < to_save->n_elms; ++i)
                    if (!moo_editor_save (editor, to_save->elms[i], NULL))
                {
                    saved = FALSE;
                    break;
                }
                if (saved)
                    do_close = TRUE;
                break;

            case MOO_SAVE_CHANGES_RESPONSE_CANCEL:
                break;

            default:
                do_close = TRUE;
                break;
        }

        moo_edit_array_free (to_save);
    }

    if (do_close)
    {
        guint i;
        for (i = 0; i < docs->n_elms; ++i)
            do_close_doc (editor, docs->elms[i]);
    }

    moo_edit_array_free (modified);
    return do_close;
}


static MooEditArray *
find_modified (MooEditArray *docs)
{
    guint i;
    MooEditArray *modified = moo_edit_array_new ();
    for (i = 0; i < docs->n_elms; ++i)
        if (moo_edit_is_modified (docs->elms[i]) && !moo_edit_get_clean (docs->elms[i]))
            moo_edit_array_append (modified, docs->elms[i]);
    return modified;
}


gboolean
_moo_editor_close_all (MooEditor *editor)
{
    guint i;
    MooEditWindowArray *windows;

    g_return_val_if_fail (MOO_IS_EDITOR (editor), FALSE);

    windows = moo_editor_get_windows (editor);

    for (i = 0; i < windows->n_elms; ++i)
    {
        if (!moo_editor_close_window (editor, windows->elms[i]))
        {
            moo_edit_window_array_free (windows);
            return FALSE;
        }
    }

    moo_edit_window_array_free (windows);
    return TRUE;
}


static EditPtr
load_doc_session (MooEditor     *editor,
                  MooEditWindow *window,
                  MooMarkupNode *elm,
                  gboolean       file_is_uri)
{
    gstr uri;

    if (file_is_uri)
    {
        uri = gstr::wrap(moo_markup_get_content(elm));
    }
    else
    {
        const char *filename = moo_markup_get_content (elm);
        if (filename)
            uri = g::filename_to_uri(filename);
    }

    if (uri.empty())
        return EditPtr::wrap(moo_editor_new_doc(editor, window));

    const char *encoding = moo_markup_get_prop (elm, "encoding");
    std::unique_ptr<MooOpenInfo> info(moo_open_info_new_uri(uri, encoding, -1, MOO_OPEN_FLAGS_NONE));

    gerrp ignored;
    return moo_editor_load_file(editor, info.get(), window, GTK_WIDGET(window), TRUE, FALSE, ignored);
}

static MooMarkupNode *
save_doc_session (MooEdit       *doc,
                  MooMarkupNode *elm)
{
    char *uri;
    const char *encoding;
    MooMarkupNode *node;

    uri = moo_edit_get_uri (doc);
    encoding = moo_edit_get_encoding (doc);

    if (uri)
    {
        node = moo_markup_create_text_element (elm, "document", uri);

        if (encoding && encoding[0])
            moo_markup_set_prop (node, "encoding", encoding);
    }
    else
    {
        node = moo_markup_create_element (elm, "document");
    }

    g_free (uri);
    return node;
}

static MooEditWindow *
load_window_session (MooEditor     *editor,
                     MooMarkupNode *elm,
                     gboolean       file_is_uri)
{
    MooEditWindow *window;
    MooEdit *active_doc = NULL;
    MooMarkupNode *node;

    window = create_window (editor);

    for (node = elm->children; node != NULL; node = node->next)
    {
        if (MOO_MARKUP_IS_ELEMENT (node))
        {
            EditPtr doc = load_doc_session (editor, window, node, file_is_uri);

            if (doc && moo_markup_bool_prop (node, "active", FALSE))
                active_doc = doc.gobj();
        }
    }

    if (active_doc)
        moo_edit_window_set_active_doc (window, active_doc);

    return window;
}

static MooMarkupNode *
save_window_session (MooEditWindow *window,
                     MooMarkupNode *elm)
{
    MooMarkupNode *node;
    MooEdit *active_doc;
    MooEditArray *docs;
    guint i;

    active_doc = moo_edit_window_get_active_doc (window);
    docs = moo_edit_window_get_docs (window);

    node = moo_markup_create_element (elm, "window");

    for (i = 0; i < docs->n_elms; ++i)
    {
        MooMarkupNode *doc_node;
        MooEdit *doc = docs->elms[i];

        doc_node = save_doc_session (doc, node);

        if (doc_node && doc == active_doc)
            moo_markup_set_bool_prop (doc_node, "active", TRUE);
    }

    moo_edit_array_free (docs);
    return node;
}

void
_moo_editor_load_session (MooEditor     *editor,
                          MooMarkupNode *xml)
{
    MooMarkupNode *editor_node;
    gboolean old_format = FALSE;

    g_return_if_fail (MOO_IS_EDITOR (editor));
    g_return_if_fail (MOO_MARKUP_IS_ELEMENT (xml));

    editor_node = moo_markup_get_element (xml, "editor");

    if (editor_node)
    {
        const char *version = moo_markup_get_prop (editor_node, "version");
        if (!version)
            old_format = TRUE;
        else if (strcmp (version, CURRENT_SESSION_VERSION) != 0)
            editor_node = NULL;
    }

    if (editor_node)
    {
        MooEditWindow *active_window = NULL;
        MooMarkupNode *node;

        for (node = editor_node->children; node != NULL; node = node->next)
        {
            MooEditWindow *window;

            if (!MOO_MARKUP_IS_ELEMENT (node))
                continue;

            window = load_window_session (editor, node, !old_format);

            if (window && moo_markup_bool_prop (node, "active", FALSE))
                active_window = window;
        }

        if (active_window)
            moo_editor_set_active_window (editor, active_window);
    }
}

void
_moo_editor_save_session (MooEditor     *editor,
                          MooMarkupNode *xml)
{
    MooMarkupNode *node;
    MooEditWindow *active_window;
    MooEditWindowArray *windows;
    guint i;

    g_return_if_fail (MOO_IS_EDITOR (editor));
    g_return_if_fail (MOO_MARKUP_IS_ELEMENT (xml));

    active_window = moo_editor_get_active_window (editor);
    windows = moo_editor_get_windows (editor);

    node = moo_markup_create_element (xml, "editor");
    moo_markup_set_prop (node, "version", CURRENT_SESSION_VERSION);

    for (i = 0; i < windows->n_elms; ++i)
    {
        MooEditWindow *window = windows->elms[i];
        MooMarkupNode *window_node;

        window_node = save_window_session (window, node);

        if (window_node && window == active_window)
            moo_markup_set_bool_prop (window_node, "active", TRUE);
    }

    moo_edit_window_array_free (windows);
}


/**
 * moo_editor_get_windows:
 *
 * Returns: (transfer full)
 */
MooEditWindowArray *
moo_editor_get_windows (MooEditor *editor)
{
    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);

    MooEditWindowArray* copy = moo_edit_window_array_new ();
    MOO_IP_ARRAY_GROW (MooEditWindow*, copy, elms, editor->priv->windows.size());
    gsize i = 0;
    for (const auto& window: editor->priv->windows)
    {
        copy->elms[i++] = MOO_EDIT_WINDOW(g_object_ref(window));
    }

    return copy;
}

/**
 * moo_editor_get_docs:
 *
 * Returns: (transfer full)
 */
MooEditArray *
moo_editor_get_docs (MooEditor *editor)
{
    MooEditArray *docs;

    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);

    docs = moo_edit_array_new ();

    for (const auto& window: editor->priv->windows)
    {
        MooEditArray *docs_here = moo_edit_window_get_docs (window);
        moo_edit_array_append_array (docs, docs_here);
        moo_edit_array_free (docs_here);
    }

    return docs;
}


/**
 * moo_editor_open_files:
 *
 * @editor:
 * @files:
 * @parent: (allow-none) (default NULL)
 * @error:
 */
gboolean
moo_editor_open_files (MooEditor        *editor,
                       MooOpenInfoArray *files,
                       GtkWidget        *parent,
                       GError          **error)
{
    MooEditArray *docs;
    gboolean ret;

    moo_return_error_if_fail (MOO_IS_EDITOR (editor));
    moo_return_error_if_fail (!moo_open_info_array_is_empty (files));

    gerrp error_here(error);
    docs = _moo_editor_open_files (editor, files, parent, error_here);

    ret = !moo_edit_array_is_empty (docs);

    moo_assert (moo_edit_array_is_empty (docs) ||
                moo_edit_array_get_size (docs) ==
                    moo_open_info_array_get_size (files));

    moo_edit_array_free (docs);
    return ret;
}

/**
 * moo_editor_new_file:
 *
 * @editor:
 * @info:
 * @parent: (allow-none) (default NULL)
 * @error:
 */
MooEdit *
moo_editor_new_file (MooEditor    *editor,
                     MooOpenInfo  *info,
                     GtkWidget    *parent,
                     GError      **error)
{
    MooEdit *doc;

    moo_return_error_if_fail_p (MOO_IS_EDITOR (editor));
    moo_return_error_if_fail_p (info != nullptr);

    std::unique_ptr<MooOpenInfo> info_copy (moo_open_info_dup (info));
    info_copy->flags |= MOO_OPEN_FLAG_CREATE_NEW;

    doc = moo_editor_open_file (editor, info_copy.get (), parent, error);

    return doc;
}

/**
 * moo_editor_open_file:
 *
 * @editor:
 * @info:
 * @parent: (allow-none) (default NULL)
 * @error:
 */
MooEdit *
moo_editor_open_file (MooEditor   *editor,
                      MooOpenInfo *info,
                      GtkWidget   *parent,
                      GError     **error)
{
    MooEditArray *docs;
    MooOpenInfoArray *files;
    MooEdit *ret = NULL;

    moo_return_error_if_fail_p (info != NULL);

    files = moo_open_info_array_new ();
    moo_open_info_array_append (files, info);

    gerrp error_here(error);
    docs = _moo_editor_open_files (editor, files, parent, error_here);

    moo_open_info_array_free (files);

    if (docs)
    {
        moo_release_assert (docs->n_elms > 0);
        ret = docs->elms[0];
    }

    moo_edit_array_free (docs);
    return ret;
}

/**
 * moo_editor_open_uri: (moo-kwargs)
 *
 * @editor:
 * @uri: (type const-utf8)
 * @encoding: (type const-utf8) (allow-none) (default NULL)
 * @line: (default -1)
 * @window: (allow-none) (default NULL)
 */
MooEdit *
moo_editor_open_uri (MooEditor     *editor,
                     const char    *uri,
                     const char    *encoding,
                     int            line,
                     MooEditWindow *window)
{
    std::unique_ptr<MooOpenInfo> info (moo_open_info_new_uri (uri, encoding, line, MOO_OPEN_FLAGS_NONE));
    return moo_editor_open_file (editor, info.get(), window ? GTK_WIDGET (window) : NULL, NULL);
}

/**
 * moo_editor_open_path: (moo-kwargs)
 *
 * @editor:
 * @path: (type const-filename)
 * @encoding: (type const-utf8) (allow-none) (default NULL)
 * @line: (default -1)
 * @window: (allow-none) (default NULL)
 */
MooEdit *
moo_editor_open_path (MooEditor     *editor,
                      const char    *path,
                      const char    *encoding,
                      int            line,
                      MooEditWindow *window)
{
    std::unique_ptr<MooOpenInfo> info (moo_open_info_new (path, encoding, line, MOO_OPEN_FLAGS_NONE));
    return moo_editor_open_file (editor, info.get(), window ? GTK_WIDGET (window) : NULL, NULL);
}


// MooEdit *
// moo_editor_open_file (MooEditor      *editor,
//                       MooEditWindow  *window,
//                       GtkWidget      *parent,
//                       const char     *filename,
//                       const char     *encoding)
// {
//     gboolean result;
//
//     g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
//     g_return_val_if_fail (!window || MOO_IS_EDIT_WINDOW (window), NULL);
//     g_return_val_if_fail (!parent || GTK_IS_WIDGET (parent), NULL);
//
//     if (!filename)
//     {
//         result = moo_editor_open (editor, window, parent, NULL);
//     }
//     else
//     {
//         MooFileEncArray *list;
//
//         list = moo_file_enc_array_new ();
//         moo_file_enc_array_take (list, moo_file_enc_new_for_path (filename, encoding));
//
//         result = moo_editor_open (editor, window, parent, list);
//
//         moo_file_enc_array_free (list);
//     }
//
//     if (!result)
//         return NULL;
//
//     return moo_editor_get_doc (editor, filename);
// }


// MooEdit *
// moo_editor_open_file_line (MooEditor      *editor,
//                            const char     *filename,
//                            int             line,
//                            MooEditWindow  *window)
// {
//     MooEdit *doc = NULL;
//     char *freeme = NULL;
//     MooFileEnc *fenc = NULL;
//
//     g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
//     g_return_val_if_fail (filename != NULL, NULL);
//
//     doc = moo_editor_get_doc (editor, filename);
//
//     if (doc)
//     {
//         if (line >= 0)
//             moo_text_view_move_cursor (MOO_TEXT_VIEW (doc), line, 0, FALSE, FALSE);
//         moo_editor_set_active_doc (editor, doc);
//         gtk_widget_grab_focus (GTK_WIDGET (doc));
//         return doc;
//     }
//
//     freeme = _moo_normalize_file_path (filename);
//     filename = freeme;
//
//     if (!g_file_test (filename, G_FILE_TEST_EXISTS))
//         goto out;
//
//     fenc = moo_file_enc_new_for_path (filename, NULL);
//     moo_editor_load_file (editor, window, NULL, fenc,
//                           FALSE, TRUE, line, &doc);
//
//     /* XXX */
//     moo_editor_set_active_doc (editor, doc);
//     if (line >= 0)
//         moo_text_view_move_cursor (MOO_TEXT_VIEW (doc), line, 0, FALSE, TRUE);
//     gtk_widget_grab_focus (GTK_WIDGET (doc));
//
// out:
//     moo_file_enc_free (fenc);
//     g_free (freeme);
//     return doc;
// }


// static MooEdit *
// moo_editor_new_uri (MooEditor     *editor,
//                     MooEditWindow *window,
//                     GtkWidget     *parent,
//                     const char    *uri,
//                     const char    *encoding)
// {
//     MooEdit *doc = NULL;
//     char *path;
//     GFile *file;
//
//     g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
//     g_return_val_if_fail (!window || MOO_IS_EDIT_WINDOW (window), NULL);
//     g_return_val_if_fail (!parent || GTK_IS_WIDGET (parent), NULL);
//
//     if (!uri)
//         return moo_editor_open_uri (editor, window, parent, NULL, NULL);
//
//     file = g_file_new_for_uri (uri);
//     path = g_file_get_path (file);
//
//     if (path && g_file_test (path, G_FILE_TEST_EXISTS))
//     {
//         g_free (path);
//         g_object_unref (file);
//         return moo_editor_open_uri (editor, window, parent,
//                                     uri, encoding);
//     }
//
//     if (!window)
//         window = moo_editor_get_active_window (editor);
//
//     if (window)
//     {
//         doc = moo_edit_window_get_active_doc (window);
//
//         if (!doc || !moo_edit_is_empty (doc))
//             doc = NULL;
//     }
//
//     if (!doc)
//         doc = moo_editor_new_doc (editor, window);
//
//     _moo_edit_set_status (doc, MOO_EDIT_STATUS_NEW);
//     _moo_edit_set_file (doc, file, encoding);
//     moo_editor_set_active_doc (editor, doc);
//     gtk_widget_grab_focus (GTK_WIDGET (doc));
//
//     g_free (path);
//     g_object_unref (file);
//     return doc;
// }

// MooEdit *
// moo_editor_new_file (MooEditor      *editor,
//                      MooEditWindow  *window,
//                      GtkWidget      *parent,
//                      const char     *filename,
//                      const char     *encoding)
// {
//     MooEdit *doc = NULL;
//     char *freeme = NULL;
//     GFile *file;
//
//     g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
//     g_return_val_if_fail (!window || MOO_IS_EDIT_WINDOW (window), NULL);
//     g_return_val_if_fail (!parent || GTK_IS_WIDGET (parent), NULL);
//
//     if (!filename)
//         return moo_editor_open_file (editor, window, parent, NULL, NULL);
//
//     if (g_file_test (filename, G_FILE_TEST_EXISTS))
//         return moo_editor_open_file (editor, window, parent,
//                                      filename, encoding);
//
//     freeme = _moo_normalize_file_path (filename);
//     filename = freeme;
//
//     if (!window)
//         window = moo_editor_get_active_window (editor);
//
//     if (window)
//     {
//         doc = moo_edit_window_get_active_doc (window);
//
//         if (!doc || !moo_edit_is_empty (doc))
//             doc = NULL;
//     }
//
//     if (!doc)
//         doc = moo_editor_new_doc (editor, window);
//
//     _moo_edit_set_status (doc, MOO_EDIT_STATUS_NEW);
//     file = g_file_new_for_path (filename);
//     _moo_edit_set_file (doc, file, encoding);
//     moo_editor_set_active_doc (editor, doc);
//     gtk_widget_grab_focus (GTK_WIDGET (doc));
//
//     g_object_unref (file);
//     g_free (freeme);
//     return doc;
// }
//
//
// MooEdit *
// moo_editor_open_uri (MooEditor      *editor,
//                      MooEditWindow  *window,
//                      GtkWidget      *parent,
//                      const char     *uri,
//                      const char     *encoding)
// {
//     char *filename;
//     MooEdit *doc;
//
//     g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
//     g_return_val_if_fail (!window || MOO_IS_EDIT_WINDOW (window), NULL);
//     g_return_val_if_fail (!parent || GTK_IS_WIDGET (parent), NULL);
//     g_return_val_if_fail (uri != NULL, NULL);
//
//     filename = g_filename_from_uri (uri, NULL, NULL);
//     g_return_val_if_fail (filename != NULL, NULL);
//
//     doc = moo_editor_open_file (editor, window, parent, filename, encoding);
//
//     g_free (filename);
//     return doc;
// }


/**
 * moo_editor_reload:
 *
 * @editor:
 * @doc:
 * @info: (allow-none) (default NULL)
 * @error:
 **/
gboolean
moo_editor_reload (MooEditor     *editor,
                   MooEdit       *doc,
                   MooReloadInfo *info,
                   GError       **errorp)
{
    guint i;
    gerrp error(errorp);
    MooEditViewArray *views = NULL;
    gboolean ret = FALSE;

    moo_return_error_if_fail (MOO_IS_EDITOR (editor));

    if (Edit(*doc)._is_busy())
    {
        g_set_error (&error,
                     MOO_EDIT_RELOAD_ERROR,
                     MOO_EDIT_RELOAD_ERROR_BUSY,
                     "document is busy");
        goto out;
    }

    if (moo_edit_is_untitled (doc))
    {
        g_set_error (&error,
                     MOO_EDIT_RELOAD_ERROR,
                     MOO_EDIT_RELOAD_ERROR_UNTITLED,
                     "document is untitled");
        goto out;
    }

    if (!moo_edit_get_clean (doc) &&
        moo_edit_is_modified (doc) &&
        !_moo_edit_reload_modified_dialog (doc))
    {
        g_set_error (&error,
                     MOO_EDIT_RELOAD_ERROR,
                     MOO_EDIT_RELOAD_ERROR_CANCELLED,
                     "cancelled by user");
        goto out;
    }

    views = moo_edit_get_views (doc);

    for (i = 0; i < moo_edit_view_array_get_size (views); ++i)
    {
        int cursor_line, cursor_offset;
        GtkTextIter iter;
        MooEditView *view = views->elms[i];

        moo_text_view_get_cursor (GTK_TEXT_VIEW (view), &iter);
        cursor_line = gtk_text_iter_get_line (&iter);
        cursor_offset = moo_text_iter_get_visual_line_offset (&iter, 8);

        if (info != NULL && info->line >= 0 && info->line != cursor_line)
        {
            cursor_line = info->line;
            cursor_offset = 0;
        }

        g_object_set_data (G_OBJECT (view), "moo-reload-cursor-line", GINT_TO_POINTER (cursor_line));
        g_object_set_data (G_OBJECT (view), "moo-reload-cursor-offset", GINT_TO_POINTER (cursor_offset));
    }

    if (!_moo_edit_reload_file(*doc, info ? (const char*) info->encoding : nullptr, error))
    {
        if (!_moo_is_file_error_cancelled (error))
            _moo_edit_reload_error_dialog (doc, error.get());

        g_object_set_data (G_OBJECT (doc), "moo-scroll-to", NULL);
        goto out;
    }

    for (i = 0; i < moo_edit_view_array_get_size (views); ++i)
    {
        int cursor_line, cursor_offset;
        MooEditView *view = views->elms[i];

        cursor_line = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (view), "moo-reload-cursor-line"));
        cursor_offset = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (view), "moo-reload-cursor-offset"));

        moo_text_view_move_cursor (MOO_TEXT_VIEW (view), cursor_line,
                                   cursor_offset, TRUE, TRUE);
    }

    ret = TRUE;

out:
    moo_edit_view_array_free (views);
    return ret;
}


static MooSaveResponse
moo_editor_before_save (G_GNUC_UNUSED MooEditor *editor,
                        G_GNUC_UNUSED MooEdit *doc,
                        G_GNUC_UNUSED GFile *file)
{
    return MOO_SAVE_RESPONSE_CONTINUE;
}

static MooEditSaveFlags
moo_editor_get_save_flags (MooEditor *editor)
{
    MooEditSaveFlags flags = MOO_EDIT_SAVE_FLAGS_NONE;

    if (test_flag (editor, SAVE_BACKUPS))
        flags |= MOO_EDIT_SAVE_BACKUP;

    return flags;
}

static void
moo_editor_will_save (G_GNUC_UNUSED MooEditor *editor,
                      MooEdit *doc,
                      G_GNUC_UNUSED GFile *file)
{
    g_return_if_fail(doc != nullptr);
    if (moo_edit_config_get_bool (doc->config, "strip"))
        Edit(*doc)._strip_whitespace();
    if (moo_edit_config_get_bool (doc->config, "add-newline"))
        Edit(*doc)._ensure_newline();
}

static bool
do_save(MooEditor&  editor,
        Edit        doc,
        g::File     file,
        const char* encoding,
        gerrp&      error)
{
    int response = MOO_SAVE_RESPONSE_CONTINUE;
    gerrp error_here;
    gboolean result;

    g_signal_emit(&editor, signals[BEFORE_SAVE], 0, doc, file, &response);

    if (response != MOO_SAVE_RESPONSE_CANCEL)
        doc.signal_emit_by_name("before-save", file, &response);

    if (response == MOO_SAVE_RESPONSE_CANCEL)
    {
        g_set_error(&error,
                    MOO_EDIT_SAVE_ERROR,
                    MOO_EDIT_SAVE_ERROR_CANCELLED,
                    "cancelled");
        return FALSE;
    }

    g_signal_emit(&editor, signals[WILL_SAVE], 0, doc, file);
    doc.signal_emit_by_name("will-save", file);

    result = _moo_edit_save_file(doc, file, encoding,
                                 moo_editor_get_save_flags(&editor),
                                 error_here);
    if (!result && error_here->domain == MOO_EDIT_FILE_ERROR &&
        error_here->code == MOO_EDIT_FILE_ERROR_ENCODING)
    {
        error_here.clear();

        if (_moo_edit_save_error_enc_dialog(doc, file, encoding))
        {
            result = _moo_edit_save_file(doc, file, "UTF-8",
                                         moo_editor_get_save_flags(&editor),
                                         error_here);
        }
        else
        {
            g_set_error(&error,
                        MOO_EDIT_SAVE_ERROR,
                        MOO_EDIT_SAVE_ERROR_CANCELLED,
                        "cancelled");
            return FALSE;
        }
    }

    if (!result)
    {
        _moo_edit_save_error_dialog(doc, file, error_here.get());
        error = std::move(error_here);
        return FALSE;
    }

    update_history_item_for_doc(&editor, &doc, TRUE);

    doc.signal_emit_by_name("after-save");
    g_signal_emit(&editor, signals[AFTER_SAVE], 0, doc);

    return true;
}

/**
 * moo_editor_save:
 **/
gboolean
moo_editor_save (MooEditor  *editor,
                 MooEdit    *doc,
                 GError    **error)
{
    moo_return_error_if_fail (MOO_IS_EDITOR (editor));
    moo_return_error_if_fail (MOO_IS_EDIT (doc));

    if (Edit(*doc)._is_busy())
    {
        g_set_error (error,
                     MOO_EDIT_SAVE_ERROR,
                     MOO_EDIT_SAVE_ERROR_BUSY,
                     "document is busy");
        return FALSE;
    }

    if (moo_edit_is_untitled (doc))
        return moo_editor_save_as (editor, doc, NULL, error);

    g::FilePtr file = wrap_new(moo_edit_get_file(doc));
    gstr encoding = gstr::wrap(moo_edit_get_encoding(doc));

    if ((moo_edit_get_status (doc) & MOO_EDIT_STATUS_MODIFIED_ON_DISK) &&
        !_moo_edit_overwrite_modified_dialog (doc))
    {
        g_set_error (error,
                     MOO_EDIT_SAVE_ERROR,
                     MOO_EDIT_SAVE_ERROR_CANCELLED,
                     "cancelled by user");
        return false;
    }

    gerrp error_here(error);
    return do_save(*editor, *doc, *file, encoding, error_here);
}

/**
 * moo_editor_save_as:
 *
 * @editor:
 * @doc:
 * @info: (allow-none) (default NULL)
 * @error:
 *
 * Save document with new filename and/or encoding. If @info is
 * missing or %NULL then user is asked for new filename first.
 **/
gboolean
moo_editor_save_as (MooEditor   *editor,
                    MooEdit     *doc,
                    MooSaveInfo *info_init,
                    GError     **error)
{
    moo_return_error_if_fail (MOO_IS_EDITOR (editor));
    moo_return_error_if_fail (MOO_IS_EDIT (doc));
    moo_return_error_if_fail (!info_init || !info_init->file);

    if (Edit(*doc)._is_busy())
    {
        g_set_error (error,
                     MOO_EDIT_SAVE_ERROR,
                     MOO_EDIT_SAVE_ERROR_BUSY,
                     "document is busy");
        return false;
    }

    std::unique_ptr<MooSaveInfo> info (info_init ? moo_save_info_dup (info_init) : nullptr);

    if (!info)
    {
        info.reset(_moo_edit_save_as_dialog(doc, moo_edit_get_display_basename(doc)));

        if (!info)
        {
            g_set_error (error,
                         MOO_EDIT_SAVE_ERROR,
                         MOO_EDIT_SAVE_ERROR_CANCELLED,
                         "cancelled by user");
            return false;
        }
    }
    else if (info->encoding.empty())
    {
        info.reset(moo_save_info_new_file(info->file.gobj(), moo_edit_get_encoding(doc)));
    }

    update_history_item_for_doc(editor, doc, FALSE);

    gerrp error_here(error);
    return do_save(*editor, *doc, *info->file, info->encoding, error_here);
}

/**
 * moo_editor_save_copy:
 **/
gboolean
moo_editor_save_copy (MooEditor   *editor,
                      MooEdit     *doc,
                      MooSaveInfo *info,
                      GError     **error)
{
    moo_return_error_if_fail (MOO_IS_EDITOR (editor));
    moo_return_error_if_fail (MOO_IS_EDIT (doc));
    moo_return_error_if_fail (info != nullptr && info->file != nullptr);

    gerrp error_here(error);
    return _moo_edit_save_file_copy (*doc, *info->file,
                                     !info->encoding.empty() ? info->encoding : moo_edit_get_encoding (doc),
                                     moo_editor_get_save_flags (editor),
                                     error_here);
}


static MooEdit *
doc_array_find_norm_name (MooEditArray *docs,
                          const char   *norm_name)
{
    guint i;

    g_return_val_if_fail (docs != NULL, NULL);
    g_return_val_if_fail (norm_name != NULL, NULL);

    for (i = 0; i < docs->n_elms; ++i)
    {
        Edit doc = *docs->elms[i];
        const gstr& doc_norm_name = doc._get_normalized_name();
        if (doc_norm_name == norm_name)
            return &doc;
    }

    return NULL;
}

// static MooEdit *
// doc_array_find_norm_name (const std::vector<gobj_ptr<MooEdit>>& docs,
//                           const char   *norm_name)
// {
//     g_return_val_if_fail (norm_name != NULL, NULL);
//
//     for (const auto& doc: docs)
//     {
//         char *doc_norm_name = _moo_edit_get_normalized_name (doc.gobj());
//         gboolean this_doc = doc_norm_name != NULL && strcmp (doc_norm_name, norm_name) == 0;
//         g_free (doc_norm_name);
//         if (this_doc)
//             return doc.gobj();
//     }
//
//     return NULL;
// }


/**
 * moo_editor_get_doc_for_file:
 *
 * Finds open document by #GFile.
 */
MooEdit *
moo_editor_get_doc_for_file (MooEditor *editor,
                             GFile     *file)
{
    MooEdit *doc = NULL;

    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
    g_return_val_if_fail (G_IS_FILE (file), NULL);

    gstr norm_name = Edit::_get_normalized_name (*file);
    g_return_val_if_fail (!norm_name.empty(), NULL);

    for (const auto& window: editor->priv->windows)
    {
        MooEditArray *docs = moo_edit_window_get_docs (window);
        doc = doc_array_find_norm_name (docs, norm_name);
        moo_edit_array_free (docs);

        if (doc != nullptr)
            break;
    }

    return doc;
}

/**
 * moo_editor_get_doc:
 *
 * @editor:
 * @filename: (type const-filename)
 *
 * Finds open document by filename.
 */
MooEdit *
moo_editor_get_doc (MooEditor  *editor,
                    const char *filename)
{
    GFile *file;
    MooEdit *doc;

    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
    g_return_val_if_fail (filename != NULL, NULL);

    file = g_file_new_for_path (filename);
    doc = moo_editor_get_doc_for_file (editor, file);

    g_object_unref (file);
    return doc;
}

/**
 * moo_editor_get_doc_for_uri:
 *
 * @editor:
 * @uri: (type const-utf8)
 *
 * Finds open document by URI.
 */
MooEdit *
moo_editor_get_doc_for_uri (MooEditor  *editor,
                            const char *uri)
{
    GFile *file;
    MooEdit *doc;

    g_return_val_if_fail (MOO_IS_EDITOR (editor), NULL);
    g_return_val_if_fail (uri != NULL, NULL);

    file = g_file_new_for_uri (uri);
    doc = moo_editor_get_doc_for_file (editor, file);

    g_object_unref (file);
    return doc;
}


/**
 * moo_editor_set_window_type: (moo.lua 0)
 */
void
moo_editor_set_window_type (MooEditor      *editor,
                            GType           type)
{
    g_return_if_fail (MOO_IS_EDITOR (editor));
    g_return_if_fail (g_type_is_a (type, MOO_TYPE_EDIT_WINDOW));
    editor->priv->window_type = type;
}


/**
 * moo_editor_set_doc_type: (moo.lua 0)
 */
void
moo_editor_set_doc_type (MooEditor      *editor,
                         GType           type)
{
    g_return_if_fail (MOO_IS_EDITOR (editor));
    g_return_if_fail (g_type_is_a (type, MOO_TYPE_EDIT));
    editor->priv->doc_type = type;
}


void
_moo_editor_apply_prefs (MooEditor *editor)
{
    gboolean backups;
    const char *color_scheme;

    _moo_edit_window_update_title ();
    _moo_edit_window_set_use_tabs ();

    _moo_edit_update_global_config ();
    _moo_edit_queue_recheck_config_all ();

    color_scheme = moo_prefs_get_string (moo_edit_setting (MOO_EDIT_PREFS_COLOR_SCHEME));

    if (color_scheme)
        _moo_lang_mgr_set_active_scheme (editor->priv->lang_mgr.gobj(), color_scheme);

    backups = moo_prefs_get_bool (moo_edit_setting (MOO_EDIT_PREFS_MAKE_BACKUPS));

    g_object_set (editor,
                  "save-backups", backups,
                  NULL);
}


// void
// _moo_editor_open_uri (MooEditor  *editor,
//                       const char *uri,
//                       const char *encoding,
//                       guint       line,
//                       guint       options)
// {
//     MooEdit *doc;
//     MooEditWindow *window;
//
//     g_return_if_fail (MOO_IS_EDITOR (editor));
//     g_return_if_fail (uri != NULL);
//
//     doc = moo_editor_get_doc_for_uri (editor, uri);
//
//     if (doc)
//     {
//         if (line > 0)
//             moo_text_view_move_cursor (MOO_TEXT_VIEW (doc), line - 1, 0, FALSE, FALSE);
//         moo_editor_set_active_doc (editor, doc);
//         gtk_widget_grab_focus (GTK_WIDGET (doc));
//
//         if (options & MOO_OPEN_RELOAD)
//             _moo_editor_reload (editor, doc, NULL, NULL);
//
//         return;
//     }
//
//     window = moo_editor_get_active_window (editor);
//     doc = window ? moo_edit_window_get_active_doc (window) : NULL;
//
//     if (!doc || !moo_edit_is_empty (doc))
//     {
//         gboolean new_window = moo_prefs_get_bool (moo_edit_setting (MOO_EDIT_PREFS_OPEN_NEW_WINDOW));
//
//         if (options & MOO_OPEN_NEW_TAB)
//             new_window = FALSE;
//         else if (options & MOO_OPEN_NEW_WINDOW)
//             new_window = TRUE;
//
//         if (new_window)
//             window = moo_editor_new_window (editor);
//     }
//
//     doc = moo_editor_new_uri (editor, window, NULL, uri, encoding);
//     g_return_if_fail (doc != NULL);
//
//     moo_editor_set_active_doc (editor, doc);
//     if (line > 0)
//         moo_text_view_move_cursor (MOO_TEXT_VIEW (doc), line - 1, 0, FALSE, TRUE);
//     gtk_widget_grab_focus (GTK_WIDGET (doc));
//
//     if (options & MOO_OPEN_RELOAD)
//         _moo_editor_reload (editor, doc, NULL, NULL);
// }