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