enjoy/src/bin/page.c

#include "private.h"
#include "mpris.h"

#include <ctype.h>
#include <stdlib.h>

/*
 * TODO:
 *  - create page_folder that contains something other than songs, click one
 *    should create a new page, stack it into the parent list and recurse.
 *  - add suffle action for page_songs
 */

/* number of songs to populate at once before going back to mainloop */
#define PAGE_SONGS_POPULATE_ITERATION_COUNT (64)

/* number of folders to populate at once before going back to mainloop */
#define PAGE_FOLDERS_POPULATE_ITERATION_COUNT (64)

#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))

struct Array_Iterator
{
   Eina_Iterator base;
   const void *container;
   size_t current, count, item_size;
};

static void *
_array_iterator_container_get(Eina_Iterator *iterator)
{
   struct Array_Iterator *it = (struct Array_Iterator *)iterator;
   if (!EINA_MAGIC_CHECK(iterator, EINA_MAGIC_ITERATOR))
     {
        EINA_MAGIC_FAIL(iterator, EINA_MAGIC_ITERATOR);
        return NULL;
     }
   return (void *)it->container;
}

static void
_array_iterator_free(Eina_Iterator *iterator)
{
   struct Array_Iterator *it = (struct Array_Iterator *)iterator;
   if (!EINA_MAGIC_CHECK(iterator, EINA_MAGIC_ITERATOR))
     {
        EINA_MAGIC_FAIL(iterator, EINA_MAGIC_ITERATOR);
        return;
     }
   EINA_MAGIC_SET(&it->base, EINA_MAGIC_NONE);
   free(it);
}

static Eina_Bool
_array_iterator_next(Eina_Iterator *iterator, void **data)
{
   struct Array_Iterator *it = (struct Array_Iterator *)iterator;
   if (!EINA_MAGIC_CHECK(iterator, EINA_MAGIC_ITERATOR))
     {
        EINA_MAGIC_FAIL(iterator, EINA_MAGIC_ITERATOR);
        return EINA_FALSE;
     }
   EINA_SAFETY_ON_NULL_RETURN_VAL(data, EINA_FALSE);
   *data = NULL;
   if (it->current >= it->count) return EINA_FALSE;
   *data = ((char *)it->container) + it->item_size * it->current;
   it->current++;
   return EINA_TRUE;
}

static Eina_Iterator *
_array_iterator_new(const void *array, size_t item_size, size_t count)
{
   struct Array_Iterator *it = calloc(1, sizeof(*it));
   EINA_SAFETY_ON_NULL_RETURN_VAL(it, NULL);
   it->base.get_container = _array_iterator_container_get;
   it->base.free = _array_iterator_free;
   it->base.next = _array_iterator_next;
   it->container = array;
   it->item_size = item_size;
   it->count = count;
   EINA_MAGIC_SET(&it->base, EINA_MAGIC_ITERATOR);
   return &it->base;
}

static void *
_data_from_itr_passthrough(const void *data)
{
   return (void *)data;
}

typedef struct _Page Page;

typedef struct _Page_Class
{
   const char *name;
   const char *key;
   const char *layout;
   Eina_Bool (*init)(Page *page);      /* optional extra initializer */
   void (*after_populate)(Page *page); /* called after page has been populated */
   Evas_Smart_Cb selected;
   const Elm_Genlist_Item_Class *item_cls;
   size_t populate_iteration_count;
   void *(*data_from_itr)(const void *data);
   size_t data_letter_offset;
   unsigned short icon_size;
} Page_Class;

struct _Page
{
   const Page_Class *cls;
   Evas_Object *layout;
   Evas_Object *edje;
   Evas_Object *list;
   Evas_Object *index;
   Evas_Object *parent;
   size_t num_elements;
   const char *title;
   void *container;
   void *model;
   Elm_Genlist_Item *selected;
   Elm_Genlist_Item *first;
   Eina_Iterator *iterator;
   Ecore_Idler *populate;
   char last_index_letter[2];
   struct {
      void *data;
      void (*free)(void *data);
   } item;
};

