path: root/e-util/e-import.c

/*
 * This program 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 of the License, or (at your option) version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Authors:
 *      Michael Zucchi <notzed@ximian.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef HAVE_IMPORT_H
#include <import.h>
#endif

#include <string.h>
#include <stdlib.h>

#include <gtk/gtk.h>

#include "e-import.h"

#include <glib/gi18n.h>

#define d(x)

typedef struct _EImportImporters EImportImporters;

struct _EImportImporters {
    EImportImporter *importer;
    EImportImporterFunc free;
    gpointer data;
};

G_DEFINE_TYPE (
    EImport,
    e_import,
    G_TYPE_OBJECT)

static void
import_finalize (GObject *object)
{
    EImport *import = E_IMPORT (object);

    g_free (import->id);

    /* Chain up to parent's finalize () method. */
    G_OBJECT_CLASS (e_import_parent_class)->finalize (object);
}

static void
import_target_free (EImport *import,
                    EImportTarget *target)
{
    switch (target->type) {
    case E_IMPORT_TARGET_URI: {
        EImportTargetURI *s = (EImportTargetURI *) target;

        g_free (s->uri_src);
        g_free (s->uri_dest);
        break; }
    default:
        break;
    }

    g_datalist_clear (&target->data);
    g_free (target);
    g_object_unref (import);
}

static void
e_import_class_init (EImportClass *class)
{
    GObjectClass *object_class;

    object_class = G_OBJECT_CLASS (class);
    object_class->finalize = import_finalize;

    class->target_free = import_target_free;
}

static void
e_import_init (EImport *import)
{
}

/**
 * e_import_construct:
 * @import: The instance to initialise.
 * @id: The name of the instance.
 *
 * Used by implementing classes to initialise base parameters.
 *
 * Return value: @ep is returned.
 **/
EImport *
e_import_construct (EImport *import,
                    const gchar *id)
{
    import->id = g_strdup (id);

    return import;
}

EImport *
e_import_new (const gchar *id)
{
    EImport *import;

    import = g_object_new (E_TYPE_IMPORT, NULL);

    return e_import_construct (import, id);
}

/**
 * e_import_import:
 * @import: an #EImport
 * @target: Target to import.
 * @importer: Importer to use.
 * @status: Status callback, called with progress information.
 * @done: Complete callback, will always be called once complete.
 * @data: user data for callback functions
 *
 * Run the import function of the selected importer.  Once the
 * importer has finished, it MUST call the e_import_complete ()
 * function.  This allows importers to run in synchronous or
 * asynchronous mode.
 *
 * When complete, the @done callback will be called.
 **/
void
e_import_import (EImport *import,
                 EImportTarget *target,
                 EImportImporter *importer,
                 EImportStatusFunc status,
                 EImportCompleteFunc done,
                 gpointer data)
{
    g_return_if_fail (importer != NULL);

    import->status = status;
    import->done = done;
    import->done_data = data;

    importer->import (import, target, importer);
}

void
e_import_cancel (EImport *import,
                 EImportTarget *t,
                 EImportImporter *im)
{
    if (im->cancel)
        im->cancel (import, t, im);
}

/**
 * e_import_get_widget:
 * @import: an #EImport
 * @target: Target of interest
 * @importer: Importer to get widget of
 *
 * Gets a widget that the importer uses to configure its
 * destination.  This widget should be packed into a container
 * widget.  It should not be shown_all.
 *
 * Return value: NULL if the importer doesn't support/require
 * a destination.
 **/
GtkWidget *
e_import_get_widget (EImport *import,
                     EImportTarget *target,
                     EImportImporter *importer)
{
    g_return_val_if_fail (importer != NULL, NULL);
    g_return_val_if_fail (target != NULL, NULL);

    return importer->get_widget (import, target, importer);
}

/**
 * e_import_get_preview_widget:
 * @import: an #EImport
 * @target: Target of interest
 * @im: Importer to get a preview widget of
 *
 * Gets a widget that the importer uses to preview data to be
 * imported.  This widget should be packed into a container
 * widget.  It should not be shown_all.
 *
 * Return value: NULL if the importer doesn't support preview.
 **/
GtkWidget *
e_import_get_preview_widget (EImport *import,
                     EImportTarget *target,
                     EImportImporter *im)
{
    g_return_val_if_fail (im != NULL, NULL);
    g_return_val_if_fail (target != NULL, NULL);

    if (!im->get_preview)
        return NULL;

    return im->get_preview (import, target, im);
}

/**
 * e_import_complete:
 * @import: an #EImport
 * @target: Target just completed (unused currently)
 *
 * Signify that an import is complete.  This must be called by
 * importer implementations when they are done.
 **/
void
e_import_complete (EImport *import,
                   EImportTarget *target)
{
    if (import->done)
        import->done (import, import->done_data);
}

void
e_import_status (EImport *import,
                 EImportTarget *target,
                 const gchar *what,
                 gint pc)
{
    if (import->status)
        import->status (import, what, pc, import->done_data);
}

