src/plugin.c

   1 /* Gnome Music Player Client (GMPC)
   2  * Copyright (C) 2004-2011 Qball Cow <qball@sarine.nl>
   3  * Project homepage: http://gmpc.wikia.com/
   4
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include <string.h>
  21 #include <glib.h>
  22 #include <gtk/gtk.h>
  23 #include <gmodule.h>
  24 #include "gmpc-extras.h"
  25 #include "main.h"
  26 #include "metadata.h"
  27
  28 #define PLUGIN_LOG_DOMAIN "Plugin"
  29
  30 gmpcPluginParent **plugins = NULL;
  31 int num_plugins = 0;
  32
  33 gmpcPluginParent *plugin_get_from_id(int id)
  34 {
  35     int pos = plugin_get_pos(id);
  36     g_assert_cmpint(pos, <, num_plugins);
  37     return plugins[pos];
  38 }
  39
  40
  41 static GQuark plugin_quark(void)
  42 {
  43     return g_quark_from_static_string("gmpc_plugin");
  44 }
  45
  46
  47 int plugin_get_pos(int id)
  48 {
  49     return id & (PLUGIN_ID_MARK - 1);
  50 }
  51
  52
  53 static int plugin_validate(gmpcPlugin * plug, GError ** error)
  54 {
  55     int i;
  56     if (plug->name == NULL)
  57     {
  58         g_set_error(error, plugin_quark(), 0, "%s: %s", _("Failed to load plugin"), _("plugin has no name"));
  59         g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "pluging has no name: %s", plug->path);
  60         return FALSE;
  61     }
  62     for (i = 0; i < num_plugins; i++)
  63     {
  64         if (strcmp(gmpc_plugin_get_name(plugins[i]), plug->name) == 0)
  65         {
  66             g_set_error(error, plugin_quark(), 0, "%s '%s': %s", _("Failed to load plugin"), plug->name,
  67                 _("plugin with same name already exists"));
  68             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "pluging with same name already exists: %s", plug->name);
  69             return FALSE;
  70         }
  71     }
  72     if (plug->set_enabled == NULL || plug->get_enabled == NULL)
  73     {
  74         g_set_error(error, plugin_quark(), 0, "%s: %s", _("Failed to load plugin"),
  75             _("plugin is missing set/get enable function"));
  76         g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "%s: set_enabled == NULL || get_enabled == NULL failed",
  77             plug->name);
  78         return FALSE;
  79     }
  80     if (plug->plugin_type & GMPC_PLUGIN_PL_BROWSER)
  81     {
  82         if (plug->browser == NULL)
  83         {
  84             g_set_error(error, plugin_quark(), 0, "%s: %s", _("Failed to load plugin"),
  85                 _("plugin browser structure is incorrect"));
  86             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
  87                 "%s: plugin_type&GMPC_PLUGIN_PL_BROWSER && plugin->browser != NULL Failed", plug->name);
  88             return FALSE;
  89         }
  90         if (plug->browser->cat_key_press != NULL)
  91         {
  92             g_set_error(error, plugin_quark(), 0, "%s: %s", _("Failed to load plugin"),
  93                 _("plugin browser structure is incorrect"));
  94             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
  95                 "Plugin %s implements a cat_key_press event handler that is deprecated", plug->name);
  96         }
  97     }
  98     if (plug->plugin_type & GMPC_PLUGIN_META_DATA)
  99     {
 100         if (plug->metadata == NULL)
 101         {
 102             g_set_error(error, plugin_quark(), 0, "%s: %s", _("Failed to load plugin"),
 103                 _("plugin metadata structure is incorrect"));
 104             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 105                 "%s: plugin_type&GMPC_PLUGIN_META_DATA && plugin->metadata != NULL Failed", plug->name);
 106             return FALSE;
 107         }
 108         if (plug->metadata->get_priority == NULL)
 109         {
 110             g_set_error(error, plugin_quark(), 0, "%s: %s", _("Failed to load plugin"),
 111                 _("plugin metadata structure is incorrect"));
 112             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 113                 "%s: plugin_type&GMPC_PLUGIN_META_DATA && plugin->metadata->get_priority != NULL Failed", plug->name);
 114             return FALSE;
 115         }
 116         if (plug->metadata->set_priority == NULL)
 117         {
 118             g_set_error(error, plugin_quark(), 0, "%s: %s", _("Failed to load plugin"),
 119                 _("plugin metadata structure is incorrect"));
 120             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 121                 "%s: plugin_type&GMPC_PLUGIN_META_DATA && plugin->metadata->set_priority != NULL Failed", plug->name);
 122             return FALSE;
 123         }
 124         if (plug->metadata->get_image != NULL)
 125         {
 126             g_set_error(error, plugin_quark(), 0, "%s: %s %s", _("Failed to load plugin"), plug->name,
 127                 _("plugin get_image api is deprecated "));
 128             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 129                 "%s: plugin_type&GMPC_PLUGIN_META_DATA && plugin->metadata->get_image != NULL was true", plug->name);
 130             return FALSE;
 131         }
 132         if (plug->metadata->get_uris != NULL)
 133         {
 134             g_set_error(error, plugin_quark(), 0, "%s: %s %s", _("Failed to load plugin"), plug->name,
 135                 _("plugin get_uris api is deprecated "));
 136             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 137                 "%s: plugin_type&GMPC_PLUGIN_META_DATA && plugin->metadata->get_uris != NULL was true", plug->name);
 138             return FALSE;
 139         }
 140         if (plug->metadata->get_metadata == NULL)
 141         {
 142             g_set_error(error, plugin_quark(), 0, "%s: %s", _("Failed to load plugin"),
 143                 _("plugin metadata structure is incorrect"));
 144             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 145                 "%s: plugin_type&GMPC_PLUGIN_META_DATA && plugin->metadata->get_image != NULL Failed", plug->name);
 146             return FALSE;
 147         }
 148     }
 149     /* if there is a browser field, check validity */
 150     if (plug->browser)
 151     {
 152         if ((plug->browser->selected && plug->browser->unselected == NULL)
 153             || (plug->browser->selected == NULL && plug->browser->unselected))
 154         {
 155             g_set_error(error, plugin_quark(), 0, "%s: %s", _("Failed to load plugin"),
 156                 _("plugin browser structure is incorrect"));
 157             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 158                 "%s: If a plugin provides a browser pane, it needs both selected and unselected", plug->name);
 159             return FALSE;
 160         }
 161     }
 162     /* if there is a pref window withouth both construct/destroy, give an error */
 163     if (plug->pref)
 164     {
 165         if (!(plug->pref->construct && plug->pref->destroy))
 166         {
 167             g_set_error(error, plugin_quark(), 0, "%s: %s", _("Failed to load plugin"),
 168                 _("plugin preferences structure is incorrect"));
 169             g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 170                 "%s: If a plugin has a preferences pane, it needs both construct and destroy", plug->name);
 171         }
 172     }
 173
 174     return TRUE;
 175 }
 176
 177
 178 void plugin_add(gmpcPlugin * plug, int plugin, GError ** error)
 179 {
 180     gmpcPluginParent *parent = g_malloc0(sizeof(*parent));
 181     parent->old = plug;
 182     parent->new = NULL;
 183     /* set plugin id */
 184     plug->id = num_plugins | ((plugin) ? PLUGIN_ID_MARK : PLUGIN_ID_INTERNALL);
 185     /* put it in the list */
 186     num_plugins++;
 187     plugins = g_realloc(plugins, (num_plugins + 1) * sizeof(gmpcPlugin **));
 188     plugins[num_plugins - 1] = parent;
 189     plugins[num_plugins] = NULL;
 190
 191                                  //plug->plugin_type&GMPC_PLUGIN_META_DATA)
 192     if (gmpc_plugin_is_metadata(parent))
 193     {
 194         meta_data_add_plugin(parent);
 195     }
 196 }
 197
 198
 199 void plugin_add_new(GmpcPluginBase * plug, int plugin, GError ** error)
 200 {
 201     gmpcPluginParent *parent = g_malloc0(sizeof(*parent));
 202     parent->new = plug;
 203     parent->old = NULL;
 204     /* set plugin id */
 205     plug->id = num_plugins | ((plugin) ? PLUGIN_ID_MARK : PLUGIN_ID_INTERNALL);
 206     /* put it in the list */
 207     num_plugins++;
 208     plugins = g_realloc(plugins, (num_plugins + 1) * sizeof(gmpcPlugin **));
 209     plugins[num_plugins - 1] = parent;
 210     plugins[num_plugins] = NULL;
 211
 212     if (plug->plugin_type & GMPC_PLUGIN_META_DATA)
 213     {
 214         meta_data_add_plugin(parent);
 215     }
 216 }
 217
 218
 219 static int plugin_load(const char *path, const char *file, GError ** error)
 220 {
 221     gpointer function;
 222     GModule *handle;
 223     int *api_version = 0;
 224     gmpcPlugin *plug = NULL;
 225     gchar *string = NULL;
 226     gchar *full_path = NULL;
 227     if (path == NULL)
 228     {
 229         return 1;
 230     }
 231     full_path = g_strdup_printf("%s%c%s", path, G_DIR_SEPARATOR, file);
 232
 233     g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "plugin_load: trying to load plugin %s", full_path);
 234
 235     handle = g_module_open(full_path, G_MODULE_BIND_LOCAL);
 236     q_free(full_path);
 237     if (!handle)
 238     {
 239         g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 240             "plugin_load: module failed to load: %s:%s\n", file, g_module_error());
 241         g_set_error(error, plugin_quark(), 0, "%s %s: '%s'", _("Failed to load plugin"), file, g_module_error());
 242         return 1;
 243     }
 244
 245     if (g_module_symbol(handle, "plugin_get_type", (gpointer) & function))
 246     {
 247         GmpcPluginBase *new;
 248         GType(*get_type) (void);
 249         get_type = function;
 250         new = g_object_newv(get_type(), 0, NULL);
 251
 252         if (!new)
 253         {
 254             g_set_error(error, plugin_quark(), 0, "%s %s: '%s'", _("Failed to create plugin instance"), file,
 255                 g_module_error());
 256             return 1;
 257         }
 258         new->path = g_strdup(path);
 259         plugin_add_new(new, 1, error);
 260         return 0;
 261     }
 262     if (!g_module_symbol(handle, "plugin_api_version", (gpointer) & api_version))
 263     {
 264
 265         g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 266             "plugin_load: symbol failed to bind: %s:%s\n", file, g_module_error());
 267
 268         g_set_error(error, plugin_quark(), 0, "%s %s: '%s'", _("Failed to bind symbol in plugin"), file,
 269             g_module_error());
 270
 271         q_free(string);
 272         g_module_close(handle);
 273         return 1;
 274     }
 275     if (*api_version != PLUGIN_API_VERSION)
 276     {
 277         g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 278             "Plugin '%s' has the wrong api version.\nPlugin api is %i, but we need %i",
 279             file, *api_version, PLUGIN_API_VERSION);
 280
 281         g_set_error(error, plugin_quark(), 0, _("Plugin %s has wrong api version: %i"), file, *api_version);
 282
 283         q_free(string);
 284         g_module_close(handle);
 285         return 1;
 286     }
 287     if (!g_module_symbol(handle, "plugin", (gpointer) & (plug)))
 288     {
 289         g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 290             "plugin_load: symbol failed to bind: %s:%s\n", file, g_module_error());
 291
 292         g_set_error(error, plugin_quark(), 0, "%s %s: '%s'", _("Plugin %s has wrong no plugin structure: %s"), file,
 293             g_module_error());
 294         q_free(string);
 295         g_module_close(handle);
 296         return 1;
 297     }
 298     if (plug == NULL)
 299     {
 300         g_set_error(error, plugin_quark(), 0, "%s %s: '%s'", _("Plugin %s has wrong no plugin structure: %s"), file,
 301             g_module_error());
 302         g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "%s: plugin load: unknown type of plugin.\n", file);
 303         g_module_close(handle);
 304         return 1;
 305     }
 306     /* set path, plugins might want this for images and glade files. */
 307     plug->path = g_strdup(path);
 308     if (!plugin_validate(plug, error))
 309     {
 310         g_module_close(handle);
 311         return 1;
 312     }
 313     /* add the plugin to the list */
 314     plugin_add(plug, 1, error);
 315     return 0;
 316 }
 317
 318
 319 static gboolean __show_plugin_load_error(gpointer data)
 320 {
 321     playlist3_show_error_message(_("One or more plugins failed to load, see help->messages for more information"),
 322         ERROR_CRITICAL);
 323     return FALSE;
 324 }
 325
 326
 327 void plugin_load_dir(const gchar * path)
 328 {
 329     GDir *dir = g_dir_open(path, 0, NULL);
 330     int failure = 0;
 331     if (dir)
 332     {
 333         const gchar *dirname = NULL;
 334         while ((dirname = g_dir_read_name(dir)) != NULL)
 335         {
 336             gchar *full_path = g_strdup_printf("%s%c%s", path, G_DIR_SEPARATOR, dirname);
 337             /* Make sure only to load plugins */
 338             if (g_str_has_suffix(dirname, G_MODULE_SUFFIX))
 339             {
 340                 GError *error = NULL;
 341                 if (plugin_load(path, dirname, &error))
 342                 {
 343                     failure = 1;
 344                     playlist3_show_error_message(error->message, ERROR_CRITICAL);
 345                     g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 346                         "Failed to load plugin: %s: %s\n", dirname, error->message);
 347                     g_error_free(error);
 348                     error = NULL;
 349                 }
 350             } else
 351             {
 352                 g_log(PLUGIN_LOG_DOMAIN, G_LOG_LEVEL_INFO,
 353                     "%s not loaded, wrong extention, should be: '%s'", dirname, G_MODULE_SUFFIX);
 354             }
 355             q_free(full_path);
 356         }
 357         g_dir_close(dir);
 358     }
 359     if (failure)
 360     {
 361         gtk_init_add(__show_plugin_load_error, NULL);
 362     }
 363 }
 364
 365
 366 /**
 367  * gmpcPlugin
 368  */
 369
 370 void gmpc_plugin_destroy(gmpcPluginParent * plug)
 371 {
 372     if (plug->new)
 373     {
 374         g_object_unref(plug->new);
 375         return;
 376     }
 377     if (plug->old->destroy)
 378     {
 379         plug->old->destroy();
 380     }
 381 }
 382
 383
 384 void gmpc_plugin_init(gmpcPluginParent * plug)
 385 {
 386     if (plug->new)
 387     {
 388
 389         return;
 390     }
 391     if (plug->old->init)
 392     {
 393         plug->old->init();
 394     }
 395 }
 396
 397
 398 void gmpc_plugin_status_changed(gmpcPluginParent * plug, MpdObj * mi, ChangedStatusType what)
 399 {
 400     if (plug->new)
 401         return;
 402     if (plug->old->mpd_status_changed)
 403     {
 404         plug->old->mpd_status_changed(mi, what, NULL);
 405     }
 406 }
 407
 408
 409 const char *gmpc_plugin_get_name(gmpcPluginParent * plug)
 410 {
 411     /* if new plugin, use that method */
 412     if (plug->new)
 413     {
 414         return gmpc_plugin_base_get_name(plug->new);
 415     }
 416     g_assert(plug->old->name != NULL);
 417     return plug->old->name;
 418 }
 419
 420
 421 void gmpc_plugin_save_yourself(gmpcPluginParent * plug)
 422 {
 423     if (plug->new)
 424     {
 425         gmpc_plugin_base_save_yourself(plug->new);
 426         return;
 427     }
 428     if (plug->old->save_yourself)
 429     {
 430         plug->old->save_yourself();
 431     }
 432 }
 433
 434
 435 gboolean gmpc_plugin_get_enabled(gmpcPluginParent * plug)
 436 {
 437     if (plug->new)
 438     {
 439         return gmpc_plugin_base_get_enabled(plug->new);
 440     }
 441     if (plug->old->get_enabled)
 442     {
 443         return plug->old->get_enabled();
 444     }
 445     return TRUE;
 446 }
 447
 448
 449 void gmpc_plugin_set_enabled(gmpcPluginParent * plug, gboolean enabled)
 450 {
 451     if (plug->new)
 452     {
 453         return gmpc_plugin_base_set_enabled(plug->new, enabled);
 454     }
 455     if (plug->old->set_enabled)
 456     {
 457         plug->old->set_enabled(enabled);
 458     }
 459 }
 460
 461
 462 const gchar *gmpc_plugin_get_translation_domain(gmpcPluginParent * plug)
 463 {
 464     if (plug->new)
 465     {
 466         return plug->new->translation_domain;
 467     }
 468     if (plug->old && plug->old->get_translation_domain)
 469     {
 470         return plug->old->get_translation_domain();
 471     }
 472     return NULL;
 473 }
 474
 475
 476 gchar *gmpc_plugin_get_data_path(gmpcPlugin * plug)
 477 {
 478     #ifdef WIN32
 479     gchar *url = g_win32_get_package_installation_directory_of_module(NULL);
 480     gchar *retv = g_build_path(G_DIR_SEPARATOR_S, url, "share", "gmpc", "plugins", NULL);
 481     return retv;                 //g_strdup(plug->path);
 482     #else
 483     int i;
 484     const gchar *const *paths = g_get_system_data_dirs();
 485     gchar *url = NULL;
 486     gchar *homedir = gmpc_get_user_path("");
 487     if (strncmp(plug->path, homedir, strlen(homedir)) == 0)
 488     {
 489         url = g_strdup(plug->path);
 490     } else
 491     {
 492         /* Ok it is a homedir */
 493         url = g_build_path(G_DIR_SEPARATOR_S, PACKAGE_DATA_DIR, "gmpc", "plugins", NULL);
 494     }
 495
 496     g_free(homedir);
 497
 498     if (url)
 499     {
 500         if (g_file_test(url, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))
 501         {
 502             return url;
 503         }
 504         g_free(url);
 505         url = NULL;
 506     }
 507
 508     for (i = 0; paths && paths[i]; i++)
 509     {
 510         url = g_build_filename(paths[i], "gmpc", "plugins", NULL);
 511         if (g_file_test(url, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))
 512         {
 513             return url;
 514         }
 515         g_free(url);
 516         url = NULL;
 517     }
 518     return url;
 519     #endif
 520 }
 521
 522
 523 void gmpc_plugin_mpd_connection_changed(gmpcPluginParent * plug, MpdObj * mi, int connected, gpointer data)
 524 {
 525     g_assert(plug != NULL);
 526
 527     if (plug->new)
 528         return;
 529     if (plug->old->mpd_connection_changed != NULL)
 530     {
 531         plug->old->mpd_connection_changed(mi, connected, data);
 532     }
 533 }
 534
 535
 536 gboolean gmpc_plugin_is_browser(gmpcPluginParent * plug)
 537 {
 538     if (plug->new)
 539     {
 540         return GMPC_PLUGIN_IS_BROWSER_IFACE(plug->new);
 541     }
 542     return ((plug->old->plugin_type & GMPC_PLUGIN_PL_BROWSER) != 0);
 543 }
 544
 545
 546 void gmpc_plugin_browser_unselected(gmpcPluginParent * plug, GtkWidget * container)
 547 {
 548     if (gmpc_plugin_is_browser(plug))
 549     {
 550         if (plug->new)
 551         {
 552             gmpc_plugin_browser_iface_browser_unselected((GmpcPluginBrowserIface *) plug->new,
 553                 GTK_CONTAINER(container));
 554             return;
 555         }
 556         g_assert(plug->old->browser != NULL);
 557         g_assert(plug->old->browser->unselected != NULL);
 558         plug->old->browser->unselected(container);
 559     }
 560 }
 561
 562
 563 void gmpc_plugin_browser_selected(gmpcPluginParent * plug, GtkWidget * container)
 564 {
 565     if (gmpc_plugin_is_browser(plug))
 566     {
 567         if (plug->new)
 568         {
 569             gmpc_plugin_browser_iface_browser_selected((GmpcPluginBrowserIface *) plug->new, GTK_CONTAINER(container));
 570             return;
 571         }
 572         g_assert(plug->old->browser != NULL);
 573         g_assert(plug->old->browser->selected != NULL);
 574         plug->old->browser->selected(container);
 575     }
 576 }
 577
 578
 579 void gmpc_plugin_browser_add(gmpcPluginParent * plug, GtkWidget * cat_tree)
 580 {
 581     if (gmpc_plugin_is_browser(plug))
 582     {
 583         if (plug->new)
 584         {
 585             gmpc_plugin_browser_iface_browser_add((GmpcPluginBrowserIface *) plug->new, cat_tree);
 586             return;
 587         }
 588         g_assert(plug->old->browser != NULL);
 589         if (plug->old->browser->add)
 590         {
 591             plug->old->browser->add(cat_tree);
 592         }
 593     }
 594 }
 595
 596
 597 int gmpc_plugin_browser_cat_right_mouse_menu(gmpcPluginParent * plug, GtkWidget * menu, int type, GtkWidget * tree,
 598 GdkEventButton * event)
 599 {
 600     if (gmpc_plugin_is_browser(plug))
 601     {
 602         if (plug->new)
 603         {
 604             if (type == plug->new->id)
 605                 return gmpc_plugin_browser_iface_browser_option_menu((GmpcPluginBrowserIface *) plug->new,
 606                     GTK_MENU(menu));
 607             return 0;
 608         }
 609         g_assert(plug->old->browser != NULL);
 610         if (plug->old->browser->cat_right_mouse_menu != NULL)
 611         {
 612             return plug->old->browser->cat_right_mouse_menu(menu, type, tree, event);
 613         }
 614     }
 615     return 0;
 616 }
 617
 618
 619 int gmpc_plugin_browser_key_press_event(gmpcPluginParent * plug, GtkWidget * mw, GdkEventKey * event, int type)
 620 {
 621     if (gmpc_plugin_is_browser(plug))
 622     {
 623         if (plug->new)
 624         {
 625             /* not going to be implemented */
 626             return 0;
 627         }
 628         g_assert(plug->old->browser != NULL);
 629         if (plug->old->browser->key_press_event != NULL)
 630         {
 631             return plug->old->browser->key_press_event(mw, event, type);
 632         }
 633     }
 634     return 0;
 635 }
 636
 637
 638 int gmpc_plugin_browser_add_go_menu(gmpcPluginParent * plug, GtkWidget * menu)
 639 {
 640     if (gmpc_plugin_is_browser(plug))
 641     {
 642         if (plug->new)
 643         {
 644             return gmpc_plugin_browser_iface_browser_add_go_menu((GmpcPluginBrowserIface *) plug->new, GTK_MENU(menu));
 645         }
 646         g_assert(plug->old->browser != NULL);
 647         if (plug->old->browser->add_go_menu != NULL)
 648         {
 649             return plug->old->browser->add_go_menu(menu);
 650         }
 651     }
 652     return 0;
 653 }
 654
 655
 656 int gmpc_plugin_browser_song_list_option_menu(gmpcPluginParent * plug, GmpcMpdDataTreeview * tree, GtkMenu * menu)
 657 {
 658     if (plug->new)
 659     {
 660         if (GMPC_PLUGIN_IS_SONG_LIST_IFACE(plug->new))
 661         {
 662             return gmpc_plugin_song_list_iface_song_list(GMPC_PLUGIN_SONG_LIST_IFACE(plug->new), GTK_WIDGET(tree),
 663                 menu);
 664         }
 665         return 0;
 666     }
 667     if (gmpc_plugin_is_browser(plug))
 668     {
 669         g_assert(plug->old->browser != NULL);
 670         if (plug->old->browser->song_list_option_menu)
 671         {
 672             return plug->old->browser->song_list_option_menu(tree, menu);
 673         }
 674     }
 675     return 0;
 676 }
 677
 678
 679 gboolean gmpc_plugin_browser_has_integrate_search(gmpcPluginParent * plug)
 680 {
 681     if (plug->new)
 682     {
 683         return GMPC_PLUGIN_IS_INTEGRATE_SEARCH_IFACE(plug->new);
 684     }
 685     if (gmpc_plugin_is_browser(plug))
 686     {
 687         return plug->old->browser->integrate_search != NULL;
 688     }
 689     return FALSE;
 690 }
 691
 692
 693 MpdData *gmpc_plugin_browser_integrate_search(gmpcPluginParent * plug, const int search_field, const gchar * query,
 694 GError ** error)
 695 {
 696     if (!gmpc_plugin_browser_has_integrate_search(plug))
 697         return NULL;
 698     if (plug->new)
 699         return gmpc_plugin_integrate_search_iface_search(GMPC_PLUGIN_INTEGRATE_SEARCH_IFACE(plug->new), search_field,
 700             query);
 701     return plug->old->browser->integrate_search(search_field, query, error);
 702 }
 703
 704
 705 gboolean gmpc_plugin_browser_integrate_search_field_supported(gmpcPluginParent * plug, const int search_field)
 706 {
 707     if (!gmpc_plugin_browser_has_integrate_search(plug))
 708         return FALSE;
 709
 710     if (plug->new)
 711         return gmpc_plugin_integrate_search_iface_field_supported(GMPC_PLUGIN_INTEGRATE_SEARCH_IFACE(plug->new),
 712             search_field);
 713
 714     if (plug->old->browser->integrate_search_field_supported == NULL)
 715         return TRUE;
 716     return plug->old->browser->integrate_search_field_supported(search_field);
 717 }
 718
 719
 720 gboolean gmpc_plugin_has_preferences(gmpcPluginParent * plug)
 721 {
 722     if (plug->new)
 723     {
 724         return GMPC_PLUGIN_IS_PREFERENCES_IFACE(plug->new);
 725     }
 726     return (plug->old->pref != NULL);
 727 }
 728
 729
 730 void gmpc_plugin_preferences_construct(gmpcPluginParent * plug, GtkWidget * wid)
 731 {
 732     if (gmpc_plugin_has_preferences(plug))
 733     {
 734         if (plug->new)
 735         {
 736             gmpc_plugin_preferences_iface_preferences_pane_construct(GMPC_PLUGIN_PREFERENCES_IFACE(plug->new),
 737                 GTK_CONTAINER(wid));
 738             return;
 739         }
 740         g_assert(plug->old->pref != NULL);
 741         g_assert(plug->old->pref->construct);
 742         plug->old->pref->construct(wid);
 743     }
 744 }
 745
 746
 747 void gmpc_plugin_preferences_destroy(gmpcPluginParent * plug, GtkWidget * wid)
 748 {
 749     if (gmpc_plugin_has_preferences(plug))
 750     {
 751         if (plug->new)
 752         {
 753             gmpc_plugin_preferences_iface_preferences_pane_destroy(GMPC_PLUGIN_PREFERENCES_IFACE(plug->new),
 754                 GTK_CONTAINER(wid));
 755             return;
 756         }
 757         g_assert(plug->old->pref != NULL);
 758         g_assert(plug->old->pref->destroy);
 759         plug->old->pref->destroy(wid);
 760     }
 761 }
 762
 763
 764 gboolean gmpc_plugin_is_internal(gmpcPluginParent * plug)
 765 {
 766     if (plug->new)
 767     {
 768         return (((plug->new->plugin_type) & GMPC_INTERNALL) != 0);
 769         ;
 770     }
 771     return (((plug->old->plugin_type) & GMPC_INTERNALL) != 0);
 772 }
 773
 774
 775 const int *gmpc_plugin_get_version(gmpcPluginParent * plug)
 776 {
 777     if (plug->new)
 778     {
 779         gint length;
 780         return (const int *)gmpc_plugin_base_get_version(plug->new, &length);
 781     }
 782     return (const int *)plug->old->version;
 783 }
 784
 785
 786 int gmpc_plugin_get_type(gmpcPluginParent * plug)
 787 {
 788     if (plug->new)
 789     {
 790         return plug->new->plugin_type;
 791     }
 792     return plug->old->plugin_type;
 793 }
 794
 795
 796 int gmpc_plugin_get_id(gmpcPluginParent * plug)
 797 {
 798     if (plug->new)
 799     {
 800         return plug->new->id;
 801     }
 802     return plug->old->id;
 803 }
 804
 805
 806 gboolean gmpc_plugin_is_metadata(gmpcPluginParent * plug)
 807 {
 808     if (plug->new)
 809     {
 810         return GMPC_PLUGIN_IS_META_DATA_IFACE(plug->new);
 811     }
 812     return (plug->old->metadata != NULL);
 813 }
 814
 815
 816 int gmpc_plugin_metadata_get_priority(gmpcPluginParent * plug)
 817 {
 818     if (gmpc_plugin_is_metadata(plug))
 819     {
 820         if (plug->new)
 821             return gmpc_plugin_meta_data_iface_get_priority(GMPC_PLUGIN_META_DATA_IFACE(plug->new));
 822         return plug->old->metadata->get_priority();
 823     }
 824     return 100;
 825 }
 826
 827
 828 void gmpc_plugin_metadata_set_priority(gmpcPluginParent * plug, int priority)
 829 {
 830     if (gmpc_plugin_is_metadata(plug))
 831     {
 832         if (plug->new)
 833             return gmpc_plugin_meta_data_iface_set_priority(GMPC_PLUGIN_META_DATA_IFACE(plug->new), priority);
 834         return plug->old->metadata->set_priority(priority);
 835     }
 836 }
 837
 838
 839 void gmpc_plugin_metadata_query_metadata_list(gmpcPluginParent * plug, mpd_Song * song, MetaDataType type,
 840 void (*callback) (GList * uris, gpointer data), gpointer data)
 841 {
 842     if (gmpc_plugin_is_metadata(plug))
 843     {
 844         if (plug->new)
 845         {
 846             gmpc_plugin_meta_data_iface_get_metadata(GMPC_PLUGIN_META_DATA_IFACE(plug->new), song, type, callback,
 847                 data);
 848             return;
 849         }
 850         if (plug->old->metadata->get_metadata)
 851         {
 852             plug->old->metadata->get_metadata(song, type, callback, data);
 853             return;
 854         }
 855     }
 856     callback(NULL, data);
 857 }
 858
 859
 860 gint gmpc_plugin_tool_menu_integration(gmpcPluginParent * plug, GtkMenu * menu)
 861 {
 862     if (plug->new)
 863     {
 864         if (GMPC_PLUGIN_IS_TOOL_MENU_IFACE(plug->new))
 865         {
 866             return gmpc_plugin_tool_menu_iface_tool_menu_integration(GMPC_PLUGIN_TOOL_MENU_IFACE(plug->new), menu);
 867         }
 868         return 0;
 869     }
 870     if (plug->old)
 871     {
 872         if (plug->old->tool_menu_integration)
 873             return plug->old->tool_menu_integration(menu);
 874     }
 875     return 0;
 876 }
 877
 878 gboolean        gmpc_plugin_has_enabled                     (gmpcPluginParent *plug)
 879 {
 880     if (plug->new)
 881     {
 882         return TRUE;
 883     }
 884     if(plug->old && plug->old->get_enabled && plug->old->set_enabled) return TRUE;
 885     return FALSE;
 886 }