src/plugin.c

   1 #include <gtk/gtk.h>
   2 #include <gmpc/plugin.h>
   3 #include <gmpc/playlist3-messages.h>
   4 #include <gmpc/gmpc-metaimage.h>
   5 #include <gmpc/misc.h>
   6 #include <libmpd/libmpd-internal.h>
   7 #include <config.h>
   8 #include "exo-wrap-table.h"
   9 #include "plugin.h"
  10
  11 static gchar * albumview_format_time(unsigned long seconds);
  12 static void albumview_browser_save_myself(void);
  13 /* Allow gmpc to check the version the plugin is compiled against */
  14 int plugin_api_version = PLUGIN_API_VERSION;
  15 GtkTreeModel *albumview_model = NULL;
  16
  17 void update_view(void);
  18 /**
  19  * Browser extention
  20  */
  21 gmpcPlBrowserPlugin albumview_gbp = {
  22         /** add */
  23         .add = albumview_add,
  24         /** selected */
  25         .selected = albumview_selected,
  26         /** unselected */
  27         .unselected = albumview_unselected,
  28 };
  29
  30
  31 /**
  32  * Define the plugin structure
  33  */
  34 gmpcPlugin plugin = {
  35         /* name */
  36         .name = "Album View",
  37         /* version */
  38         .version        = {PLUGIN_MAJOR_VERSION,PLUGIN_MINOR_VERSION,PLUGIN_MICRO_VERSION},
  39         /* type */
  40         .plugin_type = GMPC_PLUGIN_PL_BROWSER,
  41         /* init function */
  42         .init = albumview_plugin_init,
  43         /** playlist extention struct */
  44         .browser = &albumview_gbp,
  45         /** Connection changed */
  46         .mpd_connection_changed = albumview_connection_changed,
  47         /** enable/disable */
  48         .get_enabled = albumview_get_enabled,
  49         .set_enabled = albumview_set_enabled,
  50     /* Safe myself */
  51     .save_yourself = albumview_browser_save_myself
  52 };
  53
  54 static GtkTreeRowReference *albumview_ref = NULL;
  55 static GtkWidget *albumview_vbox= NULL, *albumview_tree = NULL,*albumview_combo = NULL;
  56 static gboolean cancel_query = FALSE;
  57 /**
  58  * Get/Set enable
  59  */
  60
  61 int albumview_get_enabled(void)
  62 {
  63         return cfg_get_single_value_as_int_with_default(config, "albumview", "enable", TRUE);
  64 }
  65
  66 void albumview_set_enabled(int enabled)
  67 {
  68         cfg_set_single_value_as_int(config, "albumview", "enable", enabled);
  69         if(enabled)
  70         {
  71                 if(albumview_ref == NULL)
  72                 {
  73                         albumview_add(GTK_WIDGET(playlist3_get_category_tree_view()));
  74                 }
  75         }
  76         else
  77         {
  78                 GtkTreePath *path = gtk_tree_row_reference_get_path(albumview_ref);
  79         GtkTreeModel *model = gtk_tree_row_reference_get_model(albumview_ref);
  80                 if (path){
  81                         GtkTreeIter iter;
  82                         if (gtk_tree_model_get_iter(model, &iter, path)){
  83                                 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
  84                         }
  85                         gtk_tree_path_free(path);
  86                         gtk_tree_row_reference_free(albumview_ref);
  87                         albumview_ref = NULL;
  88                 }
  89         }
  90 }
  91
  92 /**
  93  * Playlist browser functions
  94  */
  95 static void albumview_add(GtkWidget *category_tree)
  96 {
  97         GtkTreePath *path;
  98         GtkTreeModel *model = GTK_TREE_MODEL(playlist3_get_category_tree_store());
  99         GtkTreeIter iter;
 100     gint pos;
 101         /**
 102          * don't do anything if we are disabled
 103          */
 104         if(!cfg_get_single_value_as_int_with_default(config, "albumview", "enable", TRUE)) return;
 105         /**
 106          * Add ourslef to the list
 107          */
 108         pos = cfg_get_single_value_as_int_with_default(config, "albumview","position",2);
 109         playlist3_insert_browser(&iter, pos);
 110         gtk_list_store_set(GTK_LIST_STORE(model), &iter,
 111                         PL3_CAT_TYPE, plugin.id,
 112                         PL3_CAT_TITLE,"Album View",
 113                         PL3_CAT_ICON_ID, "gtk-open",
 114                         -1);
 115         /**
 116          * remove odl reference if exists
 117          */
 118         if (albumview_ref) {
 119                 gtk_tree_row_reference_free(albumview_ref);
 120                 albumview_ref = NULL;
 121         }
 122         /**
 123          * create reference to ourself in the list
 124          */
 125         path = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &iter);
 126         if (path) {
 127                 albumview_ref = gtk_tree_row_reference_new(model, path);
 128                 gtk_tree_path_free(path);
 129         }
 130 }
 131 static void albumview_browser_save_myself(void)
 132 {
 133         if(albumview_ref)
 134         {
 135                 GtkTreePath *path = gtk_tree_row_reference_get_path(albumview_ref);
 136                 if(path)
 137                 {
 138                         gint *indices = gtk_tree_path_get_indices(path);
 139                         debug_printf(DEBUG_INFO,"Saving myself to position: %i\n", indices[0]);
 140                         cfg_set_single_value_as_int(config, "albumview","position",indices[0]);
 141                         gtk_tree_path_free(path);
 142                 }
 143         }
 144 }
 145
 146 GtkWidget *entry  = NULL;
 147 int album_size = 200;
 148 int supported_columns = 1;
 149 void size_changed(GtkWidget *widget, GtkAllocation *alloc)
 150 {
 151     int columns = (alloc->width-20)/(album_size +25);
 152     if(columns != supported_columns)
 153     {
 154         supported_columns = columns;
 155         printf("update columns: %i %i %i\n", alloc->width-20,columns, album_size);
 156         if(entry && GTK_WIDGET_IS_SENSITIVE(entry))
 157         {
 158             update_view();
 159         }
 160     }
 161 }
 162 void album_size_changed(GtkRange *spin)
 163 {
 164     int new_size = ((int)gtk_range_get_value(spin))*20;
 165     if(new_size != album_size) {
 166         album_size = new_size;
 167         size_changed(albumview_vbox, &(albumview_vbox->allocation));
 168         /*
 169         if(entry && GTK_WIDGET_IS_SENSITIVE(entry))
 170         {
 171             update_view();
 172         }
 173         */
 174     }
 175     cfg_set_single_value_as_int(config, "albumview", "zoom-level", (int)gtk_range_get_value(spin));
 176 }
 177 static gboolean expose_event(GtkWidget *wid, GdkEventExpose *event, gpointer data)
 178 {
 179     /* TODO improve this, somehow applying the clipmask fail. */
 180     int offset  = ((event->area.y)%(album_size+40));
 181     int step    = (album_size +40)- offset;
 182     int start   = event->area.y;
 183     int flip    = ((int)(event->area.y+step-5)/(album_size+40))&1;
 184     int stop    = event->area.y+event->area.height;
 185     cairo_t *cc = gdk_cairo_create(GTK_WIDGET(wid)->window);
 186     do{
 187         if(flip)
 188             cairo_set_source_rgba(cc, 1.0,1.0,1.0,1.0);
 189         else
 190             cairo_set_source_rgba(cc, 0.8,0.8,0.8,1.0);
 191         cairo_rectangle(cc, 0, start, wid->allocation.width,step );
 192         cairo_fill(cc);
 193         start += step;
 194         step = album_size+40;
 195         flip = (flip == 1)?0:1;
 196     }while(start<stop);
 197     cairo_destroy(cc);
 198     return FALSE;
 199 }
 200 static void albumview_init()
 201 {
 202     /** Get an allready exposed widgets to grab theme colors from. */
 203     GtkWidget *colw = (GtkWidget *)playlist3_get_category_tree_view();
 204     GtkWidget *label = NULL;
 205     GtkWidget *event = gtk_event_box_new();
 206     int i = 0;
 207     albumview_vbox = gtk_vbox_new(FALSE, 0);
 208
 209     album_size = 20*cfg_get_single_value_as_int_with_default(config, "albumview", "zoom-level", 10);
 210     g_signal_connect(G_OBJECT(albumview_vbox), "size-allocate", G_CALLBACK(size_changed), NULL);
 211
 212     GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL);
 213     GtkWidget *iv = albumview_tree = gtk_vbox_new(FALSE, 6);
 214
 215
 216     entry = gtk_entry_new();
 217     gtk_box_pack_start(GTK_BOX(albumview_vbox), entry, FALSE, FALSE, 0);
 218     g_signal_connect(G_OBJECT(entry),"changed", G_CALLBACK(update_view), NULL);
 219
 220     GtkWidget *spin= gtk_hscale_new_with_range(1, 12, 1);
 221     gtk_scale_set_draw_value(GTK_SCALE(spin), FALSE);
 222     gtk_range_set_value(GTK_RANGE(spin), album_size);
 223     gtk_box_pack_start(GTK_BOX(albumview_vbox), spin, FALSE, FALSE, 0);
 224
 225 #if GTK_CHECK_VERSION(2,16,0)
 226     for(i=1; i<13;i++){
 227         gtk_scale_add_mark(GTK_SCALE(spin), (gdouble)i,GTK_POS_TOP, NULL);
 228     }
 229 #endif
 230
 231     gtk_range_set_value(GTK_RANGE(spin), cfg_get_single_value_as_int_with_default(config, "albumview", "zoom-level", 10));
 232     g_signal_connect(G_OBJECT(spin), "value-changed", G_CALLBACK(album_size_changed), NULL);
 233
 234
 235     gtk_box_pack_start(GTK_BOX(albumview_vbox),sw, TRUE, TRUE, 0);
 236 //    gtk_widget_modify_bg(event, GTK_STATE_NORMAL,&(albumview_vbox->style->white));
 237     gtk_event_box_set_visible_window(GTK_EVENT_BOX(event), TRUE);
 238     gtk_widget_set_app_paintable(GTK_WIDGET(event),TRUE);
 239     g_signal_connect(G_OBJECT(event), "expose-event", G_CALLBACK(expose_event), NULL);
 240
 241     gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), event);
 242     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 243     gtk_container_add(GTK_CONTAINER(event), iv);
 244
 245     gtk_widget_show_all(albumview_vbox);
 246     /* maintain my own reference to the widget, so it won't get destroyed removing
 247      * from view
 248      */
 249     g_object_ref(albumview_vbox);
 250 }
 251
 252
 253 static void albumview_selected(GtkWidget *container)
 254 {
 255     if(albumview_vbox== NULL) {
 256         albumview_init();
 257         albumview_connection_changed(connection,1,NULL);
 258     }
 259     gtk_container_add(GTK_CONTAINER(container), albumview_vbox);
 260     gtk_widget_show(albumview_vbox);
 261 }
 262
 263 static void albumview_unselected(GtkWidget *container)
 264 {
 265     gtk_container_remove(GTK_CONTAINER(container), albumview_vbox);
 266 }
 267
 268
 269
 270 void albumview_plugin_init(void)
 271 {
 272     gchar *path = gmpc_plugin_get_data_path(&plugin);
 273     gchar *url = g_build_path(G_DIR_SEPARATOR_S,path, "albumview", NULL);
 274     debug_printf(DEBUG_WARNING,"Found url: %s\n", url);
 275
 276
 277     gtk_icon_theme_append_search_path(gtk_icon_theme_get_default (),url);
 278
 279     g_free(path);
 280     g_free(url);
 281 }
 282 #define TIMER_SUB(start,stop,diff)  diff.tv_usec = stop.tv_usec - start.tv_usec;\
 283         diff.tv_sec = stop.tv_sec - start.tv_sec;\
 284         if(diff.tv_usec < 0) {\
 285             diff.tv_sec -= 1; \
 286             diff.tv_usec += G_USEC_PER_SEC; \
 287         }
 288 static gint __add_sort(gpointer aa, gpointer bb, gpointer data)
 289 {
 290     MpdData_real *a = *(MpdData_real **)aa;
 291     MpdData_real *b = *(MpdData_real **)bb;
 292     if(!a || !b) return 0;
 293     if(a->type == MPD_DATA_TYPE_SONG && b->type == MPD_DATA_TYPE_SONG)
 294     {
 295         if(a->song->artist &&  b->song->artist)
 296         {
 297             int val;
 298             {
 299                 gchar *sa,*sb;
 300                 sa = g_utf8_strdown(a->song->artist, -1);
 301                 sb = g_utf8_strdown(b->song->artist, -1);
 302                 val = g_utf8_collate(sa,sb);
 303                 g_free(sa);
 304                 g_free(sb);
 305             }/* else {
 306                 val = (a == NULL)?((b==NULL)?0:-1):1;
 307             }*/
 308             return val;
 309         }
 310     }
 311     return -1;
 312 }
 313 MpdData *complete_list = NULL;
 314 GtkWidget *pb;
 315 int max = 0, current = 0;
 316 static gboolean load_list_itterate(MpdData *data)
 317 {
 318     MpdData *data2 = NULL;
 319     current++;
 320     if(max>0){
 321         gchar *temp = g_strdup_printf("%i of %i albums loaded", current, max);
 322         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pb), current/(double)max);
 323         gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pb), temp);
 324         g_free(temp);
 325
 326     }
 327     if(data)
 328     {
 329         mpd_database_search_field_start(connection, MPD_TAG_ITEM_ARTIST);
 330         mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ALBUM, (data)->tag);
 331         data2 = mpd_database_search_commit(connection);
 332         if(data2)
 333         {
 334             mpd_Song *song = mpd_newSong();
 335             song->album = g_strdup((data)->tag);
 336             song->artist = g_strdup(data2->tag);
 337             if(!mpd_data_is_last(data2))
 338             {
 339                 /* test if server supports album artist */
 340                 if(mpd_server_tag_supported(connection, MPD_TAG_ITEM_ALBUM_ARTIST))
 341                 {
 342                     mpd_database_search_field_start(connection, MPD_TAG_ITEM_ALBUM_ARTIST);
 343                     mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ALBUM, (data)->tag);
 344                     MpdData *data3 = mpd_database_search_commit(connection);
 345                     if(mpd_data_is_last(data3)){
 346                         song->albumartist = g_strdup(data3->tag);
 347                     }
 348                     else{
 349                         mpd_freeSong(song);
 350                         song = NULL;
 351                     }
 352                     mpd_data_free(data3);
 353                 }
 354                 else {
 355                     mpd_freeSong(song);
 356                     song = NULL;
 357                 }
 358             }
 359             mpd_data_free(data2);
 360             if(song){
 361                 complete_list = mpd_new_data_struct_append(complete_list);
 362                 complete_list->song = song;
 363                 complete_list->type = MPD_DATA_TYPE_SONG;
 364                 song = NULL;
 365             }
 366         }
 367
 368         (data) = mpd_data_get_next((data));
 369     }
 370     if(data == NULL){
 371         complete_list = (MpdData *)misc_sort_mpddata(mpd_data_get_first(complete_list), (GCompareDataFunc)__add_sort, NULL);
 372         printf("update view\n");
 373         gtk_widget_destroy(pb);
 374         update_view();
 375
 376         gtk_widget_set_sensitive(entry, TRUE);
 377         return FALSE;
 378     }
 379
 380     g_idle_add((GSourceFunc)load_list_itterate, data);
 381     return FALSE;
 382 }
 383
 384 static GtkWidget *table = NULL;
 385 static void load_list(void)
 386 {
 387     mpd_data_free(complete_list);
 388     complete_list = NULL;
 389
 390     pb = gtk_progress_bar_new();
 391     gtk_box_pack_start(GTK_BOX(albumview_tree), pb, FALSE, FALSE, 0);
 392     gtk_widget_show_all(albumview_tree);
 393     mpd_database_search_field_start(connection, MPD_TAG_ITEM_ALBUM);
 394     MpdData *iter,*data = mpd_database_search_commit(connection);
 395     max = 0;
 396     current = 0;
 397     gtk_widget_set_sensitive(entry, FALSE);
 398     for(iter = data; iter; iter = mpd_data_get_next_real(iter, FALSE)) max++;
 399     g_idle_add((GSourceFunc)load_list_itterate, data);
 400 }
 401 void albumview_connection_changed(MpdObj *mi, int connect,void *usedata)
 402 {
 403
 404     if(connect && albumview_vbox)
 405     {
 406         load_list();
 407     }
 408     else if(albumview_vbox){
 409         mpd_data_free(complete_list);
 410         complete_list = NULL;
 411     }
 412 }
 413 static void album_add(GtkWidget *button, mpd_Song *song)
 414 {
 415     mpd_database_search_start(connection,TRUE);
 416
 417     mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ALBUM, song->album);
 418     if(song->albumartist){
 419         mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ALBUM_ARTIST, song->albumartist);
 420     }else{
 421         mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ARTIST, song->artist);
 422     }
 423     MpdData *data = mpd_database_search_commit(connection);
 424     for(;data;data = mpd_data_get_next(data)){
 425         mpd_playlist_queue_add(connection, data->song->file);
 426     }
 427     mpd_playlist_queue_commit(connection);
 428 }
 429 static void album_view(GtkWidget *button ,mpd_Song *song)
 430 {
 431         if (song && song->artist && song->album) {
 432                 info2_activate();
 433                 info2_fill_album_view(song->artist, song->album);
 434         }
 435 }
 436
 437 static void album_replace(GtkWidget *button, mpd_Song *song)
 438 {
 439     mpd_playlist_clear(connection);
 440     album_add(button, song);
 441     mpd_player_play(connection);
 442 }
 443 static gboolean album_button_press(GtkWidget *item, GdkEventButton *event, mpd_Song *song)
 444 {
 445     printf("button press event %i\n", event->button);
 446     if(event->button == 1 && event->type == GDK_BUTTON_PRESS)
 447     {
 448         GtkWidget *menu = gtk_menu_new();
 449         GtkWidget *item;
 450
 451         item = gtk_image_menu_item_new_with_label("Album information");
 452         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
 453                 gtk_image_new_from_stock(GTK_STOCK_INFO, GTK_ICON_SIZE_MENU));
 454         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 455         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(album_view), song);
 456
 457         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ADD,NULL);
 458         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 459         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(album_add), song);
 460
 461         /* replace the replace widget */
 462         item = gtk_image_menu_item_new_with_label("Replace");
 463         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
 464                 gtk_image_new_from_stock(GTK_STOCK_REDO, GTK_ICON_SIZE_MENU));
 465         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 466         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(album_replace), song);
 467         gtk_widget_show_all(menu);
 468         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, event->time);
 469     }
 470     else if (event->button == 2){
 471         album_add(NULL, song);
 472     }
 473     return TRUE;
 474 }
 475
 476 static guint update_timeout = 0;
 477
 478 static gboolean update_view_real(void)
 479 {
 480     MpdData *complete_list_iter;
 481     const char *search_query = gtk_entry_get_text(GTK_ENTRY(entry));
 482     int i=0;
 483     GTimeVal start, stop,diff;
 484     int j=0;
 485     gchar *artist= NULL;
 486     int items =0;
 487     MpdData *data = NULL;
 488     printf("search query: %s\n", search_query);
 489     GList *entries = NULL;
 490     GList *list = (table)?gtk_container_get_children(GTK_CONTAINER(table)):NULL;
 491     GList *iter;
 492     if(table)
 493         gtk_widget_hide(table);
 494     for(iter =  g_list_first(list); iter; iter = iter->next){
 495         GtkWidget *widget = iter->data;
 496         gtk_container_remove(GTK_CONTAINER(table), widget);
 497     }
 498     g_list_free(list);
 499     list = NULL;
 500     g_get_current_time(&start);
 501
 502     gtk_widget_show(albumview_tree);
 503
 504     /**
 505      * Create a filtered linked list
 506      */
 507     for(complete_list_iter = mpd_data_get_first(complete_list);
 508             complete_list_iter;
 509             complete_list_iter = mpd_data_get_next_real(complete_list_iter, FALSE))
 510     {
 511         if(search_query[0] == '\0' || strstr(complete_list_iter->song->artist, search_query)){
 512             items++;
 513             list = g_list_append(list, complete_list_iter);
 514         }
 515     }
 516
 517     g_get_current_time(&stop);
 518     TIMER_SUB(start, stop, diff);
 519     printf("Removing old stuff time elapsed: %lu s %lus us\n",  diff.tv_sec, diff.tv_usec);
 520     int rows = items/supported_columns+1;
 521     /**
 522      * Create holding table if it does not exist
 523      */
 524     if(!table){
 525         GtkWidget *ali = gtk_alignment_new(0.0, 0.5, 0,0);
 526         table = exo_wrap_table_new(TRUE);//gtk_table_new(rows, supported_columns, TRUE);
 527         gtk_container_add(GTK_CONTAINER(ali), table);
 528         gtk_box_pack_start(GTK_BOX(albumview_tree), ali, FALSE, FALSE, 0);
 529     }
 530 //    else gtk_table_resize(GTK_TABLE(table), rows, supported_columns);
 531
 532     /* I know how large it is going to be.. so lets set the size */
 533     gtk_widget_set_size_request(table, supported_columns*(album_size+20+6), rows*(album_size+40+6));
 534     /**
 535      * Add albums
 536      */
 537     if((iter = g_list_first(list)))
 538     do
 539     {
 540         complete_list_iter = iter->data;
 541         if(complete_list_iter->song && (complete_list_iter->song->artist)[0] != '\0')
 542         {
 543             GtkWidget *vbox = complete_list_iter->userdata;
 544             GtkWidget *item;
 545             int a,b;
 546             if(vbox == NULL){
 547                 GtkWidget *label = NULL;
 548                 gchar *temp = NULL;
 549                 /* Wrap it in a vbox */
 550                 vbox = gtk_vbox_new(FALSE, 3);
 551                 gtk_widget_set_size_request(vbox, album_size+20,album_size+40);
 552
 553                 item = gmpc_metaimage_new_size(META_ALBUM_ART,album_size);
 554                 gtk_widget_set_has_tooltip(GTK_WIDGET(item), FALSE);
 555                 gmpc_metaimage_set_squared(GMPC_METAIMAGE(item), TRUE);
 556
 557                 gmpc_metaimage_update_cover_from_song_delayed(GMPC_METAIMAGE(item), complete_list_iter->song);
 558
 559                 gtk_box_pack_start(GTK_BOX(vbox), item, TRUE, TRUE, 0);
 560                 /* Set artist name */
 561                 if(complete_list_iter->song->albumartist){
 562                     GtkWidget *label = gtk_label_new(complete_list_iter->song->albumartist);
 563                     gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_MIDDLE);
 564                     gtk_box_pack_end(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 565                 }else{
 566                     GtkWidget *label = gtk_label_new(complete_list_iter->song->artist);
 567                     gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_MIDDLE);
 568                     gtk_box_pack_end(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 569                 }
 570
 571                 /* Set album name */
 572                 label = gtk_label_new("");
 573                 temp = g_markup_printf_escaped("<b>%s</b>", complete_list_iter->song->album);
 574                 gtk_label_set_markup(GTK_LABEL(label), temp);
 575                 g_free(temp);
 576                 gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_MIDDLE);
 577                 gtk_box_pack_end(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 578
 579
 580                 /* Attach it to the song */
 581                 complete_list_iter->userdata = g_object_ref_sink(vbox);
 582                 complete_list_iter->freefunc = (void *)gtk_widget_destroy;
 583                 g_object_set_data(G_OBJECT(vbox), "item", item);
 584                 g_signal_connect(item, "button-press-event",
 585                         G_CALLBACK(album_button_press), complete_list_iter->song);
 586
 587             }
 588             else{
 589                 item = g_object_get_data(G_OBJECT(vbox), "item");
 590                 /* Resize if needed */
 591                 if(album_size != gmpc_metaimage_get_size(GMPC_METAIMAGE(item))){
 592                     gtk_widget_set_size_request(vbox, album_size+20,album_size+40);
 593                     gmpc_metaimage_set_size(GMPC_METAIMAGE(item), album_size);
 594                     gmpc_metaimage_reload_image(GMPC_METAIMAGE(item));
 595                 }
 596
 597             }
 598             entries = g_list_prepend(entries, vbox);
 599             j++;
 600         }
 601     }while((iter = g_list_next(iter)));
 602     /* remove list */
 603     if(list) g_list_free(list);
 604     list = NULL;
 605
 606     g_get_current_time(&stop);
 607     TIMER_SUB(start, stop, diff);
 608     printf("Creating/Updating albums time elapsed: %lu s %lus us\n",  diff.tv_sec, diff.tv_usec);
 609     for(iter = entries = g_list_reverse(entries); iter; iter = g_list_next(iter)){
 610         gtk_container_add(GTK_CONTAINER(table), iter->data);
 611     }
 612     if(entries) g_list_free(entries);
 613     TIMER_SUB(start, stop, diff);
 614     printf("adding items to view: %lu s %lus us\n", diff.tv_sec, diff.tv_usec);
 615
 616     gtk_widget_show_all(albumview_tree);
 617     g_get_current_time(&stop);
 618     TIMER_SUB(start, stop, diff);
 619     printf("Showing widget time elapsed: %lu s %lus us\n",  diff.tv_sec, diff.tv_usec);
 620     /**
 621      * Remove the timeout
 622      */
 623     if(update_timeout)
 624         g_source_remove(update_timeout);
 625     update_timeout = 0;
 626     return FALSE;
 627 }
 628
 629
 630 void update_view()
 631 {
 632     if(update_timeout != 0) {
 633         g_source_remove(update_timeout);
 634     }
 635     update_timeout = g_timeout_add(500, (GSourceFunc)update_view_real,NULL);
 636 }