/**
 * e_import_get_importers:
 * @import: an #EImport
 * @target: an #EImportTarget
 *
 * Get a list of importers.  If @target is supplied, then only
 * importers which support the type and location specified by the
 * target are listed.  If @target is NULL, then all importers are
 * listed.
 *
 * Return value: A list of importers.  The list should be freed when
 * no longer needed.
 **/
GSList *
e_import_get_importers (EImport *import,
                        EImportTarget *target)
{
    GSList *importers = NULL;
    GList *link;

    link = E_IMPORT_GET_CLASS (import)->importers;

    while (link != NULL) {
        EImportImporters *ei = link->data;

        if (target == NULL
            || (ei->importer->type == target->type
            && ei->importer->supported (import, target, ei->importer))) {
            importers = g_slist_append (importers, ei->importer);
        }

        link = g_list_next (link);
    }

    return importers;
}

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

static gint
importer_compare (EImportImporters *node_a,
                  EImportImporters *node_b)
{
    gint pri_a = node_a->importer->pri;
    gint pri_b = node_b->importer->pri;

    return (pri_a == pri_b) ? 0 : (pri_a < pri_b) ? -1 : 1;
}

/**
 * e_import_class_add_importer:
 * @klass: An initialised implementing instance of EImport.
 * @importer: Importer to add.
 * @freefunc: If supplied, called to free the importer node
 * when it is no longer needed.
 * @data: Data for the callback.
 *
 **/
void
e_import_class_add_importer (EImportClass *klass,
                             EImportImporter *importer,
                             EImportImporterFunc freefunc,
                             gpointer data)
{
    EImportImporters *node;

    node = g_malloc (sizeof (*node));
    node->importer = importer;
    node->free = freefunc;
    node->data = data;

    klass->importers = g_list_sort (
        g_list_prepend (klass->importers, node),
        (GCompareFunc) importer_compare);
}

/**
 * e_import_target_new:
 * @import: an #EImport
 * @type: type, up to implementor
 * @size: Size of object to allocate.
 *
 * Allocate a new import target suitable for this class.  Implementing
 * classes will define the actual content of the target.
 **/
gpointer
e_import_target_new (EImport *import,
                     gint type,
                     gsize size)
{
    EImportTarget *target;

    if (size < sizeof (EImportTarget)) {
        g_warning ("Size less than size of EImportTarget\n");
        size = sizeof (EImportTarget);
    }

    target = g_malloc0 (size);
    target->import = g_object_ref (import);
    target->type = type;

    g_datalist_init (&target->data);

    return target;
}

/**
 * e_import_target_free:
 * @import: an #EImport
 * @target: the target to free
 *
 * Free a target.  The implementing class can override this method to
 * free custom targets.
 **/
void
e_import_target_free (EImport *import,
                      gpointer target)
{
    E_IMPORT_GET_CLASS (import)->target_free (
        import, (EImportTarget *) target);
}

EImportTargetURI *
e_import_target_new_uri (EImport *import,
                         const gchar *uri_src,
                         const gchar *uri_dst)
{
    EImportTargetURI *t;

    t = e_import_target_new (import, E_IMPORT_TARGET_URI, sizeof (*t));
    t->uri_src = g_strdup (uri_src);
    t->uri_dest = g_strdup (uri_dst);

    return t;
}

EImportTargetHome *
e_import_target_new_home (EImport *import)
{
    return e_import_target_new (
        import, E_IMPORT_TARGET_HOME, sizeof (EImportTargetHome));
}

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

/* Import menu plugin handler */

/*
 * <e-plugin
 *   class="org.gnome.mail.plugin.import:1.0"
 *   id="org.gnome.mail.plugin.import.item:1.0"
 *   type="shlib"
 *   location="/opt/gnome2/lib/camel/1.0/libcamelimap.so"
 *   name="imap"
 *   description="IMAP4 and IMAP4v1 mail store">
 *   <hook class="org.gnome.mail.importMenu:1.0"
 *         handler="HandleImport">
 *   <menu id="any" target="select">
 *    <item
 *     type="item|toggle|radio|image|submenu|bar"
 *     active
 *     path="foo/bar"
 *     label="label"
 *     icon="foo"
 *     activate="ep_view_emacs"/>
 *   </menu>
 * </e-plugin>
 */

#define emph ((EImportHook *)eph)

static const EImportHookTargetMask eih_no_masks[] = {
    { NULL }
};

static const EImportHookTargetMap eih_targets[] = {
    { "uri", E_IMPORT_TARGET_URI, eih_no_masks },
    { "home", E_IMPORT_TARGET_HOME, eih_no_masks },
    { NULL }
};

G_DEFINE_TYPE (
    EImportHook,
    e_import_hook,
    E_TYPE_PLUGIN_HOOK)

static gboolean
eih_supported (EImport *ei,
               EImportTarget *target,
               EImportImporter *im)
{
    struct _EImportHookImporter *ihook = (EImportHookImporter *) im;
    EImportHook *hook = im->user_data;

    return e_plugin_invoke (hook->hook.plugin, ihook->supported, target) != NULL;
}

