aboutsummaryrefslogblamecommitdiffstats
path: root/e-util/e-import.h
blob: 57bb79450d49fd595bb231e7eaf91a2a669d8731 (plain) (tree)
1
2
3
4
5
6
7
8
9
10
11
  
  



                                                                
  



                                                                    
  
                                                                   
                                                                             
  
  



                                                        


   

                  
 
                    
 

















                                             
 
             







                                                

                                                                                          
 

                                                                              
                                                                                            
                                                                                           
                                                                                     








                                                                                   

                            


                                                                           
                                                                                                                                   
                           

                                                                             






                                           
                 



                                       
                                 
                                      
 
                           

                

                           



                                               
  

                                                              


                                                        
  



                                                                   
                        


                     

                    






                                                                  
                             
 

                        


                           
                             



                                                   
  

                       


                                                        




                       
                  
 
                                 
                                 
                           



                                                          
  







                                                                      
  



                                  
                         
 

                                                                        

  





















                                                                              


                                                                       
















                                                                        
 








                                                                            


















                                                      

































                                                                     
                    






                                                                     
                  










                                                        



                                                                          
 
           
 
                       
/*
 *
 * 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)
 *
 */

#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);
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 object);
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 */