1d17f75f284ce1ee665486db88423089cf911ab6
1 /*
2 * (c) 2005 by Kalle Wallin <kaw@linux.se>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 */
19 #include "ncmpc.h"
20 #include "options.h"
21 #include "support.h"
22 #include "mpdclient.h"
23 #include "utils.h"
24 #include "strfsong.h"
25 #include "command.h"
26 #include "screen.h"
27 #include "screen_utils.h"
28 #include "screen_browser.h"
29 #include "gcc.h"
31 #include <ctype.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <glib.h>
35 #include <ncurses.h>
37 #define BUFSIZE 1024
39 typedef enum { LIST_ARTISTS, LIST_ALBUMS, LIST_SONGS } artist_mode_t;
41 static artist_mode_t mode = LIST_ARTISTS;
42 static char *artist = NULL;
43 static char *album = NULL;
44 static GPtrArray *metalist = NULL;
46 static struct screen_browser browser;
48 static gint
49 compare_utf8(gconstpointer s1, gconstpointer s2)
50 {
51 char *key1, *key2;
52 int n;
54 key1 = g_utf8_collate_key(s1,-1);
55 key2 = g_utf8_collate_key(s2,-1);
56 n = strcmp(key1,key2);
57 g_free(key1);
58 g_free(key2);
59 return n;
60 }
62 /* list_window callback */
63 static const char *
64 artist_lw_callback(unsigned idx, mpd_unused int *highlight, mpd_unused void *data)
65 {
66 static char buf[BUFSIZE];
67 char *str, *str_utf8;
69 if (mode == LIST_ALBUMS) {
70 if (idx == 0)
71 return "[..]";
72 else if (idx == metalist->len + 1) {
73 str = utf8_to_locale(_("All tracks"));
74 g_snprintf(buf, BUFSIZE, "[%s]", str);
75 g_free(str);
76 return buf;
77 }
79 --idx;
80 }
82 if (idx >= metalist->len)
83 return NULL;
85 str_utf8 = g_ptr_array_index(metalist, idx);
86 assert(str_utf8 != NULL);
88 str = utf8_to_locale(str_utf8);
89 g_snprintf(buf, BUFSIZE, "[%s]", str);
90 g_free(str);
92 return buf;
93 }
95 static void
96 paint(mpdclient_t *c);
98 static void
99 artist_repaint(void)
100 {
101 paint(NULL);
102 wrefresh(browser.lw->w);
103 }
105 static void
106 artist_repaint_if_active(void)
107 {
108 if (screen_is_visible(&screen_artist))
109 artist_repaint();
110 }
112 /* the playlist have been updated -> fix highlights */
113 static void
114 playlist_changed_callback(mpdclient_t *c, int event, gpointer data)
115 {
116 browser_playlist_changed(&browser, c, event, data);
118 artist_repaint_if_active();
119 }
121 static GPtrArray *
122 g_list_to_ptr_array(GList *in)
123 {
124 GPtrArray *out = g_ptr_array_sized_new(g_list_length(in));
125 GList *head = in;
127 while (in != NULL) {
128 g_ptr_array_add(out, in->data);
129 in = g_list_next(in);
130 }
132 g_list_free(head);
133 return out;
134 }
136 static void
137 string_array_free(GPtrArray *array)
138 {
139 unsigned i;
141 for (i = 0; i < array->len; ++i) {
142 char *value = g_ptr_array_index(array, i);
143 free(value);
144 }
146 g_ptr_array_free(array, TRUE);
147 }
149 static void
150 free_lists(struct mpdclient *c)
151 {
152 if (metalist != NULL) {
153 string_array_free(metalist);
154 metalist = NULL;
155 }
157 if (browser.filelist) {
158 if (c != NULL)
159 mpdclient_remove_playlist_callback(c, playlist_changed_callback);
160 filelist_free(browser.filelist);
161 browser.filelist = NULL;
162 }
163 }
165 static void
166 load_artist_list(struct mpdclient *c)
167 {
168 GList *list;
170 assert(mode == LIST_ARTISTS);
171 assert(artist == NULL);
172 assert(album == NULL);
173 assert(metalist == NULL);
174 assert(browser.filelist == NULL);
176 list = mpdclient_get_artists_utf8(c);
177 /* sort list */
178 list = g_list_sort(list, compare_utf8);
180 metalist = g_list_to_ptr_array(list);
181 }
183 static void
184 load_album_list(struct mpdclient *c)
185 {
186 GList *list;
188 assert(mode == LIST_ALBUMS);
189 assert(artist != NULL);
190 assert(album == NULL);
191 assert(metalist == NULL);
192 assert(browser.filelist == NULL);
194 list = mpdclient_get_albums_utf8(c, artist);
195 /* sort list */
196 list = g_list_sort(list, compare_utf8);
198 metalist = g_list_to_ptr_array(list);
199 }
201 static void
202 load_song_list(struct mpdclient *c)
203 {
204 assert(mode == LIST_SONGS);
205 assert(artist != NULL);
206 assert(album != NULL);
207 assert(browser.filelist == NULL);
209 if (album[0] == 0) {
210 album = g_strdup(_("All tracks"));
211 browser.filelist =
212 mpdclient_filelist_search_utf8(c, TRUE,
213 MPD_TABLE_ARTIST,
214 artist);
215 } else
216 browser.filelist =
217 mpdclient_filelist_search_utf8(c, TRUE,
218 MPD_TABLE_ALBUM,
219 album);
220 if (browser.filelist == NULL)
221 browser.filelist = filelist_new(NULL);
223 /* add a dummy entry for ".." */
224 filelist_prepend(browser.filelist, NULL);
226 /* install playlist callback and fix highlights */
227 sync_highlights(c, browser.filelist);
228 mpdclient_install_playlist_callback(c, playlist_changed_callback);
229 }
231 static void
232 free_state(struct mpdclient *c)
233 {
234 g_free(artist);
235 g_free(album);
236 artist = NULL;
237 album = NULL;
239 free_lists(c);
240 }
242 static void
243 open_artist_list(struct mpdclient *c)
244 {
245 free_state(c);
247 mode = LIST_ARTISTS;
248 load_artist_list(c);
249 }
251 static void
252 open_album_list(struct mpdclient *c, char *_artist)
253 {
254 assert(_artist != NULL);
256 free_state(c);
258 mode = LIST_ALBUMS;
259 artist = _artist;
260 load_album_list(c);
261 }
263 static void
264 open_song_list(struct mpdclient *c, char *_artist, char *_album)
265 {
266 assert(_artist != NULL);
267 assert(_album != NULL);
269 free_state(c);
271 mode = LIST_SONGS;
272 artist = _artist;
273 album = _album;
274 load_song_list(c);
275 }
277 static void
278 reload_lists(struct mpdclient *c)
279 {
280 free_lists(c);
282 switch (mode) {
283 case LIST_ARTISTS:
284 load_artist_list(c);
285 break;
287 case LIST_ALBUMS:
288 load_album_list(c);
289 break;
291 case LIST_SONGS:
292 load_song_list(c);
293 break;
294 }
295 }
297 /* db updated */
298 static void
299 browse_callback(mpdclient_t *c, int event, mpd_unused gpointer data)
300 {
301 switch(event) {
302 case BROWSE_DB_UPDATED:
303 D("screen_artist.c> browse_callback() [BROWSE_DB_UPDATED]\n");
304 reload_lists(c);
305 break;
306 default:
307 break;
308 }
310 artist_repaint_if_active();
311 }
313 static void
314 init(WINDOW *w, int cols, int rows)
315 {
316 browser.lw = list_window_init(w, cols, rows);
317 browser.lw_state = list_window_init_state();
318 artist = NULL;
319 album = NULL;
320 }
322 static void
323 quit(void)
324 {
325 free_state(NULL);
326 list_window_free(browser.lw);
327 list_window_free_state(browser.lw_state);
328 }
330 static void
331 open(mpd_unused screen_t *screen, mpdclient_t *c)
332 {
333 static gboolean callback_installed = FALSE;
335 if (metalist == NULL && browser.filelist == NULL)
336 reload_lists(c);
337 if (!callback_installed) {
338 mpdclient_install_browse_callback(c, browse_callback);
339 callback_installed = TRUE;
340 }
341 }
343 static void
344 resize(int cols, int rows)
345 {
346 browser.lw->cols = cols;
347 browser.lw->rows = rows;
348 }
350 static void
351 paint(mpd_unused mpdclient_t *c)
352 {
353 if (browser.filelist) {
354 list_window_paint(browser.lw, browser_lw_callback,
355 browser.filelist);
356 } else if (metalist) {
357 list_window_paint(browser.lw, artist_lw_callback, metalist);
358 } else {
359 wmove(browser.lw->w, 0, 0);
360 wclrtobot(browser.lw->w);
361 }
362 }
364 static const char *
365 get_title(char *str, size_t size)
366 {
367 char *s1 = artist ? utf8_to_locale(artist) : NULL;
368 char *s2 = album ? utf8_to_locale(album) : NULL;
370 switch(mode) {
371 case LIST_ARTISTS:
372 g_snprintf(str, size, _("Artist: [db browser - EXPERIMENTAL]"));
373 break;
374 case LIST_ALBUMS:
375 g_snprintf(str, size, _("Artist: %s"), s1);
376 break;
377 case LIST_SONGS:
378 g_snprintf(str, size, _("Artist: %s - %s"), s1, s2);
379 break;
380 }
381 g_free(s1);
382 g_free(s2);
383 return str;
384 }
386 static void
387 add_query(mpdclient_t *c, int table, char *_filter)
388 {
389 char *str;
390 mpdclient_filelist_t *addlist;
392 assert(filter != NULL);
394 str = utf8_to_locale(_filter);
395 if (table== MPD_TABLE_ALBUM)
396 screen_status_printf("Adding album %s...", str);
397 else
398 screen_status_printf("Adding %s...", str);
399 g_free(str);
401 addlist = mpdclient_filelist_search_utf8(c, TRUE, table, _filter);
402 if (addlist) {
403 mpdclient_filelist_add_all(c, addlist);
404 filelist_free(addlist);
405 }
406 }
408 static unsigned
409 metalist_length(void)
410 {
411 assert(metalist != NULL);
413 return mode == LIST_ALBUMS
414 ? metalist->len + 2
415 : metalist->len;
416 }
418 static int
419 artist_lw_cmd(command_t cmd)
420 {
421 switch (mode) {
422 case LIST_ARTISTS:
423 case LIST_ALBUMS:
424 return list_window_cmd(browser.lw, metalist_length(), cmd);
426 case LIST_SONGS:
427 return list_window_cmd(browser.lw,
428 filelist_length(browser.filelist),
429 cmd);
430 }
432 assert(0);
433 return 0;
434 }
436 static int
437 artist_cmd(screen_t *screen, mpdclient_t *c, command_t cmd)
438 {
439 char *selected;
440 int ret;
442 if (artist_lw_cmd(cmd)) {
443 artist_repaint();
444 wrefresh(browser.lw->w);
445 return 1;
446 }
448 switch(cmd) {
449 case CMD_PLAY:
450 switch (mode) {
451 case LIST_ARTISTS:
452 selected = g_ptr_array_index(metalist,
453 browser.lw->selected);
454 open_album_list(c, g_strdup(selected));
455 list_window_push_state(browser.lw_state, browser.lw);
457 list_window_paint(browser.lw, artist_lw_callback, metalist);
458 wrefresh(browser.lw->w);
459 break;
461 case LIST_ALBUMS:
462 if (browser.lw->selected == 0) {
463 /* handle ".." */
465 open_artist_list(c);
466 list_window_reset(browser.lw);
467 /* restore previous list window state */
468 list_window_pop_state(browser.lw_state, browser.lw);
469 } else if (browser.lw->selected == metalist->len + 1) {
470 /* handle "show all" */
471 open_song_list(c, g_strdup(artist), g_strdup("\0"));
472 list_window_push_state(browser.lw_state, browser.lw);
473 } else {
474 /* select album */
475 selected = g_ptr_array_index(metalist,
476 browser.lw->selected - 1);
477 open_song_list(c, g_strdup(artist), g_strdup(selected));
478 list_window_push_state(browser.lw_state, browser.lw);
479 }
481 artist_repaint();
482 break;
484 case LIST_SONGS:
485 if (browser.lw->selected == 0) {
486 /* handle ".." */
488 open_album_list(c, g_strdup(artist));
489 list_window_reset(browser.lw);
490 /* restore previous list window state */
491 list_window_pop_state(browser.lw_state,
492 browser.lw);
494 list_window_paint(browser.lw, artist_lw_callback, metalist);
495 wrefresh(browser.lw->w);
496 } else
497 browser_handle_enter(&browser, c);
498 break;
499 }
500 return 1;
503 /* FIXME? CMD_GO_* handling duplicates code from CMD_PLAY */
505 case CMD_GO_PARENT_DIRECTORY:
506 switch (mode) {
507 case LIST_ARTISTS:
508 break;
510 case LIST_ALBUMS:
511 open_artist_list(c);
512 list_window_reset(browser.lw);
513 /* restore previous list window state */
514 list_window_pop_state(browser.lw_state, browser.lw);
515 break;
517 case LIST_SONGS:
518 open_album_list(c, g_strdup(artist));
519 list_window_reset(browser.lw);
520 /* restore previous list window state */
521 list_window_pop_state(browser.lw_state, browser.lw);
522 break;
523 }
525 artist_repaint();
526 break;
528 case CMD_GO_ROOT_DIRECTORY:
529 switch (mode) {
530 case LIST_ARTISTS:
531 break;
533 case LIST_ALBUMS:
534 case LIST_SONGS:
535 open_artist_list(c);
536 list_window_reset(browser.lw);
537 /* restore first list window state (pop while returning true) */
538 while(list_window_pop_state(browser.lw_state, browser.lw));
539 break;
540 }
542 artist_repaint();
543 break;
545 case CMD_SELECT:
546 case CMD_ADD:
547 switch(mode) {
548 case LIST_ARTISTS:
549 selected = g_ptr_array_index(metalist,
550 browser.lw->selected);
551 add_query(c, MPD_TABLE_ARTIST, selected);
552 cmd = CMD_LIST_NEXT; /* continue and select next item... */
553 break;
555 case LIST_ALBUMS:
556 if (browser.lw->selected == metalist->len + 1)
557 add_query(c, MPD_TABLE_ARTIST, artist);
558 else if (browser.lw->selected > 0) {
559 selected = g_ptr_array_index(metalist,
560 browser.lw->selected - 1);
561 add_query(c, MPD_TABLE_ALBUM, selected);
562 cmd = CMD_LIST_NEXT; /* continue and select next item... */
563 }
564 break;
566 case LIST_SONGS:
567 ret = cmd == CMD_SELECT
568 ? browser_handle_select(&browser, c)
569 : browser_handle_add(&browser, c);
570 if (ret == 0)
571 /* continue and select next item... */
572 cmd = CMD_LIST_NEXT;
573 break;
574 }
575 break;
577 /* continue and update... */
578 case CMD_SCREEN_UPDATE:
579 reload_lists(c);
580 screen_status_printf(_("Screen updated!"));
581 return 0;
583 case CMD_LIST_FIND:
584 case CMD_LIST_RFIND:
585 case CMD_LIST_FIND_NEXT:
586 case CMD_LIST_RFIND_NEXT:
587 if (browser.filelist)
588 screen_find(screen,
589 browser.lw, filelist_length(browser.filelist),
590 cmd, browser_lw_callback,
591 browser.filelist);
592 else if (metalist)
593 screen_find(screen,
594 browser.lw, metalist_length(),
595 cmd, artist_lw_callback, metalist);
596 else
597 return 1;
599 artist_repaint();
600 return 1;
602 case CMD_MOUSE_EVENT:
603 return browser_handle_mouse_event(&browser, c);
605 default:
606 break;
607 }
609 return 0;
610 }
612 const struct screen_functions screen_artist = {
613 .init = init,
614 .exit = quit,
615 .open = open,
616 .resize = resize,
617 .paint = paint,
618 .cmd = artist_cmd,
619 .get_title = get_title,
620 };