static GtkWidget *
eih_get_widget (EImport *ei,
                EImportTarget *target,
                EImportImporter *im)
{
    struct _EImportHookImporter *ihook = (EImportHookImporter *) im;
    EImportHook *hook = im->user_data;

    return e_plugin_invoke (hook->hook.plugin, ihook->get_widget, target);
}

static void
eih_import (EImport *ei,
            EImportTarget *target,
            EImportImporter *im)
{
    struct _EImportHookImporter *ihook = (EImportHookImporter *) im;
    EImportHook *hook = im->user_data;

    e_plugin_invoke (hook->hook.plugin, ihook->import, target);
}

static void
eih_cancel (EImport *ei,
            EImportTarget *target,
            EImportImporter *im)
{
    struct _EImportHookImporter *ihook = (EImportHookImporter *) im;
    EImportHook *hook = im->user_data;

    e_plugin_invoke (hook->hook.plugin, ihook->cancel, target);
}

static void
eih_free_importer (EImportImporter *im,
                   gpointer data)
{
    EImportHookImporter *ihook = (EImportHookImporter *) im;

    g_free (ihook->supported);
    g_free (ihook->get_widget);
    g_free (ihook->import);
    g_free (ihook);
}

static struct _EImportHookImporter *
emph_construct_importer (EPluginHook *eph,
                         xmlNodePtr root)
{
    struct _EImportHookImporter *item;
    EImportHookTargetMap *map;
    EImportHookClass *class = (EImportHookClass *) G_OBJECT_GET_CLASS (eph);
    gchar *tmp;

    d (printf ("  loading import item\n"));
    item = g_malloc0 (sizeof (*item));

    tmp = (gchar *) xmlGetProp (root, (const guchar *)"target");
    if (tmp == NULL)
        goto error;
    map = g_hash_table_lookup (class->target_map, tmp);
    xmlFree (tmp);
    if (map == NULL)
        goto error;

    item->importer.type = map->id;
    item->supported = e_plugin_xml_prop (root, "supported");
    item->get_widget = e_plugin_xml_prop (root, "get-widget");
    item->import = e_plugin_xml_prop (root, "import");
    item->cancel = e_plugin_xml_prop (root, "cancel");

    item->importer.name = e_plugin_xml_prop (root, "name");
    item->importer.description = e_plugin_xml_prop (root, "description");

    item->importer.user_data = eph;

    if (item->import == NULL || item->supported == NULL)
        goto error;

    item->importer.supported = eih_supported;
    item->importer.import = eih_import;
    if (item->get_widget)
        item->importer.get_widget = eih_get_widget;
    if (item->cancel)
        item->importer.cancel = eih_cancel;

    return item;
error:
    d (printf ("error!\n"));
    eih_free_importer ((EImportImporter *) item, NULL);
    return NULL;
}

static gint
emph_construct (EPluginHook *eph,
                EPlugin *ep,
                xmlNodePtr root)
{
    xmlNodePtr node;
    EImportClass *class;

    d (printf ("loading import hook\n"));

    if (E_PLUGIN_HOOK_CLASS (e_import_hook_parent_class)->
        construct (eph, ep, root) == -1)
        return -1;

    class = E_IMPORT_HOOK_GET_CLASS (eph)->import_class;

    node = root->children;
    while (node) {
        if (strcmp ((gchar *) node->name, "importer") == 0) {
            struct _EImportHookImporter *ihook;

            ihook = emph_construct_importer (eph, node);
            if (ihook) {
                e_import_class_add_importer (
                    class, &ihook->importer,
                    eih_free_importer, eph);
                emph->importers = g_slist_append (
                    emph->importers, ihook);
            }
        }
        node = node->next;
    }

    eph->plugin = ep;

    return 0;
}

static void
e_import_hook_class_init (EImportHookClass *class)
{
    EPluginHookClass *plugin_hook_class;
    gint ii;

    plugin_hook_class = E_PLUGIN_HOOK_CLASS (class);
    plugin_hook_class->id = "org.gnome.evolution.import:1.0";
    plugin_hook_class->construct = emph_construct;

    /** @HookClass: Evolution Importers
     * @Id: org.gnome.evolution.import:1.0
     * @Target: EImportTarget
     *
     * A hook for data importers.
     **/

    class->target_map = g_hash_table_new (g_str_hash, g_str_equal);
    class->import_class = g_type_class_ref (E_TYPE_IMPORT);

    for (ii = 0; eih_targets[ii].type; ii++)
        e_import_hook_class_add_target_map (class, &eih_targets[ii]);
}

static void
e_import_hook_init (EImportHook *hook)
{
}

/**
 * e_import_hook_class_add_target_map:
 *
 * @class: The dervied EimportHook class.
 * @map: A map used to describe a single EImportTarget type for this
 * class.
 *
 * Add a targe tmap to a concrete derived class of EImport.  The
 * target map enumates the target types available for the implenting
 * class.
 **/
void
e_import_hook_class_add_target_map (EImportHookClass *class,
                                    const EImportHookTargetMap *map)
{
    g_hash_table_insert (
        class->target_map, (gpointer) map->type, (gpointer) map);
}