/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* Authors: Michael Zucchi <notzed@ximian.com>
*
* Copyright 2005 Novell Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#ifdef HAVE_IMPORT_H
#include <import.h>
#endif
#include <string.h>
#include <stdlib.h>
#include <glib.h>
#include <gtk/gtknotebook.h>
#include <gtk/gtkvbox.h>
#include <gtk/gtkhbox.h>
#include <gtk/gtktable.h>
#include <gtk/gtklabel.h>
#include <gtk/gtkframe.h>
#include <gtk/gtkalignment.h>
#include <libgnomeui/gnome-druid.h>
#include <libgnomeui/gnome-druid-page-standard.h>
#include <libgnomeui/gnome-druid-page-edge.h>
#include "e-import.h"
#include <e-util/e-icon-factory.h>
#include <glib/gi18n.h>
#define d(x)
#define _PRIVATE(o) (g_type_instance_get_private ((GTypeInstance *)o, e_import_get_type()))
struct _EImportImporters {
struct _EImportImporters *next, *prev;
EImportImporter *importer;
EImportImporterFunc free;
void *data;
};
struct _EImportPrivate {
int dummy;
};
static GObjectClass *ep_parent;
static void
ep_init(GObject *o)
{
/*EImport *emp = (EImport *)o;*/
}
static void
ep_finalise(GObject *o)
{
EImport *emp = (EImport *)o;
d(printf("finalising EImport %p\n", o));
g_free(emp->id);
((GObjectClass *)ep_parent)->finalize(o);
}
static void
ec_target_free(EImport *ep, EImportTarget *t)
{
switch (t->type) {
case E_IMPORT_TARGET_URI: {
EImportTargetURI *s = (EImportTargetURI *)t;
g_free(s->uri_src);
g_free(s->uri_dest);
break; }
case E_IMPORT_TARGET_HOME: {
EImportTargetHome *s = (EImportTargetHome *)t;
g_free(s->homedir);
break; }
}
g_datalist_clear(&t->data);
g_free(t);
g_object_unref(ep);
}
static void
ep_class_init(GObjectClass *klass)
{
d(printf("EImport class init %p '%s'\n", klass, g_type_name(((GObjectClass *)klass)->g_type_class.g_type)));
g_type_class_add_private(klass, sizeof(struct _EImportPrivate));
klass->finalize = ep_finalise;
((EImportClass *)klass)->target_free = ec_target_free;
}
static void
ep_base_init(GObjectClass *klass)
{
e_dlist_init(&((EImportClass *)klass)->importers);
}
/**
* e_import_get_type:
*
* Standard GObject method. Used to subclass for the concrete
* implementations.
*
* Return value: EImport type.
**/
GType
e_import_get_type(void)
{
static GType type = 0;
if (type == 0) {
static const GTypeInfo info = {
sizeof(EImportClass),
(GBaseInitFunc)ep_base_init, NULL,
(GClassInitFunc)ep_class_init, NULL, NULL,
sizeof(EImport), 0,
(GInstanceInitFunc)ep_init
};
ep_parent = g_type_class_ref(G_TYPE_OBJECT);
type = g_type_register_static(G_TYPE_OBJECT, "EImport", &info, 0);
}
return type;
}
/**
* e_import_construct:
* @ep: 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 *ep, const char *id)
{
ep->id = g_strdup(id);
return ep;
}
EImport *e_import_new(const char *id)
{
EImport *ei = g_object_new(e_import_get_type(), NULL);
return e_import_construct(ei, id);
}
/**
* e_import_import:
* @ei:
* @t: Target to import.
* @im: Importer to use.
* @status: Status callback, called with progress information.
* @done: Complete callback, will always be called once complete.
* @data:
*
* 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 *ei, EImportTarget *t, EImportImporter *im, EImportStatusFunc status, EImportCompleteFunc done, void *data)
{
g_return_if_fail(im != NULL);
g_return_if_fail(im != NULL);
ei->status = status;
ei->done = done;
ei->done_data = data;
im->import(ei, t, im);
}
void e_import_cancel(EImport *ei, EImportTarget *t, EImportImporter *im)
{
if (im->cancel)
im->cancel(ei, t, im);
}
/**
* e_import_get_widget:
* @ei:
* @target: Target of interest
* @im: 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.
**/
struct _GtkWidget *
e_import_get_widget(EImport *ei, EImportTarget *target, EImportImporter *im)
{
g_return_val_if_fail(im != NULL, NULL);
g_return_val_if_fail(target != NULL, NULL);
return im->get_widget(ei, target, im);
}
/**
* e_import_complete:
* @ei:
* @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 *ei, EImportTarget *target)
{
if (ei->done)
ei->done(ei, ei->done_data);
}
void e_import_status(EImport *ei, EImportTarget *target, const char *what, int pc)
{
if (ei->status)
ei->status(ei, what, pc, ei->done_data);
}
/**
* e_import_get_importers:
* @emp:
* @target:
*
* 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 *emp, EImportTarget *target)
{
EImportClass *k = (EImportClass *)G_OBJECT_GET_CLASS(emp);
struct _EImportImporters *ei;
GSList *importers = NULL;
for (ei = (struct _EImportImporters *)k->importers.head;
ei->next;
ei = ei->next) {
if (target == NULL
|| (ei->importer->type == target->type
&& ei->importer->supported(emp, target, ei->importer))) {
importers = g_slist_append(importers, ei->importer);
}
}
return importers;
}
/* ********************************************************************** */
/**
* e_import_class_add_importer:
* @ec: 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, void *data)
{
struct _EImportImporters *node, *ei, *en;
node = g_malloc(sizeof(*node));
node->importer = importer;
node->free = freefunc;
node->data = data;
ei = (struct _EImportImporters *)klass->importers.head;
en = ei->next;
while (en && ei->importer->pri < importer->pri) {
ei = en;
en = en->next;
}
if (en == NULL)
e_dlist_addtail(&klass->importers, (EDListNode *)node);
else {
node->next = ei->next;
node->next->prev = node;
node->prev = ei;
ei->next = node;
}
}
void e_import_class_remove_importer(EImportClass *klass, EImportImporter *f)
{
struct _EImportImporters *ei, *en;
ei = (struct _EImportImporters *)klass->importers.head;
en = ei->next;
while (en) {
if (ei->importer == f) {
e_dlist_remove((EDListNode *)ei);
if (ei->free)
ei->free(f, ei->data);
g_free(ei);
}
ei = en;
en = en->next;
}
}
/**
* e_import_target_new:
* @ep: Parent EImport object.
* @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.
**/
void *e_import_target_new(EImport *ep, int type, size_t size)
{
EImportTarget *t;
if (size < sizeof(EImportTarget)) {
g_warning ("Size less than size of EImportTarget\n");
size = sizeof (EImportTarget);
}
t = g_malloc0(size);
t->import = ep;
g_object_ref(ep);
t->type = type;
g_datalist_init(&t->data);
return t;
}
/**
* e_import_target_free:
* @ep: Parent EImport object.
* @o: The target to fre.
*
* Free a target. The implementing class can override this method to
* free custom targets.
**/
void
e_import_target_free(EImport *ep, void *o)
{
EImportTarget *t = o;
((EImportClass *)G_OBJECT_GET_CLASS(ep))->target_free(ep, t);
}
EImportTargetURI *e_import_target_new_uri(EImport *ei, const char *suri, const char *duri)
{
EImportTargetURI *t = e_import_target_new(ei, E_IMPORT_TARGET_URI, sizeof(*t));
t->uri_src = g_strdup(suri);
t->uri_dest = g_strdup(duri);
return t;
}
EImportTargetHome *e_import_target_new_home(EImport *ei, const char *home)
{
EImportTargetHome *t = e_import_target_new(ei, E_IMPORT_TARGET_HOME, sizeof(*t));
t->homedir = g_strdup(home);
return t;
}
/* ********************************************************************** */
/* 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>
</extension>
*/
static void *emph_parent_class;
#define emph ((EImportHook *)eph)
static const EImportHookTargetMask eih_no_masks[] = {
{ 0 }
};
static const EImportHookTargetMap eih_targets[] = {
{ "uri", E_IMPORT_TARGET_URI, eih_no_masks },
{ "home", E_IMPORT_TARGET_HOME, eih_no_masks },
{ 0 }
};
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 struct _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, void *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 *klass = (EImportHookClass *)G_OBJECT_GET_CLASS(eph);
char *tmp;
d(printf(" loading import item\n"));
item = g_malloc0(sizeof(*item));
tmp = (char *)xmlGetProp(root, (const unsigned char *)"target");
if (tmp == NULL)
goto error;
map = g_hash_table_lookup(klass->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 int
emph_construct(EPluginHook *eph, EPlugin *ep, xmlNodePtr root)
{
xmlNodePtr node;
EImportClass *klass;
d(printf("loading import hook\n"));
if (((EPluginHookClass *)emph_parent_class)->construct(eph, ep, root) == -1)
return -1;
klass = ((EImportHookClass *)G_OBJECT_GET_CLASS(eph))->import_class;
node = root->children;
while (node) {
if (strcmp((char *)node->name, "importer") == 0) {
struct _EImportHookImporter *ihook;
ihook = emph_construct_importer(eph, node);
if (ihook) {
e_import_class_add_importer(klass, &ihook->importer, eih_free_importer, eph);
emph->importers = g_slist_append(emph->importers, ihook);
}
}
node = node->next;
}
eph->plugin = ep;
return 0;
}
static void
emph_finalise(GObject *o)
{
/*EPluginHook *eph = (EPluginHook *)o;*/
/* free importers? */
((GObjectClass *)emph_parent_class)->finalize(o);
}
static void
emph_class_init(EPluginHookClass *klass)
{
int i;
((GObjectClass *)klass)->finalize = emph_finalise;
klass->construct = emph_construct;
/** @HookClass: Evolution Importers
* @Id: org.gnome.evolution.import:1.0
* @Target: EImportTarget
*
* A hook for data importers.
**/
klass->id = "org.gnome.evolution.import:1.0";
d(printf("EImportHook: init class %p '%s'\n", klass, g_type_name(((GObjectClass *)klass)->g_type_class.g_type)));
((EImportHookClass *)klass)->target_map = g_hash_table_new(g_str_hash, g_str_equal);
((EImportHookClass *)klass)->import_class = g_type_class_ref(e_import_get_type());
for (i=0;eih_targets[i].type;i++)
e_import_hook_class_add_target_map((EImportHookClass *)klass, &eih_targets[i]);
}
/**
* e_import_hook_get_type:
*
* Standard GObject function to get the object type.
*
* Return value: The EImportHook class type.
**/
GType
e_import_hook_get_type(void)
{
static GType type = 0;
if (!type) {
static const GTypeInfo info = {
sizeof(EImportHookClass), NULL, NULL, (GClassInitFunc) emph_class_init, NULL, NULL,
sizeof(EImportHook), 0, (GInstanceInitFunc) NULL,
};
emph_parent_class = g_type_class_ref(e_plugin_hook_get_type());
type = g_type_register_static(e_plugin_hook_get_type(), "EImportHook", &info, 0);
}
return type;
}
/**
* e_import_hook_class_add_target_map:
*
* @klass: 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 *klass, const EImportHookTargetMap *map)
{
g_hash_table_insert(klass->target_map, (void *)map->type, (void *)map);
}
