src/plugin.c

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