src/plugin.c

   1 #include <config.h>
   2 #include <glib.h>
   3 #include <glib/gi18n-lib.h>
   4 #include <gtk/gtk.h>
   5 #include <gdk/gdkkeysyms.h>
   6 #include <gmpc/plugin.h>
   7 #include <gmpc/playlist3-messages.h>
   8 #include <gmpc/gmpc-metaimage.h>
   9 #include <gmpc/misc.h>
  10 #include <libmpd/libmpd-internal.h>
  11 #include <math.h>
  12 #include "exo-wrap-table.h"
  13 #include "plugin.h"
  14
  15 const GType albumview_plugin_get_type(void);
  16 #define ALBUM_VIEW_PLUGIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), albumview_plugin_get_type(), AlbumViewPlugin))
  17 #define AV_LOG_DOMAIN "AlbumViewPlugin"
  18
  19 typedef struct _AlbumViewPluginPrivate {
  20     int supported_columns;
  21     int supported_rows;
  22     int album_size;
  23     GtkWidget *filter_entry;
  24     GtkWidget *slider_scale;
  25     GtkWidget *progress_bar;
  26     GtkWidget *item_table;
  27     GtkWidget *albumview_box;
  28     GtkWidget *albumview_main_box;
  29     GtkWidget *event_bg;
  30     int max_entries;
  31     int current_entry;
  32
  33     MpdData *complete_list;
  34     guint update_timeout;
  35     /* temp */
  36     MpdData *data;
  37     GList *current_item;
  38     GtkTreeRowReference *albumview_ref;
  39 }_AlbumViewPluginPrivate;
  40
  41
  42
  43 static gchar * albumview_format_time(unsigned long seconds);
  44 static void albumview_browser_save_myself(GmpcPluginBase *plug);
  45 static void position_changed(GtkRange *range, gpointer data);
  46 static void filter_list(GtkEntry *entry, gpointer data);
  47 void update_view(AlbumViewPlugin *self);
  48 /**
  49  * Get/Set enable
  50  */
  51
  52 static int albumview_get_enabled(GmpcPluginBase *plug)
  53 {
  54         return cfg_get_single_value_as_int_with_default(config, "albumview", "enable", TRUE);
  55 }
  56
  57 void albumview_set_enabled(GmpcPluginBase *plug, int enabled)
  58 {
  59     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(plug);
  60         cfg_set_single_value_as_int(config, "albumview", "enable", enabled);
  61         if(enabled)
  62         {
  63                 if(self->priv->albumview_ref == NULL)
  64                 {
  65                         albumview_add(GMPC_PLUGIN_BROWSER_IFACE(plug), GTK_WIDGET(playlist3_get_category_tree_view()));
  66                 }
  67         }
  68         else
  69         {
  70                 GtkTreePath *path = gtk_tree_row_reference_get_path(self->priv->albumview_ref);
  71         GtkTreeModel *model = gtk_tree_row_reference_get_model(self->priv->albumview_ref);
  72                 if (path){
  73                         GtkTreeIter iter;
  74                         if (gtk_tree_model_get_iter(model, &iter, path)){
  75                                 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
  76                         }
  77                         gtk_tree_path_free(path);
  78                         gtk_tree_row_reference_free(self->priv->albumview_ref);
  79                         self->priv->albumview_ref = NULL;
  80                 }
  81         }
  82 }
  83
  84 /**
  85  * Playlist browser functions
  86  */
  87 static void albumview_add(GmpcPluginBrowserIface *plug, GtkWidget *category_tree)
  88 {
  89     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(plug);
  90         GtkTreePath *path;
  91         GtkTreeModel *model = GTK_TREE_MODEL(playlist3_get_category_tree_store());
  92         GtkTreeIter iter;
  93     gint pos;
  94         /**
  95          * don't do anything if we are disabled
  96          */
  97         if(!cfg_get_single_value_as_int_with_default(config, "albumview", "enable", TRUE)) return;
  98         /**
  99          * Add ourslef to the list
 100          */
 101         pos = cfg_get_single_value_as_int_with_default(config, "albumview","position",2);
 102         playlist3_insert_browser(&iter, pos);
 103         gtk_list_store_set(GTK_LIST_STORE(model), &iter,
 104                         PL3_CAT_TYPE, GMPC_PLUGIN_BASE(plug)->id,
 105                         PL3_CAT_TITLE,"Album View",
 106                         PL3_CAT_ICON_ID, "stylized-no-cover",
 107                         -1);
 108         /**
 109          * remove odl reference if exists
 110          */
 111         if (self->priv->albumview_ref) {
 112                 gtk_tree_row_reference_free(self->priv->albumview_ref);
 113                 self->priv->albumview_ref = NULL;
 114         }
 115         /**
 116          * create reference to ourself in the list
 117          */
 118         path = gtk_tree_model_get_path(GTK_TREE_MODEL(model), &iter);
 119         if (path) {
 120                 self->priv->albumview_ref = gtk_tree_row_reference_new(model, path);
 121                 gtk_tree_path_free(path);
 122         }
 123 }
 124 static void albumview_browser_save_myself(GmpcPluginBase *plug)
 125 {
 126     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(plug);
 127         if(self->priv->albumview_ref)
 128         {
 129                 GtkTreePath *path = gtk_tree_row_reference_get_path(self->priv->albumview_ref);
 130                 if(path)
 131                 {
 132                         gint *indices = gtk_tree_path_get_indices(path);
 133                         g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Saving myself to position: %i", indices[0]);
 134                         cfg_set_single_value_as_int(config, "albumview","position",indices[0]);
 135                         gtk_tree_path_free(path);
 136                 }
 137         }
 138 }
 139
 140 void size_changed(GtkWidget *widget, GtkAllocation *alloc, gpointer user_data)
 141 {
 142     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(user_data);
 143     int columns = (alloc->width-10)/(self->priv->album_size +25);
 144     int rows = (alloc->height-10)/(self->priv->album_size +40);
 145
 146     if(columns != self->priv->supported_columns || rows != self->priv->supported_rows)
 147     {
 148         self->priv->supported_columns = (columns)?columns:1;
 149         self->priv->supported_rows = (rows)?rows:1;
 150         g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "update columns: %i %i %i\n", alloc->width-20,columns, self->priv->album_size);
 151         if(self->priv->filter_entry && GTK_WIDGET_IS_SENSITIVE(self->priv->filter_entry))
 152         {
 153             update_view(self);
 154         }
 155     }
 156
 157 }
 158 void album_size_changed(GtkSpinButton *spin, gpointer user_data)
 159 {
 160     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(user_data);
 161     int new_size = ((int)gtk_spin_button_get_value(spin))*25+50;
 162     if(new_size != self->priv->album_size) {
 163         self->priv->album_size = new_size;
 164         g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Set new size: %i\n", new_size);
 165         /* Reset so it gets redrawn */
 166         self->priv->supported_columns = -1;
 167         /* Force re-display */
 168         size_changed(self->priv->albumview_main_box, &(self->priv->albumview_main_box->allocation), self);
 169     }
 170     cfg_set_single_value_as_int(config, "albumview", "zoom-level", (int)gtk_spin_button_get_value(spin));
 171 }
 172
 173 static gboolean albumview_scroll_event(GtkWidget *event_box, GdkEventScroll *event, gpointer data)
 174 {
 175     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(data);
 176     if(self->priv->current_item == NULL) return FALSE;
 177     if(event->direction == GDK_SCROLL_UP)
 178     {
 179         int value = gtk_range_get_value(GTK_RANGE(self->priv->slider_scale))-self->priv->supported_columns;
 180         gtk_range_set_value(GTK_RANGE(self->priv->slider_scale), value);
 181         return TRUE;
 182     }else if(event->direction == GDK_SCROLL_DOWN) {
 183         int value = gtk_range_get_value(GTK_RANGE(self->priv->slider_scale))+self->priv->supported_columns;
 184         gtk_range_set_value(GTK_RANGE(self->priv->slider_scale), value);
 185         return TRUE;
 186     }
 187     return FALSE;
 188 }
 189 static gboolean albumview_key_press_event(GtkWidget *event_box, GdkEventKey *event, gpointer data)
 190 {
 191     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(data);
 192     if(self->priv->current_item == NULL) return FALSE;
 193
 194     if(event->keyval == GDK_Up){
 195         int value = gtk_range_get_value(GTK_RANGE(self->priv->slider_scale))-self->priv->supported_columns;
 196         gtk_range_set_value(GTK_RANGE(self->priv->slider_scale), value);
 197         return TRUE;
 198     }else if (event->keyval == GDK_Down){
 199         int value = gtk_range_get_value(GTK_RANGE(self->priv->slider_scale))+self->priv->supported_columns;
 200         gtk_range_set_value(GTK_RANGE(self->priv->slider_scale), value);
 201         return TRUE;
 202     }else if (event->keyval == GDK_Page_Up) {
 203         int value = gtk_range_get_value(GTK_RANGE(self->priv->slider_scale))-self->priv->supported_columns*self->priv->supported_rows;
 204         gtk_range_set_value(GTK_RANGE(self->priv->slider_scale), value);
 205         return TRUE;
 206
 207     }else if (event->keyval == GDK_Page_Down) {
 208         int value = gtk_range_get_value(GTK_RANGE(self->priv->slider_scale))+self->priv->supported_columns*self->priv->supported_rows;
 209         gtk_range_set_value(GTK_RANGE(self->priv->slider_scale), value);
 210         return TRUE;
 211
 212     }
 213
 214     return FALSE;
 215 }
 216 static gboolean albumview_button_press_event(GtkWidget *event_box, GdkEventButton *event, gpointer data)
 217 {
 218     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(data);
 219     if(self->priv->current_item == NULL) return FALSE;
 220     gtk_widget_grab_focus(self->priv->event_bg);
 221 }
 222 static gboolean albumview_focus(GtkWidget *wid,GdkEventFocus *event,  gpointer data)
 223 {
 224     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(data);
 225     g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "focus in");
 226     gtk_widget_queue_draw(self->priv->event_bg);
 227     return TRUE;
 228 }
 229 static gboolean albumview_focus_out(GtkWidget *wid,GdkEventFocus *event,  gpointer data)
 230 {
 231     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(data);
 232     g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "focus out");
 233
 234     gtk_widget_queue_draw(self->priv->event_bg);
 235     return TRUE;
 236 }
 237 static gboolean albumview_expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
 238 {
 239         int width = widget->allocation.width;
 240         int height = widget->allocation.height;
 241     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(data);
 242
 243         gtk_paint_flat_box(widget->style,
 244                                         widget->window,
 245                                         GTK_STATE_NORMAL,
 246                                         GTK_SHADOW_NONE,
 247                                         NULL,
 248                                         widget,
 249                                         "entry_bg",
 250                                         0,0,width,height);
 251     if(gtk_widget_is_focus(widget))
 252     {
 253         gtk_paint_focus(widget->style, widget->window,
 254                 GTK_STATE_NORMAL,
 255                 NULL,
 256                 widget,
 257                 "entry_bg",
 258                 0,0,width,height);
 259     }
 260     return FALSE;
 261 }
 262 static void albumview_init(AlbumViewPlugin *self)
 263 {
 264     /** Get an allready exposed widgets to grab theme colors from. */
 265     GtkWidget *colw = (GtkWidget *)playlist3_get_category_tree_view();
 266     GtkWidget *label = NULL;
 267     GtkWidget *event = gtk_scrolled_window_new(NULL, NULL);
 268     GtkWidget *hbox = NULL;     int i = 0;
 269     self->priv->event_bg = gtk_event_box_new();
 270     self->priv->albumview_main_box = gtk_vbox_new(FALSE, 6);
 271
 272     self->priv->album_size = 25*cfg_get_single_value_as_int_with_default(config, "albumview", "zoom-level", 5)+50;
 273     g_signal_connect(G_OBJECT(event), "size-allocate", G_CALLBACK(size_changed), self);
 274
 275     GtkWidget *iv = self->priv->albumview_box = gtk_vbox_new(FALSE, 6);
 276     self->priv->slider_scale = gtk_vscale_new_with_range(0,1,1);
 277     gtk_scale_set_draw_value(GTK_SCALE(self->priv->slider_scale), FALSE);
 278     g_signal_connect(G_OBJECT(self->priv->slider_scale), "value-changed", G_CALLBACK(position_changed), self);
 279
 280     self->priv->filter_entry = gtk_entry_new();
 281 //    gtk_box_pack_start(GTK_BOX(self->priv->albumview_main_box), self->priv->filter_entry, FALSE, FALSE, 0);
 282     g_signal_connect(G_OBJECT(self->priv->filter_entry),"changed", G_CALLBACK(filter_list), self);
 283
 284     GtkWidget *spin= gtk_spin_button_new_with_range(1, 10, 1);
 285 //    gtk_scale_set_draw_value(GTK_SCALE(spin), FALSE);
 286     gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), self->priv->album_size);
 287
 288     hbox = gtk_hbox_new(FALSE, 6);
 289     gtk_box_pack_start(GTK_BOX(hbox),gtk_label_new(("Filter")), FALSE, FALSE, 0);
 290     gtk_box_pack_start(GTK_BOX(hbox),self->priv->filter_entry, TRUE, TRUE, 0);
 291
 292     gtk_box_pack_start(GTK_BOX(hbox),gtk_label_new(("Zoom level")), FALSE, FALSE, 0);
 293     gtk_widget_set_size_request(spin, 140, -1);
 294     gtk_box_pack_start(GTK_BOX(hbox),spin, FALSE, FALSE, 0);
 295     gtk_box_pack_end(GTK_BOX(self->priv->albumview_main_box), hbox, FALSE, FALSE, 0);
 296
 297 #if GTK_CHECK_VERSION(2,16,0)
 298 /*    for(i=4; i<15;i++){
 299         gtk_scale_add_mark(GTK_SCALE(spin), (gdouble)i,GTK_POS_TOP, NULL);
 300     }*/
 301 #endif
 302
 303     gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), cfg_get_single_value_as_int_with_default(config, "albumview", "zoom-level", 10));
 304     g_signal_connect(G_OBJECT(spin), "value-changed", G_CALLBACK(album_size_changed), self);
 305
 306
 307     hbox = gtk_hbox_new(FALSE, 6);
 308     gtk_box_pack_start(GTK_BOX(self->priv->albumview_main_box),hbox, TRUE, TRUE, 0);
 309     gtk_box_pack_start(GTK_BOX(hbox),event, TRUE, TRUE, 0);
 310     gtk_box_pack_start(GTK_BOX(hbox),self->priv->slider_scale, FALSE, FALSE, 0);//gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), event);
 311     gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(event), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 312     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(event), GTK_SHADOW_ETCHED_IN);
 313     /* setup bg */
 314     /* TODO draw focus */
 315 //    gtk_widget_modify_bg(self->priv->event_bg, GTK_STATE_NORMAL,&(self->priv->albumview_main_box->style->white));
 316     gtk_widget_set_app_paintable(self->priv->event_bg, TRUE);
 317     g_signal_connect(G_OBJECT(self->priv->event_bg), "expose-event", G_CALLBACK(albumview_expose_event), self);
 318     gtk_event_box_set_visible_window(GTK_EVENT_BOX(self->priv->event_bg), TRUE);
 319
 320     g_object_set(self->priv->event_bg, "can-focus", TRUE,NULL);
 321     GTK_WIDGET_SET_FLAGS(self->priv->event_bg, GTK_HAS_FOCUS);
 322     gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(event), self->priv->event_bg);
 323     gtk_container_add(GTK_CONTAINER(self->priv->event_bg), iv);
 324     gtk_widget_add_events(self->priv->event_bg, GDK_SCROLL_MASK|GDK_BUTTON_PRESS_MASK|GDK_FOCUS_CHANGE_MASK);
 325     g_signal_connect_object(G_OBJECT(self->priv->event_bg), "scroll-event", G_CALLBACK(albumview_scroll_event), self,0);
 326     g_signal_connect_object(G_OBJECT(self->priv->event_bg), "key-press-event", G_CALLBACK(albumview_key_press_event), self,0);
 327     g_signal_connect_object(G_OBJECT(self->priv->event_bg), "focus-in-event", G_CALLBACK(albumview_focus), self,0);
 328     g_signal_connect_object(G_OBJECT(self->priv->event_bg), "focus-out-event", G_CALLBACK(albumview_focus_out), self, 0);
 329     g_signal_connect_object(G_OBJECT(self->priv->filter_entry), "key-press-event", G_CALLBACK(albumview_key_press_event), self,0);
 330     g_signal_connect_object(G_OBJECT(self->priv->event_bg), "button-press-event", G_CALLBACK(albumview_button_press_event), self,0);
 331
 332     gtk_widget_show_all(self->priv->albumview_main_box);
 333     /* maintain my own reference to the widget, so it won't get destroyed removing
 334      * from view
 335      */
 336     g_object_ref_sink(self->priv->albumview_main_box);
 337 }
 338
 339
 340 static void albumview_selected(GmpcPluginBrowserIface *plug, GtkWidget *container)
 341 {
 342     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(plug);
 343     if(self->priv->albumview_main_box== NULL) {
 344         albumview_init((AlbumViewPlugin *)plug);
 345         albumview_connection_changed(gmpcconn, connection,1,self);
 346     }
 347     gtk_container_add(GTK_CONTAINER(container), self->priv->albumview_main_box);
 348     gtk_widget_show(self->priv->albumview_main_box);
 349     gtk_widget_grab_focus(self->priv->event_bg);
 350 }
 351
 352 static void albumview_unselected(GmpcPluginBrowserIface *plug,GtkWidget *container)
 353 {
 354     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(plug);
 355     gtk_container_remove(GTK_CONTAINER(container), self->priv->albumview_main_box);
 356 }
 357
 358
 359
 360 void albumview_plugin_init(AlbumViewPlugin *self)
 361 {
 362 /*  TODO: fix this */
 363 /*
 364     gchar *path = gmpc_plugin_get_data_path(&plugin);
 365     gchar *url = g_build_path(G_DIR_SEPARATOR_S,path, "albumview", NULL);
 366     debug_printf(DEBUG_WARNING,"Found url: %s\n", url);
 367
 368
 369     gtk_icon_theme_append_search_path(gtk_icon_theme_get_default (),url);
 370
 371     g_free(path);
 372     g_free(url);
 373     */
 374 }
 375 #define TIMER_SUB(start,stop,diff)  diff.tv_usec = stop.tv_usec - start.tv_usec;\
 376         diff.tv_sec = stop.tv_sec - start.tv_sec;\
 377         if(diff.tv_usec < 0) {\
 378             diff.tv_sec -= 1; \
 379             diff.tv_usec += G_USEC_PER_SEC; \
 380         }
 381 static gint __add_sort(gpointer aa, gpointer bb, gpointer data)
 382 {
 383     MpdData_real *a = *(MpdData_real **)aa;
 384     MpdData_real *b = *(MpdData_real **)bb;
 385     if(!a || !b) return 0;
 386     if(a->type == MPD_DATA_TYPE_SONG && b->type == MPD_DATA_TYPE_SONG)
 387     {
 388         if(a->song->artist &&  b->song->artist)
 389         {
 390             int val;
 391             {
 392                 gchar *sa,*sb;
 393                 sa = g_utf8_strdown(a->song->artist, -1);
 394                 sb = g_utf8_strdown(b->song->artist, -1);
 395                 val = g_utf8_collate(sa,sb);
 396                 g_free(sa);
 397                 g_free(sb);
 398             }/* else {
 399                 val = (a == NULL)?((b==NULL)?0:-1):1;
 400             }*/
 401             if(val != 0)
 402                 return val;
 403             if (a->song->album && b->song->album)
 404             {
 405                 gchar *sa,*sb;
 406                 sa = g_utf8_strdown(a->song->album, -1);
 407                 sb = g_utf8_strdown(b->song->album, -1);
 408                 val = g_utf8_collate(sa,sb);
 409                 g_free(sa);
 410                 g_free(sb);
 411
 412             }
 413             return val;
 414         }
 415     }
 416     return -1;
 417 }
 418
 419 static gboolean load_list_itterate(AlbumViewPlugin *self)
 420 {
 421     MpdData *data2 = NULL;
 422     self->priv->current_entry++;
 423     if(self->priv->max_entries>0 && self->priv->current_entry%25 == 0){
 424         gchar *temp = g_strdup_printf("%i of %i albums loaded", self->priv->current_entry, self->priv->max_entries);
 425         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(self->priv->progress_bar), self->priv->current_entry/(double)self->priv->max_entries);
 426         gtk_progress_bar_set_text(GTK_PROGRESS_BAR(self->priv->progress_bar), temp);
 427         g_free(temp);
 428
 429     }
 430     if(self->priv->data)
 431     {
 432         mpd_database_search_field_start(connection, MPD_TAG_ITEM_ARTIST);
 433         mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ALBUM, (self->priv->data)->tag);
 434         data2 = mpd_database_search_commit(connection);
 435         if(data2)
 436         {
 437             mpd_Song *song = mpd_newSong();
 438             song->album = g_strdup((self->priv->data)->tag);
 439             song->artist = g_strdup(data2->tag);
 440             if(!mpd_data_is_last(data2))
 441             {
 442                 /* test if server supports album artist */
 443                 if(mpd_server_tag_supported(connection, MPD_TAG_ITEM_ALBUM_ARTIST))
 444                 {
 445                     mpd_database_search_field_start(connection, MPD_TAG_ITEM_ALBUM_ARTIST);
 446                     mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ALBUM, (self->priv->data)->tag);
 447                     MpdData *data3 = mpd_database_search_commit(connection);
 448                     if(mpd_data_is_last(data3)){
 449                         if(strlen(data3->tag) > 0)
 450                         {
 451                             song->albumartist = g_strdup(data3->tag);
 452                             if(song->artist) g_free(song->artist);
 453                             song->artist = g_strdup(data3->tag);
 454                         }
 455                     }
 456                     else{
 457                         mpd_freeSong(song);
 458                         song = NULL;
 459                     }
 460                     mpd_data_free(data3);
 461                 }
 462                 else {
 463                     mpd_freeSong(song);
 464                     song = NULL;
 465                 }
 466             }
 467             mpd_data_free(data2);
 468             if(song){
 469                 self->priv->complete_list = mpd_new_data_struct_append(self->priv->complete_list);
 470                 self->priv->complete_list->song = song;
 471                 self->priv->complete_list->type = MPD_DATA_TYPE_SONG;
 472                 song = NULL;
 473             }
 474         }
 475
 476         (self->priv->data) = mpd_data_get_next((self->priv->data));
 477     }
 478     if(self->priv->data == NULL){
 479         int items = 0;
 480         MpdData_real *iter;
 481         self->priv->complete_list = (MpdData *)misc_sort_mpddata(mpd_data_get_first(self->priv->complete_list), (GCompareDataFunc)__add_sort, NULL);
 482         g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,"update view\n");
 483         gtk_widget_destroy(self->priv->progress_bar);
 484         self->priv->progress_bar = NULL;
 485         for(iter = (MpdData_real*)self->priv->complete_list; iter; iter = iter->next) items++;
 486
 487         gtk_widget_set_sensitive(self->priv->filter_entry, TRUE);
 488         filter_list(GTK_ENTRY(self->priv->filter_entry), self);
 489
 490         gtk_widget_grab_focus(self->priv->event_bg);
 491         return FALSE;
 492     }
 493
 494     g_idle_add((GSourceFunc)load_list_itterate, self);
 495     return FALSE;
 496 }
 497
 498 static void load_list(AlbumViewPlugin *self)
 499 {
 500     if(self->priv->complete_list)mpd_data_free(self->priv->complete_list);
 501     self->priv->complete_list = NULL;
 502     if(self->priv->current_item) g_list_free(self->priv->current_item);
 503     self->priv->current_item = NULL;
 504
 505
 506     self->priv->progress_bar = gtk_progress_bar_new();
 507     gtk_box_pack_start(GTK_BOX(self->priv->albumview_box), self->priv->progress_bar, FALSE, FALSE, 0);
 508     gtk_widget_show(self->priv->progress_bar);
 509     mpd_database_search_field_start(connection, MPD_TAG_ITEM_ALBUM);
 510     MpdData *iter,*data = mpd_database_search_commit(connection);
 511     self->priv->max_entries= 0;
 512     self->priv->current_entry = 0;
 513     gtk_widget_set_sensitive(self->priv->filter_entry, FALSE);
 514     for(iter = data; iter; iter = mpd_data_get_next_real(iter, FALSE)) self->priv->max_entries++;
 515     self->priv->data= data;
 516     g_idle_add((GSourceFunc)load_list_itterate, self);
 517 }
 518 void albumview_connection_changed(GmpcConnection *conn, MpdObj *mi, int connect,void *usedata)
 519 {
 520     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(usedata);
 521
 522     if(connect && self->priv->albumview_main_box)
 523     {
 524         load_list(self);
 525     }
 526     else if(self->priv->albumview_main_box){
 527         mpd_data_free(self->priv->complete_list);
 528         self->priv->complete_list = NULL;
 529         if(self->priv->item_table)
 530             gtk_widget_hide(self->priv->item_table);
 531     }
 532 }
 533 static void album_add(GtkWidget *button, mpd_Song *song)
 534 {
 535     mpd_database_search_start(connection,TRUE);
 536
 537     mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ALBUM, song->album);
 538     if(song->albumartist && strlen(song->albumartist) >0){
 539         mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ALBUM_ARTIST, song->albumartist);
 540     }else{
 541         mpd_database_search_add_constraint(connection, MPD_TAG_ITEM_ARTIST, song->artist);
 542     }
 543     MpdData *data = mpd_database_search_commit(connection);
 544     /* Sort it before adding */
 545     data = misc_sort_mpddata_by_album_disc_track(data);
 546     for(;data;data = mpd_data_get_next(data)){
 547         mpd_playlist_queue_add(connection, data->song->file);
 548     }
 549     mpd_playlist_queue_commit(connection);
 550 }
 551 static void album_view(GtkWidget *button ,mpd_Song *song)
 552 {
 553         if (song && song->artist && song->album) {
 554                 info2_activate();
 555                 info2_fill_album_view(song->artist, song->album);
 556         }
 557 }
 558
 559 static void album_replace(GtkWidget *button, mpd_Song *song)
 560 {
 561     mpd_playlist_clear(connection);
 562     album_add(button, song);
 563     mpd_player_play(connection);
 564 }
 565 static gboolean album_button_press(GtkWidget *item, GdkEventButton *event, mpd_Song *song)
 566 {
 567     g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,  "button press event %i\n", event->button);
 568     if(event->button == 1 && event->type == GDK_BUTTON_PRESS)
 569     {
 570         GtkWidget *menu = gtk_menu_new();
 571         GtkWidget *item;
 572
 573         item = gtk_image_menu_item_new_with_label("Album information");
 574         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
 575                 gtk_image_new_from_stock(GTK_STOCK_INFO, GTK_ICON_SIZE_MENU));
 576         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 577         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(album_view), song);
 578
 579         item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ADD,NULL);
 580         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 581         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(album_add), song);
 582
 583         /* replace the replace widget */
 584         item = gtk_image_menu_item_new_with_label("Replace");
 585         gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
 586                 gtk_image_new_from_stock(GTK_STOCK_REDO, GTK_ICON_SIZE_MENU));
 587         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 588         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(album_replace), song);
 589         gtk_widget_show_all(menu);
 590         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, event->time);
 591     }
 592     else if (event->button == 2){
 593         album_add(NULL, song);
 594     }
 595     return TRUE;
 596 }
 597 static GtkWidget * create_button(AlbumViewPlugin *self, MpdData_real *complete_list_iter)
 598 {
 599     GtkWidget *item;
 600     GtkWidget *vbox;
 601     GtkWidget *label = NULL;
 602     gchar *temp = NULL;
 603     /* Wrap it in a vbox */
 604     vbox = gtk_vbox_new(FALSE, 3);
 605     gtk_widget_set_size_request(vbox, self->priv->album_size+20,self->priv->album_size+40);
 606
 607     item = gmpc_metaimage_new_size(META_ALBUM_ART,self->priv->album_size);
 608     gmpc_metaimage_set_scale_up(GMPC_METAIMAGE(item), TRUE);
 609     gtk_widget_set_has_tooltip(GTK_WIDGET(item), FALSE);
 610     gmpc_metaimage_set_squared(GMPC_METAIMAGE(item), TRUE);
 611
 612     gmpc_metaimage_update_cover_from_song_delayed(GMPC_METAIMAGE(item), complete_list_iter->song);
 613
 614     gtk_box_pack_start(GTK_BOX(vbox), item, TRUE, TRUE, 0);
 615     /* Set artist name */
 616     if(complete_list_iter->song->albumartist){
 617         GtkWidget *label = gtk_label_new(complete_list_iter->song->albumartist);
 618         gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_MIDDLE);
 619         gtk_box_pack_end(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 620     }else{
 621         GtkWidget *label = gtk_label_new(complete_list_iter->song->artist);
 622         gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_MIDDLE);
 623         gtk_box_pack_end(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 624     }
 625
 626     /* Set album name */
 627     label = gtk_label_new("");
 628     temp = g_markup_printf_escaped("<b>%s</b>", complete_list_iter->song->album);
 629     gtk_label_set_markup(GTK_LABEL(label), temp);
 630     g_free(temp);
 631     gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_MIDDLE);
 632     gtk_box_pack_end(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 633
 634
 635     /* Attach it to the song */
 636     complete_list_iter->userdata = g_object_ref_sink(vbox);
 637     complete_list_iter->freefunc = (void *)gtk_widget_destroy;
 638     g_object_set_data(G_OBJECT(vbox), "item", item);
 639     g_signal_connect(item, "button-press-event",
 640             G_CALLBACK(album_button_press), complete_list_iter->song);
 641     return vbox;
 642 }
 643
 644 static void filter_list(GtkEntry *entry, gpointer data)
 645 {
 646     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(data);
 647     GRegex *regex = NULL;
 648     int items = 0;
 649     GList *list = NULL;
 650     const gchar *search_query = gtk_entry_get_text(GTK_ENTRY(self->priv->filter_entry));
 651     MpdData_real *complete_list_iter = NULL;
 652     if(search_query[0] != '\0')
 653     {
 654         gchar *str = g_strdup(search_query);
 655         gchar **test = g_strsplit(g_strstrip(str), " ", -1);
 656         int i=0;
 657         GString *s = g_string_new("((?:");
 658         GError *error = NULL;
 659         g_free(str);
 660         for(i=0;test && test[i];i++){
 661             gchar *temp = g_regex_escape_string(test[i], -1);
 662             s = g_string_append(s, ".*");
 663             s= g_string_append(s, temp);
 664             s = g_string_append(s, ".*");
 665             if(test[i+1] != NULL)
 666                 s = g_string_append(s, "|");
 667             g_free(temp);
 668         }
 669         g_string_append_printf(s,"){%i})",i);
 670         g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,"regex: %s\n", s->str);
 671         regex = g_regex_new(s->str, G_REGEX_CASELESS|G_REGEX_EXTENDED, 0,&error);;
 672         if(regex)
 673         {
 674             g_string_free(s, TRUE);
 675             for(complete_list_iter = (MpdData_real *) mpd_data_get_first(self->priv->complete_list);
 676                     complete_list_iter;
 677                     complete_list_iter = (MpdData_real *)mpd_data_get_next_real((MpdData *)complete_list_iter, FALSE))
 678             {
 679                 if(g_regex_match(regex,complete_list_iter->song->album,0,NULL)||
 680                         g_regex_match(regex,complete_list_iter->song->artist,0,NULL)||
 681                         (complete_list_iter->song->albumartist && g_regex_match(regex,complete_list_iter->song->albumartist,0,NULL))){
 682                     items++;
 683                     list = g_list_append(list, complete_list_iter);
 684                 }
 685             }
 686         }
 687         if(error) {
 688             g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_WARNING," error creating regex: %s\n", error->message);
 689             g_error_free(error);
 690         }
 691         g_regex_unref(regex);
 692     }
 693     if(self->priv->current_item) g_list_free(self->priv->current_item);
 694     self->priv->current_item = g_list_first(list);
 695     if((items-self->priv->supported_rows*self->priv->supported_columns) > 0)
 696     {
 697         gtk_widget_set_sensitive(GTK_WIDGET(self->priv->slider_scale), TRUE);
 698         gtk_range_set_range(GTK_RANGE(self->priv->slider_scale), 0,
 699                 ((items-self->priv->supported_rows*self->priv->supported_columns)>0)?(items-self->priv->supported_rows*self->priv->supported_columns):1);
 700     }
 701     else{
 702         gtk_widget_set_sensitive(GTK_WIDGET(self->priv->slider_scale), FALSE);
 703         gtk_range_set_range(GTK_RANGE(self->priv->slider_scale), 0,1);
 704     }
 705     gtk_range_set_value(GTK_RANGE(self->priv->slider_scale), 0);
 706     update_view(self);
 707 }
 708
 709 static void position_changed(GtkRange *range, gpointer data)
 710 {
 711     AlbumViewPlugin *self = ALBUM_VIEW_PLUGIN(data);
 712     gint i=0,value = (int)gtk_range_get_value(range);
 713     self->priv->current_item = g_list_first(self->priv->current_item);
 714     for(i=0;i<value && self->priv->current_item && self->priv->current_item->next; self->priv->current_item = self->priv->current_item->next){i++;}
 715     update_view(self);
 716 }
 717 static gboolean update_view_real(AlbumViewPlugin *self)
 718 {
 719     MpdData *complete_list_iter;
 720     const char *search_query = gtk_entry_get_text(GTK_ENTRY(self->priv->filter_entry));
 721     int i=0;
 722     int j=0;
 723     gchar *artist= NULL;
 724     int items =0;
 725     MpdData *data = NULL;
 726     GList *entries = NULL;
 727     GList *list = (self->priv->item_table)?gtk_container_get_children(GTK_CONTAINER(self->priv->item_table)):NULL;
 728     GList *iter;
 729     GRegex *regex = NULL;
 730
 731     g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,"search query: %s\n", search_query);
 732
 733     if(self->priv->item_table)
 734         gtk_widget_hide(self->priv->item_table);
 735     for(iter =  g_list_first(list); iter; iter = iter->next){
 736         GtkWidget *widget = iter->data;
 737         gtk_container_remove(GTK_CONTAINER(self->priv->item_table), widget);
 738     }
 739     g_list_free(list);
 740     list = NULL;
 741
 742
 743
 744     gtk_widget_show(self->priv->albumview_box);
 745     if(self->priv->current_item ==  NULL){
 746         int items  =0;
 747         for(complete_list_iter = mpd_data_get_first(self->priv->complete_list);
 748                 complete_list_iter;
 749                 complete_list_iter = mpd_data_get_next_real(complete_list_iter, FALSE))
 750         {
 751             items++;
 752             self->priv->current_item = g_list_append(self->priv->current_item, complete_list_iter);
 753         }
 754         self->priv->current_item = g_list_first(self->priv->current_item);
 755         if((items-self->priv->supported_rows*self->priv->supported_columns) > 0)
 756         {
 757             gtk_widget_set_sensitive(GTK_WIDGET(self->priv->slider_scale), TRUE);
 758             gtk_range_set_range(GTK_RANGE(self->priv->slider_scale), 0,
 759                     ((items-self->priv->supported_rows*self->priv->supported_columns)>0)?(items-self->priv->supported_rows*self->priv->supported_columns):1);
 760         }
 761         else{
 762             gtk_widget_set_sensitive(GTK_WIDGET(self->priv->slider_scale), FALSE);
 763             gtk_range_set_range(GTK_RANGE(self->priv->slider_scale), 0,1);
 764         }
 765         gtk_range_set_value(GTK_RANGE(self->priv->slider_scale), 0);
 766     }
 767
 768     int rows = self->priv->supported_rows;
 769     /**
 770      * Create holding table if it does not exist
 771      */
 772     if(!self->priv->item_table){
 773         GtkWidget *ali = gtk_alignment_new(0.0, 0.5, 0,0);
 774         self->priv->item_table = exo_wrap_table_new(TRUE);//gtk_table_new(rows, supported_columns, TRUE);
 775         gtk_container_add(GTK_CONTAINER(ali), self->priv->item_table);
 776         gtk_box_pack_start(GTK_BOX(self->priv->albumview_box), ali, FALSE, FALSE, 0);
 777     }
 778
 779     /* I know how large it is going to be.. so lets set the size */
 780     gtk_widget_set_size_request(self->priv->item_table, self->priv->supported_columns*(self->priv->album_size+20)+6, (rows)*(self->priv->album_size+40));
 781     /**
 782      * Add albums
 783      */
 784
 785     if(self->priv->current_item)//(iter = g_list_first(list)))
 786     {
 787         GList *iter = self->priv->current_item;
 788         int v_items = 0;
 789         do
 790         {
 791             complete_list_iter = iter->data;
 792             if(complete_list_iter->song/* && (complete_list_iter->song->artist)[0] != '\0'*/)
 793             {
 794                 GtkWidget *vbox = complete_list_iter->userdata;
 795                 GtkWidget *item;
 796                 int a,b;
 797                 if(vbox == NULL){
 798                    vbox = create_button(self, (MpdData_real *)complete_list_iter);
 799                 }
 800                 else{
 801                     item = g_object_get_data(G_OBJECT(vbox), "item");
 802                     /* Resize if needed */
 803                     if(self->priv->album_size != gmpc_metaimage_get_size(GMPC_METAIMAGE(item))){
 804                         gtk_widget_set_size_request(vbox, self->priv->album_size+20,self->priv->album_size+40);
 805                         gmpc_metaimage_set_size(GMPC_METAIMAGE(item), self->priv->album_size);
 806                         gmpc_metaimage_reload_image(GMPC_METAIMAGE(item));
 807                     }
 808
 809                 }
 810                 entries = g_list_prepend(entries, vbox);
 811                 j++;
 812             }
 813             v_items++;
 814         }while(v_items < (rows*self->priv->supported_columns)&& (iter = iter->next));
 815     }
 816     /* remove list */
 817     if(list) g_list_free(list);
 818     list = NULL;
 819
 820     for(iter = entries = g_list_reverse(entries); iter; iter = g_list_next(iter)){
 821         gtk_container_add(GTK_CONTAINER(self->priv->item_table), iter->data);
 822     }
 823     if(entries) g_list_free(entries);
 824
 825     gtk_widget_show_all(self->priv->albumview_box);
 826     /**
 827      * Remove the timeout
 828      */
 829     if(self->priv->update_timeout)
 830         g_source_remove(self->priv->update_timeout);
 831     self->priv->update_timeout = 0;
 832     return FALSE;
 833 }
 834
 835
 836 void update_view(AlbumViewPlugin *self)
 837 {
 838     if(self->priv->update_timeout != 0) {
 839         g_source_remove(self->priv->update_timeout);
 840     }
 841     self->priv->update_timeout = g_timeout_add(10, (GSourceFunc)update_view_real,self);
 842 }
 843
 844 /**
 845  * Gobject plugin
 846  */
 847 static void albumview_plugin_class_init (AlbumViewPluginClass *klass);
 848
 849 static int *albumview_plugin_get_version(GmpcPluginBase *plug, int *length)
 850 {
 851         static int version[3] = {PLUGIN_MAJOR_VERSION,PLUGIN_MINOR_VERSION,PLUGIN_MICRO_VERSION};
 852         if(length) *length = 3;
 853         return (int *)version;
 854 }
 855
 856 static const char *albumview_plugin_get_name(GmpcPluginBase *plug)
 857 {
 858         return ("Album View");
 859 }
 860 static GObject *albumview_plugin_constructor(GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
 861         AlbumViewPluginClass * klass;
 862         AlbumViewPlugin *self;
 863         GObjectClass * parent_class;
 864         klass = (g_type_class_peek (albumview_plugin_get_type()));
 865         parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
 866         self = (AlbumViewPlugin *) parent_class->constructor (type, n_construct_properties, construct_properties);
 867
 868     g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Constructing plugin");
 869
 870         /* setup private structure */
 871         self->priv = g_malloc0(sizeof(AlbumViewPluginPrivate));
 872     /* set defaults */
 873     self->priv->supported_rows = 1;
 874     self->priv->supported_columns = 1;
 875     self->priv->data = NULL;
 876     self->priv->album_size = 200;
 877     self->priv->filter_entry = NULL;
 878     self->priv->slider_scale = NULL;
 879     self->priv->progress_bar = NULL;
 880     self->priv->max_entries = 0;
 881     self->priv->current_entry = 0;
 882     self->priv->current_item = NULL;
 883     self->priv->update_timeout = 0;
 884     self->priv->complete_list = NULL;
 885     self->priv->item_table = NULL;
 886     self->priv->albumview_ref = NULL;
 887     self->priv->albumview_box = NULL;
 888
 889     /* Watch status changed signals */
 890     g_signal_connect_object(G_OBJECT(gmpcconn), "connection-changed", G_CALLBACK(albumview_connection_changed), self, 0);
 891
 892     /* Setup textdomain */
 893         bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
 894         bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
 895
 896     GMPC_PLUGIN_BASE(self)->translation_domain = GETTEXT_PACKAGE;
 897         GMPC_PLUGIN_BASE(self)->plugin_type = GMPC_PLUGIN_NO_GUI;
 898
 899     albumview_plugin_init(self);
 900
 901         return G_OBJECT(self);
 902 }
 903 static void albumview_plugin_finalize(GObject *obj) {
 904     AlbumViewPlugin *self = (AlbumViewPlugin *)obj;
 905         AlbumViewPluginClass * klass = (g_type_class_peek (play_queue_plugin_get_type()));
 906         gpointer parent_class = g_type_class_peek_parent (klass);
 907
 908     g_log(AV_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Destroying plugin");
 909
 910     if(self->priv){
 911         if(self->priv->current_item) g_list_free(self->priv->current_item);
 912         self->priv->current_item = NULL;
 913         if(self->priv->complete_list) mpd_data_free(self->priv->complete_list);
 914         self->priv->complete_list = NULL;
 915
 916         g_free(self->priv);
 917                 self->priv = NULL;
 918         }
 919         if(parent_class)
 920                 G_OBJECT_CLASS(parent_class)->finalize(obj);
 921 }
 922
 923
 924 static void albumview_plugin_class_init (AlbumViewPluginClass *klass)
 925 {
 926         G_OBJECT_CLASS(klass)->finalize =               albumview_plugin_finalize;
 927         G_OBJECT_CLASS(klass)->constructor =    albumview_plugin_constructor;
 928         /* Connect plugin functions */
 929         GMPC_PLUGIN_BASE_CLASS(klass)->get_version = albumview_plugin_get_version;
 930         GMPC_PLUGIN_BASE_CLASS(klass)->get_name =        albumview_plugin_get_name;
 931
 932         GMPC_PLUGIN_BASE_CLASS(klass)->get_enabled = albumview_get_enabled;
 933         GMPC_PLUGIN_BASE_CLASS(klass)->set_enabled = albumview_set_enabled;
 934
 935         GMPC_PLUGIN_BASE_CLASS(klass)->save_yourself = albumview_browser_save_myself;
 936 }
 937
 938 static void albumview_plugin_browser_iface_init(GmpcPluginBrowserIfaceIface * iface) {
 939         iface->browser_add = albumview_add;
 940     iface->browser_selected = albumview_selected;
 941     iface->browser_unselected = albumview_unselected;
 942 }
 943
 944 const GType albumview_plugin_get_type(void) {
 945         static GType albumview_plugin_type_id = 0;
 946         if(albumview_plugin_type_id == 0) {
 947                 static const GTypeInfo info = {
 948                         .class_size = sizeof(AlbumViewPluginClass),
 949                         .class_init = (GClassInitFunc)albumview_plugin_class_init,
 950                         .instance_size = sizeof(AlbumViewPlugin),
 951                         .n_preallocs = 0
 952                 };
 953
 954                 albumview_plugin_type_id = g_type_register_static(GMPC_PLUGIN_TYPE_BASE, "AlbumViewPlugin", &info, 0);
 955
 956         /** Browser interface */
 957                 static const GInterfaceInfo iface_info = { (GInterfaceInitFunc) albumview_plugin_browser_iface_init,
 958             (GInterfaceFinalizeFunc) NULL, NULL};
 959                 g_type_add_interface_static (albumview_plugin_type_id, GMPC_PLUGIN_TYPE_BROWSER_IFACE, &iface_info);
 960         }
 961         return albumview_plugin_type_id;
 962 }
 963
 964 G_MODULE_EXPORT GType plugin_get_type(void)
 965 {
 966     return albumview_plugin_get_type();
 967 }