src/plugin.c

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