1 /* 2 * Copyright 2011 kubtek <kubtek@mail.com> 3 * 4 * This file is part of StarDict. 5 * 6 * StarDict is free software: you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation, either version 3 of the License, or 9 * (at your option) any later version. 10 * 11 * StarDict is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with StarDict. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #ifndef _STARDICT_PLUG_MANAGER_H_ 21 #define _STARDICT_PLUG_MANAGER_H_ 22 23 #include <glib.h> 24 #include <gmodule.h> 25 #include <string> 26 #include <vector> 27 #include <list> 28 #include "plugin.h" 29 #include "virtualdictplugin.h" 30 #include "netdictplugin.h" 31 #include "specialdictplugin.h" 32 #include "ttsplugin.h" 33 #include "parsedata_plugin.h" 34 #include "dictbase.h" 35 #include "iappdirs.h" 36 #include "dictitemid.h" 37 38 struct StarDictPluginBaseObject { 39 StarDictPluginBaseObject(const char *filename, GModule *module_, plugin_configure_func_t configure_func_); 40 std::string plugin_filename; 41 GModule *module; 42 plugin_configure_func_t configure_func; 43 }; 44 45 class StarDictPluginBase { 46 public: 47 StarDictPluginBase(StarDictPluginBaseObject *baseobj_); 48 ~StarDictPluginBase(); 49 const char *get_filename(); 50 void configure(); 51 protected: 52 StarDictPluginBaseObject *baseobj; 53 }; 54 55 class StarDictVirtualDictPlugin : public StarDictPluginBase { 56 public: 57 StarDictVirtualDictPlugin(StarDictPluginBaseObject *baseobj, StarDictVirtualDictPlugInObject *virtualdict_plugin_obj); 58 ~StarDictVirtualDictPlugin(); 59 void lookup(const char *word, char ***pppWord, char ****ppppWordData); 60 const char *dict_name(); 61 const char *dict_id(); 62 private: 63 StarDictVirtualDictPlugInObject *obj; 64 }; 65 66 class StarDictVirtualDictPlugins { 67 public: 68 StarDictVirtualDictPlugins(); 69 ~StarDictVirtualDictPlugins(); 70 void add(StarDictPluginBaseObject *baseobj, StarDictVirtualDictPlugInObject *virtualdict_plugin_obj); 71 void lookup(size_t iPlugin, const gchar *word, char ***pppWord, char ****ppppWordData); ndicts()72 size_t ndicts() { return oPlugins.size(); } 73 const char *dict_name(size_t iPlugin); 74 const char *dict_id(size_t iPlugin); 75 bool find_dict_by_id(const DictItemId& id, size_t &iPlugin) const; 76 void unload_plugin(const char *filename); 77 void configure_plugin(const char *filename); 78 void reorder(const std::list<std::string>& order_list); 79 private: 80 std::vector<StarDictVirtualDictPlugin *> oPlugins; 81 }; 82 83 class StarDictNetDictPlugin : public StarDictPluginBase { 84 public: 85 StarDictNetDictPlugin(StarDictPluginBaseObject *baseobj, StarDictNetDictPlugInObject *netdict_plugin_obj); 86 ~StarDictNetDictPlugin(); 87 void lookup(const char *word, bool ismainwin); 88 const char *dict_name(); 89 const char *dict_link(); 90 const char *dict_id(); 91 const char *dict_cacheid(); 92 private: 93 StarDictNetDictPlugInObject *obj; 94 }; 95 96 class StarDictNetDictPlugins { 97 public: 98 StarDictNetDictPlugins(); 99 ~StarDictNetDictPlugins(); 100 void add(StarDictPluginBaseObject *baseobj, StarDictNetDictPlugInObject *netdict_plugin_obj); 101 void lookup(size_t iPlugin, const gchar *word, bool ismainwin); ndicts()102 size_t ndicts() { return oPlugins.size(); } 103 const char *dict_name(size_t iPlugin); 104 const char *dict_link(size_t iPlugin); 105 const char *dict_id(size_t iPlugin); 106 const char *dict_cacheid(size_t iPlugin); 107 bool find_dict_by_id(const DictItemId& id, size_t &iPlugin) const; 108 void unload_plugin(const char *filename); 109 void configure_plugin(const char *filename); 110 void reorder(const std::list<std::string>& order_list); 111 private: 112 std::vector<StarDictNetDictPlugin *> oPlugins; 113 }; 114 115 class StarDictSpecialDictPlugin : public StarDictPluginBase { 116 public: 117 StarDictSpecialDictPlugin(StarDictPluginBaseObject *baseobj, StarDictSpecialDictPlugInObject *speicaldict_plugin_obj); 118 ~StarDictSpecialDictPlugin(); 119 void render_widget(bool ismainwin, size_t dictid, const gchar *orig_word, gchar **Word, gchar ***WordData, GtkWidget **widget); 120 const char *dict_type(); 121 private: 122 StarDictSpecialDictPlugInObject *obj; 123 }; 124 125 class StarDictSpecialDictPlugins { 126 public: 127 StarDictSpecialDictPlugins(); 128 ~StarDictSpecialDictPlugins(); 129 void add(StarDictPluginBaseObject *baseobj, StarDictSpecialDictPlugInObject *specialdict_plugin_obj); 130 void render_widget(size_t iPlugin, bool ismainwin, size_t dictid, const gchar *orig_word, gchar **Word, gchar ***WordData, GtkWidget **widget); nplugins()131 size_t nplugins() { return oPlugins.size(); } 132 const char *dict_type(size_t iPlugin); 133 void unload_plugin(const char *filename); 134 void configure_plugin(const char *filename); 135 void reorder(const std::list<std::string>& order_list); 136 private: 137 std::vector<StarDictSpecialDictPlugin *> oPlugins; 138 }; 139 140 class StarDictTtsPlugin : public StarDictPluginBase { 141 public: 142 StarDictTtsPlugin(StarDictPluginBaseObject *baseobj, StarDictTtsPlugInObject *tts_plugin_obj); 143 ~StarDictTtsPlugin(); 144 void saytext(const gchar *text); 145 const char *tts_name(); 146 private: 147 StarDictTtsPlugInObject *obj; 148 }; 149 150 class StarDictTtsPlugins { 151 public: 152 StarDictTtsPlugins(); 153 ~StarDictTtsPlugins(); 154 void add(StarDictPluginBaseObject *baseobj, StarDictTtsPlugInObject *tts_plugin_obj); 155 void saytext(size_t iPlugin, const gchar *text); 156 const char* tts_name(size_t iPlugin); nplugins()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<StarDictTtsPlugin *> oPlugins; 163 }; 164 165 class StarDictParseDataPlugin : public StarDictPluginBase { 166 public: 167 StarDictParseDataPlugin(StarDictPluginBaseObject *baseobj, StarDictParseDataPlugInObject *parsedata_plugin_obj); 168 ~StarDictParseDataPlugin(); 169 bool parse(const char *p, unsigned int *parsed_size, ParseResult &result, const char *oword); 170 private: 171 StarDictParseDataPlugInObject *obj; 172 }; 173 174 class StarDictParseDataPlugins { 175 public: 176 StarDictParseDataPlugins(); 177 ~StarDictParseDataPlugins(); 178 void add(StarDictPluginBaseObject *baseobj, StarDictParseDataPlugInObject *parsedata_plugin_obj); 179 bool parse(size_t iPlugin, const char *p, unsigned int *parsed_size, ParseResult &result, const char *oword); nplugins()180 size_t nplugins() { return oPlugins.size(); } 181 void unload_plugin(const char *filename); 182 void configure_plugin(const char *filename); 183 void reorder(const std::list<std::string>& order_list); 184 private: 185 std::vector<StarDictParseDataPlugin *> oPlugins; 186 }; 187 188 class StarDictMiscPlugin : public StarDictPluginBase { 189 public: 190 StarDictMiscPlugin(StarDictPluginBaseObject *baseobj); 191 ~StarDictMiscPlugin(); 192 void on_mainwin_finish(); 193 }; 194 195 class StarDictMiscPlugins { 196 public: 197 StarDictMiscPlugins(); 198 ~StarDictMiscPlugins(); 199 void add(StarDictPluginBaseObject *baseobj); 200 void unload_plugin(const char *filename); 201 void configure_plugin(const char *filename); 202 void on_mainwin_finish(); 203 void reorder(const std::list<std::string>& order_list); 204 private: 205 std::vector<StarDictMiscPlugin *> oPlugins; 206 }; 207 208 struct StarDictPluginInfo { 209 std::string filename; 210 StarDictPlugInType plugin_type; 211 std::string info_xml; 212 bool can_configure; 213 }; 214 215 class StarDictPlugins { 216 public: 217 StarDictPlugins(const std::string& dirpath, 218 const std::list<std::string>& order_list, 219 const std::list<std::string>& disable_list); 220 ~StarDictPlugins(); 221 void get_plugin_list(const std::list<std::string>& order_list, std::list<std::pair<StarDictPlugInType, std::list<StarDictPluginInfo> > > &plugin_list); 222 bool get_loaded(const char *filename); 223 void load_plugin(const char *filename); 224 void configure_plugin(const char *filename, StarDictPlugInType plugin_type); 225 void unload_plugin(const char *filename, StarDictPlugInType plugin_type); 226 void reorder(const std::list<std::string>& order_list); 227 StarDictVirtualDictPlugins VirtualDictPlugins; 228 StarDictNetDictPlugins NetDictPlugins; 229 StarDictSpecialDictPlugins SpecialDictPlugins; 230 StarDictTtsPlugins TtsPlugins; 231 StarDictParseDataPlugins ParseDataPlugins; 232 StarDictMiscPlugins MiscPlugins; 233 private: 234 std::string plugindirpath; 235 /* Plugins that we've tried to load irrespective of the fact were they loaded 236 * successfully or not. */ 237 std::list<std::string> loaded_plugin_list; 238 void load(const std::string& dirpath, const std::list<std::string>& order_list, const std::list<std::string>& disable_list); 239 void get_plugin_info(const char *filename, StarDictPlugInType &plugin_type, std::string &info_xml, bool &can_configure); 240 friend class PluginLoader; 241 friend class PluginInfoLoader; 242 }; 243 244 #endif 245