334 lines
9.0 KiB
C
334 lines
9.0 KiB
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:
|
|
* Michel Zucchi <notzed@ximian.com>
|
|
*
|
|
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
|
|
*
|
|
*/
|
|
|
|
#if !defined (__E_UTIL_H_INSIDE__) && !defined (LIBEUTIL_COMPILATION)
|
|
#error "Only <e-util/e-util.h> should be included directly."
|
|
#endif
|
|
|
|
#ifndef E_IMPORT_H
|
|
#define E_IMPORT_H
|
|
|
|
#include <gtk/gtk.h>
|
|
|
|
/* Standard GObject macros */
|
|
#define E_TYPE_IMPORT \
|
|
(e_import_get_type ())
|
|
#define E_IMPORT(obj) \
|
|
(G_TYPE_CHECK_INSTANCE_CAST \
|
|
((obj), E_TYPE_IMPORT, EImport))
|
|
#define E_IMPORT_CLASS(cls) \
|
|
(G_TYPE_CHECK_CLASS_CAST \
|
|
((cls), E_TYPE_IMPORT, EImportClass))
|
|
#define E_IS_IMPORT(obj) \
|
|
(G_TYPE_CHECK_INSTANCE_TYPE \
|
|
((obj), E_TYPE_IMPORT))
|
|
#define E_IS_IMPORT_CLASS(cls) \
|
|
(G_TYPE_CHECK_CLASS_TYPE \
|
|
((cls), E_TYPE_IMPORT))
|
|
#define E_IMPORT_GET_CLASS(obj) \
|
|
(G_TYPE_INSTANCE_GET_CLASS \
|
|
((obj), E_TYPE_IMPORT, EImportClass))
|
|
|
|
G_BEGIN_DECLS
|
|
|
|
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,
|
|
gpointer data);
|
|
typedef void (*EImportStatusFunc) (EImport *ei,
|
|
const gchar *what,
|
|
gint pc,
|
|
gpointer data);
|
|
|
|
typedef void (*EImportFactoryFunc) (EImport *ei,
|
|
gpointer data);
|
|
typedef void (*EImportImporterFunc) (EImportImporter *importer,
|
|
gpointer data);
|
|
typedef gboolean (*EImportSupportedFunc) (EImport *ei,
|
|
EImportTarget *,
|
|
EImportImporter *im);
|
|
typedef GtkWidget * (*EImportWidgetFunc) (EImport *ei,
|
|
EImportTarget *,
|
|
EImportImporter *im);
|
|
typedef void (*EImportImportFunc) (EImport *ei,
|
|
EImportTarget *,
|
|
EImportImporter *im);
|
|
|
|
/* 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 assistant. It will update the target.
|
|
* @import: Run the import.
|
|
* @cancel: Cancel the import.
|
|
* @get_preview: Callback to create a preview widget for just importing data.
|
|
* @user_data: User data for the callbacks;
|
|
*
|
|
* Base importer description.
|
|
**/
|
|
struct _EImportImporter {
|
|
enum _e_import_target_t type;
|
|
|
|
gint pri;
|
|
|
|
EImportSupportedFunc supported;
|
|
EImportWidgetFunc get_widget;
|
|
EImportImportFunc import;
|
|
EImportImportFunc cancel;
|
|
EImportWidgetFunc get_preview;
|
|
|
|
gpointer user_data;
|
|
|
|
/* ?? */
|
|
gchar *name;
|
|
gchar *description;
|
|
};
|
|
|
|
/**
|
|
* struct _EImportTarget - importation context.
|
|
*
|
|
* @import: The parent object.
|
|
* @type: The type of target, defined by implementing classes.
|
|
* @data: This can be used to store run-time information
|
|
* about this target. Any allocated data must be set so
|
|
* as to free it when the target is freed.
|
|
*
|
|
* The base target object is used as the parent and placeholder for
|
|
* import context for a given importer.
|
|
**/
|
|
struct _EImportTarget {
|
|
EImport *import;
|
|
|
|
guint32 type;
|
|
|
|
GData *data;
|
|
|
|
/* implementation fields follow, depends on target type */
|
|
};
|
|
|
|
typedef struct _EImportTargetURI EImportTargetURI;
|
|
typedef struct _EImportTargetHome EImportTargetHome;
|
|
|
|
struct _EImportTargetURI {
|
|
EImportTarget target;
|
|
|
|
gchar *uri_src;
|
|
gchar *uri_dest;
|
|
};
|
|
|
|
struct _EImportTargetHome {
|
|
EImportTarget target;
|
|
};
|
|
|
|
/**
|
|
* struct _EImport - An importer management object.
|
|
*
|
|
* @object: Superclass.
|
|
* @id: ID of importer.
|
|
* @status: Status callback of current running import.
|
|
* @done: Completion callback of current running import.
|
|
* @done_data: Callback data for both of above.
|
|
*
|
|
**/
|
|
struct _EImport {
|
|
GObject object;
|
|
|
|
gchar *id;
|
|
|
|
EImportStatusFunc status;
|
|
EImportCompleteFunc done;
|
|
gpointer 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;
|
|
|
|
GList *importers;
|
|
|
|
void (*target_free) (EImport *import,
|
|
EImportTarget *target);
|
|
};
|
|
|
|
GType e_import_get_type (void) G_GNUC_CONST;
|
|
EImport * e_import_new (const gchar *id);
|
|
void e_import_class_add_importer (EImportClass *klass,
|
|
EImportImporter *importer,
|
|
EImportImporterFunc freefunc,
|
|
gpointer data);
|
|
GSList * e_import_get_importers (EImport *import,
|
|
EImportTarget *target);
|
|
EImport * e_import_construct (EImport *import,
|
|
const gchar *id);
|
|
void e_import_import (EImport *import,
|
|
EImportTarget *target,
|
|
EImportImporter *importer,
|
|
EImportStatusFunc status,
|
|
EImportCompleteFunc done,
|
|
gpointer data);
|
|
void e_import_cancel (EImport *import,
|
|
EImportTarget *target,
|
|
EImportImporter *importer);
|
|
GtkWidget * e_import_get_widget (EImport *import,
|
|
EImportTarget *target,
|
|
EImportImporter *importer);
|
|
GtkWidget * e_import_get_preview_widget (EImport *import,
|
|
EImportTarget *target,
|
|
EImportImporter *im);
|
|
void e_import_status (EImport *import,
|
|
EImportTarget *target,
|
|
const gchar *what,
|
|
gint pc);
|
|
void e_import_complete (EImport *import,
|
|
EImportTarget *target);
|
|
gpointer e_import_target_new (EImport *import,
|
|
gint type,
|
|
gsize size);
|
|
void e_import_target_free (EImport *import,
|
|
gpointer target);
|
|
EImportTargetURI *
|
|
e_import_target_new_uri (EImport *import,
|
|
const gchar *uri_src,
|
|
const gchar *uri_dst);
|
|
EImportTargetHome *
|
|
e_import_target_new_home (EImport *import);
|
|
|
|
/* ********************************************************************** */
|
|
|
|
/* 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>
|
|
|
|
/* Standard GObject macros */
|
|
#define E_TYPE_IMPORT_HOOK \
|
|
(e_import_hook_get_type ())
|
|
#define E_IMPORT_HOOK(obj) \
|
|
(G_TYPE_CHECK_INSTANCE_CAST \
|
|
((obj), E_TYPE_IMPORT_HOOK, EImportHook))
|
|
#define E_IMPORT_HOOK_CLASS(cls) \
|
|
(G_TYPE_CHECK_CLASS_CAST \
|
|
((cls), E_TYPE_IMPORT_HOOK, EImportHookClass))
|
|
#define E_IS_IMPORT_HOOK(obj) \
|
|
(G_TYPE_CHECK_INSTANCE_TYPE \
|
|
((obj), E_TYPE_IMPORT_HOOK))
|
|
#define E_IS_IMPORT_HOOK_CLASS(cls) \
|
|
(G_TYPE_CHECK_CLASS_TYPE \
|
|
((cls), E_TYPE_IMPORT_HOOK))
|
|
#define E_IMPORT_HOOK_GET_CLASS(obj) \
|
|
(G_TYPE_INSTANCE_GET_CLASS \
|
|
((obj), E_TYPE_IMPORT_HOOK, EImportHookClass))
|
|
|
|
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 */
|
|
|
|
gchar *supported;
|
|
gchar *get_widget;
|
|
gchar *import;
|
|
gchar *cancel;
|
|
};
|
|
|
|
/**
|
|
* 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;
|
|
};
|
|
|
|
/**
|
|
* EImportHookClass:
|
|
* @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
|
|
* import 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);
|
|
void e_import_hook_class_add_target_map
|
|
(EImportHookClass *klass,
|
|
const EImportHookTargetMap *map);
|
|
|
|
G_END_DECLS
|
|
|
|
#endif /* E_IMPORT_H */
|