vcs.maemo.org Git - mstardict/blob - src/lib/pluginmanager.h

   1 #ifndef _STARDICT_PLUG_MANAGER_H_
   2 #define _STARDICT_PLUG_MANAGER_H_
   3
   4 #include "plugin.h"
   5 #include "virtualdictplugin.h"
   6 #include "netdictplugin.h"
   7 #include "specialdictplugin.h"
   8 #include "ttsplugin.h"
   9 #include "parsedata_plugin.h"
  10 #include <glib.h>
  11 #include <gmodule.h>
  12 #include <string>
  13 #include <vector>
  14 #include <list>
  15 #include "dictmask.h"
  16
  17 struct StarDictPluginBaseObject {
  18         StarDictPluginBaseObject(const char *filename, GModule *module_, plugin_configure_func_t configure_func_);
  19         std::string plugin_filename;
  20         GModule *module;
  21         plugin_configure_func_t configure_func;
  22 };
  23
  24 class StarDictPluginBase {
  25 public:
  26         StarDictPluginBase(StarDictPluginBaseObject *baseobj_);
  27         ~StarDictPluginBase();
  28         const char *get_filename();
  29         void configure();
  30 protected:
  31         StarDictPluginBaseObject *baseobj;
  32 };
  33
  34 class StarDictVirtualDictPlugin : public StarDictPluginBase {
  35 public:
  36         StarDictVirtualDictPlugin(StarDictPluginBaseObject *baseobj, StarDictVirtualDictPlugInObject *virtualdict_plugin_obj);
  37         ~StarDictVirtualDictPlugin();
  38         void lookup(const char *word, char ***pppWord, char ****ppppWordData);
  39         const char *dict_name();
  40         const char *dict_id();
  41 private:
  42         StarDictVirtualDictPlugInObject *obj;
  43 };
  44
  45 class StarDictVirtualDictPlugins {
  46 public:
  47         StarDictVirtualDictPlugins();
  48         ~StarDictVirtualDictPlugins();
  49         void add(StarDictPluginBaseObject *baseobj, StarDictVirtualDictPlugInObject *virtualdict_plugin_obj);
  50         void lookup(size_t iPlugin, const gchar *word, char ***pppWord, char ****ppppWordData);
  51         size_t ndicts() { return oPlugins.size(); }
  52         const char *dict_name(size_t iPlugin);
  53         const char *dict_id(size_t iPlugin);
  54         bool find_dict_by_id(const char *id, size_t &iPlugin);
  55         void unload_plugin(const char *filename);
  56         void configure_plugin(const char *filename);
  57         void reorder(const std::list<std::string>& order_list);
  58 private:
  59         std::vector<StarDictVirtualDictPlugin *> oPlugins;
  60 };
  61
  62 class StarDictNetDictPlugin : public StarDictPluginBase {
  63 public:
  64         StarDictNetDictPlugin(StarDictPluginBaseObject *baseobj, StarDictNetDictPlugInObject *netdict_plugin_obj);
  65         ~StarDictNetDictPlugin();
  66         void lookup(const char *word, bool ismainwin);
  67         const char *dict_name();
  68         const char *dict_id();
  69         const char *dict_cacheid();
  70 private:
  71         StarDictNetDictPlugInObject *obj;
  72 };
  73
  74 class StarDictNetDictPlugins {
  75 public:
  76         StarDictNetDictPlugins();
  77         ~StarDictNetDictPlugins();
  78         void add(StarDictPluginBaseObject *baseobj, StarDictNetDictPlugInObject *netdict_plugin_obj);
  79         void lookup(size_t iPlugin, const gchar *word, bool ismainwin);
  80         size_t ndicts() { return oPlugins.size(); }
  81         const char *dict_name(size_t iPlugin);
  82         const char *dict_id(size_t iPlugin);
  83         const char *dict_cacheid(size_t iPlugin);
  84         bool find_dict_by_id(const char *id, size_t &iPlugin);
  85         void unload_plugin(const char *filename);
  86         void configure_plugin(const char *filename);
  87         void reorder(const std::list<std::string>& order_list);
  88 private:
  89         std::vector<StarDictNetDictPlugin *> oPlugins;
  90 };
  91
  92 class StarDictSpecialDictPlugin : public StarDictPluginBase {
  93 public:
  94         StarDictSpecialDictPlugin(StarDictPluginBaseObject *baseobj, StarDictSpecialDictPlugInObject *speicaldict_plugin_obj);
  95         ~StarDictSpecialDictPlugin();
  96         void render_widget(bool ismainwin, size_t dictid, const gchar *orig_word, gchar **Word, gchar ***WordData, GtkWidget **widget);
  97         const char *dict_type();
  98 private:
  99         StarDictSpecialDictPlugInObject *obj;
 100 };
 101
 102 class StarDictSpecialDictPlugins {
 103 public:
 104         StarDictSpecialDictPlugins();
 105         ~StarDictSpecialDictPlugins();
 106         void add(StarDictPluginBaseObject *baseobj, StarDictSpecialDictPlugInObject *specialdict_plugin_obj);
 107         void render_widget(size_t iPlugin, bool ismainwin, size_t dictid, const gchar *orig_word, gchar **Word, gchar ***WordData, GtkWidget **widget);
 108         size_t nplugins() { return oPlugins.size(); }
 109         const char *dict_type(size_t iPlugin);
 110         void unload_plugin(const char *filename);
 111         void configure_plugin(const char *filename);
 112         void reorder(const std::list<std::string>& order_list);
 113 private:
 114         std::vector<StarDictSpecialDictPlugin *> oPlugins;
 115 };
 116
 117 class StarDictTtsPlugin : public StarDictPluginBase {
 118 public:
 119         StarDictTtsPlugin(StarDictPluginBaseObject *baseobj, StarDictTtsPlugInObject *tts_plugin_obj);
 120         ~StarDictTtsPlugin();
 121         void saytext(const gchar *text);
 122         const char *tts_name();
 123 private:
 124         StarDictTtsPlugInObject *obj;
 125 };
 126
 127 class StarDictTtsPlugins {
 128 public:
 129         StarDictTtsPlugins();
 130         ~StarDictTtsPlugins();
 131         void add(StarDictPluginBaseObject *baseobj, StarDictTtsPlugInObject *tts_plugin_obj);
 132         void saytext(size_t iPlugin, const gchar *text);
 133         const char* tts_name(size_t iPlugin);
 134         size_t nplugins() { return oPlugins.size(); }
 135         void unload_plugin(const char *filename);
 136         void configure_plugin(const char *filename);
 137         void reorder(const std::list<std::string>& order_list);
 138 private:
 139         std::vector<StarDictTtsPlugin *> oPlugins;
 140 };
 141
 142 class StarDictParseDataPlugin : public StarDictPluginBase {
 143 public:
 144         StarDictParseDataPlugin(StarDictPluginBaseObject *baseobj, StarDictParseDataPlugInObject *parsedata_plugin_obj);
 145         ~StarDictParseDataPlugin();
 146         bool parse(const char *p, unsigned int *parsed_size, ParseResult &result, const char *oword);
 147 private:
 148         StarDictParseDataPlugInObject *obj;
 149 };
 150
 151 class StarDictParseDataPlugins {
 152 public:
 153         StarDictParseDataPlugins();
 154         ~StarDictParseDataPlugins();
 155         void add(StarDictPluginBaseObject *baseobj, StarDictParseDataPlugInObject *parsedata_plugin_obj);
 156         bool parse(size_t iPlugin, const char *p, unsigned int *parsed_size, ParseResult &result, const char *oword);
 157         size_t nplugins() { return oPlugins.size(); }
 158         void unload_plugin(const char *filename);
 159         void configure_plugin(const char *filename);
 160         void reorder(const std::list<std::string>& order_list);
 161 private:
 162         std::vector<StarDictParseDataPlugin *> oPlugins;
 163 };
 164
 165 class StarDictMiscPlugin : public StarDictPluginBase {
 166 public:
 167         StarDictMiscPlugin(StarDictPluginBaseObject *baseobj);
 168         ~StarDictMiscPlugin();
 169 };
 170
 171 class StarDictMiscPlugins {
 172 public:
 173         StarDictMiscPlugins();
 174         ~StarDictMiscPlugins();
 175         void add(StarDictPluginBaseObject *baseobj);
 176         void unload_plugin(const char *filename);
 177         void configure_plugin(const char *filename);
 178         void reorder(const std::list<std::string>& order_list);
 179 private:
 180         std::vector<StarDictMiscPlugin *> oPlugins;
 181 };
 182
 183 struct StarDictPluginInfo {
 184         std::string filename;
 185         StarDictPlugInType plugin_type;
 186         std::string info_xml;
 187         bool can_configure;
 188 };
 189
 190 class StarDictPlugins {
 191 public:
 192         StarDictPlugins(const char *dirpath, const std::list<std::string>& order_list, const std::list<std::string>& disable_list);
 193         ~StarDictPlugins();
 194         void get_plugin_list(const std::list<std::string>& order_list, std::list<std::pair<StarDictPlugInType, std::list<StarDictPluginInfo> > > &plugin_list);
 195         bool get_loaded(const char *filename);
 196         void load_plugin(const char *filename);
 197         void configure_plugin(const char *filename, StarDictPlugInType plugin_type);
 198         void unload_plugin(const char *filename, StarDictPlugInType plugin_type);
 199         void reorder(const std::list<std::string>& order_list);
 200         StarDictVirtualDictPlugins VirtualDictPlugins;
 201         StarDictNetDictPlugins NetDictPlugins;
 202         StarDictSpecialDictPlugins SpecialDictPlugins;
 203         StarDictTtsPlugins TtsPlugins;
 204         StarDictParseDataPlugins ParseDataPlugins;
 205 private:
 206         StarDictMiscPlugins MiscPlugins;
 207         std::string plugindirpath;
 208         std::list<std::string> loaded_plugin_list;
 209         void load(const char *dirpath, const std::list<std::string>& order_list, const std::list<std::string>& disable_list);
 210         void get_plugin_info(const char *filename, StarDictPlugInType &plugin_type, std::string &info_xml, bool &can_configure);
 211         friend class PluginLoader;
 212         friend class PluginInfoLoader;
 213 };
 214
 215 #endif