X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Fscreen_artist.c;h=2190cbbff54a7f3b4aed0068a47f9cb7d4c52df0;hb=e73ca303e9c688dde39ec70b20b7e1f811fe99e8;hp=bf7e54df09034017c87a13dbb68becbed8185d6b;hpb=9e27391e321912878f7cddaa92f2c8201c6e91de;p=ncmpc.git diff --git a/src/screen_artist.c b/src/screen_artist.c index bf7e54d..2190cbb 100644 --- a/src/screen_artist.c +++ b/src/screen_artist.c @@ -1,5 +1,6 @@ -/* - * (c) 2005 by Kalle Wallin +/* ncmpc (Ncurses MPD Client) + * (c) 2004-2017 The Music Player Daemon Project + * Project homepage: http://musicpd.org * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -10,54 +11,49 @@ * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#include "config.h" - -#ifndef DISABLE_ARTIST_SCREEN -#include "ncmpc.h" -#include "options.h" -#include "support.h" -#include "mpdclient.h" -#include "utils.h" -#include "strfsong.h" -#include "command.h" +#include "screen_artist.h" +#include "screen_interface.h" +#include "screen_status.h" +#include "screen_find.h" +#include "screen_browser.h" #include "screen.h" -#include "screen_utils.h" +#include "i18n.h" +#include "charset.h" +#include "mpdclient.h" #include "screen_browser.h" -#include "gcc.h" +#include "filelist.h" +#include "options.h" -#include -#include +#include #include #include -#include #define BUFSIZE 1024 typedef enum { LIST_ARTISTS, LIST_ALBUMS, LIST_SONGS } artist_mode_t; static artist_mode_t mode = LIST_ARTISTS; +static GPtrArray *artist_list, *album_list; static char *artist = NULL; static char *album = NULL; -static unsigned metalist_length = 0; -static GList *metalist = NULL; +static char ALL_TRACKS[] = ""; static struct screen_browser browser; static gint compare_utf8(gconstpointer s1, gconstpointer s2) { - char *key1, *key2; - int n; + const char *const*t1 = s1, *const*t2 = s2; - key1 = g_utf8_collate_key(s1,-1); - key2 = g_utf8_collate_key(s2,-1); - n = strcmp(key1,key2); + char *key1 = g_utf8_collate_key(*t1,-1); + char *key2 = g_utf8_collate_key(*t2,-1); + int n = strcmp(key1,key2); g_free(key1); g_free(key2); return n; @@ -65,276 +61,524 @@ compare_utf8(gconstpointer s1, gconstpointer s2) /* list_window callback */ static const char * -artist_lw_callback(unsigned idx, mpd_unused int *highlight, mpd_unused void *data) +screen_artist_lw_callback(unsigned idx, void *data) { - static char buf[BUFSIZE]; - char *str, *str_utf8; + GPtrArray *list = data; + + if (mode == LIST_ALBUMS) { + if (idx == 0) + return ".."; + else if (idx == list->len + 1) + return _("All tracks"); + + --idx; + } + + assert(idx < list->len); + + char *str_utf8 = g_ptr_array_index(list, idx); + assert(str_utf8 != NULL); - if ((str_utf8 = (char *)g_list_nth_data(metalist, idx)) == NULL) - return NULL; + char *str = utf8_to_locale(str_utf8); - str = utf8_to_locale(str_utf8); - g_snprintf(buf, BUFSIZE, "[%s]", str); + static char buf[BUFSIZE]; + g_strlcpy(buf, str, sizeof(buf)); g_free(str); return buf; } -/* the playlist have been updated -> fix highlights */ static void -playlist_changed_callback(mpdclient_t *c, int event, gpointer data) +string_array_free(GPtrArray *array) { - browser_playlist_changed(&browser, c, event, data); + for (unsigned i = 0; i < array->len; ++i) { + char *value = g_ptr_array_index(array, i); + g_free(value); + } + + g_ptr_array_free(array, TRUE); } -/* fetch artists/albums/songs from mpd */ static void -update_metalist(mpdclient_t *c, char *m_artist, char *m_album) +free_lists(void) { - g_free(artist); - g_free(album); - artist = NULL; - album = NULL; + if (artist_list != NULL) { + string_array_free(artist_list); + artist_list = NULL; + } + + if (album_list != NULL) { + string_array_free(album_list); + album_list = NULL; + } - if (metalist) - metalist = string_list_free(metalist); if (browser.filelist) { - mpdclient_remove_playlist_callback(c, playlist_changed_callback); filelist_free(browser.filelist); browser.filelist = NULL; } +} - if (m_album) { - /* retreive songs... */ - artist = m_artist; - album = m_album; - if (album[0] == 0) { - album = g_strdup(_("All tracks")); - browser.filelist = - mpdclient_filelist_search_utf8(c, TRUE, - MPD_TABLE_ARTIST, - artist); - } else - browser.filelist = - mpdclient_filelist_search_utf8(c, TRUE, - MPD_TABLE_ALBUM, - album); - if (browser.filelist == NULL) - browser.filelist = filelist_new(NULL); - - /* add a dummy entry for ".." */ - filelist_prepend(browser.filelist, NULL); - - /* install playlist callback and fix highlights */ - sync_highlights(c, browser.filelist); - mpdclient_install_playlist_callback(c, playlist_changed_callback); - mode = LIST_SONGS; - } else if (m_artist) { - /* retreive albums... */ - - artist = m_artist; - metalist = mpdclient_get_albums_utf8(c, m_artist); - /* sort list */ - metalist = g_list_sort(metalist, compare_utf8); - /* add a dummy entry for ".." */ - metalist = g_list_insert(metalist, g_strdup(".."), 0); - /* add a dummy entry for all songs */ - metalist = g_list_insert(metalist, g_strdup(_("All tracks")), -1); - mode = LIST_ALBUMS; - } else { - /* retreive artists... */ - - metalist = mpdclient_get_artists_utf8(c); - /* sort list */ - metalist = g_list_sort(metalist, compare_utf8); - mode = LIST_ARTISTS; +static void +recv_tag_values(struct mpd_connection *connection, enum mpd_tag_type tag, + GPtrArray *list) +{ + struct mpd_pair *pair; + + while ((pair = mpd_recv_pair_tag(connection, tag)) != NULL) { + g_ptr_array_add(list, g_strdup(pair->value)); + mpd_return_pair(connection, pair); + } +} + +static void +load_artist_list(struct mpdclient *c) +{ + struct mpd_connection *connection = mpdclient_get_connection(c); + + assert(mode == LIST_ARTISTS); + assert(artist == NULL); + assert(album == NULL); + assert(artist_list == NULL); + assert(album_list == NULL); + assert(browser.filelist == NULL); + + artist_list = g_ptr_array_new(); + + if (connection != NULL) { + mpd_search_db_tags(connection, MPD_TAG_ARTIST); + mpd_search_commit(connection); + recv_tag_values(connection, MPD_TAG_ARTIST, artist_list); + + mpdclient_finish_command(c); + } + + /* sort list */ + g_ptr_array_sort(artist_list, compare_utf8); + list_window_set_length(browser.lw, artist_list->len); +} + +static void +load_album_list(struct mpdclient *c) +{ + struct mpd_connection *connection = mpdclient_get_connection(c); + + assert(mode == LIST_ALBUMS); + assert(artist != NULL); + assert(album == NULL); + assert(album_list == NULL); + assert(browser.filelist == NULL); + + album_list = g_ptr_array_new(); + + if (connection != NULL) { + mpd_search_db_tags(connection, MPD_TAG_ALBUM); + mpd_search_add_tag_constraint(connection, + MPD_OPERATOR_DEFAULT, + MPD_TAG_ARTIST, artist); + mpd_search_commit(connection); + + recv_tag_values(connection, MPD_TAG_ALBUM, album_list); + + mpdclient_finish_command(c); } - metalist_length = g_list_length(metalist); + + /* sort list */ + g_ptr_array_sort(album_list, compare_utf8); + + list_window_set_length(browser.lw, album_list->len + 2); +} + +static void +load_song_list(struct mpdclient *c) +{ + struct mpd_connection *connection = mpdclient_get_connection(c); + + assert(mode == LIST_SONGS); + assert(artist != NULL); + assert(album != NULL); + assert(browser.filelist == NULL); + + browser.filelist = filelist_new(); + /* add a dummy entry for ".." */ + filelist_append(browser.filelist, NULL); + + if (connection != NULL) { + mpd_search_db_songs(connection, true); + mpd_search_add_tag_constraint(connection, MPD_OPERATOR_DEFAULT, + MPD_TAG_ARTIST, artist); + if (album != ALL_TRACKS) + mpd_search_add_tag_constraint(connection, MPD_OPERATOR_DEFAULT, + MPD_TAG_ALBUM, album); + mpd_search_commit(connection); + + filelist_recv(browser.filelist, connection); + + mpdclient_finish_command(c); + } + + /* fix highlights */ + screen_browser_sync_highlights(browser.filelist, &c->playlist); + list_window_set_length(browser.lw, filelist_length(browser.filelist)); +} + +static void +free_state(void) +{ + g_free(artist); + if (album != ALL_TRACKS) + g_free(album); + artist = NULL; + album = NULL; + + free_lists(); +} + +static void +open_artist_list(struct mpdclient *c) +{ + free_state(); + + mode = LIST_ARTISTS; + load_artist_list(c); +} + +static void +open_album_list(struct mpdclient *c, char *_artist) +{ + assert(_artist != NULL); + + free_state(); + + mode = LIST_ALBUMS; + artist = _artist; + load_album_list(c); } -/* db updated */ static void -browse_callback(mpdclient_t *c, int event, mpd_unused gpointer data) +open_song_list(struct mpdclient *c, char *_artist, char *_album) { - switch(event) { - case BROWSE_DB_UPDATED: - D("screen_artist.c> browse_callback() [BROWSE_DB_UPDATED]\n"); - update_metalist(c, g_strdup(artist), g_strdup(album)); + assert(_artist != NULL); + assert(_album != NULL); + + free_state(); + + mode = LIST_SONGS; + artist = _artist; + album = _album; + load_song_list(c); +} + +static void +reload_lists(struct mpdclient *c) +{ + free_lists(); + + switch (mode) { + case LIST_ARTISTS: + load_artist_list(c); break; - default: + + case LIST_ALBUMS: + load_album_list(c); + break; + + case LIST_SONGS: + load_song_list(c); break; } } static void -init(WINDOW *w, int cols, int rows) +screen_artist_init(WINDOW *w, unsigned cols, unsigned rows) { browser.lw = list_window_init(w, cols, rows); - browser.lw_state = list_window_init_state(); + browser.song_format = options.list_format; artist = NULL; album = NULL; } static void -quit(void) +screen_artist_quit(void) { - if (browser.filelist) - filelist_free(browser.filelist); - if (metalist) - string_list_free(metalist); - g_free(artist); - g_free(album); - artist = NULL; - album = NULL; + free_state(); list_window_free(browser.lw); - list_window_free_state(browser.lw_state); } static void -open(mpd_unused screen_t *screen, mpdclient_t *c) +screen_artist_open(struct mpdclient *c) { - static gboolean callback_installed = FALSE; - - if (metalist == NULL && browser.filelist == NULL) - update_metalist(c, NULL, NULL); - if (!callback_installed) { - mpdclient_install_browse_callback(c, browse_callback); - callback_installed = TRUE; - } + if (artist_list == NULL && album_list == NULL && + browser.filelist == NULL) + reload_lists(c); } static void -resize(int cols, int rows) +screen_artist_resize(unsigned cols, unsigned rows) { - browser.lw->cols = cols; - browser.lw->rows = rows; + list_window_resize(browser.lw, cols, rows); } +/** + * Paint one item in the artist list. + */ static void -paint(mpd_unused screen_t *screen, mpd_unused mpdclient_t *c) +paint_artist_callback(WINDOW *w, unsigned i, + gcc_unused unsigned y, unsigned width, + bool selected, const void *data) { - if (browser.filelist) { - list_window_paint(browser.lw, browser_lw_callback, - browser.filelist); - browser.filelist->updated = FALSE; - } else if (metalist) { - list_window_paint(browser.lw, artist_lw_callback, metalist); - } else { - wmove(browser.lw->w, 0, 0); - wclrtobot(browser.lw->w); - } + const GPtrArray *list = data; + char *p = utf8_to_locale(g_ptr_array_index(list, i)); - wnoutrefresh(browser.lw->w); + screen_browser_paint_directory(w, width, selected, p); + g_free(p); } +/** + * Paint one item in the album list. There are two virtual items + * inserted: at the beginning, there's the special item ".." to go to + * the parent directory, and at the end, there's the item "All tracks" + * to view the tracks of all albums. + */ static void -update(screen_t *screen, mpdclient_t *c) +paint_album_callback(WINDOW *w, unsigned i, + gcc_unused unsigned y, unsigned width, + bool selected, const void *data) { - if (browser.filelist && !browser.filelist->updated) - list_window_paint(browser.lw, browser_lw_callback, - browser.filelist); - else if (metalist) - list_window_paint(browser.lw, artist_lw_callback, metalist); + const GPtrArray *list = data; + const char *p; + char *q = NULL; + + if (i == 0) + p = ".."; + else if (i == list->len + 1) + p = _("All tracks"); else - paint(screen, c); - wnoutrefresh(browser.lw->w); + p = q = utf8_to_locale(g_ptr_array_index(list, i - 1)); + + screen_browser_paint_directory(w, width, selected, p); + g_free(q); } -static const char * -get_title(char *str, size_t size) +static void +screen_artist_paint(void) { - char *s1 = artist ? utf8_to_locale(artist) : NULL; - char *s2 = album ? utf8_to_locale(album) : NULL; + if (browser.filelist) { + screen_browser_paint(&browser); + } else if (album_list != NULL) + list_window_paint2(browser.lw, + paint_album_callback, album_list); + else if (artist_list != NULL) + list_window_paint2(browser.lw, + paint_artist_callback, artist_list); + else { + wmove(browser.lw->w, 0, 0); + wclrtobot(browser.lw->w); + } +} +static const char * +screen_artist_get_title(char *str, size_t size) +{ switch(mode) { + char *s1, *s2; + case LIST_ARTISTS: - g_snprintf(str, size, _("Artist: [db browser - EXPERIMENTAL]")); + g_snprintf(str, size, _("All artists")); break; + case LIST_ALBUMS: - g_snprintf(str, size, _("Artist: %s"), s1); + s1 = utf8_to_locale(artist); + g_snprintf(str, size, _("Albums of artist: %s"), s1); + g_free(s1); break; + case LIST_SONGS: - g_snprintf(str, size, _("Artist: %s - %s"), s1, s2); + s1 = utf8_to_locale(artist); + + if (album == ALL_TRACKS) + g_snprintf(str, size, + _("All tracks of artist: %s"), s1); + else if (*album != 0) { + s2 = utf8_to_locale(album); + g_snprintf(str, size, _("Album: %s - %s"), s1, s2); + g_free(s2); + } else + g_snprintf(str, size, + _("Tracks of no album of artist: %s"), s1); + g_free(s1); break; } - g_free(s1); - g_free(s2); + return str; } static void -add_query(mpdclient_t *c, int table, char *_filter) +screen_artist_update(struct mpdclient *c) +{ + if (browser.filelist == NULL) + return; + + if (c->events & MPD_IDLE_DATABASE) + /* the db has changed -> update the list */ + reload_lists(c); + + if (c->events & (MPD_IDLE_DATABASE | MPD_IDLE_QUEUE)) + screen_browser_sync_highlights(browser.filelist, &c->playlist); + + if (c->events & (MPD_IDLE_DATABASE +#ifndef NCMPC_MINI + | MPD_IDLE_QUEUE +#endif + )) + screen_artist_paint(); +} + +/* add_query - Add all songs satisfying specified criteria. + _artist is actually only used in the ALBUM case to distinguish albums with + the same name from different artists. */ +static void +add_query(struct mpdclient *c, enum mpd_tag_type table, const char *_filter, + const char *_artist) { - char *str; - mpdclient_filelist_t *addlist; + struct mpd_connection *connection = mpdclient_get_connection(c); + + assert(_filter != NULL); - assert(filter != NULL); + if (connection == NULL) + return; - str = utf8_to_locale(_filter); - if (table== MPD_TABLE_ALBUM) - screen_status_printf("Adding album %s...", str); + char *str = utf8_to_locale(_filter); + if (table == MPD_TAG_ALBUM) + screen_status_printf(_("Adding album %s..."), str); else - screen_status_printf("Adding %s...", str); + screen_status_printf(_("Adding %s..."), str); g_free(str); - addlist = mpdclient_filelist_search_utf8(c, TRUE, table, _filter); - if (addlist) { + mpd_search_db_songs(connection, true); + mpd_search_add_tag_constraint(connection, MPD_OPERATOR_DEFAULT, + table, _filter); + if (table == MPD_TAG_ALBUM) + mpd_search_add_tag_constraint(connection, MPD_OPERATOR_DEFAULT, + MPD_TAG_ARTIST, _artist); + mpd_search_commit(connection); + + struct filelist *addlist = filelist_new_recv(connection); + + if (mpdclient_finish_command(c)) mpdclient_filelist_add_all(c, addlist); - filelist_free(addlist); + + filelist_free(addlist); +} + +static int +screen_artist_lw_cmd(struct mpdclient *c, command_t cmd) +{ + switch (mode) { + case LIST_ARTISTS: + case LIST_ALBUMS: + return list_window_cmd(browser.lw, cmd); + + case LIST_SONGS: + return browser_cmd(&browser, c, cmd); } + + assert(0); + return 0; } static int -artist_cmd(screen_t *screen, mpdclient_t *c, command_t cmd) +string_array_find(GPtrArray *array, const char *value) { - char *selected; + guint i; + + for (i = 0; i < array->len; ++i) + if (strcmp((const char*)g_ptr_array_index(array, i), + value) == 0) + return i; + return -1; +} + +static bool +screen_artist_cmd(struct mpdclient *c, command_t cmd) +{ switch(cmd) { + struct list_window_range range; + char *selected; + char *old; + char *old_ptr; + int idx; + case CMD_PLAY: switch (mode) { case LIST_ARTISTS: - selected = (char *) g_list_nth_data(metalist, - browser.lw->selected); - update_metalist(c, g_strdup(selected), NULL); - list_window_push_state(browser.lw_state, browser.lw); - break; + if (browser.lw->selected >= artist_list->len) + return true; + + selected = g_ptr_array_index(artist_list, + browser.lw->selected); + open_album_list(c, g_strdup(selected)); + list_window_reset(browser.lw); + + screen_artist_paint(); + return true; case LIST_ALBUMS: if (browser.lw->selected == 0) { /* handle ".." */ + old = g_strdup(artist); - update_metalist(c, NULL, NULL); + open_artist_list(c); list_window_reset(browser.lw); /* restore previous list window state */ - list_window_pop_state(browser.lw_state, browser.lw); - } else if (browser.lw->selected == metalist_length - 1) { + idx = string_array_find(artist_list, old); + g_free(old); + + if (idx >= 0) { + list_window_set_cursor(browser.lw, idx); + list_window_center(browser.lw, idx); + } + } else if (browser.lw->selected == album_list->len + 1) { /* handle "show all" */ - update_metalist(c, g_strdup(artist), g_strdup("\0")); - list_window_push_state(browser.lw_state, browser.lw); + open_song_list(c, g_strdup(artist), ALL_TRACKS); + list_window_reset(browser.lw); } else { /* select album */ - selected = g_list_nth_data(metalist, - browser.lw->selected); - update_metalist(c, g_strdup(artist), g_strdup(selected)); - list_window_push_state(browser.lw_state, browser.lw); + selected = g_ptr_array_index(album_list, + browser.lw->selected - 1); + open_song_list(c, g_strdup(artist), g_strdup(selected)); + list_window_reset(browser.lw); } - break; + + screen_artist_paint(); + return true; case LIST_SONGS: if (browser.lw->selected == 0) { /* handle ".." */ + old = g_strdup(album); + old_ptr = album; - update_metalist(c, g_strdup(artist), NULL); + open_album_list(c, g_strdup(artist)); list_window_reset(browser.lw); /* restore previous list window state */ - list_window_pop_state(browser.lw_state, - browser.lw); - } else - browser_handle_enter(&browser, c); + idx = old_ptr == ALL_TRACKS + ? (int)album_list->len + : string_array_find(album_list, old); + g_free(old); + + if (idx >= 0) { + ++idx; + list_window_set_cursor(browser.lw, idx); + list_window_center(browser.lw, idx); + } + + screen_artist_paint(); + return true; + } break; } - return 1; - + break; /* FIXME? CMD_GO_* handling duplicates code from CMD_PLAY */ @@ -344,19 +588,41 @@ artist_cmd(screen_t *screen, mpdclient_t *c, command_t cmd) break; case LIST_ALBUMS: - update_metalist(c, NULL, NULL); + old = g_strdup(artist); + + open_artist_list(c); list_window_reset(browser.lw); /* restore previous list window state */ - list_window_pop_state(browser.lw_state, browser.lw); + idx = string_array_find(artist_list, old); + g_free(old); + + if (idx >= 0) { + list_window_set_cursor(browser.lw, idx); + list_window_center(browser.lw, idx); + } break; case LIST_SONGS: - update_metalist(c, g_strdup(artist), NULL); + old = g_strdup(album); + old_ptr = album; + + open_album_list(c, g_strdup(artist)); list_window_reset(browser.lw); /* restore previous list window state */ - list_window_pop_state(browser.lw_state, browser.lw); + idx = old_ptr == ALL_TRACKS + ? (int)album_list->len + : string_array_find(album_list, old); + g_free(old); + + if (idx >= 0) { + ++idx; + list_window_set_cursor(browser.lw, idx); + list_window_center(browser.lw, idx); + } break; } + + screen_artist_paint(); break; case CMD_GO_ROOT_DIRECTORY: @@ -366,95 +632,121 @@ artist_cmd(screen_t *screen, mpdclient_t *c, command_t cmd) case LIST_ALBUMS: case LIST_SONGS: - update_metalist(c, NULL, NULL); + open_artist_list(c); list_window_reset(browser.lw); /* restore first list window state (pop while returning true) */ - while(list_window_pop_state(browser.lw_state, browser.lw)); + /* XXX */ break; } + + screen_artist_paint(); break; case CMD_SELECT: + case CMD_ADD: switch(mode) { case LIST_ARTISTS: - selected = g_list_nth_data(metalist, - browser.lw->selected); - if (selected == NULL) - return 1; + if (browser.lw->selected >= artist_list->len) + return true; - add_query(c, MPD_TABLE_ARTIST, selected); - cmd = CMD_LIST_NEXT; /* continue and select next item... */ + list_window_get_range(browser.lw, &range); + for (unsigned i = range.start; i < range.end; ++i) { + selected = g_ptr_array_index(artist_list, i); + add_query(c, MPD_TAG_ARTIST, selected, NULL); + cmd = CMD_LIST_NEXT; /* continue and select next item... */ + } break; case LIST_ALBUMS: - if (browser.lw->selected && - browser.lw->selected == metalist_length - 1) - add_query(c, MPD_TABLE_ARTIST, artist); - else if (browser.lw->selected > 0) { - selected = g_list_nth_data(metalist, - browser.lw->selected); - if (selected == NULL) - return 1; - - add_query(c, MPD_TABLE_ALBUM, selected); - cmd = CMD_LIST_NEXT; /* continue and select next item... */ + list_window_get_range(browser.lw, &range); + for (unsigned i = range.start; i < range.end; ++i) { + if(i == album_list->len + 1) + add_query(c, MPD_TAG_ARTIST, artist, NULL); + else if (i > 0) + { + selected = g_ptr_array_index(album_list, + browser.lw->selected - 1); + add_query(c, MPD_TAG_ALBUM, selected, artist); + cmd = CMD_LIST_NEXT; /* continue and select next item... */ + } } break; case LIST_SONGS: - if (browser_handle_select(&browser, c) == 0) - /* continue and select next item... */ - cmd = CMD_LIST_NEXT; + /* handled by browser_cmd() */ break; } break; /* continue and update... */ case CMD_SCREEN_UPDATE: - update_metalist(c, g_strdup(artist), g_strdup(album)); - screen_status_printf(_("Screen updated!")); - return 0; + reload_lists(c); + return false; case CMD_LIST_FIND: case CMD_LIST_RFIND: case CMD_LIST_FIND_NEXT: case CMD_LIST_RFIND_NEXT: - if (browser.filelist) - return screen_find(screen, - browser.lw, filelist_length(browser.filelist), - cmd, browser_lw_callback, - browser.filelist); - else if (metalist) - return screen_find(screen, - browser.lw, metalist_length, - cmd, artist_lw_callback, metalist); - else - return 1; - - case CMD_MOUSE_EVENT: - return browser_handle_mouse_event(&browser, c); + switch (mode) { + case LIST_ARTISTS: + screen_find(browser.lw, cmd, + screen_artist_lw_callback, artist_list); + screen_artist_paint(); + return true; + + case LIST_ALBUMS: + screen_find(browser.lw, cmd, + screen_artist_lw_callback, album_list); + screen_artist_paint(); + return true; + + case LIST_SONGS: + /* handled by browser_cmd() */ + break; + } + case CMD_LIST_JUMP: + switch (mode) { + case LIST_ARTISTS: + screen_jump(browser.lw, + screen_artist_lw_callback, artist_list, + paint_artist_callback, artist_list); + screen_artist_paint(); + return true; + + case LIST_ALBUMS: + screen_jump(browser.lw, + screen_artist_lw_callback, album_list, + paint_album_callback, album_list); + screen_artist_paint(); + return true; + + case LIST_SONGS: + /* handled by browser_cmd() */ + break; + } + + break; default: break; } - if (browser.filelist) - return list_window_cmd(browser.lw, filelist_length(browser.filelist), cmd); - else if (metalist) - return list_window_cmd(browser.lw, metalist_length, cmd); + if (screen_artist_lw_cmd(c, cmd)) { + if (screen_is_visible(&screen_artist)) + screen_artist_paint(); + return true; + } - return 0; + return false; } const struct screen_functions screen_artist = { - .init = init, - .exit = quit, - .open = open, - .resize = resize, - .paint = paint, - .update = update, - .cmd = artist_cmd, - .get_title = get_title, + .init = screen_artist_init, + .exit = screen_artist_quit, + .open = screen_artist_open, + .resize = screen_artist_resize, + .paint = screen_artist_paint, + .update = screen_artist_update, + .cmd = screen_artist_cmd, + .get_title = screen_artist_get_title, }; - -#endif /* ENABLE_ARTIST_SCREEN */