#define PAGE_GET_OR_RETURN(page, obj, ...)                      \
  Page *page = evas_object_data_get(obj, "_enjoy_page");        \
  do                                                            \
    {                                                           \
       if (!page)                                               \
         {                                                      \
            CRITICAL("Not a page: "#obj": %p", obj);            \
            return __VA_ARGS__;                                 \
         }                                                      \
    }                                                           \
  while (0)

static DB *
_page_db_get(const Evas_Object *obj)
{
   Page *page, *ppage;

   page = evas_object_data_get(obj, "_enjoy_page");
   EINA_SAFETY_ON_NULL_RETURN_VAL(page, NULL);
   ppage = evas_object_data_get(page->parent, "_enjoy_page");
   if (ppage) return _page_db_get(page->parent);
   return list_db_get(page->parent);
}

static Eina_Bool
_page_populate(void *data)
{
   Page *page = data;
   const Page_Class *cls = page->cls;
   unsigned int count;

   for (count = 0; count < cls->populate_iteration_count; count++)
     {
        Elm_Genlist_Item *it;
        char letter;
        void *id, *od;
        const char **letter_str;

        if (!eina_iterator_next(page->iterator, &id)) goto end;
        // TODO: evaluate if we should keep a full copy or just store
        // fields of interest such as id, title, artist and album
        od = cls->data_from_itr(id);
        if (!od) goto end;

        it = elm_genlist_item_append
          (page->list, cls->item_cls, od,
           NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);

        letter_str = (const char **)(((char *)od) + cls->data_letter_offset);

        letter = toupper((*letter_str)[0]);
        if ((page->index) &&
            (isalpha(letter) && (page->last_index_letter[0] != letter)))
          {
             if ((page->first) && (!page->last_index_letter[0]))
               elm_index_item_append(page->index, "Special", page->first);

             page->last_index_letter[0] = letter;
             elm_index_item_append(page->index, page->last_index_letter, it);
          }
        if (!page->first) page->first = it;
        page->num_elements++;
     }

   return EINA_TRUE;

 end:
   if (cls->after_populate)
     cls->after_populate(page);

   page->populate = NULL;
   return EINA_FALSE;
}

static void
_page_selected(void *data, Evas_Object *o, void *event_info)
{
   Page *page = data;
   Elm_Genlist_Item *it = event_info;
   if (page->selected == it) return;
   page->selected = it;
   page->cls->selected(data, o, event_info);
}



static void
_page_index_changed(void *data __UNUSED__, Evas_Object *o __UNUSED__, void *event_info)
{
   Elm_Genlist_Item *it = event_info;
   elm_genlist_item_top_bring_in(it);
}

static void
_page_del(void *data, Evas *e __UNUSED__, Evas_Object *o __UNUSED__, void *event_info __UNUSED__)
{
   Page *page = data;
   eina_stringshare_del(page->title);
   if (page->iterator) eina_iterator_free(page->iterator);
   if (page->populate) ecore_idler_del(page->populate);
   if (page->item.free) page->item.free(page->item.data);
   free(page);
}

static void
_page_back(void *data, Evas_Object *o __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
{
   Page *page = data;
   evas_object_smart_callback_call(page->layout, "back", NULL);
}

static void
_page_songs(void *data, Evas_Object *o __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
{
   Page *page = data;
   evas_object_smart_callback_call(page->layout, "songs", NULL);
}

static Evas_Object *
_page_add(Evas_Object *parent, void *model, Eina_Iterator *it, const char *title, const Page_Class *cls)
{
   Evas_Object *obj;
   Page *page;
   const char *s;

   EINA_SAFETY_ON_NULL_RETURN_VAL(it, NULL);
   EINA_SAFETY_ON_NULL_RETURN_VAL(cls, NULL);
   EINA_SAFETY_ON_NULL_RETURN_VAL(cls->name, NULL);
   EINA_SAFETY_ON_NULL_RETURN_VAL(cls->key, NULL);
   EINA_SAFETY_ON_NULL_RETURN_VAL(cls->layout, NULL);
   EINA_SAFETY_ON_NULL_RETURN_VAL(cls->selected, NULL);
   EINA_SAFETY_ON_NULL_RETURN_VAL(cls->item_cls, NULL);
   EINA_SAFETY_ON_NULL_RETURN_VAL(cls->data_from_itr, NULL);

   DBG("creating page %s with key %s, item style %s",
       cls->name, cls->key, cls->item_cls->item_style);

   obj = elm_layout_add(parent);
   if (!obj)
     {
        eina_iterator_free(it);
        return NULL;
     }

   page = calloc(1, sizeof(*page));
   if (!page)
     {
        CRITICAL("could not allocate page memory!");
        eina_iterator_free(it);
        goto error;
     }
   evas_object_data_set(obj, "_enjoy_page", page);
   evas_object_data_set(obj, cls->key, page);
   evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _page_del, page);
   page->layout = obj;
   page->model = model;
   page->iterator = it;
   page->cls = cls;
   page->parent = parent;

   if (!elm_layout_file_set(obj, PACKAGE_DATA_DIR "/default.edj", cls->layout))
     {
        CRITICAL("no theme for '%s' at %s",
                 cls->layout, PACKAGE_DATA_DIR "/default.edj");
        goto error;
     }

   page->title = eina_stringshare_add(title);
   page->edje = elm_layout_edje_get(obj);
   edje_object_part_text_set(page->edje, "ejy.text.title", page->title);
   edje_object_signal_callback_add
     (page->edje, "ejy,back,clicked", "ejy", _page_back, page);
   edje_object_signal_callback_add
     (page->edje, "ejy,songs,clicked", "ejy", _page_songs, page);

   page->list = elm_genlist_add(obj);
   elm_genlist_bounce_set(page->list, EINA_FALSE, EINA_TRUE);
   elm_genlist_horizontal_mode_set(page->list, ELM_LIST_COMPRESS);
   elm_genlist_compress_mode_set(page->list, EINA_TRUE);
   elm_object_style_set(page->list, "enjoy");

   s = edje_object_data_get(page->edje, "homogeneous");
   elm_genlist_homogeneous_set(page->list, s ? !!atoi(s) : EINA_FALSE);

   elm_layout_content_set(obj, "ejy.swallow.list", page->list);

   if (edje_object_part_exists(page->edje, "ejy.swallow.index"))
     {
        page->index = elm_index_add(obj);
        evas_object_smart_callback_add
          (page->index, "delay,changed", _page_index_changed, page);
        elm_layout_content_set(obj, "ejy.swallow.index", page->index);
     }

   page->container = eina_iterator_container_get(it);
   evas_object_data_set(page->list, "_enjoy_container", page->container);
   evas_object_data_set(page->list, "_enjoy_page", page);
   evas_object_smart_callback_add(page->list, "selected", _page_selected, page);

   if (cls->init)
     {
        if (!cls->init(page)) goto error;
     }

   page->populate = ecore_idler_add(_page_populate, page);

   return obj;

 error:
   evas_object_del(obj); /* should delete everything */
   return NULL;
}

void
page_songs_exists_changed(Evas_Object *obj, Eina_Bool exists)
{
   PAGE_GET_OR_RETURN(page, obj);
   if (exists)
     edje_object_signal_emit(page->edje, "ejy,songs,show", "ejy");
   else
     edje_object_signal_emit(page->edje, "ejy,songs,hide", "ejy");

}

const char *
page_title_get(const Evas_Object *obj)
{
   PAGE_GET_OR_RETURN(page, obj, NULL);
   return page->title;
}


/***********************************************************************
 * SONGS
 ***********************************************************************/

#define PAGE_SONGS_GET_OR_RETURN(page, obj, ...)                \
  Page *page = evas_object_data_get(obj, "_enjoy_page_songs");  \
  do                                                            \
    {                                                           \
       if (!page)                                               \
         {                                                      \
            CRITICAL("Not a page_song: "#obj": %p", obj);       \
            return __VA_ARGS__;                                 \
         }                                                      \
    }                                                           \
  while (0)


static char *
_song_item_label_get(void *data, Evas_Object *list, const char *part)
{
   Song *song = data;

   /* check if matches protocol */
   if (strncmp(part, "ejy.text.", sizeof("ejy.text.") - 1) != 0)
     return NULL;
   part += sizeof("ejy.text.") - 1;

   if (!strcmp(part, "title"))
     return strdup(song->title);
   else if (!strcmp(part, "trackno-title"))
     {
        char *str;
        if (song->trackno < 1) return strdup(song->title);
        if (asprintf(&str, "%d - %s", song->trackno, song->title) > 0)
          return str;
        return NULL;
     }
   else if (!strcmp(part, "album-artist"))
     {
        char *str;

        if ((!song->flags.fetched_album) || (!song->flags.fetched_artist))
          {
             DB *db = evas_object_data_get(list, "_enjoy_container");
             db_song_album_fetch(db, song);
             db_song_artist_fetch(db, song);
          }

        if ((!song->album) && (!song->artist)) return NULL;
        else if (!song->album) return strdup(song->artist);
        else if (!song->artist) return strdup(song->album);

        if (asprintf(&str, "%s - %s", song->album, song->artist) > 0)
          return str;
        return NULL;
     }
   else if (!strcmp(part, "album"))
     {
        if (!song->flags.fetched_album)
          {
             DB *db = evas_object_data_get(list, "_enjoy_container");
             db_song_album_fetch(db, song);
          }
        return song->album ? strdup(song->album) : NULL;
     }
   else if (!strcmp(part, "artist"))
     {
        if (!song->flags.fetched_artist)
          {
             DB *db = evas_object_data_get(list, "_enjoy_container");
             db_song_artist_fetch(db, song);
          }
        return song->artist ? strdup(song->artist) : NULL;
     }
   else if (!strcmp(part, "genre"))
     {
        if (!song->flags.fetched_genre)
          {
             DB *db = evas_object_data_get(list, "_enjoy_container");
             db_song_genre_fetch(db, song);
          }
        return song->genre ? strdup(song->genre) : NULL;
     }
   else if (!strcmp(part, "trackno"))
     {
        char *str;
        if (song->trackno < 1) return NULL;
        if (asprintf(&str, "%d", song->trackno) > 0)
          return str;
        return NULL;
     }
   else if (!strcmp(part, "playcnt"))
     {
        char *str;
        if (song->playcnt < 1) return NULL;
        if (asprintf(&str, "%d", song->playcnt) > 0)
          return str;
        return NULL;
     }
   else if (!strcmp(part, "rating"))
     {
        char *str;
        if (song->rating < 1) return NULL;
        if (asprintf(&str, "%d", song->rating) > 0)
          return str;
        return NULL;
     }
   else if (!strcmp(part, "length"))
     {
        char *str;
        int len;
        if (song->length < 1) return NULL;
        if (song->length < 60)
          len = asprintf(&str, "%d", song->length);
        else if (song->length < 60 * 60)
          len = asprintf(&str, "%d:%02d", song->length / 60, song->length % 60);
        else
          len = asprintf(&str, "%d:%02d:%02d",
                         song->length / (60 * 60),
                         (song->length / 60) % 60,
                         song->length % 60);
        if (len > 0) return str;
        return NULL;
     }

   return NULL;
}

static Eina_Bool
_song_item_state_get(void *data, Evas_Object *list, const char *part)
{
   Song *song = data;

   /* check if matches protocol */
   if (strncmp(part, "ejy.state.", sizeof("ejy.state.") - 1) != 0)
     return EINA_FALSE;
   part += sizeof("ejy.state.") - 1;

   if (!strcmp(part, "title")) return EINA_TRUE;
   else if (!strcmp(part, "trackno")) return song->trackno > 0;
   else if (!strcmp(part, "playcnt")) return song->playcnt > 0;
   else if (!strcmp(part, "rating")) return song->rating > 0;
   else if (!strcmp(part, "length")) return song->length > 0;
   else if (!strcmp(part, "artist"))
     {
        if (!song->flags.fetched_artist)
          {
             DB *db = evas_object_data_get(list, "_enjoy_container");
             db_song_artist_fetch(db, song);
          }

        return !!song->artist;
     }
   else if (!strcmp(part, "album"))
     {
        if (!song->flags.fetched_album)
          {
             DB *db = evas_object_data_get(list, "_enjoy_container");
             db_song_album_fetch(db, song);
          }

        return !!song->album;
     }
   else if (!strcmp(part, "genre"))
     {
        if (!song->flags.fetched_genre)
          {
             DB *db = evas_object_data_get(list, "_enjoy_container");
             db_song_genre_fetch(db, song);
          }
        return !!song->genre;
     }

   return EINA_FALSE;
}


static void
_song_item_del(void *data, Evas_Object *list __UNUSED__)
{
   db_song_free(data);
}

static void
_song_item_selected(void *data, Evas_Object *list __UNUSED__, void *event_info)
{
   Page *page = data;
   Song *song = elm_genlist_item_data_get(event_info);
   if (song) evas_object_smart_callback_call(page->layout, "song", song);
}

static void
_page_songs_after_populate(Page *page)
{
   mpris_signal_tracklist_tracklist_change(page->num_elements);
}

static Evas_Object *
_page_songs_add(Evas_Object *parent, NameID *nameid, Eina_Iterator *it, const char *title)
{
   static const Elm_Genlist_Item_Class song_item_cls = {
     "song",
     {
       _song_item_label_get,
       NULL,
       _song_item_state_get,
       _song_item_del
     }
   };
   static const Page_Class song_cls = {
     "song",
     "_enjoy_page_songs",
     "page/songs",
     NULL,
     _page_songs_after_populate,
     _song_item_selected,
     &song_item_cls,
     PAGE_SONGS_POPULATE_ITERATION_COUNT,
     (void *(*)(const void*))db_song_copy,
     offsetof(Song, title),
     0
   };
   return _page_add(parent, nameid, it, title, &song_cls);
}

static void
_song_album_cover_size_changed(void *data, Evas *e __UNUSED__, Evas_Object *part, void *event_info __UNUSED__)
{
   Page *page = data;
   Evas_Coord size, w, h;
   Evas_Object *cover;

   evas_object_geometry_get(part, NULL, NULL, &w, &h);
   if (w < 32) w = 32;
   if (h < 32) h = 32;
   size = (w < h) ? w : h;

   DBG("cover view changed size to %dx%d, query cover size %d", w, h, size);
   cover = cover_album_fetch(page->layout, page->container, page->model, size);
   elm_layout_content_set(page->layout, "ejy.swallow.cover", cover);
}

static Eina_Bool
_song_album_init(Page *page)
{
   Album *album = page->model;

   if (edje_object_part_exists(page->edje, "ejy.swallow.cover"))
     {
        DB *db = _page_db_get(page->layout);
        Evas_Object *cover, *part;
        const char *s;
        int size = 0;

        s = edje_object_data_get(page->edje, "cover_size");
        if (s) size = atoi(s);
        if (size < 32) size = 32;

        cover = cover_album_fetch(page->layout, db, album, size);
        elm_layout_content_set(page->layout, "ejy.swallow.cover", cover);

        part = (Evas_Object *)
          edje_object_part_object_get(page->edje, "ejy.swallow.cover");
        evas_object_event_callback_add
          (part, EVAS_CALLBACK_RESIZE, _song_album_cover_size_changed, page);
     }

   if (album->name)
     edje_object_part_text_set(page->edje, "ejy.text.album", album->name);
   else
     edje_object_part_text_set(page->edje, "ejy.text.album", "");

   if (album->artist)
     edje_object_part_text_set(page->edje, "ejy.text.artist", album->artist);
   else
     edje_object_part_text_set(page->edje, "ejy.text.artist", "");

   return EINA_TRUE;
}

static Evas_Object *
_page_album_songs_add(Evas_Object *parent, Album *album)
{
   DB *db = _page_db_get(parent);
   Eina_Iterator *it;
   static const Elm_Genlist_Item_Class song_item_cls = {
     "song-album",
     {
       _song_item_label_get,
       NULL,
       _song_item_state_get,
       _song_item_del
     }
   };
   static const Page_Class song_cls = {
     "song",
     "_enjoy_page_songs",
     "page/songs-album",
     _song_album_init,
     _page_songs_after_populate,
     _song_item_selected,
     &song_item_cls,
     PAGE_SONGS_POPULATE_ITERATION_COUNT,
     (void *(*)(const void*))db_song_copy,
     offsetof(Song, title),
     0
   };

   it = db_album_songs_get(db, album->id);

   if ((!album->artist) && (!album->flags.fetched_artist))
     db_album_artist_fetch(db, album);

   return _page_add(parent, album, it, "Album Songs", &song_cls);
}

Song *
page_songs_selected_get(const Evas_Object *obj)
{
   PAGE_SONGS_GET_OR_RETURN(page, obj, NULL);
   return page->selected ? elm_genlist_item_data_get(page->selected) : NULL;
}

Eina_Bool
page_songs_song_updated(Evas_Object *obj)
{
   PAGE_SONGS_GET_OR_RETURN(page, obj, EINA_FALSE);
   if (page->selected)
     {
        elm_genlist_item_update(page->selected);
        return EINA_TRUE;
     }
   return EINA_FALSE;
}

Eina_Bool
page_songs_next_exists(const Evas_Object *obj)
{
   PAGE_SONGS_GET_OR_RETURN(page, obj, EINA_FALSE);
   Elm_Genlist_Item *it = page->selected;
   if (!it) return EINA_FALSE;
   it = elm_genlist_item_next_get(it);
   return !!it;
}

Song *
page_songs_next_go(Evas_Object *obj)
{
   PAGE_SONGS_GET_OR_RETURN(page, obj, NULL);
   Elm_Genlist_Item *it = page->selected;
   Song *song;
   if (!it) return NULL;
   it = elm_genlist_item_next_get(it);
   if (!it) return NULL;
   song = elm_genlist_item_data_get(it);
   page->selected = it;
   elm_genlist_item_selected_set(it, EINA_TRUE);
   elm_genlist_item_bring_in(it);
   mpris_signal_player_track_change(song);
   return song;
}

int32_t
page_songs_selected_n_get(Evas_Object *obj)
{
   PAGE_SONGS_GET_OR_RETURN(page, obj, 0);
   Elm_Genlist_Item *it;
   int n;
   for (n = 0, it = page->first;
        it && it != page->selected;
        n++, it = elm_genlist_item_next_get(it));
   return (it) ? n : 0;
}

Song *
page_songs_nth_get(Evas_Object *obj, int32_t n)
{
   PAGE_SONGS_GET_OR_RETURN(page, obj, NULL);
   Elm_Genlist_Item *it = page->first;
   while (it && n--) it = elm_genlist_item_next_get(it);
   if (!it) return NULL;
   return elm_genlist_item_data_get(it);
}

Song *
page_songs_random_go(Evas_Object *obj)
{
   Song *song;
   int count, song_num;

   PAGE_SONGS_GET_OR_RETURN(page, obj, NULL);
   Elm_Genlist_Item *it = page->first;
   if (!it) return NULL;
   song_num = (rand() % page->num_elements);
   for (count = 0; (it) && (count < song_num); count++)
      it = elm_genlist_item_next_get(it);
   if (!it) return NULL;
   song = elm_genlist_item_data_get(it);
   page->selected = it;
   elm_genlist_item_selected_set(it, EINA_TRUE);
   elm_genlist_item_bring_in(it);
   mpris_signal_player_track_change(song);
   return song;
}

Eina_Bool
page_songs_prev_exists(const Evas_Object *obj)
{
   PAGE_SONGS_GET_OR_RETURN(page, obj, EINA_FALSE);
   Elm_Genlist_Item *it = page->selected;
   if (!it) return EINA_FALSE;
   it = elm_genlist_item_prev_get(it);
   return !!it;
}

Song *
page_songs_prev_go(Evas_Object *obj)
{
   PAGE_SONGS_GET_OR_RETURN(page, obj, NULL);
   Elm_Genlist_Item *it = page->selected;
   Song *song;
   if (!it) return NULL;
   it = elm_genlist_item_prev_get(it);
   if (!it) return NULL;
   song = elm_genlist_item_data_get(it);
   page->selected = it;
   elm_genlist_item_selected_set(it, EINA_TRUE);
   elm_genlist_item_bring_in(it);
   mpris_signal_player_track_change(song);
   return song;
}


/***********************************************************************
 * FOLDERS
 **********************************************************************/

static char *
_album_item_label_get(void *data, Evas_Object *list, const char *part)
{
   Album *album = data;
   if (strcmp(part, "ejy.text.artist") == 0)
     {
        if (!album->flags.fetched_artist)
          {
             DB *db = evas_object_data_get(list, "_enjoy_container");
             db_album_artist_fetch(db, album);
          }
        if (album->artist) return strdup(album->artist);
        else return NULL;
     }

   return strdup(album->name);
}

static Evas_Object *
_album_item_icon_get(void *data, Evas_Object *list, const char *part __UNUSED__)
{
   Page *page = evas_object_data_get(list, "_enjoy_page");
   Album *album = data;
   return cover_album_fetch(list, page->container, album, page->cls->icon_size);
}

static void
_album_item_del(void *data, Evas_Object *list __UNUSED__)
{
   db_album_free(data);
}

static void
_album_item_selected(void *data, Evas_Object *list __UNUSED__, void *event_info)
{
   Page *page = data;
   Album *album = elm_genlist_item_data_get(event_info);
   EINA_SAFETY_ON_NULL_RETURN(album);
   Evas_Object *next = _page_album_songs_add(page->layout, album);
   if (next)
     evas_object_smart_callback_call(page->layout, "folder-songs", next);
   elm_genlist_item_selected_set(event_info, EINA_FALSE);
   page->selected = NULL;
}

static Evas_Object *
_page_albums_artist_add(Evas_Object *parent, NameID *nameid, Eina_Iterator *it, const char *title)
{
   static const Elm_Genlist_Item_Class album_item_cls = {
     "album-artist",
     {
       _album_item_label_get,
       _album_item_icon_get,
       NULL,
       _album_item_del
     }
   };
   static Page_Class album_cls = {
     "album",
     "_enjoy_page_albums",
     "page/albums",
     NULL,
     NULL,
     _album_item_selected,
     &album_item_cls,
     PAGE_FOLDERS_POPULATE_ITERATION_COUNT,
     (void *(*)(const void*))db_album_copy,
     offsetof(Album, name),
     0
   };

   if (!album_cls.icon_size)
     {
        Evas_Object *ed = edje_object_add(evas_object_evas_get(parent));
        if (edje_object_file_set
            (ed, PACKAGE_DATA_DIR"/default.edj",
             "elm/genlist/item_compress/album-artist/default"))
          {
             const char *s = edje_object_data_get(ed, "icon_size");
             if (s) album_cls.icon_size = atoi(s);
          }
        evas_object_del(ed);
        if (!album_cls.icon_size)
          {
             ERR("Could not get icon_size! assume 32");
             album_cls.icon_size = 32;
          }
     }

   return _page_add(parent, nameid, it, title, &album_cls);
}

static Evas_Object *
_page_albums_add(Evas_Object *parent, NameID *nameid, Eina_Iterator *it, const char *title)
{
   static const Elm_Genlist_Item_Class album_item_cls = {
     "album",
     {
       _album_item_label_get,
       _album_item_icon_get,
       NULL,
       _album_item_del
     }
   };
   static Page_Class album_cls = {
     "album",
     "_enjoy_page_albums",
     "page/albums",
     NULL,
     NULL,
     _album_item_selected,
     &album_item_cls,
     PAGE_FOLDERS_POPULATE_ITERATION_COUNT,
     (void *(*)(const void*))db_album_copy,
     offsetof(Album, name),
     0
   };

   if (!album_cls.icon_size)
     {
        Evas_Object *ed = edje_object_add(evas_object_evas_get(parent));
        if (edje_object_file_set
            (ed, PACKAGE_DATA_DIR"/default.edj",
             "elm/genlist/item_compress/album/default"))
          {
             const char *s = edje_object_data_get(ed, "icon_size");
             if (s) album_cls.icon_size = atoi(s);
          }
        evas_object_del(ed);
        if (!album_cls.icon_size)
          {
             ERR("Could not get icon_size! assume 32");
             album_cls.icon_size = 32;
          }
     }

   return _page_add(parent, nameid, it, title, &album_cls);
}

static char *
_item_all_songs_label_get(void *data __UNUSED__, Evas_Object *list __UNUSED__, const char *part __UNUSED__)
{
   if (strcmp(part, "ejy.text.artist") == 0)
        return NULL;
   return strdup("All Songs");
}

static Evas_Object *
_item_all_songs_icon_get(void *data __UNUSED__, Evas_Object *list __UNUSED__, const char *part __UNUSED__)
{
   Page *page = evas_object_data_get(list, "_enjoy_page");
   return cover_allsongs_fetch(list, page->cls->icon_size);
}


static const Elm_Genlist_Item_Class _item_all_songs_cls = {
  "all-song",
  {
    _item_all_songs_label_get,
    _item_all_songs_icon_get,
    NULL,
    NULL
  }
};

static char *
_nameid_item_label_get(void *data, Evas_Object *list __UNUSED__, const char *part __UNUSED__)
{
   NameID *nameid = data;
   return strdup(nameid->name);
}

static void
_nameid_item_del(void *data, Evas_Object *list __UNUSED__)
{
   db_nameid_free(data);
}

static void
_artist_item_all_songs_selected(void *data, Evas_Object *list __UNUSED__, void *event_info)
{
   Page *page = data;
   NameID *nameid = page->item.data;
   DB *db = _page_db_get(page->layout);
   Eina_Iterator *it = db_artist_songs_get(db, nameid->id);
   char buf[128];
   snprintf(buf, sizeof(buf), "Songs by %s", nameid->name);
   Evas_Object *next = _page_songs_add(page->layout, nameid, it, buf);
   if (next)
     evas_object_smart_callback_call(page->layout, "folder-songs", next);
   elm_genlist_item_selected_set(event_info, EINA_FALSE);
   page->selected = NULL;
}

static void
_artist_item_selected(void *data, Evas_Object *list __UNUSED__, void *event_info)
{
   Page *page = data;
   NameID *nameid = elm_genlist_item_data_get(event_info);
   EINA_SAFETY_ON_NULL_RETURN(nameid);
   DB *db = _page_db_get(page->layout);
   Eina_Iterator *it = db_artist_albums_get(db, nameid->id);
   char buf[128];
   snprintf(buf, sizeof(buf), "Albums by %s", nameid->name);
   Evas_Object *next = _page_albums_add(page->layout, nameid, it, buf);
   if (next)
     {
        Page *next_page = evas_object_data_get(next, "_enjoy_page");
        next_page->item.data = db_nameid_copy(nameid);
        next_page->item.free = (void (*)(void *))db_nameid_free;
        elm_genlist_item_append
          (next_page->list, &_item_all_songs_cls, NULL, NULL,
           ELM_GENLIST_ITEM_NONE, _artist_item_all_songs_selected, next_page);

        evas_object_smart_callback_call(page->layout, "folder", next);
     }
   elm_genlist_item_selected_set(event_info, EINA_FALSE);
   page->selected = NULL;
}

static Evas_Object *
_page_artists_add(Evas_Object *parent, NameID *nameid, Eina_Iterator *it, const char *title)
{
   static const Elm_Genlist_Item_Class nameid_item_cls = {
     "nameid",
     {
       _nameid_item_label_get,
       NULL,
       NULL,
       _nameid_item_del
     }
   };
   static const Page_Class nameid_cls = {
     "artist",
     "_enjoy_page_artists",
     "page/nameids",
     NULL,
     NULL,
     _artist_item_selected,
     &nameid_item_cls,
     PAGE_FOLDERS_POPULATE_ITERATION_COUNT,
     (void *(*)(const void*))db_nameid_copy,
     offsetof(NameID, name),
     0
   };
   return _page_add(parent, nameid, it, title, &nameid_cls);
}

static void
_genre_item_all_songs_selected(void *data, Evas_Object *list __UNUSED__, void *event_info)
{
   Page *page = data;
   NameID *nameid = page->item.data;
   DB *db = _page_db_get(page->layout);
   Eina_Iterator *it = db_genre_songs_get(db, nameid->id);
   char buf[128];
   snprintf(buf, sizeof(buf), "Songs of %s", nameid->name);
   Evas_Object *next = _page_songs_add(page->layout, nameid, it, buf);
   if (next)
     evas_object_smart_callback_call(page->layout, "folder-songs", next);
   elm_genlist_item_selected_set(event_info, EINA_FALSE);
   page->selected = NULL;
}

static void
_genre_item_selected(void *data, Evas_Object *list __UNUSED__, void *event_info)
{
   Page *page = data;
   NameID *nameid = elm_genlist_item_data_get(event_info);
   EINA_SAFETY_ON_NULL_RETURN(nameid);
   DB *db = _page_db_get(page->layout);
   Eina_Iterator *it = db_genre_albums_get(db, nameid->id);
   char buf[128];
   snprintf(buf, sizeof(buf), "Albums of %s", nameid->name);
   Evas_Object *next = _page_albums_artist_add(page->layout, nameid, it, buf);
   if (next)
     {
        Page *next_page = evas_object_data_get(next, "_enjoy_page");
        next_page->item.data = db_nameid_copy(nameid);
        next_page->item.free = (void (*)(void *))db_nameid_free;
        elm_genlist_item_append
          (next_page->list, &_item_all_songs_cls, NULL, NULL,
           ELM_GENLIST_ITEM_NONE, _genre_item_all_songs_selected, next_page);

        evas_object_smart_callback_call(page->layout, "folder", next);
     }
   elm_genlist_item_selected_set(event_info, EINA_FALSE);
   page->selected = NULL;
}

static Evas_Object *
_page_genres_add(Evas_Object *parent, Eina_Iterator *it, const char *title)
{
   static const Elm_Genlist_Item_Class nameid_item_cls = {
     "nameid",
     {
       _nameid_item_label_get,
       NULL,
       NULL,
       _nameid_item_del
     }
   };
   static const Page_Class nameid_cls = {
     "genre",
     "_enjoy_page_genres",
     "page/nameids",
     NULL,
     NULL,
     _genre_item_selected,
     &nameid_item_cls,
     PAGE_FOLDERS_POPULATE_ITERATION_COUNT,
     (void *(*)(const void*))db_nameid_copy,
     offsetof(NameID, name),
     0
   };
   return _page_add(parent, NULL, it, title, &nameid_cls);
}

typedef struct _Static_Item
{
   const char *label;
   Evas_Object *(*action)(Evas_Object *parent, void *data);
   const void *data;
   const char *signal;
} Static_Item;

static char *
_static_item_label_get(void *data, Evas_Object *list __UNUSED__, const char *part __UNUSED__)
{
   Static_Item *root = data;
   return strdup(root->label);
}

static void
_static_item_selected(void *data, Evas_Object *list __UNUSED__, void *event_info)
{
   Page *page = data;
   const Static_Item *si = elm_genlist_item_data_get(event_info);
   Evas_Object *next;
   EINA_SAFETY_ON_NULL_RETURN(si);
   EINA_SAFETY_ON_NULL_RETURN(si->action);
   next = si->action(page->layout, (void *)si->data);
   if (next)
     evas_object_smart_callback_call(page->layout, si->signal, next);
   elm_genlist_item_selected_set(event_info, EINA_FALSE);
   page->selected = NULL;
}

static Evas_Object *
_page_all_songs_add(Evas_Object *parent, void *data)
{
   PAGE_GET_OR_RETURN(page, parent, NULL);
   DB *db = _page_db_get(parent);
   Eina_Iterator *it = db_songs_get(db);
   return _page_songs_add(parent, NULL, it, data);
}

static Evas_Object *
_page_all_albums_add(Evas_Object *parent, void *data)
{
   PAGE_GET_OR_RETURN(page, parent, NULL);
   DB *db = _page_db_get(parent);
   Eina_Iterator *it = db_albums_get(db);
   return _page_albums_artist_add(parent, NULL, it, data);
}

static Evas_Object *
_page_all_artists_add(Evas_Object *parent, void *data)
{
   PAGE_GET_OR_RETURN(page, parent, NULL);
   DB *db = _page_db_get(parent);
   Eina_Iterator *it = db_artists_get(db);
   return _page_artists_add(parent, NULL, it, data);
}

static Evas_Object *
_page_all_genres_add(Evas_Object *parent, void *data)
{
   PAGE_GET_OR_RETURN(page, parent, NULL);
   DB *db = _page_db_get(parent);
   Eina_Iterator *it = db_genres_get(db);
   return _page_genres_add(parent, it, data);
}

Evas_Object *
page_root_add(Evas_Object *parent)
{
   static const Elm_Genlist_Item_Class root_item_cls = {
     "root", { _static_item_label_get, NULL, NULL, NULL }
   };
   static const Page_Class root_cls = {
     "root",
     "_enjoy_page_roots",
     "page/roots",
     NULL,
     NULL,
     _static_item_selected,
     &root_item_cls,
     PAGE_FOLDERS_POPULATE_ITERATION_COUNT,
     (void *(*)(const void*))_data_from_itr_passthrough,
     offsetof(Static_Item, label),
     0
   };
   static const Static_Item root_items[] = {
     {"All Songs", _page_all_songs_add, "All Songs", "folder-songs"},
     {"Albums", _page_all_albums_add, "All Albums", "folder"},
     {"Artists", _page_all_artists_add, "All Artists", "folder"},
     {"Genres", _page_all_genres_add, "All Genres", "folder"},
   };
   Eina_Iterator *it = _array_iterator_new
     (root_items, sizeof(Static_Item), ARRAY_SIZE(root_items));
   return _page_add(parent, NULL, it, "Enjoy your music!", &root_cls);
}