aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--e-util/ChangeLog5
-rw-r--r--e-util/Makefile.am2
-rw-r--r--e-util/e-import.c639
-rw-r--r--e-util/e-import.h262
4 files changed, 908 insertions, 0 deletions
diff --git a/e-util/ChangeLog b/e-util/ChangeLog
index 5f5c407550..610624fb3f 100644
--- a/e-util/ChangeLog
+++ b/e-util/ChangeLog
@@ -1,3 +1,8 @@
+2005-05-19 Not Zed <NotZed@Ximian.com>
+
+ * e-import.[ch]: Initial, and un-finished work on importer plugin
+ hooks.
+
2005-05-16 Not Zed <NotZed@Ximian.com>
* Makefile.am: added e-error.[ch], removed e-error-tool, and added
diff --git a/e-util/Makefile.am b/e-util/Makefile.am
index 888cd47cd5..25db475676 100644
--- a/e-util/Makefile.am
+++ b/e-util/Makefile.am
@@ -39,6 +39,7 @@ eutilinclude_HEADERS = \
e-gui-utils.h \
e-html-utils.h \
e-icon-factory.h \
+ e-import.h \
e-iterator.h \
e-list-iterator.h \
e-list.h \
@@ -78,6 +79,7 @@ libeutil_la_SOURCES = \
e-gui-utils.c \
e-html-utils.c \
e-icon-factory.c \
+ e-import.c \
e-iterator.c \
e-list-iterator.c \
e-list.c \
diff --git a/e-util/e-import.c b/e-util/e-import.c
new file mode 100644
index 0000000000..717805203e
--- /dev/null
+++ b/e-util/e-import.c
@@ -0,0 +1,639 @@
+/* -*- 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., 59 Temple Street #330, Boston, MA 02111-1307, 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 <libgnome/gnome-i18n.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;*/
+ struct _EImportPrivate *p;
+
+ p = _PRIVATE(o);
+}
+
+static void
+ep_finalise(GObject *o)
+{
+ EImport *emp = (EImport *)o;
+ struct _EImportPrivate *p;
+
+ p = _PRIVATE(emp);
+
+ 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_free(t);
+ g_object_unref(ep);
+}
+
+static void
+ec_set_target(EImport *emp, EImportTarget *target)
+{
+ EImportClass *k = (EImportClass *)G_OBJECT_GET_CLASS(emp);
+ struct _EImportImporters *ei;
+
+ if (emp->target)
+ e_import_target_free(emp, target);
+
+ emp->target = target;
+ emp->importer = NULL;
+
+ if (target== NULL)
+ return;
+
+ for (ei = (struct _EImportImporters *)k->importers.head;
+ ei->next;
+ ei = ei->next) {
+ if (ei->importer->type == target->type
+ && ei->importer->supported(emp, ei->importer, ei->importer->user_data)) {
+ emp->importer = ei->importer;
+ break;
+ }
+ }
+}
+
+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)->set_target = ec_set_target;
+ ((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;
+}
+
+/**
+ * e_import_import:
+ * @ei:
+ * @done:
+ * @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, EImportCompleteFunc done, void *data)
+{
+ g_return_if_fail(ei->importer != NULL);
+ g_return_if_fail(ei->target != NULL);
+
+ ei->done = done;
+ ei->done_data = data;
+
+ ei->importer->import(ei, ei->importer, ei->importer->user_data);
+}
+
+/**
+ * e_import_get_widget:
+ * @ei: An import object on which the target has been set.
+ *
+ * Gets a widget that the importer uses to configure its
+ * destination. This widget should be packed into a container
+ * widget.
+ *
+ * Return value: NULL if the importer doesn't support/require
+ * a destination.
+ **/
+struct _GtkWidget *
+e_import_get_widget(EImport *ei)
+{
+ g_return_val_if_fail(ei->importer != NULL, NULL);
+ g_return_val_if_fail(ei->target != NULL, NULL);
+
+ return ei->importer->get_widget(ei, ei->importer, ei->importer->user_data);
+}
+
+/**
+ * e_import_complete:
+ * @ei:
+ *
+ * Signify that an import is complete. This must be called by
+ * importer implementations when they are done.
+ **/
+void e_import_complete(EImport *ei)
+{
+ if (ei->done)
+ ei->done(ei, ei->done_data);
+}
+
+/**
+ * e_import_set_target:
+ * @emp: An initialised EImport.
+ * @target: A target allocated from @emp.
+ *
+ * Sets the target object for the import window. Generally the target
+ * is set only once, and will supply its own "changed" signal which
+ * can be used to drive the modal. This is a virtual method so that
+ * the implementing class can connect to the changed signal and
+ * initiate a e_import_target_changed() call where appropriate.
+ **/
+void
+e_import_set_target(EImport *emp, EImportTarget *target)
+{
+ if (emp->target != target)
+ ((EImportClass *)G_OBJECT_GET_CLASS(emp))->set_target(emp, target);
+}
+
+/**
+ * e_import_get_importers:
+ * @emp:
+ * @target:
+ *
+ * Get a list of importers. If @target is supplied, then only
+ * importers which support the 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, ei->importer, ei->importer->user_data))) {
+ importers = g_slist_append(importers, ei->importer);
+ break;
+ }
+ }
+
+ 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;
+ }
+
+ 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;
+
+ g_assert(size >= sizeof(EImportTarget));
+
+ t = g_malloc0(size);
+ t->import = ep;
+ g_object_ref(ep);
+ t->type = type;
+
+ 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_URI, eih_no_masks },
+ { 0 }
+};
+
+static gboolean eih_supported(EImport *ei, EImportImporter *im, void *data)
+{
+ struct _EImportHookImporter *ihook = (EImportHookImporter *)im;
+ EImportHook *hook = im->user_data;
+
+ return e_plugin_invoke(hook->hook.plugin, ihook->supported, ei) != NULL;
+}
+
+static struct _GtkWidget *eih_get_widget(EImport *ei, EImportImporter *im, void *data)
+{
+ struct _EImportHookImporter *ihook = (EImportHookImporter *)im;
+ EImportHook *hook = im->user_data;
+
+ return e_plugin_invoke(hook->hook.plugin, ihook->get_widget, ei);
+}
+
+static void eih_import(EImport *ei, EImportImporter *im, void *data)
+{
+ struct _EImportHookImporter *ihook = (EImportHookImporter *)im;
+ EImportHook *hook = im->user_data;
+
+ e_plugin_invoke(hook->hook.plugin, ihook->import, ei);
+}
+
+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 = xmlGetProp(root, "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->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;
+
+ 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(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;
+
+ /* this is actually an abstract implementation but list it anyway */
+ 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);
+}
diff --git a/e-util/e-import.h b/e-util/e-import.h
new file mode 100644
index 0000000000..e5bf9b393a
--- /dev/null
+++ b/e-util/e-import.h
@@ -0,0 +1,262 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Authors: Michel Zucchi <notzed@ximian.com>
+ *
+ * Copyright 2003 Ximian, Inc. (www.ximian.com)
+ *
+ * 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., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#ifndef __E_IMPORT_H__
+#define __E_IMPORT_H__
+
+#include <glib-object.h>
+#include "libedataserver/e-msgport.h"
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus */
+
+struct _GtkWindow;
+struct _GtkWidget;
+
+/* This is an importer function */
+
+typedef struct _EImport EImport;
+typedef struct _EImportClass EImportClass;
+
+typedef struct _EImportImporter EImportImporter;
+typedef struct _EImportFactory EImportFactory;
+typedef struct _EImportTarget EImportTarget;
+
+typedef void (*EImportCompleteFunc)(EImport *ei, void *data);
+
+typedef void (*EImportFactoryFunc)(EImport *ei, void *data);
+typedef void (*EImportImporterFunc)(EImportImporter *importer, void *data);
+typedef gboolean (*EImportSupportedFunc)(EImport *ei, EImportImporter *im, void *data);
+typedef struct _GtkWidget *(*EImportWidgetFunc)(EImport *ei, EImportImporter *im, void *data);
+typedef void (*EImportImportFunc)(EImport *ei, EImportImporter *im, void *data);
+
+/* The global target types, implementors may add additional ones */
+enum _e_import_target_t {
+ E_IMPORT_TARGET_URI, /* simple file */
+ E_IMPORT_TARGET_HOME, /* a home-directory thing, i.e. old applications */
+ E_IMPORT_TARGET_LAST = 256
+};
+
+/**
+ * struct _EImportImporter -
+ *
+ * @type: target type
+ * @priority: Priority of importer. Higher values will be processed first.
+ * @supported: Callback to see if this target is supported by the importer.
+ * @get_widget: A widget factory for this importer, if it needs any extra information in the druid. It will update the target.
+ * @import: Run the import.
+ * @user_data: User data for the callbacks;
+ *
+ * Base importer description.
+ **/
+struct _EImportImporter {
+ enum _e_import_target_t type;
+
+ int pri;
+
+ EImportSupportedFunc supported;
+ EImportWidgetFunc get_widget;
+ EImportImportFunc import;
+
+ void *user_data;
+
+ /* ?? */
+ char *name;
+ char *description;
+};
+
+/**
+ * struct _EImportTarget - importation context.
+ *
+ * @import: The parent object.
+ * @type: The type of target, defined by implementing classes.
+ *
+ * The base target object is used as the parent and placeholder for
+ * import context for a given importer.
+ **/
+struct _EImportTarget {
+ struct _EImport *import;
+
+ guint32 type;
+
+ /* implementation fields follow, depends on target type */
+};
+
+typedef struct _EImportTargetURI EImportTargetURI;
+typedef struct _EImportTargetHome EImportTargetHome;
+
+struct _EImportTargetURI {
+ struct _EImportTarget target;
+
+ char *uri_src;
+ char *uri_dest;
+};
+
+struct _EImportTargetHome {
+ struct _EImportTarget target;
+
+ char *homedir;
+};
+
+/**
+ * struct _EImport - An importer management object.
+ *
+ * @object: Superclass.
+ * @id: ID of importer.
+ * @target: The current target.
+ * @importer: The chosen importer for the target.
+ *
+ **/
+struct _EImport {
+ GObject object;
+
+ char *id;
+
+ EImportTarget *target;
+ EImportImporter *importer;
+
+ EImportCompleteFunc done;
+ void *done_data;
+};
+
+/**
+ * struct _EImportClass - Importer manager abstract class.
+ *
+ * @object_class: Superclass.
+ * @factories: A list of factories registered on this type of
+ * importuration manager.
+ * @set_target: A virtual method used to set the target on the
+ * importuration manager. This is used by subclasses so they may hook
+ * into changes on the target to propery drive the manager.
+ * @target_free: A virtual method used to free the target in an
+ * implementation-defined way.
+ *
+ **/
+struct _EImportClass {
+ GObjectClass object_class;
+
+ EDList importers;
+
+ void (*set_target)(EImport *ep, EImportTarget *t);
+ void (*target_free)(EImport *ep, EImportTarget *t);
+};
+
+GType e_import_get_type(void);
+
+/* Static class methods */
+void e_import_class_add_importer(EImportClass *klass, EImportImporter *importer, EImportImporterFunc freefunc, void *data);
+void e_import_class_remove_importer(EImportClass *klass, EImportImporter *f);
+
+GSList *e_import_get_importers(EImport *emp, EImportTarget *target);
+
+EImport *e_import_construct(EImport *, const char *id);
+void e_import_import(EImport *ei, EImportCompleteFunc done, void *data);
+
+struct _GtkWidget *e_import_get_widget(EImport *ei);
+
+void e_import_set_target(EImport *emp, EImportTarget *target);
+struct _GtkWidget *e_import_create_window(EImport *emp, struct _GtkWindow *parent, const char *title);
+void e_import_complete(EImport *);
+
+void *e_import_target_new(EImport *ep, int type, size_t size);
+void e_import_target_free(EImport *ep, void *o);
+
+EImportTargetURI *e_import_target_new_uri(EImport *ei, const char *suri, const char *duri);
+EImportTargetHome *e_import_target_new_home(EImport *ei, const char *home);
+
+/* ********************************************************************** */
+
+/* import plugin target, they are closely integrated */
+
+/* To implement a basic import plugin, you just need to subclass
+ this and initialise the class target type tables */
+
+#include "e-util/e-plugin.h"
+
+typedef struct _EPluginHookTargetMap EImportHookTargetMap;
+typedef struct _EPluginHookTargetKey EImportHookTargetMask;
+
+typedef struct _EImportHook EImportHook;
+typedef struct _EImportHookClass EImportHookClass;
+
+typedef struct _EImportHookImporter EImportHookImporter;
+
+struct _EImportHookImporter {
+ EImportImporter importer;
+
+ /* user_data == EImportHook */
+
+ char *supported;
+ char *get_widget;
+ char *import;
+};
+
+/**
+ * struct _EImportHook - Plugin hook for importuration windows.
+ *
+ * @hook: Superclass.
+ * @groups: A list of EImportHookGroup's of all importuration windows
+ * this plugin hooks into.
+ *
+ **/
+struct _EImportHook {
+ EPluginHook hook;
+
+ GSList *importers;
+};
+
+/**
+ * struct _EImportHookClass - Abstract class for importuration window
+ * plugin hooks.
+ *
+ * @hook_class: Superclass.
+ * @target_map: A table of EImportHookTargetMap structures describing
+ * the possible target types supported by this class.
+ * @import_class: The EImport derived class that this hook
+ * implementation drives.
+ *
+ * This is an abstract class defining the plugin hook point for
+ * importuration windows.
+ *
+ **/
+struct _EImportHookClass {
+ EPluginHookClass hook_class;
+
+ /* EImportHookTargetMap by .type */
+ GHashTable *target_map;
+ /* the import class these imports's belong to */
+ EImportClass *import_class;
+};
+
+GType e_import_hook_get_type(void);
+
+/* for implementors */
+void e_import_hook_class_add_target_map(EImportHookClass *klass, const EImportHookTargetMap *);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __E_IMPORT_H__ */