src/screen_artist.c

   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  */
  18
  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"
  30
  31 #include <ctype.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <glib.h>
  35 #include <ncurses.h>
  36
  37 #define BUFSIZE 1024
  38
  39 typedef enum { LIST_ARTISTS, LIST_ALBUMS, LIST_SONGS } artist_mode_t;
  40
  41 static artist_mode_t mode = LIST_ARTISTS;
  42 static char *artist = NULL;
  43 static char *album  = NULL;
  44 static GPtrArray *metalist = NULL;
  45
  46 static struct screen_browser browser;
  47
  48 static gint
  49 compare_utf8(gconstpointer s1, gconstpointer s2)
  50 {
  51         char *key1, *key2;
  52         int n;
  53
  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 }
  61
  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;
  68
  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                 }
  78
  79                 --idx;
  80         }
  81
  82         if (idx >= metalist->len)
  83                 return NULL;
  84
  85         str_utf8 = g_ptr_array_index(metalist, idx);
  86         assert(str_utf8 != NULL);
  87
  88         str = utf8_to_locale(str_utf8);
  89         g_snprintf(buf, BUFSIZE, "[%s]", str);
  90         g_free(str);
  91
  92         return buf;
  93 }
  94
  95 static void
  96 paint(mpdclient_t *c);
  97
  98 static void
  99 artist_repaint(void)
 100 {
 101         paint(NULL);
 102         wrefresh(browser.lw->w);
 103 }
 104
 105 static void
 106 artist_repaint_if_active(void)
 107 {
 108         if (screen_is_visible(&screen_artist))
 109                 artist_repaint();
 110 }
 111
 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);
 117
 118         artist_repaint_if_active();
 119 }
 120
 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;
 126
 127         while (in != NULL) {
 128                 g_ptr_array_add(out, in->data);
 129                 in = g_list_next(in);
 130         }
 131
 132         g_list_free(head);
 133         return out;
 134 }
 135
 136 static void
 137 string_array_free(GPtrArray *array)
 138 {
 139         unsigned i;
 140
 141         for (i = 0; i < array->len; ++i) {
 142                 char *value = g_ptr_array_index(array, i);
 143                 free(value);
 144         }
 145
 146         g_ptr_array_free(array, TRUE);
 147 }
 148
 149 static void
 150 free_lists(struct mpdclient *c)
 151 {
 152         if (metalist != NULL) {
 153                 string_array_free(metalist);
 154                 metalist = NULL;
 155         }
 156
 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 }
 164
 165 static void
 166 load_artist_list(struct mpdclient *c)
 167 {
 168         GList *list;
 169
 170         assert(mode == LIST_ARTISTS);
 171         assert(artist == NULL);
 172         assert(album == NULL);
 173         assert(metalist == NULL);
 174         assert(browser.filelist == NULL);
 175
 176         list = mpdclient_get_artists_utf8(c);
 177         /* sort list */
 178         list = g_list_sort(list, compare_utf8);
 179
 180         metalist = g_list_to_ptr_array(list);
 181 }
 182
 183 static void
 184 load_album_list(struct mpdclient *c)
 185 {
 186         GList *list;
 187
 188         assert(mode == LIST_ALBUMS);
 189         assert(artist != NULL);
 190         assert(album == NULL);
 191         assert(metalist == NULL);
 192         assert(browser.filelist == NULL);
 193
 194         list = mpdclient_get_albums_utf8(c, artist);
 195         /* sort list */
 196         list = g_list_sort(list, compare_utf8);
 197
 198         metalist = g_list_to_ptr_array(list);
 199 }
 200
 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);
 208
 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);
 222
 223         /* add a dummy entry for ".." */
 224         filelist_prepend(browser.filelist, NULL);
 225
 226         /* install playlist callback and fix highlights */
 227         sync_highlights(c, browser.filelist);
 228         mpdclient_install_playlist_callback(c, playlist_changed_callback);
 229 }
 230
 231 /* fetch artists/albums/songs from mpd */
 232 static void
 233 update_metalist(mpdclient_t *c, char *m_artist, char *m_album)
 234 {
 235         g_free(artist);
 236         g_free(album);
 237         artist = NULL;
 238         album = NULL;
 239
 240         free_lists(c);
 241
 242         if (m_album) {
 243                 /* retreive songs... */
 244                 artist = m_artist;
 245                 album = m_album;
 246
 247                 mode = LIST_SONGS;
 248                 load_song_list(c);
 249         } else if (m_artist) {
 250                 /* retreive albums... */
 251                 artist = m_artist;
 252
 253                 mode = LIST_ALBUMS;
 254                 load_album_list(c);
 255         } else {
 256                 mode = LIST_ARTISTS;
 257                 load_artist_list(c);
 258         }
 259 }
 260
 261 /* db updated */
 262 static void
 263 browse_callback(mpdclient_t *c, int event, mpd_unused gpointer data)
 264 {
 265         switch(event) {
 266         case BROWSE_DB_UPDATED:
 267                 D("screen_artist.c> browse_callback() [BROWSE_DB_UPDATED]\n");
 268                 update_metalist(c, g_strdup(artist), g_strdup(album));
 269                 break;
 270         default:
 271                 break;
 272         }
 273
 274         artist_repaint_if_active();
 275 }
 276
 277 static void
 278 init(WINDOW *w, int cols, int rows)
 279 {
 280         browser.lw = list_window_init(w, cols, rows);
 281         browser.lw_state = list_window_init_state();
 282         artist = NULL;
 283         album = NULL;
 284 }
 285
 286 static void
 287 quit(void)
 288 {
 289         free_lists(NULL);
 290         g_free(artist);
 291         g_free(album);
 292         artist = NULL;
 293         album = NULL;
 294         list_window_free(browser.lw);
 295         list_window_free_state(browser.lw_state);
 296 }
 297
 298 static void
 299 open(mpd_unused screen_t *screen, mpdclient_t *c)
 300 {
 301         static gboolean callback_installed = FALSE;
 302
 303         if (metalist == NULL && browser.filelist == NULL)
 304                 update_metalist(c, NULL, NULL);
 305         if (!callback_installed) {
 306                 mpdclient_install_browse_callback(c, browse_callback);
 307                 callback_installed = TRUE;
 308         }
 309 }
 310
 311 static void
 312 resize(int cols, int rows)
 313 {
 314         browser.lw->cols = cols;
 315         browser.lw->rows = rows;
 316 }
 317
 318 static void
 319 paint(mpd_unused mpdclient_t *c)
 320 {
 321         if (browser.filelist) {
 322                 list_window_paint(browser.lw, browser_lw_callback,
 323                                   browser.filelist);
 324         } else if (metalist) {
 325                 list_window_paint(browser.lw, artist_lw_callback, metalist);
 326         } else {
 327                 wmove(browser.lw->w, 0, 0);
 328                 wclrtobot(browser.lw->w);
 329         }
 330 }
 331
 332 static const char *
 333 get_title(char *str, size_t size)
 334 {
 335         char *s1 = artist ? utf8_to_locale(artist) : NULL;
 336         char *s2 = album ? utf8_to_locale(album) : NULL;
 337
 338         switch(mode) {
 339         case LIST_ARTISTS:
 340                 g_snprintf(str, size,  _("Artist: [db browser - EXPERIMENTAL]"));
 341                 break;
 342         case LIST_ALBUMS:
 343                 g_snprintf(str, size,  _("Artist: %s"), s1);
 344                 break;
 345         case LIST_SONGS:
 346                 g_snprintf(str, size,  _("Artist: %s - %s"), s1, s2);
 347                 break;
 348         }
 349         g_free(s1);
 350         g_free(s2);
 351         return str;
 352 }
 353
 354 static void
 355 add_query(mpdclient_t *c, int table, char *_filter)
 356 {
 357         char *str;
 358         mpdclient_filelist_t *addlist;
 359
 360         assert(filter != NULL);
 361
 362         str = utf8_to_locale(_filter);
 363         if (table== MPD_TABLE_ALBUM)
 364                 screen_status_printf("Adding album %s...", str);
 365         else
 366                 screen_status_printf("Adding %s...", str);
 367         g_free(str);
 368
 369         addlist = mpdclient_filelist_search_utf8(c, TRUE, table, _filter);
 370         if (addlist) {
 371                 mpdclient_filelist_add_all(c, addlist);
 372                 filelist_free(addlist);
 373         }
 374 }
 375
 376 static unsigned
 377 metalist_length(void)
 378 {
 379         assert(metalist != NULL);
 380
 381         return mode == LIST_ALBUMS
 382                 ? metalist->len + 2
 383                 : metalist->len;
 384 }
 385
 386 static int
 387 artist_lw_cmd(command_t cmd)
 388 {
 389         switch (mode) {
 390         case LIST_ARTISTS:
 391         case LIST_ALBUMS:
 392                 return list_window_cmd(browser.lw, metalist_length(), cmd);
 393
 394         case LIST_SONGS:
 395                 return list_window_cmd(browser.lw,
 396                                        filelist_length(browser.filelist),
 397                                        cmd);
 398         }
 399
 400         assert(0);
 401         return 0;
 402 }
 403
 404 static int
 405 artist_cmd(screen_t *screen, mpdclient_t *c, command_t cmd)
 406 {
 407         char *selected;
 408         int ret;
 409
 410         if (artist_lw_cmd(cmd)) {
 411                 artist_repaint();
 412                 wrefresh(browser.lw->w);
 413                 return 1;
 414         }
 415
 416         switch(cmd) {
 417         case CMD_PLAY:
 418                 switch (mode) {
 419                 case LIST_ARTISTS:
 420                         selected = g_ptr_array_index(metalist,
 421                                                      browser.lw->selected);
 422                         update_metalist(c, g_strdup(selected), NULL);
 423                         list_window_push_state(browser.lw_state, browser.lw);
 424
 425                         list_window_paint(browser.lw, artist_lw_callback, metalist);
 426                         wrefresh(browser.lw->w);
 427                         break;
 428
 429                 case LIST_ALBUMS:
 430                         if (browser.lw->selected == 0) {
 431                                 /* handle ".." */
 432
 433                                 update_metalist(c, NULL, NULL);
 434                                 list_window_reset(browser.lw);
 435                                 /* restore previous list window state */
 436                                 list_window_pop_state(browser.lw_state, browser.lw);
 437                         } else if (browser.lw->selected == metalist->len + 1) {
 438                                 /* handle "show all" */
 439                                 update_metalist(c, g_strdup(artist), g_strdup("\0"));
 440                                 list_window_push_state(browser.lw_state, browser.lw);
 441                         } else {
 442                                 /* select album */
 443                                 selected = g_ptr_array_index(metalist,
 444                                                              browser.lw->selected - 1);
 445                                 update_metalist(c, g_strdup(artist), g_strdup(selected));
 446                                 list_window_push_state(browser.lw_state, browser.lw);
 447                         }
 448
 449                         artist_repaint();
 450                         break;
 451
 452                 case LIST_SONGS:
 453                         if (browser.lw->selected == 0) {
 454                                 /* handle ".." */
 455
 456                                 update_metalist(c, g_strdup(artist), NULL);
 457                                 list_window_reset(browser.lw);
 458                                 /* restore previous list window state */
 459                                 list_window_pop_state(browser.lw_state,
 460                                                       browser.lw);
 461
 462                                 list_window_paint(browser.lw, artist_lw_callback, metalist);
 463                                 wrefresh(browser.lw->w);
 464                         } else
 465                                 browser_handle_enter(&browser, c);
 466                         break;
 467                 }
 468                 return 1;
 469
 470
 471                 /* FIXME? CMD_GO_* handling duplicates code from CMD_PLAY */
 472
 473         case CMD_GO_PARENT_DIRECTORY:
 474                 switch (mode) {
 475                 case LIST_ARTISTS:
 476                         break;
 477
 478                 case LIST_ALBUMS:
 479                         update_metalist(c, NULL, NULL);
 480                         list_window_reset(browser.lw);
 481                         /* restore previous list window state */
 482                         list_window_pop_state(browser.lw_state, browser.lw);
 483                         break;
 484
 485                 case LIST_SONGS:
 486                         update_metalist(c, g_strdup(artist), NULL);
 487                         list_window_reset(browser.lw);
 488                         /* restore previous list window state */
 489                         list_window_pop_state(browser.lw_state, browser.lw);
 490                         break;
 491                 }
 492
 493                 artist_repaint();
 494                 break;
 495
 496         case CMD_GO_ROOT_DIRECTORY:
 497                 switch (mode) {
 498                 case LIST_ARTISTS:
 499                         break;
 500
 501                 case LIST_ALBUMS:
 502                 case LIST_SONGS:
 503                         update_metalist(c, NULL, NULL);
 504                         list_window_reset(browser.lw);
 505                         /* restore first list window state (pop while returning true) */
 506                         while(list_window_pop_state(browser.lw_state, browser.lw));
 507                         break;
 508                 }
 509
 510                 artist_repaint();
 511                 break;
 512
 513         case CMD_SELECT:
 514         case CMD_ADD:
 515                 switch(mode) {
 516                 case LIST_ARTISTS:
 517                         selected = g_ptr_array_index(metalist,
 518                                                      browser.lw->selected);
 519                         add_query(c, MPD_TABLE_ARTIST, selected);
 520                         cmd = CMD_LIST_NEXT; /* continue and select next item... */
 521                         break;
 522
 523                 case LIST_ALBUMS:
 524                         if (browser.lw->selected == metalist->len + 1)
 525                                 add_query(c, MPD_TABLE_ARTIST, artist);
 526                         else if (browser.lw->selected > 0) {
 527                                 selected = g_ptr_array_index(metalist,
 528                                                              browser.lw->selected - 1);
 529                                 add_query(c, MPD_TABLE_ALBUM, selected);
 530                                 cmd = CMD_LIST_NEXT; /* continue and select next item... */
 531                         }
 532                         break;
 533
 534                 case LIST_SONGS:
 535                         ret = cmd == CMD_SELECT
 536                                 ? browser_handle_select(&browser, c)
 537                                 : browser_handle_add(&browser, c);
 538                         if (ret == 0)
 539                                 /* continue and select next item... */
 540                                 cmd = CMD_LIST_NEXT;
 541                         break;
 542                 }
 543                 break;
 544
 545                 /* continue and update... */
 546         case CMD_SCREEN_UPDATE:
 547                 update_metalist(c, g_strdup(artist), g_strdup(album));
 548                 screen_status_printf(_("Screen updated!"));
 549                 return 0;
 550
 551         case CMD_LIST_FIND:
 552         case CMD_LIST_RFIND:
 553         case CMD_LIST_FIND_NEXT:
 554         case CMD_LIST_RFIND_NEXT:
 555                 if (browser.filelist)
 556                         screen_find(screen,
 557                                     browser.lw, filelist_length(browser.filelist),
 558                                     cmd, browser_lw_callback,
 559                                     browser.filelist);
 560                 else if (metalist)
 561                         screen_find(screen,
 562                                     browser.lw, metalist_length(),
 563                                     cmd, artist_lw_callback, metalist);
 564                 else
 565                         return 1;
 566
 567                 artist_repaint();
 568                 return 1;
 569
 570         case CMD_MOUSE_EVENT:
 571                 return browser_handle_mouse_event(&browser, c);
 572
 573         default:
 574                 break;
 575         }
 576
 577         return 0;
 578 }
 579
 580 const struct screen_functions screen_artist = {
 581         .init = init,
 582         .exit = quit,
 583         .open = open,
 584         .resize = resize,
 585         .paint = paint,
 586         .cmd = artist_cmd,
 587         .get_title = get_title,
 588 };