src/plugin.c

   1 /* gmpc-magnatune (GMPC plugin)
   2  * Copyright (C) 2006-2009 Qball Cow <qball@sarine.nl>
   3  * Project homepage: http://gmpcwiki.sarine.nl/
   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 <stdio.h>
  21 #include <string.h>
  22 #include <gdk/gdkkeysyms.h>
  23 #include <glade/glade.h>
  24 #include <gmpc/plugin.h>
  25 #include <gmpc/gmpc_easy_download.h>
  26 #include <gmpc/metadata.h>
  27 #include <gmpc/gmpc-mpddata-model.h>
  28 #include <gmpc/gmpc-mpddata-treeview.h>
  29 #include <gmpc/TreeSearchWidget.h>
  30 #include <config.h>
  31 #include "magnatune.h"
  32
  33 extern GladeXML *pl3_xml;
  34
  35 gmpcPlugin plugin;
  36 /**
  37  * Function decleration
  38  */
  39 static void magnatune_selected(GtkWidget *container);
  40 static void magnatune_unselected(GtkWidget *container);
  41 static void magnatune_add(GtkWidget *cat_tree);
  42 static void magnatune_download_xml_callback(int download, int total,gpointer data);
  43 static void magnatune_download();
  44 static void   magnatune_mpd_status_changed(MpdObj *mi, ChangedStatusType what, void *data);
  45 static int magnatune_fetch_cover_priority(void);
  46 static int magnatune_fetch_get_image(mpd_Song *song,MetaDataType type, char **path);
  47 static int magnatune_cat_menu_popup(GtkWidget *menu, int type, GtkWidget *tree, GdkEventButton *event);
  48
  49 static int magnatune_button_release_event(GtkWidget *tree, GdkEventButton *event,gpointer data);
  50 static int magnatune_button_handle_release_event_tag(GtkWidget *tree, GdkEventButton *event,gpointer data);
  51
  52 static int magnatune_key_press(GtkWidget *tree, GdkEventKey *event);
  53 static void magnatune_show_album_list(GtkTreeSelection *selection, gpointer user_data);
  54 static void magnatune_show_song_list(GtkTreeSelection *selection, gpointer user_data);
  55 static int magnatune_button_handle_release_event_tag_add(GtkWidget *button, gpointer user_data);
  56 static void magnatune_save_myself(void);
  57 static char * __magnatune_process_string(char *name);
  58 static GtkTreeRowReference *magnatune_ref = NULL;
  59
  60
  61 static int downloading = FALSE;
  62 /**
  63  * Get set enabled
  64  */
  65 static int magnatune_get_enabled()
  66 {
  67         return cfg_get_single_value_as_int_with_default(config, "magnatune", "enable", TRUE);
  68 }
  69 static void magnatune_set_enabled(int enabled)
  70 {
  71         cfg_set_single_value_as_int(config, "magnatune", "enable", enabled);
  72         if (enabled)
  73         {
  74                 if(magnatune_ref == NULL)
  75                 {
  76                         magnatune_add(GTK_WIDGET(playlist3_get_category_tree_view()));
  77                 }
  78         }
  79         else if (magnatune_ref)
  80         {
  81                 GtkTreePath *path = gtk_tree_row_reference_get_path(magnatune_ref);
  82                 if (path){
  83                         GtkTreeIter iter;
  84             magnatune_save_myself();
  85                         if (gtk_tree_model_get_iter(GTK_TREE_MODEL(playlist3_get_category_tree_store()), &iter, path)){
  86                                 gtk_list_store_remove(playlist3_get_category_tree_store(), &iter);
  87                         }
  88                         gtk_tree_path_free(path);
  89                         gtk_tree_row_reference_free(magnatune_ref);
  90                         magnatune_ref = NULL;
  91                 }
  92         }
  93         pl3_update_go_menu();
  94 }
  95
  96
  97
  98
  99
 100 /* Playlist window row reference */
 101
 102 GtkWidget *magnatune_pb = NULL;
 103 GtkWidget *magnatune_vbox = NULL;
 104 GtkTreeModel *mt_store = NULL;
 105 TreeSearch *mt_tree_search = NULL;
 106
 107 GtkWidget *treeviews[3] = {NULL, NULL,NULL};
 108
 109 static GtkWidget *magnatune_logo=NULL;
 110 extern GladeXML *pl3_xml;
 111
 112 static void magnatune_buy_album()
 113 {
 114         gchar *uri;
 115         mpd_Song *song = NULL;
 116         gchar *artist;
 117         gchar *album;
 118
 119         if(mpd_check_connected(connection))
 120         {
 121                 song = mpd_playlist_get_current_song(connection);
 122                 artist = __magnatune_process_string(song->artist);
 123                 album = __magnatune_process_string(song->album);
 124                 uri = g_strconcat("http://www.magnatune.com/buy/choose?artist=",artist,"&album=",album,NULL);
 125                 open_uri(uri);
 126                 g_free(artist);
 127                 g_free(album);
 128                 g_free(uri);
 129         }
 130 }
 131
 132 static void magnatune_logo_add()
 133 {
 134         mpd_Song *song = NULL;
 135         GtkWidget *logo, *button;
 136         GtkWidget *ali;
 137     if(mpd_check_connected(connection))
 138         song = mpd_playlist_get_current_song(connection);
 139
 140         magnatune_logo = gtk_hbox_new(FALSE,6);
 141
 142         button = gtk_button_new_with_label("Buy this album\nfrom magnatune");
 143         gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
 144
 145         ali = gtk_alignment_new(0,0.5,0,1);
 146         gtk_container_add(GTK_CONTAINER(ali), button);
 147         logo = gtk_image_new_from_icon_name("magnatune", GTK_ICON_SIZE_DND);
 148         gtk_button_set_image(GTK_BUTTON(button), logo);
 149         gtk_box_pack_start(GTK_BOX(magnatune_logo), ali, TRUE, TRUE,0);
 150         gtk_box_pack_end(GTK_BOX(glade_xml_get_widget(pl3_xml, "vbox5")), magnatune_logo, FALSE,FALSE,0);
 151         g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(magnatune_buy_album), NULL);
 152         if(song) {
 153                 if(strstr(song->file,"magnatune.com"))
 154                 {
 155                         gtk_widget_show_all(magnatune_logo);
 156                         return;
 157                 }
 158         }
 159
 160
 161 }
 162
 163 static void magnatune_logo_init()
 164 {
 165     gchar *path = gmpc_plugin_get_data_path(&plugin);
 166     gchar *url = g_build_path(G_DIR_SEPARATOR_S,path, "magnatune", NULL);
 167     debug_printf(DEBUG_WARNING,"Found url: %s\n", url);
 168         gtk_icon_theme_append_search_path(gtk_icon_theme_get_default (),url);
 169     g_free(url);
 170     g_free(path);
 171
 172         gtk_init_add((GtkFunction )magnatune_logo_add, NULL);
 173         /**
 174          * init the magnatune stuff
 175          */
 176         magnatune_db_init();
 177         /**
 178          * open the db
 179          */
 180         magnatune_db_open();
 181 }
 182
 183
 184 static void   magnatune_mpd_status_changed(MpdObj *mi, ChangedStatusType what, void *data)
 185 {
 186         if(!magnatune_logo)
 187                 return;
 188         if(what&(MPD_CST_SONGID|MPD_CST_STATE))
 189         {
 190                 mpd_Song *song = mpd_playlist_get_current_song(mi);
 191                 if(song && mpd_player_get_state(mi) == MPD_STATUS_STATE_PLAY) {
 192                         if(strstr(song->file,"magnatune.com"))
 193                         {
 194                                 gtk_widget_show_all(magnatune_logo);
 195                                 return;
 196                         }
 197                 }
 198                 gtk_widget_hide(magnatune_logo);
 199         }
 200 }
 201
 202 void magnatune_get_genre_list()
 203 {
 204     MpdData *data = NULL;
 205         data = magnatune_db_get_genre_list();
 206     gmpc_mpddata_model_set_mpd_data(GMPC_MPDDATA_MODEL(gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[0]))),data);
 207 }
 208
 209 static void magnatune_show_album_list(GtkTreeSelection *selection, gpointer user_data)
 210 {
 211     MpdData *data = NULL;
 212     GtkTreeIter piter;
 213     GtkTreeModel *model  = gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[0]));
 214     if(gtk_tree_selection_get_selected(selection, &model, &piter))
 215     {
 216         gchar *genre;
 217         gtk_tree_model_get(model, &piter, MPDDATA_MODEL_COL_SONG_TITLE,&genre,-1);
 218         data= magnatune_db_get_artist_list(genre);
 219
 220         g_free(genre);
 221     }
 222     gmpc_mpddata_model_set_mpd_data(GMPC_MPDDATA_MODEL(gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[1]))),data);
 223 }
 224
 225 static void magnatune_show_song_list(GtkTreeSelection *selection, gpointer user_data)
 226 {
 227     MpdData *data = NULL;
 228     GtkTreeIter piter;
 229     GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[0]));
 230     GtkTreeModel *model  = gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[0]));
 231     gchar *genre = NULL, *artist = NULL, *album = NULL;
 232     if(gtk_tree_selection_get_selected(select, &model, &piter))
 233     {
 234
 235         select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[1]));
 236         gtk_tree_model_get(model, &piter, MPDDATA_MODEL_COL_SONG_TITLE,&genre,-1);
 237         /* model */
 238         model  = gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[1]));
 239         if(gtk_tree_selection_get_selected(select, &model, &piter))
 240         {
 241             gtk_tree_model_get(model, &piter, MPDDATA_MODEL_COL_SONG_TITLE,&artist,-1);
 242             select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[2]));
 243             model  = gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[2]));
 244             if(gtk_tree_selection_get_selected(select, &model, &piter))
 245             {
 246                 gtk_tree_model_get(model, &piter, MPDDATA_MODEL_COL_SONG_TITLE,&album,-1);
 247             }
 248         }
 249     }
 250     data = magnatune_db_get_song_list(genre, artist, album,TRUE);
 251     gmpc_mpddata_model_set_mpd_data(GMPC_MPDDATA_MODEL(mt_store), data);
 252 }
 253
 254 static void magnatune_show_artist_list(GtkTreeSelection *selection, gpointer user_data)
 255 {
 256     GtkTreeIter piter;
 257     MpdData *data = NULL;
 258     GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[0]));
 259     GtkTreeModel *model  = gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[0]));
 260
 261     if(gtk_tree_selection_get_selected(select, &model, &piter))
 262     {
 263         GList *iter,*list = NULL;
 264         gchar *genre;
 265
 266         select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[1]));
 267         gtk_tree_model_get(model, &piter, MPDDATA_MODEL_COL_SONG_TITLE,&genre,-1);
 268         /* model */
 269         model  = gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[1]));
 270         if(gtk_tree_selection_get_selected(select, &model, &piter))
 271         {
 272             GList *iter,*list = NULL;
 273
 274             gchar *artist;
 275             gtk_tree_model_get(model, &piter, MPDDATA_MODEL_COL_SONG_TITLE,&artist,-1);
 276             data = magnatune_db_get_album_list(genre ,artist);
 277             gmpc_mpddata_model_set_request_artist(GMPC_MPDDATA_MODEL(gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[2]))),artist);
 278             g_free(artist);
 279         }
 280         g_free(genre);
 281     }
 282     gmpc_mpddata_model_set_mpd_data(GMPC_MPDDATA_MODEL(gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[2]))),data);
 283 }
 284
 285 static void magnatune_add_album_row_activated(GtkTreeView *tree, GtkTreePath *path, GtkTreeViewColumn *col, gpointer data)
 286 {
 287     GtkTreeModel *model = gtk_tree_view_get_model(tree);
 288     GtkTreeIter iter_r;
 289
 290     if(gtk_tree_model_get_iter(model, &iter_r, path))
 291     {
 292         gchar *path;
 293         gtk_tree_model_get(model, &iter_r, MPDDATA_MODEL_COL_PATH, &path, -1);
 294         play_path(path);
 295         g_free(path);
 296     }
 297 }
 298
 299 static gboolean magnatune_search_equal_func(GtkTreeModel *model, int column, const gchar *key, GtkTreeIter *iter, gpointer data)
 300 {
 301         gchar *compare = NULL;
 302         gtk_tree_model_get(model,iter, column, &compare, -1);
 303         if(compare){
 304                 gchar *a = g_utf8_casefold(key, -1);
 305                 gchar *b = g_utf8_casefold(compare, -1);
 306                 if(strstr(b,a))
 307                 {
 308                         g_free(a);
 309                         g_free(b);
 310                         return FALSE;
 311                 }
 312                 g_free(a);
 313                 g_free(b);
 314         }
 315         return TRUE;
 316 }
 317
 318 static void magnatune_search_activate(TreeSearch *ts)
 319 {
 320         GtkTreeModel *model = GTK_TREE_MODEL(mt_store);
 321         GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ts->treeview));
 322         if (gtk_tree_selection_count_selected_rows (selection) == 1)
 323         {
 324                 GList *list = gtk_tree_selection_get_selected_rows (selection, &model);
 325                 magnatune_add_album_row_activated(GTK_TREE_VIEW(ts->treeview),(GtkTreePath *)list->data, NULL,NULL);
 326                 /* free list */
 327                 g_list_foreach (list, (GFunc) gtk_tree_path_free, NULL);
 328                 g_list_free (list);
 329         }
 330 }
 331
 332 static void magnatune_init()
 333 {
 334     int size;
 335         GtkWidget *tree             = NULL;
 336         GtkWidget *sw               = NULL;
 337         GtkCellRenderer *renderer   = NULL;
 338     GtkWidget *paned            = NULL;
 339     GtkWidget *hbox             = NULL;
 340     GtkWidget *vbox             = NULL;
 341     GtkTreeModel *model         = NULL;
 342     GtkTreeViewColumn *column   = NULL;
 343     int position  = cfg_get_single_value_as_int_with_default(config, "magnatune", "pane-pos", 150);
 344         magnatune_vbox = gtk_vpaned_new();
 345     gtk_paned_set_position(GTK_PANED(magnatune_vbox), position);
 346
 347
 348     vbox = gtk_vbox_new(FALSE,6);
 349         /**
 350          * Create list store
 351          * 1. pointer
 352          * 2. name
 353          */
 354         mt_store =  (GtkTreeModel *)gmpc_mpddata_model_new();
 355
 356     /* Paned window */
 357     paned = gtk_hbox_new(TRUE,6);
 358     model = (GtkTreeModel *) gmpc_mpddata_model_new();
 359     /* Genre list */
 360     sw = gtk_scrolled_window_new(NULL, NULL);
 361         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN);
 362         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 363     treeviews[0] = gtk_tree_view_new_with_model(model);
 364     gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeviews[0]), MPDDATA_MODEL_COL_SONG_TITLE);
 365     g_signal_connect(G_OBJECT(treeviews[0]), "button-press-event", G_CALLBACK(magnatune_button_handle_release_event_tag), GINT_TO_POINTER(0));
 366     /* Add column */
 367     column = gtk_tree_view_column_new();
 368         gtk_tree_view_column_set_title(column, "Genre");
 369
 370
 371         renderer = gtk_cell_renderer_pixbuf_new();
 372         gtk_tree_view_column_pack_start(column, renderer, FALSE);
 373     gtk_tree_view_column_add_attribute(column, renderer, "icon-name", MPDDATA_MODEL_COL_ICON_ID);
 374     gtk_tree_view_column_set_sizing(column , GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 375         renderer = gtk_cell_renderer_text_new();
 376         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 377         gtk_tree_view_column_add_attribute(column, renderer, "text", MPDDATA_MODEL_COL_SONG_TITLE);
 378         gtk_tree_view_insert_column(GTK_TREE_VIEW(treeviews[0]),column, -1);
 379
 380     gtk_container_add(GTK_CONTAINER(sw), treeviews[0]);
 381     gtk_box_pack_start(GTK_BOX(paned), sw, TRUE, TRUE, 0);
 382
 383     g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[0]))), "changed", G_CALLBACK(magnatune_show_album_list), NULL);
 384
 385     /* Artist list */
 386     model = (GtkTreeModel *) gmpc_mpddata_model_new();
 387     sw = gtk_scrolled_window_new(NULL, NULL);
 388         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN);
 389         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 390     treeviews[1] =  gtk_tree_view_new_with_model(model);
 391
 392     gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeviews[1]), MPDDATA_MODEL_COL_SONG_TITLE);
 393         g_signal_connect(G_OBJECT(treeviews[1]), "button-press-event", G_CALLBACK(magnatune_button_handle_release_event_tag), GINT_TO_POINTER(1));
 394     /* Add column */
 395     column = gtk_tree_view_column_new();
 396         gtk_tree_view_column_set_title(column, "Artist");
 397     size = cfg_get_single_value_as_int_with_default(config, "gmpc-mpddata-model", "icon-size", 64);
 398     gtk_tree_view_column_set_sizing(column , GTK_TREE_VIEW_COLUMN_FIXED);
 399     gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeviews[1]), TRUE);
 400
 401
 402     renderer = gtk_cell_renderer_pixbuf_new();
 403     gtk_cell_renderer_set_fixed_size(renderer, size,size);
 404
 405         gtk_tree_view_column_pack_start(column, renderer, FALSE);
 406     gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", MPDDATA_MODEL_META_DATA);
 407         renderer = gtk_cell_renderer_text_new();
 408         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 409         gtk_tree_view_column_add_attribute(column, renderer, "text", MPDDATA_MODEL_COL_SONG_TITLE);
 410         gtk_tree_view_insert_column(GTK_TREE_VIEW(treeviews[1]),column, -1);
 411
 412     gtk_container_add(GTK_CONTAINER(sw), treeviews[1]);
 413     gtk_box_pack_start(GTK_BOX(paned), sw, TRUE, TRUE, 0);
 414
 415     g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[1]))), "changed", G_CALLBACK(magnatune_show_artist_list), NULL);
 416
 417     /* Album list */
 418     model = (GtkTreeModel *) gmpc_mpddata_model_new();
 419     sw = gtk_scrolled_window_new(NULL, NULL);
 420         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN);
 421         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 422     treeviews[2] =  gtk_tree_view_new_with_model(model);
 423     gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeviews[2]), MPDDATA_MODEL_COL_SONG_TITLE);
 424
 425         g_signal_connect(G_OBJECT(treeviews[2]), "button-press-event", G_CALLBACK(magnatune_button_handle_release_event_tag), GINT_TO_POINTER(2));
 426     /* Add column */
 427     column = gtk_tree_view_column_new();
 428         gtk_tree_view_column_set_title(column, "Album");
 429     size = cfg_get_single_value_as_int_with_default(config, "gmpc-mpddata-model", "icon-size", 64);
 430     gtk_tree_view_column_set_sizing(column , GTK_TREE_VIEW_COLUMN_FIXED);
 431     gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeviews[2]), TRUE);
 432
 433
 434         renderer = gtk_cell_renderer_pixbuf_new();
 435     gtk_cell_renderer_set_fixed_size(renderer, size,size);
 436
 437         gtk_tree_view_column_pack_start(column, renderer, FALSE);
 438     gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", MPDDATA_MODEL_META_DATA);
 439         renderer = gtk_cell_renderer_text_new();
 440         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 441         gtk_tree_view_column_add_attribute(column, renderer, "text", MPDDATA_MODEL_COL_SONG_TITLE);
 442         gtk_tree_view_insert_column(GTK_TREE_VIEW(treeviews[2]),column, -1);
 443
 444     gtk_container_add(GTK_CONTAINER(sw), treeviews[2]);
 445     gtk_box_pack_start(GTK_BOX(paned), sw, TRUE, TRUE, 0);
 446
 447
 448     g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[0]))), "changed", G_CALLBACK(magnatune_show_song_list), NULL);
 449     g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[1]))), "changed", G_CALLBACK(magnatune_show_song_list), NULL);
 450     g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[2]))), "changed", G_CALLBACK(magnatune_show_song_list), NULL);
 451
 452     gtk_paned_add1(GTK_PANED(magnatune_vbox), paned);
 453     gtk_widget_show_all(paned);
 454     /**
 455          * tree
 456          */
 457     sw = gtk_scrolled_window_new(NULL, NULL);
 458         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN);
 459         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 460
 461
 462         tree = (GtkWidget *)gmpc_mpddata_treeview_new("magnatune",TRUE,GTK_TREE_MODEL(mt_store));
 463         g_signal_connect(G_OBJECT(tree), "row-activated", G_CALLBACK(magnatune_add_album_row_activated), NULL);
 464
 465         g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(magnatune_button_release_event), tree);
 466         g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK(magnatune_key_press), NULL);
 467
 468     gtk_container_add(GTK_CONTAINER(sw), tree);
 469     gtk_box_pack_start(GTK_BOX(vbox),sw, TRUE, TRUE,0);
 470
 471         mt_tree_search = (TreeSearch *)treesearch_new(GTK_TREE_VIEW(tree), MPDDATA_MODEL_COL_SONG_TITLE);
 472         gtk_box_pack_end(GTK_BOX(vbox), GTK_WIDGET(mt_tree_search), FALSE, TRUE, 0);
 473         g_signal_connect(G_OBJECT(mt_tree_search), "result-activate", G_CALLBACK(magnatune_search_activate),NULL);
 474
 475
 476         gtk_widget_show_all(sw);
 477     gtk_widget_show(vbox);
 478         /**
 479          * Progress Bar for the bottom
 480          */
 481         magnatune_pb = gtk_progress_bar_new();
 482         gtk_box_pack_end(GTK_BOX(vbox), magnatune_pb, FALSE, TRUE, 0);
 483     gtk_paned_add2(GTK_PANED(magnatune_vbox), vbox);
 484
 485
 486         g_object_ref(magnatune_vbox);
 487
 488
 489 }
 490 static void magnatune_selected(GtkWidget *container)
 491 {
 492         if(magnatune_vbox == NULL)
 493         {
 494                 magnatune_init();
 495                 gtk_container_add(GTK_CONTAINER(container), magnatune_vbox);
 496                 gtk_widget_show(magnatune_vbox);
 497                 if(!magnatune_db_has_data())
 498                 {
 499                         magnatune_download();
 500                 }
 501         else
 502             magnatune_get_genre_list();
 503         } else {
 504                 gtk_container_add(GTK_CONTAINER(container), magnatune_vbox);
 505                 gtk_widget_show(magnatune_vbox);
 506         }
 507 }
 508 static void magnatune_unselected(GtkWidget *container)
 509 {
 510         gtk_container_remove(GTK_CONTAINER(container), magnatune_vbox);
 511 }
 512
 513 int magnatune_end_download()
 514 {
 515     downloading = FALSE;
 516
 517     magnatune_get_genre_list();
 518         gtk_widget_hide(magnatune_pb);
 519         gtk_widget_set_sensitive(glade_xml_get_widget(pl3_xml, "pl3_win"), TRUE);
 520     return FALSE;
 521 }
 522
 523 typedef struct _Pass{
 524     GtkWidget *pb;
 525     int download;
 526     int total;
 527 }Pass;
 528
 529 static int magnatune_download_xml_callback_real(Pass *p);
 530 /* Move it to main thread, by pushing in idle */
 531 static void magnatune_download_xml_callback(int download, int total,gpointer data)
 532 {
 533     Pass *p= g_malloc0(sizeof(*p));
 534     p->pb = data;
 535     p->download = download;
 536     p->total =total;
 537     g_idle_add((GSourceFunc)magnatune_download_xml_callback_real, p);
 538 }
 539
 540 static int magnatune_download_xml_callback_real(Pass *p)
 541 {
 542         GtkWidget *pb = p->pb;
 543     int download = p->download;
 544     int total = p->total;
 545         gchar *label = NULL;
 546     gchar *size = NULL;
 547 //    gdk_threads_enter();
 548         if(total > 0)
 549                 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pb), download/(float)total);
 550         else
 551                 gtk_progress_bar_pulse(GTK_PROGRESS_BAR(pb));
 552
 553     size = g_format_size_for_display((goffset)download);
 554     label = g_strdup_printf("Downloading music catalog (%s done)",size);
 555     g_free(size);
 556     gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pb), label);
 557         g_free(label);
 558 //      while(gtk_events_pending())
 559 //              gtk_main_iteration();
 560 //    gdk_threads_leave();
 561     g_free(p);
 562     return FALSE;
 563 }
 564
 565 static void magnatune_download()
 566 {
 567     downloading = TRUE;
 568     //  gtk_widget_set_sensitive(glade_xml_get_widget(pl3_xml, "pl3_win"), FALSE);
 569     gmpc_mpddata_model_set_mpd_data(GMPC_MPDDATA_MODEL(gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[0]))),NULL);
 570         gtk_widget_show(magnatune_pb);
 571         magnatune_db_download_xml(magnatune_download_xml_callback, magnatune_pb);
 572 //      gtk_widget_hide(magnatune_pb);
 573 //      gtk_widget_set_sensitive(glade_xml_get_widget(pl3_xml, "pl3_win"), TRUE);
 574 }
 575
 576 static void magnatune_add(GtkWidget *cat_tree)
 577 {
 578         GtkTreePath *path = NULL;
 579         GtkTreeIter iter,child;
 580         GtkListStore *pl3_tree = (GtkListStore *)gtk_tree_view_get_model(GTK_TREE_VIEW(cat_tree));
 581         gint pos = cfg_get_single_value_as_int_with_default(config, "magnatune","position",20);
 582
 583         if(!cfg_get_single_value_as_int_with_default(config, "magnatune", "enable", TRUE)) return;
 584
 585     debug_printf(DEBUG_INFO,"Adding at position: %i", pos);
 586         playlist3_insert_browser(&iter, pos);
 587         gtk_list_store_set(GTK_LIST_STORE(pl3_tree), &iter,
 588                         PL3_CAT_TYPE, plugin.id,
 589                         PL3_CAT_TITLE, "Magnatune Browser",
 590                         PL3_CAT_INT_ID, "",
 591                         PL3_CAT_ICON_ID, "magnatune",
 592                         PL3_CAT_PROC, TRUE,
 593                         PL3_CAT_ICON_SIZE,GTK_ICON_SIZE_DND,-1);
 594         /**
 595          * Clean up old row reference if it exists
 596          */
 597         if (magnatune_ref)
 598         {
 599                 gtk_tree_row_reference_free(magnatune_ref);
 600                 magnatune_ref = NULL;
 601         }
 602         /**
 603          * create row reference
 604          */
 605         path = gtk_tree_model_get_path(GTK_TREE_MODEL(playlist3_get_category_tree_store()), &iter);
 606         if (path)
 607         {
 608                 magnatune_ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(playlist3_get_category_tree_store()), path);
 609                 gtk_tree_path_free(path);
 610         }
 611
 612 }
 613 static char * __magnatune_process_string(char *name)
 614 {
 615         int i = 0;
 616         int j = 0;
 617         int depth = 0;
 618         int spaces = 0;
 619
 620         /* only gonna be smaller */
 621         char *result = g_malloc0((strlen(name)+1+spaces*2)*sizeof(char));
 622         for(i=0; i < strlen(name);i++)
 623         {
 624                 if(name[i] == '(' || name[i] == '[') depth++;
 625                 else if (name[i] == ')' || name[i] == ']') depth--;
 626                 else if(!depth)
 627                 {
 628                         result[j] = name[i];
 629                         j++;
 630                 }
 631         }
 632         for(i=j-1;i>0 && result[i] == ' ';i--)
 633         {
 634                 result[i] = '\0';
 635         }
 636         return result;
 637 }
 638
 639 /*** COVER STUFF */
 640 static int magnatune_fetch_cover_priority(void){
 641         return cfg_get_single_value_as_int_with_default(config, "magnatune", "priority", 80);
 642 }
 643 static void magnatune_fetch_cover_priority_set(int priority){
 644         cfg_set_single_value_as_int(config, "magnatune", "priority", priority);
 645 }
 646 static int magnatune_fetch_get_image(mpd_Song *song,MetaDataType type, char **path)
 647 {
 648         int result = 0;
 649         if(magnatune_db_has_data() == FALSE)
 650                 return META_DATA_UNAVAILABLE;
 651         if(type == META_ARTIST_ART && song->artist)
 652         {
 653                 char *artist = __magnatune_process_string(song->artist);
 654                 char *value = magnatune_db_get_value(artist,NULL,META_ARTIST_ART);
 655                 if(value)
 656                 {
 657                         gmpc_easy_download_struct dld = {NULL, 0, -1, NULL,NULL};
 658                         *path = gmpc_get_metadata_filename(META_ARTIST_ART, song, NULL);
 659                         if(gmpc_easy_download(value, &dld))
 660                         {
 661                                 g_file_set_contents(*path, dld.data, dld.size, NULL);
 662                                 return META_DATA_AVAILABLE;
 663                         }
 664                         gmpc_easy_download_clean(&dld);
 665                         g_free(*path);
 666                         *path = NULL;
 667                 }
 668                 g_free(artist);
 669         }
 670         else if(type == META_ALBUM_ART && song->artist && song->album)
 671         {
 672                 char *artist = __magnatune_process_string(song->artist);
 673                 char *album= __magnatune_process_string(song->album);
 674                 char *value = magnatune_db_get_value(artist,album,META_ALBUM_ART);
 675                 if(value)
 676                 {
 677                         gmpc_easy_download_struct dld = {NULL, 0, -1, NULL,NULL};
 678
 679                         *path = gmpc_get_metadata_filename(META_ALBUM_ART, song, NULL);
 680                         if(gmpc_easy_download(value, &dld))
 681                         {
 682                                 g_file_set_contents(*path, dld.data, dld.size, NULL);
 683                                 return META_DATA_AVAILABLE;
 684                         }
 685                         gmpc_easy_download_clean(&dld);
 686                         g_free(*path);
 687                         *path = NULL;
 688                 }
 689                 g_free(artist);
 690         }
 691         return META_DATA_UNAVAILABLE;
 692 }
 693 static void magnatune_redownload_reload_db()
 694 {
 695         GtkTreeIter iter;
 696         GtkTreeModel *model = gtk_tree_row_reference_get_model(magnatune_ref);
 697         GtkTreePath *path = gtk_tree_row_reference_get_path(magnatune_ref);
 698         if(path && gtk_tree_model_get_iter(model, &iter, path))
 699         {
 700                 GtkTreeIter citer;
 701                 while(gtk_tree_model_iter_children(model, &citer,&iter))
 702                 {
 703                         gtk_list_store_remove(GTK_LIST_STORE(model), &citer);
 704                 }
 705                 magnatune_download();
 706                 //magnatune_get_genre_list();
 707         }
 708         if(path)
 709                 gtk_tree_path_free(path);
 710 }
 711 /*
 712 static void magnatune_cat_menu_add()
 713 {
 714         GtkTreeIter citer;
 715         GtkTreeSelection *sel = gtk_tree_view_get_selection(playlist3_get_category_tree_view());
 716         GtkTreeModel *model = (GtkTreeModel *)playlist3_get_category_tree_store();
 717         GtkTreePath *tpath;
 718         int depth = 0;
 719         if(!gtk_tree_selection_get_selected(sel,&model,&citer))
 720         {
 721                 return ;
 722         }
 723 */      /**
 724          * Get the level we are on.
 725          */
 726 /*      tpath = gtk_tree_model_get_path(model, &citer);
 727         depth = gtk_tree_path_get_depth(tpath);
 728         gtk_tree_path_free(tpath);
 729 */      /** Genre level */
 730 /*      if(depth == 2)
 731         {
 732                 GList *list, *node;
 733                 gchar *genre;
 734                 gtk_tree_model_get(model, &citer, PL3_CAT_INT_ID,&genre, -1);
 735                 if(genre)
 736                 {
 737                         list = magnatune_db_get_url_list(genre, NULL ,NULL);
 738                         for(node = list; node; node = node->next)
 739                         {
 740                                 mpd_playlist_queue_add(connection, node->data);
 741                         }
 742                         mpd_playlist_queue_commit(connection);
 743                         g_list_foreach(list, (GFunc)g_free, NULL);
 744                         g_list_free(list);
 745                         g_free(genre);
 746                 }
 747         }
 748 */      /** Artist */
 749 /*      else if(depth == 3)
 750         {
 751                 gchar *artist;
 752                 gchar *genre;
 753                 GtkTreeIter iter;
 754                 if(gtk_tree_model_iter_parent(model, &iter, &citer))
 755                 {
 756                         GList *list, *node;
 757                         gtk_tree_model_get(model, &iter, PL3_CAT_INT_ID,&genre, -1);
 758                         gtk_tree_model_get(model, &citer, PL3_CAT_INT_ID,&artist, -1);
 759                         list = magnatune_db_get_url_list(genre, artist,NULL);
 760                         for(node = list; node; node = node->next)
 761                         {
 762                                 mpd_playlist_queue_add(connection, node->data);
 763                         }
 764                         mpd_playlist_queue_commit(connection);
 765                         g_list_foreach(list, (GFunc)g_free, NULL);
 766                         g_list_free(list);
 767                         g_free(genre);
 768                         g_free(artist);
 769                 }
 770         }
 771
 772
 773
 774
 775 }
 776 */
 777 /*
 778 static void magnatune_cat_menu_replace()
 779 {
 780         mpd_playlist_clear(connection);
 781         magnatune_cat_menu_add();
 782         mpd_player_play(connection);
 783
 784 }
 785 */
 786 static int magnatune_cat_menu_popup(GtkWidget *menu, int type, GtkWidget *tree, GdkEventButton *event)
 787 {
 788         GtkWidget *item;
 789         if(type != plugin.id) return 0;
 790         else if (!downloading)
 791     {
 792         /* add the clear widget */
 793         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_REFRESH,NULL);
 794         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 795         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(magnatune_redownload_reload_db), NULL);
 796         return 1;
 797     }
 798         return 0;
 799 }
 800
 801 static void magnatune_add_selected(GtkWidget *button, GtkTreeView *tree)
 802 {
 803         GtkTreeModel *model = GTK_TREE_MODEL(mt_store);
 804         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
 805         GList *list = gtk_tree_selection_get_selected_rows(sel,&model);
 806         if(list)
 807         {
 808                 GList *node ;
 809                 for(node = list; node; node = g_list_next(node))
 810                 {
 811                         GtkTreeIter iter;
 812                         if(gtk_tree_model_get_iter(model, &iter, node->data))
 813                         {
 814                 gchar *path;
 815                                 gtk_tree_model_get(model, &iter, MPDDATA_MODEL_COL_PATH, &path, -1);
 816                 mpd_playlist_queue_add(connection, path);
 817                 g_free(path);
 818             }
 819                 }
 820                 mpd_playlist_queue_commit(connection);
 821                 g_list_foreach (list, (GFunc)gtk_tree_path_free, NULL);
 822                 g_list_free (list);
 823         }
 824 }
 825 static void magnatune_replace_selected(GtkWidget *button , GtkTreeView *tree)
 826 {
 827         mpd_playlist_clear(connection);
 828         magnatune_add_selected(button, tree);
 829         mpd_player_play(connection);
 830
 831 }
 832
 833 static void magnatune_list_edit_columns(GtkMenuItem *item, GtkWidget *widget)
 834 {
 835         gmpc_mpddata_treeview_edit_columns(GMPC_MPDDATA_TREEVIEW(widget));
 836 }
 837 static int magnatune_button_handle_release_event_tag_add(GtkWidget *button, gpointer userdata)
 838 {
 839     GList *list;
 840     MpdData *data;
 841     int position = GPOINTER_TO_INT(userdata);
 842     gchar *genre=NULL, *artist=NULL, *album=NULL;
 843     GtkTreeSelection *select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[0]));
 844     GtkTreeModel *model  = gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[0]));
 845     GtkTreeIter piter;
 846     if(gtk_tree_selection_get_selected(select, &model, &piter))
 847     {
 848         gtk_tree_model_get(model, &piter, MPDDATA_MODEL_COL_SONG_TITLE,&genre,-1);
 849     }
 850     if(position >= 1)
 851     {
 852         select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[1]));
 853         model  = gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[1]));
 854         if(gtk_tree_selection_get_selected(select, &model, &piter))
 855         {
 856             gtk_tree_model_get(model, &piter, MPDDATA_MODEL_COL_SONG_TITLE,&artist,-1);
 857         }
 858     }
 859     if(position >= 2)
 860     {
 861         select = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeviews[2]));
 862         model  = gtk_tree_view_get_model(GTK_TREE_VIEW(treeviews[2]));
 863         if(gtk_tree_selection_get_selected(select, &model, &piter))
 864         {
 865             gtk_tree_model_get(model, &piter, MPDDATA_MODEL_COL_SONG_TITLE,&album,-1);
 866         }
 867     }
 868     list = magnatune_db_get_url_list(genre, artist, album);
 869     for(;list; list = list->next)
 870     {
 871         mpd_playlist_queue_add(connection, list->data);
 872     }
 873     mpd_playlist_queue_commit(connection);
 874     if(list)
 875     {
 876         g_list_foreach(list, (GFunc)g_free, NULL);
 877         g_list_free(list);
 878     }
 879     if(genre)
 880         g_free(genre);
 881     if(artist)
 882         g_free(artist);
 883     if(album)
 884         g_free(album);
 885
 886 }
 887
 888 static int magnatune_button_handle_release_event_tag_replace(GtkWidget *button, gpointer userdata)
 889 {
 890     mpd_playlist_clear(connection);
 891     magnatune_button_handle_release_event_tag_add(button,userdata);
 892     mpd_player_play(connection);
 893
 894 }
 895
 896 static int magnatune_button_handle_release_event_tag(GtkWidget *tree, GdkEventButton *event,gpointer data)
 897 {
 898     int i;
 899     int position = GPOINTER_TO_INT(data);
 900         if(event->button != 3) return FALSE;
 901         GtkWidget *item;
 902
 903         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
 904         if(gtk_tree_selection_count_selected_rows(sel)> 0)
 905         {
 906                 GtkWidget *menu = gtk_menu_new();
 907
 908
 909         /* Add */
 910         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ADD,NULL);
 911                 gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), item);
 912                 g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK( magnatune_button_handle_release_event_tag_add), data);
 913                 /* Replace */
 914                 item = gtk_image_menu_item_new_with_label("Replace");
 915                 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
 916                                 gtk_image_new_from_stock(GTK_STOCK_REDO, GTK_ICON_SIZE_MENU));
 917                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 918         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK( magnatune_button_handle_release_event_tag_replace), data);
 919         gtk_widget_show_all(menu);
 920         gtk_menu_popup(GTK_MENU(menu), NULL, NULL,NULL, NULL, event->button, event->time);
 921         return TRUE;
 922     }
 923     return FALSE;
 924 }
 925
 926 static int magnatune_button_release_event(GtkWidget *tree, GdkEventButton *event,gpointer data)
 927 {
 928         if(event->button != 3) return FALSE;
 929         GtkWidget *item;
 930
 931         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
 932
 933         if(gtk_tree_selection_count_selected_rows(sel)> 0)
 934         {
 935                 GtkWidget *menu = gtk_menu_new();
 936                 GtkTreeModel *model = GTK_TREE_MODEL(mt_store);
 937                 /* Add */
 938                 item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ADD,NULL);
 939                 gtk_menu_shell_prepend(GTK_MENU_SHELL(menu), item);
 940                 g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(magnatune_add_selected), tree);
 941                 /* Replace */
 942                 item = gtk_image_menu_item_new_with_label("Replace");
 943                 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
 944                                 gtk_image_new_from_stock(GTK_STOCK_REDO, GTK_ICON_SIZE_MENU));
 945                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 946
 947                 g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(magnatune_replace_selected), tree);
 948
 949         /* Separator */
 950         item = gtk_separator_menu_item_new();
 951         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 952         /* Edit columns */
 953         item = gtk_image_menu_item_new_with_label(("Edit Columns"));
 954                 gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
 955                                 gtk_image_new_from_stock(GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU));
 956                 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 957                 g_signal_connect(G_OBJECT(item), "activate",
 958                                 G_CALLBACK(magnatune_list_edit_columns), tree);
 959
 960         gtk_widget_show_all(menu);
 961
 962         gtk_menu_popup(GTK_MENU(menu), NULL, NULL,NULL, NULL, event->button, event->time);
 963         return TRUE;
 964         }
 965         return FALSE;
 966 }
 967 /*
 968 static void magnatune_cat_key_press(GtkWidget *tree, GdkEventKey *event, int selected_type)
 969 {
 970         if(selected_type != plugin.id) return;
 971         if(event->state&GDK_CONTROL_MASK && event->keyval == GDK_Insert)
 972         {
 973                 magnatune_cat_menu_replace();
 974         }
 975         else if(event->keyval == GDK_Insert)
 976         {
 977                 magnatune_cat_menu_add();
 978         }
 979
 980 }
 981 */
 982 static int magnatune_key_press(GtkWidget *tree, GdkEventKey *event)
 983 {
 984         if(event->state&GDK_CONTROL_MASK && event->keyval == GDK_Insert)
 985         {
 986                 magnatune_replace_selected(NULL, GTK_TREE_VIEW(tree));
 987         }
 988         else if(event->keyval == GDK_Insert)
 989         {
 990                 magnatune_add_selected(NULL, GTK_TREE_VIEW(tree));
 991         }
 992         else if (event->keyval == GDK_f && event->state&GDK_CONTROL_MASK)
 993         {
 994                 treesearch_start(mt_tree_search);
 995                 return TRUE;
 996         }
 997         else if((event->state&(GDK_CONTROL_MASK|GDK_MOD1_MASK)) == 0 &&
 998                         ((event->keyval >= GDK_space && event->keyval <= GDK_z)))
 999         {
1000                 char data[2];
1001                 data[0] = (char)gdk_keyval_to_unicode(event->keyval);
1002                 data[1] = '\0';
1003                 treesearch_start(TREESEARCH(mt_tree_search));
1004                 gtk_entry_set_text(GTK_ENTRY(TREESEARCH(mt_tree_search)->entry),data);
1005                 gtk_editable_set_position(GTK_EDITABLE(TREESEARCH(mt_tree_search)->entry),1);
1006                 return TRUE;
1007         }
1008         return FALSE;
1009 }
1010 static void magnatune_save_myself(void)
1011 {
1012     if(magnatune_vbox)
1013     {
1014         int position = gtk_paned_get_position(GTK_PANED(magnatune_vbox));
1015         cfg_set_single_value_as_int(config, "magnatune", "pane-pos", position);
1016     }
1017         if (magnatune_ref)
1018     {
1019         GtkTreePath *path = gtk_tree_row_reference_get_path(magnatune_ref);
1020         if(path)
1021         {
1022             gint *indices = gtk_tree_path_get_indices(path);
1023             debug_printf(DEBUG_INFO,"Saving myself to position: %i\n", indices[0]);
1024             cfg_set_single_value_as_int(config, "magnatune","position",indices[0]);
1025             gtk_tree_path_free(path);
1026         }
1027     }
1028 }
1029
1030 static void magnatune_destroy(void)
1031 {
1032     magnatune_db_destroy();
1033     if(magnatune_vbox)
1034         gtk_widget_destroy(magnatune_vbox);
1035 }
1036
1037 static MpdData * magnatune_integrate_search(const int search_field, const gchar *query,GError **error)
1038 {
1039     const gchar *genre = NULL, *artist=NULL, *album=NULL;
1040     if(!magnatune_get_enabled()) return NULL;
1041     switch(search_field){
1042         case MPD_TAG_ITEM_ARTIST:
1043             artist = query;
1044             break;
1045         case MPD_TAG_ITEM_ALBUM:
1046             album = query;
1047             break;
1048         case MPD_TAG_ITEM_GENRE:
1049             genre = query;
1050             break;
1051         default:
1052             g_set_error(error, 0,0, "This type of search query is not supported");
1053             return NULL;
1054             break;
1055     }
1056     return magnatune_db_get_song_list(genre, artist, album,FALSE);
1057 }
1058
1059 gmpcMetaDataPlugin magnatune_cover = {
1060         .get_priority = magnatune_fetch_cover_priority,
1061     .set_priority = magnatune_fetch_cover_priority_set,
1062         .get_image = magnatune_fetch_get_image
1063 };
1064
1065
1066 /* Needed plugin_wp stuff */
1067 gmpcPlBrowserPlugin magnatune_gbp = {
1068         .add                    = magnatune_add,
1069         .selected               = magnatune_selected,
1070         .unselected             = magnatune_unselected,
1071         .cat_right_mouse_menu   = magnatune_cat_menu_popup,
1072     .integrate_search       = magnatune_integrate_search
1073 };
1074
1075 int plugin_api_version = PLUGIN_API_VERSION;
1076
1077 gmpcPlugin plugin = {
1078         .name                       = "Magnatune Stream Browser",
1079         .version                    = {PLUGIN_MAJOR_VERSION,PLUGIN_MINOR_VERSION,PLUGIN_MICRO_VERSION},
1080         .plugin_type                = GMPC_PLUGIN_PL_BROWSER|GMPC_PLUGIN_META_DATA,
1081     /* Creation and destruction */
1082         .init                       = magnatune_logo_init,
1083     .destroy                    = magnatune_destroy,
1084     .save_yourself              = magnatune_save_myself,
1085     .mpd_status_changed         = magnatune_mpd_status_changed,
1086
1087     /* Browser extention */
1088         .browser                    = &magnatune_gbp,
1089         .metadata                   = &magnatune_cover,
1090
1091     /* get/set enabled  */
1092         .get_enabled                = magnatune_get_enabled,
1093         .set_enabled                = magnatune_set_enabled
1094 };
1095
1096