1 /*
2 * $Id$
3 *
4 * (c) 2005 by Kalle Wallin <kaw@linux.se>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 */
21 #include "config.h"
23 #ifndef DISABLE_ARTIST_SCREEN
24 #include "ncmpc.h"
25 #include "options.h"
26 #include "support.h"
27 #include "mpdclient.h"
28 #include "utils.h"
29 #include "strfsong.h"
30 #include "command.h"
31 #include "screen.h"
32 #include "screen_utils.h"
33 #include "screen_browser.h"
34 #include "gcc.h"
36 #include <ctype.h>
37 #include <stdlib.h>
38 #include <string.h>
39 #include <glib.h>
40 #include <ncurses.h>
42 #define BUFSIZE 1024
44 typedef enum { LIST_ARTISTS, LIST_ALBUMS, LIST_SONGS } artist_mode_t;
46 static artist_mode_t mode = LIST_ARTISTS;
47 static char *artist = NULL;
48 static char *album = NULL;
49 static unsigned metalist_length = 0;
50 static GList *metalist = NULL;
52 static struct screen_browser browser;
54 static gint
55 compare_utf8(gconstpointer s1, gconstpointer s2)
56 {
57 char *key1, *key2;
58 int n;
60 key1 = g_utf8_collate_key(s1,-1);
61 key2 = g_utf8_collate_key(s2,-1);
62 n = strcmp(key1,key2);
63 g_free(key1);
64 g_free(key2);
65 return n;
66 }
68 /* list_window callback */
69 static const char *
70 artist_lw_callback(unsigned idx, mpd_unused int *highlight, mpd_unused void *data)
71 {
72 static char buf[BUFSIZE];
73 char *str, *str_utf8;
75 if ((str_utf8 = (char *)g_list_nth_data(metalist, idx)) == NULL)
76 return NULL;
78 str = utf8_to_locale(str_utf8);
79 g_snprintf(buf, BUFSIZE, "[%s]", str);
80 g_free(str);
82 return buf;
83 }
85 /* the playlist have been updated -> fix highlights */
86 static void
87 playlist_changed_callback(mpdclient_t *c, int event, mpd_unused gpointer data)
88 {
89 if (browser.filelist == NULL)
90 return;
92 D("screen_artist.c> playlist_callback() [%d]\n", event);
93 switch(event) {
94 case PLAYLIST_EVENT_CLEAR:
95 clear_highlights(browser.filelist);
96 break;
97 default:
98 sync_highlights(c, browser.filelist);
99 break;
100 }
101 }
103 /* fetch artists/albums/songs from mpd */
104 static void
105 update_metalist(mpdclient_t *c, char *m_artist, char *m_album)
106 {
107 g_free(artist);
108 g_free(album);
109 artist = NULL;
110 album = NULL;
112 if (metalist)
113 metalist = string_list_free(metalist);
114 if (browser.filelist) {
115 mpdclient_remove_playlist_callback(c, playlist_changed_callback);
116 mpdclient_filelist_free(browser.filelist);
117 browser.filelist = NULL;
118 }
120 if (m_album) {
121 /* retreive songs... */
122 filelist_entry_t *entry;
124 artist = m_artist;
125 album = m_album;
126 if (album[0] == 0) {
127 album = g_strdup(_("All tracks"));
128 browser.filelist =
129 mpdclient_filelist_search_utf8(c, TRUE,
130 MPD_TABLE_ARTIST,
131 artist);
132 } else
133 browser.filelist =
134 mpdclient_filelist_search_utf8(c, TRUE,
135 MPD_TABLE_ALBUM,
136 album);
137 /* add a dummy entry for ".." */
138 entry = g_malloc0(sizeof(filelist_entry_t));
139 entry->entity = NULL;
140 browser.filelist->list = g_list_insert(browser.filelist->list,
141 entry, 0);
142 browser.filelist->length++;
143 /* install playlist callback and fix highlights */
144 sync_highlights(c, browser.filelist);
145 mpdclient_install_playlist_callback(c, playlist_changed_callback);
146 mode = LIST_SONGS;
147 } else if (m_artist) {
148 /* retreive albums... */
150 artist = m_artist;
151 metalist = mpdclient_get_albums_utf8(c, m_artist);
152 /* sort list */
153 metalist = g_list_sort(metalist, compare_utf8);
154 /* add a dummy entry for ".." */
155 metalist = g_list_insert(metalist, g_strdup(".."), 0);
156 /* add a dummy entry for all songs */
157 metalist = g_list_insert(metalist, g_strdup(_("All tracks")), -1);
158 mode = LIST_ALBUMS;
159 } else {
160 /* retreive artists... */
162 metalist = mpdclient_get_artists_utf8(c);
163 /* sort list */
164 metalist = g_list_sort(metalist, compare_utf8);
165 mode = LIST_ARTISTS;
166 }
167 metalist_length = g_list_length(metalist);
168 browser.lw->clear = TRUE;
169 }
171 /* db updated */
172 static void
173 browse_callback(mpdclient_t *c, int event, mpd_unused gpointer data)
174 {
175 switch(event) {
176 case BROWSE_DB_UPDATED:
177 D("screen_artist.c> browse_callback() [BROWSE_DB_UPDATED]\n");
178 browser.lw->clear = 1;
179 browser.lw->repaint = 1;
180 update_metalist(c, g_strdup(artist), g_strdup(album));
181 break;
182 default:
183 break;
184 }
185 }
187 static void
188 init(WINDOW *w, int cols, int rows)
189 {
190 browser.lw = list_window_init(w, cols, rows);
191 browser.lw_state = list_window_init_state();
192 artist = NULL;
193 album = NULL;
194 }
196 static void
197 quit(void)
198 {
199 if (browser.filelist)
200 mpdclient_filelist_free(browser.filelist);
201 if (metalist)
202 string_list_free(metalist);
203 g_free(artist);
204 g_free(album);
205 artist = NULL;
206 album = NULL;
207 list_window_free(browser.lw);
208 list_window_free_state(browser.lw_state);
209 }
211 static void
212 open(mpd_unused screen_t *screen, mpdclient_t *c)
213 {
214 static gboolean callback_installed = FALSE;
216 if (metalist == NULL && browser.filelist == NULL)
217 update_metalist(c, NULL, NULL);
218 if (!callback_installed) {
219 mpdclient_install_browse_callback(c, browse_callback);
220 callback_installed = TRUE;
221 }
222 }
224 static void
225 resize(int cols, int rows)
226 {
227 browser.lw->cols = cols;
228 browser.lw->rows = rows;
229 }
231 static void
232 paint(mpd_unused screen_t *screen, mpd_unused mpdclient_t *c)
233 {
234 browser.lw->clear = 1;
236 if (browser.filelist) {
237 list_window_paint(browser.lw, browser_lw_callback,
238 browser.filelist);
239 browser.filelist->updated = FALSE;
240 } else if (metalist) {
241 list_window_paint(browser.lw, artist_lw_callback, metalist);
242 } else {
243 wmove(browser.lw->w, 0, 0);
244 wclrtobot(browser.lw->w);
245 }
247 wnoutrefresh(browser.lw->w);
248 }
250 static void
251 update(screen_t *screen, mpdclient_t *c)
252 {
253 if (browser.filelist && !browser.filelist->updated)
254 list_window_paint(browser.lw, browser_lw_callback,
255 browser.filelist);
256 else if (metalist)
257 list_window_paint(browser.lw, artist_lw_callback, metalist);
258 else
259 paint(screen, c);
260 wnoutrefresh(browser.lw->w);
261 }
263 static const char *
264 get_title(char *str, size_t size)
265 {
266 char *s1 = artist ? utf8_to_locale(artist) : NULL;
267 char *s2 = album ? utf8_to_locale(album) : NULL;
269 switch(mode) {
270 case LIST_ARTISTS:
271 g_snprintf(str, size, _("Artist: [db browser - EXPERIMENTAL]"));
272 break;
273 case LIST_ALBUMS:
274 g_snprintf(str, size, _("Artist: %s"), s1);
275 break;
276 case LIST_SONGS:
277 g_snprintf(str, size, _("Artist: %s - %s"), s1, s2);
278 break;
279 }
280 g_free(s1);
281 g_free(s2);
282 return str;
283 }
285 static void
286 add_query(mpdclient_t *c, int table, char *_filter)
287 {
288 char *str;
289 mpdclient_filelist_t *addlist;
291 str = utf8_to_locale(_filter);
292 if (table== MPD_TABLE_ALBUM)
293 screen_status_printf("Adding album %s...", str);
294 else
295 screen_status_printf("Adding %s...", str);
296 g_free(str);
298 addlist = mpdclient_filelist_search_utf8(c, TRUE, table, _filter);
299 if (addlist) {
300 mpdclient_filelist_add_all(c, addlist);
301 mpdclient_filelist_free(addlist);
302 }
303 }
305 static int
306 artist_cmd(screen_t *screen, mpdclient_t *c, command_t cmd)
307 {
308 char *selected;
310 switch(cmd) {
311 case CMD_PLAY:
312 switch (mode) {
313 case LIST_ARTISTS:
314 selected = (char *) g_list_nth_data(metalist,
315 browser.lw->selected);
316 update_metalist(c, g_strdup(selected), NULL);
317 list_window_push_state(browser.lw_state, browser.lw);
318 break;
320 case LIST_ALBUMS:
321 if (browser.lw->selected == 0) {
322 /* handle ".." */
324 update_metalist(c, NULL, NULL);
325 list_window_reset(browser.lw);
326 /* restore previous list window state */
327 list_window_pop_state(browser.lw_state, browser.lw);
328 } else if (browser.lw->selected == metalist_length - 1) {
329 /* handle "show all" */
330 update_metalist(c, g_strdup(artist), g_strdup("\0"));
331 list_window_push_state(browser.lw_state, browser.lw);
332 } else {
333 /* select album */
334 selected = g_list_nth_data(metalist,
335 browser.lw->selected);
336 update_metalist(c, g_strdup(artist), g_strdup(selected));
337 list_window_push_state(browser.lw_state, browser.lw);
338 }
339 break;
341 case LIST_SONGS:
342 if (browser.lw->selected == 0) {
343 /* handle ".." */
345 update_metalist(c, g_strdup(artist), NULL);
346 list_window_reset(browser.lw);
347 /* restore previous list window state */
348 list_window_pop_state(browser.lw_state,
349 browser.lw);
350 } else
351 browser_handle_enter(&browser, c);
352 break;
353 }
354 return 1;
357 /* FIXME? CMD_GO_* handling duplicates code from CMD_PLAY */
359 case CMD_GO_PARENT_DIRECTORY:
360 switch (mode) {
361 case LIST_ARTISTS:
362 break;
364 case LIST_ALBUMS:
365 update_metalist(c, NULL, NULL);
366 list_window_reset(browser.lw);
367 /* restore previous list window state */
368 list_window_pop_state(browser.lw_state, browser.lw);
369 break;
371 case LIST_SONGS:
372 update_metalist(c, g_strdup(artist), NULL);
373 list_window_reset(browser.lw);
374 /* restore previous list window state */
375 list_window_pop_state(browser.lw_state, browser.lw);
376 break;
377 }
378 break;
380 case CMD_GO_ROOT_DIRECTORY:
381 switch (mode) {
382 case LIST_ARTISTS:
383 break;
385 case LIST_ALBUMS:
386 case LIST_SONGS:
387 update_metalist(c, NULL, NULL);
388 list_window_reset(browser.lw);
389 /* restore first list window state (pop while returning true) */
390 while(list_window_pop_state(browser.lw_state, browser.lw));
391 break;
392 }
393 break;
395 case CMD_SELECT:
396 switch(mode) {
397 case LIST_ARTISTS:
398 selected = g_list_nth_data(metalist,
399 browser.lw->selected);
400 add_query(c, MPD_TABLE_ARTIST, selected);
401 cmd = CMD_LIST_NEXT; /* continue and select next item... */
402 break;
404 case LIST_ALBUMS:
405 if (browser.lw->selected &&
406 browser.lw->selected == metalist_length - 1)
407 add_query(c, MPD_TABLE_ARTIST, artist);
408 else if (browser.lw->selected > 0) {
409 selected = g_list_nth_data(metalist,
410 browser.lw->selected);
411 add_query(c, MPD_TABLE_ALBUM, selected);
412 cmd = CMD_LIST_NEXT; /* continue and select next item... */
413 }
414 break;
416 case LIST_SONGS:
417 if (browser_handle_select(&browser, c) == 0)
418 /* continue and select next item... */
419 cmd = CMD_LIST_NEXT;
420 break;
421 }
422 break;
424 /* continue and update... */
425 case CMD_SCREEN_UPDATE:
426 screen->painted = 0;
427 browser.lw->clear = 1;
428 browser.lw->repaint = 1;
429 update_metalist(c, g_strdup(artist), g_strdup(album));
430 screen_status_printf(_("Screen updated!"));
431 return 0;
433 case CMD_LIST_FIND:
434 case CMD_LIST_RFIND:
435 case CMD_LIST_FIND_NEXT:
436 case CMD_LIST_RFIND_NEXT:
437 if (browser.filelist)
438 return screen_find(screen,
439 browser.lw, browser.filelist->length,
440 cmd, browser_lw_callback,
441 browser.filelist);
442 else if (metalist)
443 return screen_find(screen,
444 browser.lw, metalist_length,
445 cmd, artist_lw_callback, metalist);
446 else
447 return 1;
449 case CMD_MOUSE_EVENT:
450 return browser_handle_mouse_event(&browser, c);
452 default:
453 break;
454 }
456 if (browser.filelist)
457 return list_window_cmd(browser.lw, browser.filelist->length, cmd);
458 else if (metalist)
459 return list_window_cmd(browser.lw, metalist_length, cmd);
461 return 0;
462 }
464 const struct screen_functions screen_artist = {
465 .init = init,
466 .exit = quit,
467 .open = open,
468 .resize = resize,
469 .paint = paint,
470 .update = update,
471 .cmd = artist_cmd,
472 .get_title = get_title,
473 };
475 #endif /* ENABLE_ARTIST_SCREEN */