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