/* * * 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 * * * Authors: * Michel Zucchi * * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com) * */ #if !defined (__E_UTIL_H_INSIDE__) && !defined (LIBEUTIL_COMPILATION) #error "Only should be included directly." #endif #ifndef E_IMPORT_H #define E_IMPORT_H #include /* 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 /* 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 */ eep-1.3.2&id=dc58c1c48fd1be69eb1a859803badcbf94beb521&showmsg=1'>Expand)AuthorAgeFilesLines * Mark a few ports BROKEN, unfetchableantoine2019-11-061-0/+2 * Drop the ipv6 virtual category for i* category as it is not relevant anymorebapt2019-10-091-1/+1 * Convert to UCL & cleanup pkg-message (categories h-k)mat2019-08-141-0/+6 * Now builds on powerpc64 (and thus presumably mips*.)linimon2018-11-151-4/+0 * Mark ports broken on mips64 that are already broken on powerpc64. Inlinimon2018-07-021-0/+2 * - Remove always-true OSVERSION conditionamdmi32018-06-161-6/+4 * Provide more descriptive error messages for ports failing on powerpc64.linimon2017-04-301-1/+1 * Remove all USE_OPENSSL occurrences.mat2017-03-151-2/+1 * When there is a do-install target, do not use a post-install target, domat2016-07-19