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

   1 #include "pluginmanager.h"
   2 #include "file.hpp"
   3 #include <string>
   4
   5 StarDictPluginBaseObject::StarDictPluginBaseObject(const char *filename, GModule *module_, plugin_configure_func_t configure_func_):
   6         plugin_filename(filename), module(module_), configure_func(configure_func_)
   7 {
   8 }
   9
  10 StarDictPluginBase::StarDictPluginBase(StarDictPluginBaseObject *baseobj_):
  11         baseobj(baseobj_)
  12 {
  13 }
  14
  15 typedef void (*stardict_plugin_exit_func_t)(void);
  16
  17 StarDictPluginBase::~StarDictPluginBase()
  18 {
  19         union {
  20                 stardict_plugin_exit_func_t stardict_plugin_exit;
  21                 gpointer stardict_plugin_exit_avoid_warning;
  22         } func;
  23         func.stardict_plugin_exit = 0;
  24         if (g_module_symbol (baseobj->module, "stardict_plugin_exit", (gpointer *)&(func.stardict_plugin_exit_avoid_warning))) {
  25                 func.stardict_plugin_exit();
  26         }
  27         g_module_close (baseobj->module);
  28         delete baseobj;
  29 }
  30
  31 void StarDictPluginBase::configure()
  32 {
  33         if (baseobj->configure_func != NULL)
  34                 baseobj->configure_func();
  35 }
  36
  37 const char *StarDictPluginBase::get_filename()
  38 {
  39         return baseobj->plugin_filename.c_str();
  40 }
  41
  42 StarDictPlugins::StarDictPlugins(const char *dirpath, const std::list<std::string>& order_list, const std::list<std::string>& disable_list)
  43 {
  44         plugindirpath = dirpath;
  45         load(dirpath, order_list, disable_list);
  46 }
  47
  48 StarDictPlugins::~StarDictPlugins()
  49 {
  50 }
  51
  52 class PluginLoader {
  53 public:
  54         PluginLoader(StarDictPlugins& plugins_): plugins(plugins_) {}
  55         void operator()(const std::string& url, bool disable) {
  56                 if (!disable)
  57                         plugins.load_plugin(url.c_str());
  58         }
  59 private:
  60         StarDictPlugins& plugins;
  61 };
  62
  63 void StarDictPlugins::load(const char *dirpath, const std::list<std::string>& order_list, const std::list<std::string>& disable_list)
  64 {
  65         std::list<std::string> plugins_dirs;
  66         plugins_dirs.push_back(dirpath);
  67         for_each_file(plugins_dirs, "."G_MODULE_SUFFIX, order_list, disable_list, PluginLoader(*this));
  68 }
  69
  70 void StarDictPlugins::reorder(const std::list<std::string>& order_list)
  71 {
  72         VirtualDictPlugins.reorder(order_list);
  73         NetDictPlugins.reorder(order_list);
  74         SpecialDictPlugins.reorder(order_list);
  75         TtsPlugins.reorder(order_list);
  76         ParseDataPlugins.reorder(order_list);
  77         MiscPlugins.reorder(order_list);
  78 }
  79
  80 bool StarDictPlugins::get_loaded(const char *filename)
  81 {
  82         bool found = false;
  83         for (std::list<std::string>::iterator iter = loaded_plugin_list.begin(); iter != loaded_plugin_list.end(); ++iter) {
  84                 if (*iter == filename) {
  85                         found = true;
  86                         break;
  87                 }
  88         }
  89         return found;
  90 }
  91
  92 class PluginInfoLoader {
  93 public:
  94         PluginInfoLoader(StarDictPlugins& plugins_, std::list<StarDictPluginInfo> &virtualdict_pluginlist_, std::list<StarDictPluginInfo> &netdict_pluginlist_, std::list<StarDictPluginInfo> &specialdict_pluginlist_, std::list<StarDictPluginInfo> &tts_pluginlist_, std::list<StarDictPluginInfo> &parsedata_pluginlist_, std::list<StarDictPluginInfo> &misc_pluginlist_): plugins(plugins_), virtualdict_pluginlist(virtualdict_pluginlist_), netdict_pluginlist(netdict_pluginlist_), specialdict_pluginlist(specialdict_pluginlist_), tts_pluginlist(tts_pluginlist_), parsedata_pluginlist(parsedata_pluginlist_), misc_pluginlist(misc_pluginlist_) {}
  95         void operator()(const std::string& url, bool disable) {
  96                 if (!disable) {
  97                         StarDictPlugInType plugin_type = StarDictPlugInType_UNKNOWN;
  98                         std::string info_xml;
  99                         bool can_configure;
 100                         plugins.get_plugin_info(url.c_str(), plugin_type, info_xml, can_configure);
 101                         if (plugin_type != StarDictPlugInType_UNKNOWN && (!info_xml.empty())) {
 102                                 StarDictPluginInfo plugin_info;
 103                                 plugin_info.filename = url;
 104                                 plugin_info.plugin_type = plugin_type;
 105                                 plugin_info.info_xml = info_xml;
 106                                 plugin_info.can_configure = can_configure;
 107                                 switch (plugin_type) {
 108                                         case StarDictPlugInType_VIRTUALDICT:
 109                                                 virtualdict_pluginlist.push_back(plugin_info);
 110                                                 break;
 111                                         case StarDictPlugInType_NETDICT:
 112                                                 netdict_pluginlist.push_back(plugin_info);
 113                                                 break;
 114                                         case StarDictPlugInType_SPECIALDICT:
 115                                                 specialdict_pluginlist.push_back(plugin_info);
 116                                                 break;
 117                                         case StarDictPlugInType_TTS:
 118                                                 tts_pluginlist.push_back(plugin_info);
 119                                                 break;
 120                                         case StarDictPlugInType_PARSEDATA:
 121                                                 parsedata_pluginlist.push_back(plugin_info);
 122                                                 break;
 123                                         case StarDictPlugInType_MISC:
 124                                                 misc_pluginlist.push_back(plugin_info);
 125                                                 break;
 126                                         default:
 127                                                 break;
 128                                 }
 129                         }
 130                 }
 131         }
 132 private:
 133         StarDictPlugins& plugins;
 134         std::list<StarDictPluginInfo> &virtualdict_pluginlist;
 135         std::list<StarDictPluginInfo> &netdict_pluginlist;
 136         std::list<StarDictPluginInfo> &specialdict_pluginlist;
 137         std::list<StarDictPluginInfo> &tts_pluginlist;
 138         std::list<StarDictPluginInfo> &parsedata_pluginlist;
 139         std::list<StarDictPluginInfo> &misc_pluginlist;
 140 };
 141
 142 void StarDictPlugins::get_plugin_list(const std::list<std::string>& order_list, std::list<std::pair<StarDictPlugInType, std::list<StarDictPluginInfo> > > &plugin_list)
 143 {
 144         plugin_list.clear();
 145         std::list<StarDictPluginInfo> virtualdict_pluginlist;
 146         std::list<StarDictPluginInfo> netdict_pluginlist;
 147         std::list<StarDictPluginInfo> specialdict_pluginlist;
 148         std::list<StarDictPluginInfo> tts_pluginlist;
 149         std::list<StarDictPluginInfo> parsedata_pluginlist;
 150         std::list<StarDictPluginInfo> misc_pluginlist;
 151
 152         std::list<std::string> plugins_dirs;
 153         plugins_dirs.push_back(plugindirpath);
 154         std::list<std::string> disable_list;
 155         for_each_file(plugins_dirs, "."G_MODULE_SUFFIX, order_list, disable_list, PluginInfoLoader(*this, virtualdict_pluginlist, netdict_pluginlist, specialdict_pluginlist, tts_pluginlist, parsedata_pluginlist, misc_pluginlist));
 156
 157         if (!virtualdict_pluginlist.empty()) {
 158                 plugin_list.push_back(std::pair<StarDictPlugInType, std::list<StarDictPluginInfo> >(StarDictPlugInType_VIRTUALDICT, virtualdict_pluginlist));
 159         }
 160         if (!netdict_pluginlist.empty()) {
 161                 plugin_list.push_back(std::pair<StarDictPlugInType, std::list<StarDictPluginInfo> >(StarDictPlugInType_NETDICT, netdict_pluginlist));
 162         }
 163         if (!specialdict_pluginlist.empty()) {
 164                 plugin_list.push_back(std::pair<StarDictPlugInType, std::list<StarDictPluginInfo> >(StarDictPlugInType_SPECIALDICT, specialdict_pluginlist));
 165         }
 166         if (!tts_pluginlist.empty()) {
 167                 plugin_list.push_back(std::pair<StarDictPlugInType, std::list<StarDictPluginInfo> >(StarDictPlugInType_TTS, tts_pluginlist));
 168         }
 169         if (!parsedata_pluginlist.empty()) {
 170                 plugin_list.push_back(std::pair<StarDictPlugInType, std::list<StarDictPluginInfo> >(StarDictPlugInType_PARSEDATA, parsedata_pluginlist));
 171         }
 172         if (!misc_pluginlist.empty()) {
 173                 plugin_list.push_back(std::pair<StarDictPlugInType, std::list<StarDictPluginInfo> >(StarDictPlugInType_MISC, misc_pluginlist));
 174         }
 175 }
 176
 177 typedef bool (*stardict_plugin_init_func_t)(StarDictPlugInObject *obj);
 178
 179 void StarDictPlugins::get_plugin_info(const char *filename, StarDictPlugInType &plugin_type, std::string &info_xml, bool &can_configure)
 180 {
 181         GModule *module;
 182         module = g_module_open (filename, G_MODULE_BIND_LAZY);
 183         if (!module) {
 184                 g_print("Load %s failed!\n", filename);
 185                 return;
 186         }
 187         union {
 188                 stardict_plugin_init_func_t stardict_plugin_init;
 189                 gpointer stardict_plugin_init_avoid_warning;
 190         } func;
 191         func.stardict_plugin_init = 0;
 192         if (!g_module_symbol (module, "stardict_plugin_init", (gpointer *)&(func.stardict_plugin_init_avoid_warning))) {
 193                 g_print("Load %s failed: No stardict_plugin_init func!\n", filename);
 194                 g_module_close (module);
 195                 return;
 196         }
 197         StarDictPlugInObject *plugin_obj = new StarDictPlugInObject();
 198         bool failed = func.stardict_plugin_init(plugin_obj);
 199         if (failed) {
 200                 g_print("Load %s failed!\n", filename);
 201                 g_module_close (module);
 202                 delete plugin_obj;
 203                 return;
 204         }
 205         plugin_type = plugin_obj->type;
 206         info_xml = plugin_obj->info_xml;
 207         can_configure = (plugin_obj->configure_func != NULL);
 208         delete plugin_obj;
 209         g_module_close (module);
 210 }
 211
 212 typedef bool (*stardict_virtualdict_plugin_init_func_t)(StarDictVirtualDictPlugInObject *obj);
 213 typedef bool (*stardict_netdict_plugin_init_func_t)(StarDictNetDictPlugInObject *obj);
 214 typedef bool (*stardict_specialdict_plugin_init_func_t)(StarDictSpecialDictPlugInObject *obj);
 215 typedef bool (*stardict_tts_plugin_init_func_t)(StarDictTtsPlugInObject *obj);
 216 typedef bool (*stardict_parsedata_plugin_init_func_t)(StarDictParseDataPlugInObject *obj);
 217 typedef bool (*stardict_misc_plugin_init_func_t)(void);
 218
 219 void StarDictPlugins::load_plugin(const char *filename)
 220 {
 221         bool found = false;
 222         for (std::list<std::string>::iterator iter = loaded_plugin_list.begin(); iter != loaded_plugin_list.end(); ++iter) {
 223                 if (*iter == filename) {
 224                         found = true;
 225                         break;
 226                 }
 227         }
 228         if (found)
 229                 return;
 230         loaded_plugin_list.push_back(filename);
 231         GModule *module;
 232         module = g_module_open (filename, G_MODULE_BIND_LAZY);
 233         if (!module) {
 234                 g_print("Load %s failed!\n", filename);
 235                 return;
 236         }
 237         union {
 238                 stardict_plugin_init_func_t stardict_plugin_init;
 239                 gpointer stardict_plugin_init_avoid_warning;
 240         } func;
 241         func.stardict_plugin_init = 0;
 242         if (!g_module_symbol (module, "stardict_plugin_init", (gpointer *)&(func.stardict_plugin_init_avoid_warning))) {
 243                 g_print("Load %s failed: No stardict_plugin_init func!\n", filename);
 244                 g_module_close (module);
 245                 return;
 246         }
 247         StarDictPlugInObject *plugin_obj = new StarDictPlugInObject();
 248         bool failed = func.stardict_plugin_init(plugin_obj);
 249         if (failed) {
 250                 g_print("Load %s failed!\n", filename);
 251                 g_module_close (module);
 252                 delete plugin_obj;
 253                 return;
 254         }
 255         StarDictPlugInType ptype = plugin_obj->type;
 256         StarDictPluginBaseObject *baseobj = new StarDictPluginBaseObject(filename, module, plugin_obj->configure_func);
 257         delete plugin_obj;
 258         if (ptype == StarDictPlugInType_VIRTUALDICT) {
 259                 union {
 260                         stardict_virtualdict_plugin_init_func_t stardict_virtualdict_plugin_init;
 261                         gpointer stardict_virtualdict_plugin_init_avoid_warning;
 262                 } func2;
 263                 func2.stardict_virtualdict_plugin_init = 0;
 264                 if (!g_module_symbol (module, "stardict_virtualdict_plugin_init", (gpointer *)&(func2.stardict_virtualdict_plugin_init_avoid_warning))) {
 265                         printf("Load %s failed: No stardict_virtualdict_plugin_init func!\n", filename);
 266                         g_module_close (module);
 267                         delete baseobj;
 268                         return;
 269                 }
 270                 StarDictVirtualDictPlugInObject *virtualdict_plugin_obj = new StarDictVirtualDictPlugInObject();
 271                 failed = func2.stardict_virtualdict_plugin_init(virtualdict_plugin_obj);
 272                 if (failed) {
 273                         g_print("Load %s failed!\n", filename);
 274                         g_module_close (module);
 275                         delete baseobj;
 276                         delete virtualdict_plugin_obj;
 277                         return;
 278                 }
 279                 VirtualDictPlugins.add(baseobj, virtualdict_plugin_obj);
 280         } else if (ptype == StarDictPlugInType_NETDICT) {
 281                 union {
 282                         stardict_netdict_plugin_init_func_t stardict_netdict_plugin_init;
 283                         gpointer stardict_netdict_plugin_init_avoid_warning;
 284                 } func2;
 285                 func2.stardict_netdict_plugin_init = 0;
 286                 if (!g_module_symbol (module, "stardict_netdict_plugin_init", (gpointer *)&(func2.stardict_netdict_plugin_init_avoid_warning))) {
 287                         printf("Load %s failed: No stardict_netdict_plugin_init func!\n", filename);
 288                         g_module_close (module);
 289                         delete baseobj;
 290                         return;
 291                 }
 292                 StarDictNetDictPlugInObject *netdict_plugin_obj = new StarDictNetDictPlugInObject();
 293                 failed = func2.stardict_netdict_plugin_init(netdict_plugin_obj);
 294                 if (failed) {
 295                         g_print("Load %s failed!\n", filename);
 296                         g_module_close (module);
 297                         delete baseobj;
 298                         delete netdict_plugin_obj;
 299                         return;
 300                 }
 301                 NetDictPlugins.add(baseobj, netdict_plugin_obj);
 302         } else if (ptype == StarDictPlugInType_SPECIALDICT) {
 303                 union {
 304                         stardict_specialdict_plugin_init_func_t stardict_specialdict_plugin_init;
 305                         gpointer stardict_specialdict_plugin_init_avoid_warning;
 306                 } func2;
 307                 func2.stardict_specialdict_plugin_init = 0;
 308                 if (!g_module_symbol (module, "stardict_specialdict_plugin_init", (gpointer *)&(func2.stardict_specialdict_plugin_init_avoid_warning))) {
 309                         printf("Load %s failed: No stardict_specialdict_plugin_init func!\n", filename);
 310                         g_module_close (module);
 311                         delete baseobj;
 312                         return;
 313                 }
 314                 StarDictSpecialDictPlugInObject *specialdict_plugin_obj = new StarDictSpecialDictPlugInObject();
 315                 failed = func2.stardict_specialdict_plugin_init(specialdict_plugin_obj);
 316                 if (failed) {
 317                         g_print("Load %s failed!\n", filename);
 318                         g_module_close (module);
 319                         delete baseobj;
 320                         delete specialdict_plugin_obj;
 321                         return;
 322                 }
 323                 SpecialDictPlugins.add(baseobj, specialdict_plugin_obj);
 324         } else if (ptype == StarDictPlugInType_TTS) {
 325                 union {
 326                         stardict_tts_plugin_init_func_t stardict_tts_plugin_init;
 327                         gpointer stardict_tts_plugin_init_avoid_warning;
 328                 } func2;
 329                 func2.stardict_tts_plugin_init = 0;
 330                 if (!g_module_symbol (module, "stardict_tts_plugin_init", (gpointer *)&(func2.stardict_tts_plugin_init_avoid_warning))) {
 331                         printf("Load %s failed: No stardict_tts_plugin_init func!\n", filename);
 332                         g_module_close (module);
 333                         delete baseobj;
 334                         return;
 335                 }
 336                 StarDictTtsPlugInObject *tts_plugin_obj = new StarDictTtsPlugInObject();
 337                 failed = func2.stardict_tts_plugin_init(tts_plugin_obj);
 338                 if (failed) {
 339                         g_print("Load %s failed!\n", filename);
 340                         g_module_close (module);
 341                         delete baseobj;
 342                         delete tts_plugin_obj;
 343                         return;
 344                 }
 345                 TtsPlugins.add(baseobj, tts_plugin_obj);
 346         } else if (ptype == StarDictPlugInType_PARSEDATA) {
 347                 union {
 348                         stardict_parsedata_plugin_init_func_t stardict_parsedata_plugin_init;
 349                         gpointer stardict_parsedata_plugin_init_avoid_warning;
 350                 } func3;
 351                 func3.stardict_parsedata_plugin_init = 0;
 352                 if (!g_module_symbol (module, "stardict_parsedata_plugin_init", (gpointer *)&(func3.stardict_parsedata_plugin_init_avoid_warning))) {
 353                         printf("Load %s failed: No stardict_parsedata_plugin_init func!\n", filename);
 354                         g_module_close (module);
 355                         delete baseobj;
 356                         return;
 357                 }
 358                 StarDictParseDataPlugInObject *parsedata_plugin_obj = new StarDictParseDataPlugInObject();
 359                 failed = func3.stardict_parsedata_plugin_init(parsedata_plugin_obj);
 360                 if (failed) {
 361                         g_print("Load %s failed!\n", filename);
 362                         g_module_close (module);
 363                         delete baseobj;
 364                         delete parsedata_plugin_obj;
 365                         return;
 366                 }
 367                 ParseDataPlugins.add(baseobj, parsedata_plugin_obj);
 368         } else if (ptype == StarDictPlugInType_MISC) {
 369                 union {
 370                         stardict_misc_plugin_init_func_t stardict_misc_plugin_init;
 371                         gpointer stardict_misc_plugin_init_avoid_warning;
 372                 } func4;
 373                 func4.stardict_misc_plugin_init = 0;
 374                 if (!g_module_symbol (module, "stardict_misc_plugin_init", (gpointer *)&(func4.stardict_misc_plugin_init_avoid_warning))) {
 375                         printf("Load %s failed: No stardict_misc_plugin_init func!\n", filename);
 376                         g_module_close (module);
 377                         delete baseobj;
 378                         return;
 379                 }
 380                 failed = func4.stardict_misc_plugin_init();
 381                 if (failed) {
 382                         g_print("Load %s failed!\n", filename);
 383                         g_module_close (module);
 384                         delete baseobj;
 385                         return;
 386                 }
 387                 MiscPlugins.add(baseobj);
 388         } else {
 389                 g_print("Load %s failed: Unknow type plugin!\n", filename);
 390                 g_module_close (module);
 391                 delete baseobj;
 392                 return;
 393         }
 394 }
 395
 396 void StarDictPlugins::unload_plugin(const char *filename, StarDictPlugInType plugin_type)
 397 {
 398         for (std::list<std::string>::iterator iter = loaded_plugin_list.begin(); iter != loaded_plugin_list.end(); ++iter) {
 399                 if (*iter == filename) {
 400                         loaded_plugin_list.erase(iter);
 401                         break;
 402                 }
 403         }
 404         switch (plugin_type) {
 405                 case StarDictPlugInType_VIRTUALDICT:
 406                         VirtualDictPlugins.unload_plugin(filename);
 407                         break;
 408                 case StarDictPlugInType_NETDICT:
 409                         NetDictPlugins.unload_plugin(filename);
 410                         break;
 411                 case StarDictPlugInType_SPECIALDICT:
 412                         SpecialDictPlugins.unload_plugin(filename);
 413                         break;
 414                 case StarDictPlugInType_TTS:
 415                         TtsPlugins.unload_plugin(filename);
 416                         break;
 417                 case StarDictPlugInType_PARSEDATA:
 418                         ParseDataPlugins.unload_plugin(filename);
 419                         break;
 420                 case StarDictPlugInType_MISC:
 421                         MiscPlugins.unload_plugin(filename);
 422                         break;
 423                 default:
 424                         break;
 425         }
 426 }
 427
 428 void StarDictPlugins::configure_plugin(const char *filename, StarDictPlugInType plugin_type)
 429 {
 430         switch (plugin_type) {
 431                 case StarDictPlugInType_VIRTUALDICT:
 432                         VirtualDictPlugins.configure_plugin(filename);
 433                         break;
 434                 case StarDictPlugInType_NETDICT:
 435                         NetDictPlugins.configure_plugin(filename);
 436                         break;
 437                 case StarDictPlugInType_SPECIALDICT:
 438                         SpecialDictPlugins.configure_plugin(filename);
 439                         break;
 440                 case StarDictPlugInType_TTS:
 441                         TtsPlugins.configure_plugin(filename);
 442                         break;
 443                 case StarDictPlugInType_PARSEDATA:
 444                         ParseDataPlugins.configure_plugin(filename);
 445                         break;
 446                 case StarDictPlugInType_MISC:
 447                         MiscPlugins.configure_plugin(filename);
 448                         break;
 449                 default:
 450                         break;
 451         }
 452 }
 453
 454 //
 455 // class StarDictVirtualDictPlugins begin.
 456 //
 457
 458 StarDictVirtualDictPlugins::StarDictVirtualDictPlugins()
 459 {
 460 }
 461
 462 StarDictVirtualDictPlugins::~StarDictVirtualDictPlugins()
 463 {
 464         for (std::vector<StarDictVirtualDictPlugin *>::iterator i = oPlugins.begin(); i != oPlugins.end(); ++i) {
 465                 delete *i;
 466         }
 467 }
 468
 469 void StarDictVirtualDictPlugins::add(StarDictPluginBaseObject *baseobj, StarDictVirtualDictPlugInObject *virtualdict_plugin_obj)
 470 {
 471         StarDictVirtualDictPlugin *plugin = new StarDictVirtualDictPlugin(baseobj, virtualdict_plugin_obj);
 472         oPlugins.push_back(plugin);
 473 }
 474
 475 void StarDictVirtualDictPlugins::unload_plugin(const char *filename)
 476 {
 477         for (std::vector<StarDictVirtualDictPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 478                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 479                         delete *iter;
 480                         oPlugins.erase(iter);
 481                         break;
 482                 }
 483         }
 484 }
 485
 486 void StarDictVirtualDictPlugins::configure_plugin(const char *filename)
 487 {
 488         for (std::vector<StarDictVirtualDictPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 489                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 490                         (*iter)->configure();
 491                         break;
 492                 }
 493         }
 494 }
 495
 496 void StarDictVirtualDictPlugins::lookup(size_t iPlugin, const gchar *word, char ***pppWord, char ****ppppWordData)
 497 {
 498         oPlugins[iPlugin]->lookup(word, pppWord, ppppWordData);
 499 }
 500
 501 const char *StarDictVirtualDictPlugins::dict_name(size_t iPlugin)
 502 {
 503         return oPlugins[iPlugin]->dict_name();
 504 }
 505
 506 const char *StarDictVirtualDictPlugins::dict_id(size_t iPlugin)
 507 {
 508         return oPlugins[iPlugin]->get_filename();
 509 }
 510
 511 bool StarDictVirtualDictPlugins::find_dict_by_id(const char *id, size_t &iPlugin)
 512 {
 513         for (std::vector<StarDictVirtualDictPlugin *>::size_type i = 0; i < oPlugins.size(); i++) {
 514                 if (strcmp(oPlugins[i]->get_filename(), id)==0) {
 515                         iPlugin = i;
 516                         return true;
 517                 }
 518         }
 519         return false;
 520 }
 521
 522 //
 523 // class StarDictVirtualDictPlugin begin.
 524 //
 525
 526 StarDictVirtualDictPlugin::StarDictVirtualDictPlugin(StarDictPluginBaseObject *baseobj_, StarDictVirtualDictPlugInObject *virtualdict_plugin_obj):
 527         StarDictPluginBase(baseobj_)
 528 {
 529         obj = virtualdict_plugin_obj;
 530 }
 531
 532 StarDictVirtualDictPlugin::~StarDictVirtualDictPlugin()
 533 {
 534         delete obj;
 535 }
 536
 537 void StarDictVirtualDictPlugin::lookup(const char *word, char ***pppWord, char ****ppppWordData)
 538 {
 539         obj->lookup_func(word, pppWord, ppppWordData);
 540 }
 541
 542 const char *StarDictVirtualDictPlugin::dict_name()
 543 {
 544         return obj->dict_name;
 545 }
 546
 547 //
 548 // class StarDictNetDictPlugins begin.
 549 //
 550
 551 StarDictNetDictPlugins::StarDictNetDictPlugins()
 552 {
 553 }
 554
 555 StarDictNetDictPlugins::~StarDictNetDictPlugins()
 556 {
 557         for (std::vector<StarDictNetDictPlugin *>::iterator i = oPlugins.begin(); i != oPlugins.end(); ++i) {
 558                 delete *i;
 559         }
 560 }
 561
 562 void StarDictNetDictPlugins::add(StarDictPluginBaseObject *baseobj, StarDictNetDictPlugInObject *netdict_plugin_obj)
 563 {
 564         StarDictNetDictPlugin *plugin = new StarDictNetDictPlugin(baseobj, netdict_plugin_obj);
 565         oPlugins.push_back(plugin);
 566 }
 567
 568 void StarDictNetDictPlugins::unload_plugin(const char *filename)
 569 {
 570         for (std::vector<StarDictNetDictPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 571                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 572                         delete *iter;
 573                         oPlugins.erase(iter);
 574                         break;
 575                 }
 576         }
 577 }
 578
 579 void StarDictNetDictPlugins::configure_plugin(const char *filename)
 580 {
 581         for (std::vector<StarDictNetDictPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 582                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 583                         (*iter)->configure();
 584                         break;
 585                 }
 586         }
 587 }
 588
 589 void StarDictNetDictPlugins::lookup(size_t iPlugin, const gchar *word, bool ismainwin)
 590 {
 591         oPlugins[iPlugin]->lookup(word, ismainwin);
 592 }
 593
 594 const char *StarDictNetDictPlugins::dict_name(size_t iPlugin)
 595 {
 596         return oPlugins[iPlugin]->dict_name();
 597 }
 598
 599 const char *StarDictNetDictPlugins::dict_id(size_t iPlugin)
 600 {
 601         return oPlugins[iPlugin]->get_filename();
 602 }
 603
 604 const char *StarDictNetDictPlugins::dict_cacheid(size_t iPlugin)
 605 {
 606         return oPlugins[iPlugin]->dict_cacheid();
 607 }
 608
 609 bool StarDictNetDictPlugins::find_dict_by_id(const char *id, size_t &iPlugin)
 610 {
 611         for (std::vector<StarDictNetDictPlugin *>::size_type i = 0; i < oPlugins.size(); i++) {
 612                 if (strcmp(oPlugins[i]->get_filename(), id)==0) {
 613                         iPlugin = i;
 614                         return true;
 615                 }
 616         }
 617         return false;
 618 }
 619
 620 //
 621 // class StarDictNetDictPlugin begin.
 622 //
 623
 624 StarDictNetDictPlugin::StarDictNetDictPlugin(StarDictPluginBaseObject *baseobj_, StarDictNetDictPlugInObject *netdict_plugin_obj):
 625         StarDictPluginBase(baseobj_)
 626 {
 627         obj = netdict_plugin_obj;
 628 }
 629
 630 StarDictNetDictPlugin::~StarDictNetDictPlugin()
 631 {
 632         delete obj;
 633 }
 634
 635 void StarDictNetDictPlugin::lookup(const char *word, bool ismainwin)
 636 {
 637         obj->lookup_func(word, ismainwin);
 638 }
 639
 640 const char *StarDictNetDictPlugin::dict_name()
 641 {
 642         return obj->dict_name;
 643 }
 644
 645 const char *StarDictNetDictPlugin::dict_cacheid()
 646 {
 647         return obj->dict_cacheid;
 648 }
 649
 650 //
 651 // class StarDictSpecialDictPlugins begin.
 652 //
 653
 654 StarDictSpecialDictPlugins::StarDictSpecialDictPlugins()
 655 {
 656 }
 657
 658 StarDictSpecialDictPlugins::~StarDictSpecialDictPlugins()
 659 {
 660         for (std::vector<StarDictSpecialDictPlugin *>::iterator i = oPlugins.begin(); i != oPlugins.end(); ++i) {
 661                 delete *i;
 662         }
 663 }
 664
 665 void StarDictSpecialDictPlugins::add(StarDictPluginBaseObject *baseobj, StarDictSpecialDictPlugInObject *specialdict_plugin_obj)
 666 {
 667         StarDictSpecialDictPlugin *plugin = new StarDictSpecialDictPlugin(baseobj, specialdict_plugin_obj);
 668         oPlugins.push_back(plugin);
 669 }
 670
 671 void StarDictSpecialDictPlugins::unload_plugin(const char *filename)
 672 {
 673         for (std::vector<StarDictSpecialDictPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 674                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 675                         delete *iter;
 676                         oPlugins.erase(iter);
 677                         break;
 678                 }
 679         }
 680 }
 681
 682 void StarDictSpecialDictPlugins::configure_plugin(const char *filename)
 683 {
 684         for (std::vector<StarDictSpecialDictPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 685                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 686                         (*iter)->configure();
 687                         break;
 688                 }
 689         }
 690 }
 691
 692 void StarDictSpecialDictPlugins::render_widget(size_t iPlugin, bool ismainwin, size_t dictid, const gchar *orig_word, gchar **Word, gchar ***WordData, GtkWidget **widget)
 693 {
 694         oPlugins[iPlugin]->render_widget(ismainwin, dictid, orig_word, Word, WordData, widget);
 695 }
 696
 697 const char *StarDictSpecialDictPlugins::dict_type(size_t iPlugin)
 698 {
 699         return oPlugins[iPlugin]->dict_type();
 700 }
 701
 702 //
 703 // class StarDictSpecialDictPlugin begin.
 704 //
 705
 706 StarDictSpecialDictPlugin::StarDictSpecialDictPlugin(StarDictPluginBaseObject *baseobj_, StarDictSpecialDictPlugInObject *specialdict_plugin_obj):
 707         StarDictPluginBase(baseobj_)
 708 {
 709         obj = specialdict_plugin_obj;
 710 }
 711
 712 StarDictSpecialDictPlugin::~StarDictSpecialDictPlugin()
 713 {
 714         delete obj;
 715 }
 716
 717 void StarDictSpecialDictPlugin::render_widget(bool ismainwin, size_t dictid, const gchar *orig_word, gchar **Word, gchar ***WordData, GtkWidget **widget)
 718 {
 719         obj->render_widget_func(ismainwin, dictid, orig_word, Word, WordData, widget);
 720 }
 721
 722 const char *StarDictSpecialDictPlugin::dict_type()
 723 {
 724         return obj->dict_type;
 725 }
 726
 727 //
 728 // class StarDictTtsPlugins begin.
 729 //
 730
 731 StarDictTtsPlugins::StarDictTtsPlugins()
 732 {
 733 }
 734
 735 StarDictTtsPlugins::~StarDictTtsPlugins()
 736 {
 737         for (std::vector<StarDictTtsPlugin *>::iterator i = oPlugins.begin(); i != oPlugins.end(); ++i) {
 738                 delete *i;
 739         }
 740 }
 741
 742 void StarDictTtsPlugins::add(StarDictPluginBaseObject *baseobj, StarDictTtsPlugInObject *tts_plugin_obj)
 743 {
 744         StarDictTtsPlugin *plugin = new StarDictTtsPlugin(baseobj, tts_plugin_obj);
 745         oPlugins.push_back(plugin);
 746 }
 747
 748 void StarDictTtsPlugins::unload_plugin(const char *filename)
 749 {
 750         for (std::vector<StarDictTtsPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 751                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 752                         delete *iter;
 753                         oPlugins.erase(iter);
 754                         break;
 755                 }
 756         }
 757 }
 758
 759 void StarDictTtsPlugins::configure_plugin(const char *filename)
 760 {
 761         for (std::vector<StarDictTtsPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 762                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 763                         (*iter)->configure();
 764                         break;
 765                 }
 766         }
 767 }
 768
 769 void StarDictTtsPlugins::saytext(size_t iPlugin, const gchar *text)
 770 {
 771         oPlugins[iPlugin]->saytext(text);
 772 }
 773
 774 const char *StarDictTtsPlugins::tts_name(size_t iPlugin)
 775 {
 776         return oPlugins[iPlugin]->tts_name();
 777 }
 778
 779 //
 780 // class StarDictTtsPlugin begin.
 781 //
 782
 783 StarDictTtsPlugin::StarDictTtsPlugin(StarDictPluginBaseObject *baseobj_, StarDictTtsPlugInObject *tts_plugin_obj):
 784         StarDictPluginBase(baseobj_)
 785 {
 786         obj = tts_plugin_obj;
 787 }
 788
 789 StarDictTtsPlugin::~StarDictTtsPlugin()
 790 {
 791         delete obj;
 792 }
 793
 794 void StarDictTtsPlugin::saytext(const char *text)
 795 {
 796         obj->saytext_func(text);
 797 }
 798
 799 const char *StarDictTtsPlugin::tts_name()
 800 {
 801         return obj->tts_name;
 802 }
 803
 804 //
 805 // class StarDictParseDataPlugins begin.
 806 //
 807
 808 StarDictParseDataPlugins::StarDictParseDataPlugins()
 809 {
 810 }
 811
 812 StarDictParseDataPlugins::~StarDictParseDataPlugins()
 813 {
 814         for (std::vector<StarDictParseDataPlugin *>::iterator i = oPlugins.begin(); i != oPlugins.end(); ++i) {
 815                 delete *i;
 816         }
 817 }
 818
 819 void StarDictParseDataPlugins::add(StarDictPluginBaseObject *baseobj, StarDictParseDataPlugInObject *tts_plugin_obj)
 820 {
 821         StarDictParseDataPlugin *plugin = new StarDictParseDataPlugin(baseobj, tts_plugin_obj);
 822         oPlugins.push_back(plugin);
 823 }
 824
 825 void StarDictParseDataPlugins::unload_plugin(const char *filename)
 826 {
 827         for (std::vector<StarDictParseDataPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 828                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 829                         delete *iter;
 830                         oPlugins.erase(iter);
 831                         break;
 832                 }
 833         }
 834 }
 835
 836 void StarDictParseDataPlugins::configure_plugin(const char *filename)
 837 {
 838         for (std::vector<StarDictParseDataPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 839                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 840                         (*iter)->configure();
 841                         break;
 842                 }
 843         }
 844 }
 845
 846 bool StarDictParseDataPlugins::parse(size_t iPlugin, const char *p, unsigned int *parsed_size, ParseResult &result, const char *oword)
 847 {
 848         return oPlugins[iPlugin]->parse(p, parsed_size, result, oword);
 849 }
 850
 851 //
 852 // class StarDictParseDataPlugin begin.
 853 //
 854
 855 StarDictParseDataPlugin::StarDictParseDataPlugin(StarDictPluginBaseObject *baseobj_, StarDictParseDataPlugInObject *parsedata_plugin_obj):
 856         StarDictPluginBase(baseobj_)
 857 {
 858         obj = parsedata_plugin_obj;
 859 }
 860
 861 StarDictParseDataPlugin::~StarDictParseDataPlugin()
 862 {
 863         delete obj;
 864 }
 865
 866 bool StarDictParseDataPlugin::parse(const char *p, unsigned int *parsed_size, ParseResult &result, const char *oword)
 867 {
 868         return obj->parse_func(p, parsed_size, result, oword);
 869 }
 870
 871 //
 872 // class StarDictMiscPlugins begin.
 873 //
 874
 875 StarDictMiscPlugins::StarDictMiscPlugins()
 876 {
 877 }
 878
 879 StarDictMiscPlugins::~StarDictMiscPlugins()
 880 {
 881         for (std::vector<StarDictMiscPlugin *>::iterator i = oPlugins.begin(); i != oPlugins.end(); ++i) {
 882                 delete *i;
 883         }
 884 }
 885
 886 void StarDictMiscPlugins::add(StarDictPluginBaseObject *baseobj)
 887 {
 888         StarDictMiscPlugin *plugin = new StarDictMiscPlugin(baseobj);
 889         oPlugins.push_back(plugin);
 890 }
 891
 892 void StarDictMiscPlugins::unload_plugin(const char *filename)
 893 {
 894         for (std::vector<StarDictMiscPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 895                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 896                         delete *iter;
 897                         oPlugins.erase(iter);
 898                         break;
 899                 }
 900         }
 901 }
 902
 903 void StarDictMiscPlugins::configure_plugin(const char *filename)
 904 {
 905         for (std::vector<StarDictMiscPlugin *>::iterator iter = oPlugins.begin(); iter != oPlugins.end(); ++iter) {
 906                 if (strcmp((*iter)->get_filename(), filename) == 0) {
 907                         (*iter)->configure();
 908                         break;
 909                 }
 910         }
 911 }
 912
 913 //
 914 // class StarDictMiscPlugin begin.
 915 //
 916
 917 StarDictMiscPlugin::StarDictMiscPlugin(StarDictPluginBaseObject *baseobj_):
 918         StarDictPluginBase(baseobj_)
 919 {
 920 }
 921
 922 StarDictMiscPlugin::~StarDictMiscPlugin()
 923 {
 924 }
 925
 926 template<typename TV, typename TI>
 927 void plugins_reorder(TV &oPlugins, const std::list<std::string>& order_list)
 928 {
 929         TV prev(oPlugins);
 930         oPlugins.clear();
 931         for (std::list<std::string>::const_iterator i = order_list.begin(); i != order_list.end(); ++i) {
 932                 for (TI j = prev.begin(); j != prev.end(); ++j) {
 933                         if (*i == (*j)->get_filename()) {
 934                                 oPlugins.push_back(*j);
 935                         }
 936                 }
 937         }
 938         for (TI i=prev.begin(); i!=prev.end(); ++i) {
 939                 TI j;
 940                 for (j=oPlugins.begin(); j!=oPlugins.end(); ++j) {
 941                         if (*j == *i)
 942                                 break;
 943                 }
 944                 if (j == oPlugins.end())
 945                         delete *i;
 946         }
 947 }
 948
 949 void StarDictVirtualDictPlugins::reorder(const std::list<std::string>& order_list)
 950 {
 951         plugins_reorder<std::vector<StarDictVirtualDictPlugin *>, std::vector<StarDictVirtualDictPlugin *>::iterator>(oPlugins, order_list);
 952 }
 953
 954 void StarDictNetDictPlugins::reorder(const std::list<std::string>& order_list)
 955 {
 956         plugins_reorder<std::vector<StarDictNetDictPlugin *>, std::vector<StarDictNetDictPlugin *>::iterator>(oPlugins, order_list);
 957 }
 958
 959 void StarDictSpecialDictPlugins::reorder(const std::list<std::string>& order_list)
 960 {
 961         plugins_reorder<std::vector<StarDictSpecialDictPlugin *>, std::vector<StarDictSpecialDictPlugin *>::iterator>(oPlugins, order_list);
 962 }
 963
 964 void StarDictTtsPlugins::reorder(const std::list<std::string>& order_list)
 965 {
 966         plugins_reorder<std::vector<StarDictTtsPlugin *>, std::vector<StarDictTtsPlugin *>::iterator>(oPlugins, order_list);
 967 }
 968
 969 void StarDictParseDataPlugins::reorder(const std::list<std::string>& order_list)
 970 {
 971         plugins_reorder<std::vector<StarDictParseDataPlugin *>, std::vector<StarDictParseDataPlugin *>::iterator>(oPlugins, order_list);
 972 }
 973
 974 void StarDictMiscPlugins::reorder(const std::list<std::string>& order_list)
 975 {
 976         plugins_reorder<std::vector<StarDictMiscPlugin *>, std::vector<StarDictMiscPlugin *>::iterator>(oPlugins, order_list);
 977 }