src/screen_artist.c

   1 /* ncmpc (Ncurses MPD Client)
   2  * (c) 2004-2009 The Music Player Daemon Project
   3  * Project homepage: http://musicpd.org
   4
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "i18n.h"
  21 #include "options.h"
  22 #include "charset.h"
  23 #include "mpdclient.h"
  24 #include "utils.h"
  25 #include "strfsong.h"
  26 #include "command.h"
  27 #include "screen.h"
  28 #include "screen_utils.h"
  29 #include "screen_browser.h"
  30
  31 #include <ctype.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <glib.h>
  35
  36 #define BUFSIZE 1024
  37
  38 typedef enum { LIST_ARTISTS, LIST_ALBUMS, LIST_SONGS } artist_mode_t;
  39
  40 static artist_mode_t mode = LIST_ARTISTS;
  41 static GPtrArray *artist_list, *album_list;
  42 static char *artist = NULL;
  43 static char *album  = NULL;
  44
  45 static struct screen_browser browser;
  46
  47 static gint
  48 compare_utf8(gconstpointer s1, gconstpointer s2)
  49 {
  50         char *key1, *key2;
  51         int n;
  52
  53         key1 = g_utf8_collate_key(s1,-1);
  54         key2 = g_utf8_collate_key(s2,-1);
  55         n = strcmp(key1,key2);
  56         g_free(key1);
  57         g_free(key2);
  58         return n;
  59 }
  60
  61 /* list_window callback */
  62 static const char *
  63 artist_lw_callback(unsigned idx, G_GNUC_UNUSED bool *highlight,
  64                    G_GNUC_UNUSED void *data)
  65 {
  66         GPtrArray *list = data;
  67         static char buf[BUFSIZE];
  68         char *str, *str_utf8;
  69
  70         if (mode == LIST_ALBUMS) {
  71                 if (idx == 0)
  72                         return "[..]";
  73                 else if (idx == list->len + 1) {
  74                         str = utf8_to_locale(_("All tracks"));
  75                         g_snprintf(buf, BUFSIZE, "[%s]", str);
  76                         g_free(str);
  77                         return buf;
  78                 }
  79
  80                 --idx;
  81         }
  82
  83         if (idx >= list->len)
  84                 return NULL;
  85
  86         str_utf8 = g_ptr_array_index(list, idx);
  87         assert(str_utf8 != NULL);
  88
  89         str = utf8_to_locale(str_utf8);
  90         g_snprintf(buf, BUFSIZE, "[%s]", str);
  91         g_free(str);
  92
  93         return buf;
  94 }
  95
  96 static void
  97 paint(void);
  98
  99 static void
 100 artist_repaint(void)
 101 {
 102         paint();
 103         wrefresh(browser.lw->w);
 104 }
 105
 106 static void
 107 artist_repaint_if_active(void)
 108 {
 109         if (screen_is_visible(&screen_artist))
 110                 artist_repaint();
 111 }
 112
 113 #ifndef NCMPC_MINI
 114 /* the playlist have been updated -> fix highlights */
 115 static void
 116 playlist_changed_callback(mpdclient_t *c, int event, gpointer data)
 117 {
 118         browser_playlist_changed(&browser, c, event, data);
 119
 120         artist_repaint_if_active();
 121 }
 122 #endif
 123
 124 static GPtrArray *
 125 g_list_to_ptr_array(GList *in)
 126 {
 127         GPtrArray *out = g_ptr_array_sized_new(g_list_length(in));
 128         GList *head = in;
 129
 130         while (in != NULL) {
 131                 g_ptr_array_add(out, in->data);
 132                 in = g_list_next(in);
 133         }
 134
 135         g_list_free(head);
 136         return out;
 137 }
 138
 139 static void
 140 string_array_free(GPtrArray *array)
 141 {
 142         unsigned i;
 143
 144         for (i = 0; i < array->len; ++i) {
 145                 char *value = g_ptr_array_index(array, i);
 146                 free(value);
 147         }
 148
 149         g_ptr_array_free(array, TRUE);
 150 }
 151
 152 static void
 153 free_lists(G_GNUC_UNUSED struct mpdclient *c)
 154 {
 155         if (artist_list != NULL) {
 156                 string_array_free(artist_list);
 157                 artist_list = NULL;
 158         }
 159
 160         if (album_list != NULL) {
 161                 string_array_free(album_list);
 162                 album_list = NULL;
 163         }
 164
 165         if (browser.filelist) {
 166 #ifndef NCMPC_MINI
 167                 if (c != NULL)
 168                         mpdclient_remove_playlist_callback(c, playlist_changed_callback);
 169 #endif
 170                 filelist_free(browser.filelist);
 171                 browser.filelist = NULL;
 172         }
 173 }
 174
 175 static void
 176 load_artist_list(struct mpdclient *c)
 177 {
 178         GList *list;
 179
 180         assert(mode == LIST_ARTISTS);
 181         assert(artist == NULL);
 182         assert(album == NULL);
 183         assert(artist_list == NULL);
 184         assert(album_list == NULL);
 185         assert(browser.filelist == NULL);
 186
 187         list = mpdclient_get_artists(c);
 188         /* sort list */
 189         list = g_list_sort(list, compare_utf8);
 190
 191         artist_list = g_list_to_ptr_array(list);
 192 }
 193
 194 static void
 195 load_album_list(struct mpdclient *c)
 196 {
 197         GList *list;
 198
 199         assert(mode == LIST_ALBUMS);
 200         assert(artist != NULL);
 201         assert(album == NULL);
 202         assert(album_list == NULL);
 203         assert(browser.filelist == NULL);
 204
 205         list = mpdclient_get_albums(c, artist);
 206         /* sort list */
 207         list = g_list_sort(list, compare_utf8);
 208
 209         album_list = g_list_to_ptr_array(list);
 210 }
 211
 212 static void
 213 load_song_list(struct mpdclient *c)
 214 {
 215         assert(mode == LIST_SONGS);
 216         assert(artist != NULL);
 217         assert(album != NULL);
 218         assert(browser.filelist == NULL);
 219
 220         if (album[0] == 0)
 221                 browser.filelist =
 222                         mpdclient_filelist_search(c, TRUE,
 223                                                   MPD_TABLE_ARTIST,
 224                                                   artist);
 225         else
 226                 browser.filelist =
 227                         mpdclient_filelist_search(c, TRUE,
 228                                                   MPD_TABLE_ALBUM,
 229                                                   album);
 230         if (browser.filelist == NULL)
 231                 browser.filelist = filelist_new(NULL);
 232
 233         /* add a dummy entry for ".." */
 234         filelist_prepend(browser.filelist, NULL);
 235
 236 #ifndef NCMPC_MINI
 237         /* install playlist callback and fix highlights */
 238         sync_highlights(c, browser.filelist);
 239         mpdclient_install_playlist_callback(c, playlist_changed_callback);
 240 #endif
 241 }
 242
 243 static void
 244 free_state(struct mpdclient *c)
 245 {
 246         g_free(artist);
 247         g_free(album);
 248         artist = NULL;
 249         album = NULL;
 250
 251         free_lists(c);
 252 }
 253
 254 static void
 255 open_artist_list(struct mpdclient *c)
 256 {
 257         free_state(c);
 258
 259         mode = LIST_ARTISTS;
 260         load_artist_list(c);
 261 }
 262
 263 static void
 264 open_album_list(struct mpdclient *c, char *_artist)
 265 {
 266         assert(_artist != NULL);
 267
 268         free_state(c);
 269
 270         mode = LIST_ALBUMS;
 271         artist = _artist;
 272         load_album_list(c);
 273 }
 274
 275 static void
 276 open_song_list(struct mpdclient *c, char *_artist, char *_album)
 277 {
 278         assert(_artist != NULL);
 279         assert(_album != NULL);
 280
 281         free_state(c);
 282
 283         mode = LIST_SONGS;
 284         artist = _artist;
 285         album = _album;
 286         load_song_list(c);
 287 }
 288
 289 static void
 290 reload_lists(struct mpdclient *c)
 291 {
 292         free_lists(c);
 293
 294         switch (mode) {
 295         case LIST_ARTISTS:
 296                 load_artist_list(c);
 297                 break;
 298
 299         case LIST_ALBUMS:
 300                 load_album_list(c);
 301                 break;
 302
 303         case LIST_SONGS:
 304                 load_song_list(c);
 305                 break;
 306         }
 307 }
 308
 309 /* db updated */
 310 static void
 311 browse_callback(mpdclient_t *c, int event, G_GNUC_UNUSED gpointer data)
 312 {
 313         switch(event) {
 314         case BROWSE_DB_UPDATED:
 315                 reload_lists(c);
 316                 break;
 317         default:
 318                 break;
 319         }
 320
 321         artist_repaint_if_active();
 322 }
 323
 324 static void
 325 init(WINDOW *w, int cols, int rows)
 326 {
 327         browser.lw = list_window_init(w, cols, rows);
 328         artist = NULL;
 329         album = NULL;
 330 }
 331
 332 static void
 333 quit(void)
 334 {
 335         free_state(NULL);
 336         list_window_free(browser.lw);
 337 }
 338
 339 static void
 340 open(mpdclient_t *c)
 341 {
 342         static gboolean callback_installed = FALSE;
 343
 344         if (artist_list == NULL && album_list == NULL &&
 345             browser.filelist == NULL)
 346                 reload_lists(c);
 347         if (!callback_installed) {
 348                 mpdclient_install_browse_callback(c, browse_callback);
 349                 callback_installed = TRUE;
 350         }
 351 }
 352
 353 static void
 354 resize(int cols, int rows)
 355 {
 356         browser.lw->cols = cols;
 357         browser.lw->rows = rows;
 358 }
 359
 360 static void
 361 paint(void)
 362 {
 363         if (browser.filelist) {
 364                 list_window_paint(browser.lw, browser_lw_callback,
 365                                   browser.filelist);
 366         } else if (album_list != NULL)
 367                 list_window_paint(browser.lw, artist_lw_callback, album_list);
 368         else if (artist_list != NULL)
 369                 list_window_paint(browser.lw, artist_lw_callback, artist_list);
 370         else {
 371                 wmove(browser.lw->w, 0, 0);
 372                 wclrtobot(browser.lw->w);
 373         }
 374 }
 375
 376 static const char *
 377 get_title(char *str, size_t size)
 378 {
 379         char *s1, *s2;
 380
 381         switch(mode) {
 382         case LIST_ARTISTS:
 383                 g_snprintf(str, size, _("All artists"));
 384                 break;
 385
 386         case LIST_ALBUMS:
 387                 s1 = utf8_to_locale(artist);
 388                 g_snprintf(str, size, _("Albums of artist: %s"), s1);
 389                 g_free(s1);
 390                 break;
 391
 392         case LIST_SONGS:
 393                 s1 = utf8_to_locale(artist);
 394                 if (*album != 0) {
 395                         s2 = utf8_to_locale(album);
 396                         g_snprintf(str, size,
 397                                    _("Album: %s - %s"), s1, s2);
 398                         g_free(s2);
 399                 } else
 400                         g_snprintf(str, size,
 401                                    _("All tracks of artist: %s"), s1);
 402                 g_free(s1);
 403                 break;
 404         }
 405
 406         return str;
 407 }
 408
 409 static void
 410 add_query(mpdclient_t *c, int table, char *_filter)
 411 {
 412         char *str;
 413         mpdclient_filelist_t *addlist;
 414
 415         assert(filter != NULL);
 416
 417         str = utf8_to_locale(_filter);
 418         if (table== MPD_TABLE_ALBUM)
 419                 screen_status_printf("Adding album %s...", str);
 420         else
 421                 screen_status_printf("Adding %s...", str);
 422         g_free(str);
 423
 424         addlist = mpdclient_filelist_search(c, TRUE, table, _filter);
 425         if (addlist) {
 426                 mpdclient_filelist_add_all(c, addlist);
 427                 filelist_free(addlist);
 428         }
 429 }
 430
 431 static unsigned
 432 metalist_length(void)
 433 {
 434         assert(mode != LIST_ARTISTS || artist_list != NULL);
 435         assert(mode != LIST_ALBUMS || album_list != NULL);
 436
 437         return mode == LIST_ALBUMS
 438                 ? album_list->len + 2
 439                 : artist_list->len;
 440 }
 441
 442 static int
 443 artist_lw_cmd(struct mpdclient *c, command_t cmd)
 444 {
 445         switch (mode) {
 446         case LIST_ARTISTS:
 447         case LIST_ALBUMS:
 448                 return list_window_cmd(browser.lw, metalist_length(), cmd);
 449
 450         case LIST_SONGS:
 451                 return browser_cmd(&browser, c, cmd);
 452         }
 453
 454         assert(0);
 455         return 0;
 456 }
 457
 458 static int
 459 string_array_find(GPtrArray *array, const char *value)
 460 {
 461         guint i;
 462
 463         for (i = 0; i < array->len; ++i)
 464                 if (strcmp((const char*)g_ptr_array_index(array, i),
 465                            value) == 0)
 466                         return i;
 467
 468         return -1;
 469 }
 470
 471 static bool
 472 artist_cmd(mpdclient_t *c, command_t cmd)
 473 {
 474         char *selected;
 475         char *old;
 476         int idx;
 477
 478         switch(cmd) {
 479         case CMD_PLAY:
 480                 switch (mode) {
 481                 case LIST_ARTISTS:
 482                         selected = g_ptr_array_index(artist_list,
 483                                                      browser.lw->selected);
 484                         open_album_list(c, g_strdup(selected));
 485                         list_window_reset(browser.lw);
 486
 487                         artist_repaint();
 488                         return true;
 489
 490                 case LIST_ALBUMS:
 491                         if (browser.lw->selected == 0) {
 492                                 /* handle ".." */
 493                                 old = g_strdup(artist);
 494
 495                                 open_artist_list(c);
 496                                 list_window_reset(browser.lw);
 497                                 /* restore previous list window state */
 498                                 idx = string_array_find(artist_list, old);
 499                                 g_free(old);
 500
 501                                 if (idx >= 0) {
 502                                         list_window_set_selected(browser.lw, idx);
 503                                         list_window_center(browser.lw,
 504                                                            artist_list->len, idx);
 505                                 }
 506                         } else if (browser.lw->selected == album_list->len + 1) {
 507                                 /* handle "show all" */
 508                                 open_song_list(c, g_strdup(artist), g_strdup("\0"));
 509                                 list_window_reset(browser.lw);
 510                         } else {
 511                                 /* select album */
 512                                 selected = g_ptr_array_index(album_list,
 513                                                              browser.lw->selected - 1);
 514                                 open_song_list(c, g_strdup(artist), g_strdup(selected));
 515                                 list_window_reset(browser.lw);
 516                         }
 517
 518                         artist_repaint();
 519                         return true;
 520
 521                 case LIST_SONGS:
 522                         if (browser.lw->selected == 0) {
 523                                 /* handle ".." */
 524                                 old = g_strdup(album);
 525
 526                                 open_album_list(c, g_strdup(artist));
 527                                 list_window_reset(browser.lw);
 528                                 /* restore previous list window state */
 529                                 idx = *old == 0
 530                                         ? (int)album_list->len
 531                                         : string_array_find(album_list, old);
 532                                 g_free(old);
 533
 534                                 if (idx >= 0) {
 535                                         ++idx;
 536                                         list_window_set_selected(browser.lw, idx);
 537                                         list_window_center(browser.lw,
 538                                                            album_list->len, idx);
 539                                 }
 540
 541                                 artist_repaint();
 542                                 return true;
 543                         }
 544                         break;
 545                 }
 546                 break;
 547
 548                 /* FIXME? CMD_GO_* handling duplicates code from CMD_PLAY */
 549
 550         case CMD_GO_PARENT_DIRECTORY:
 551                 switch (mode) {
 552                 case LIST_ARTISTS:
 553                         break;
 554
 555                 case LIST_ALBUMS:
 556                         old = g_strdup(artist);
 557
 558                         open_artist_list(c);
 559                         list_window_reset(browser.lw);
 560                         /* restore previous list window state */
 561                         idx = string_array_find(artist_list, old);
 562                         g_free(old);
 563
 564                         if (idx >= 0) {
 565                                 list_window_set_selected(browser.lw, idx);
 566                                 list_window_center(browser.lw,
 567                                                    artist_list->len, idx);
 568                         }
 569                         break;
 570
 571                 case LIST_SONGS:
 572                         old = g_strdup(album);
 573
 574                         open_album_list(c, g_strdup(artist));
 575                         list_window_reset(browser.lw);
 576                         /* restore previous list window state */
 577                         idx = *old == 0
 578                                 ? (int)album_list->len
 579                                 : string_array_find(album_list, old);
 580                         g_free(old);
 581
 582                         if (idx >= 0) {
 583                                 ++idx;
 584                                 list_window_set_selected(browser.lw, idx);
 585                                 list_window_center(browser.lw,
 586                                                    album_list->len, idx);
 587                         }
 588                         break;
 589                 }
 590
 591                 artist_repaint();
 592                 break;
 593
 594         case CMD_GO_ROOT_DIRECTORY:
 595                 switch (mode) {
 596                 case LIST_ARTISTS:
 597                         break;
 598
 599                 case LIST_ALBUMS:
 600                 case LIST_SONGS:
 601                         open_artist_list(c);
 602                         list_window_reset(browser.lw);
 603                         /* restore first list window state (pop while returning true) */
 604                         /* XXX */
 605                         break;
 606                 }
 607
 608                 artist_repaint();
 609                 break;
 610
 611         case CMD_SELECT:
 612         case CMD_ADD:
 613                 switch(mode) {
 614                 case LIST_ARTISTS:
 615                 {
 616                         unsigned i;
 617                         for(i = browser.lw->selected_start; i <= browser.lw->selected_end; ++i)
 618                         {
 619                                 selected = g_ptr_array_index(artist_list, i);
 620                                 add_query(c, MPD_TABLE_ARTIST, selected);
 621                                 cmd = CMD_LIST_NEXT; /* continue and select next item... */
 622                         }
 623                         break;
 624                 }
 625                 case LIST_ALBUMS:
 626                 {
 627                         unsigned i;
 628                         for(i = browser.lw->selected_start; i <= browser.lw->selected_end; ++i)
 629                         {
 630                                 if(i == album_list->len + 1)
 631                                         add_query(c, MPD_TABLE_ARTIST, artist);
 632                                 else if (i > 0)
 633                                 {
 634                                         selected = g_ptr_array_index(album_list,
 635                                                                      browser.lw->selected - 1);
 636                                         add_query(c, MPD_TABLE_ALBUM, selected);
 637                                         cmd = CMD_LIST_NEXT; /* continue and select next item... */
 638                                 }
 639                         }
 640                         break;
 641                 }
 642
 643                 case LIST_SONGS:
 644                         /* handled by browser_cmd() */
 645                         break;
 646                 }
 647                 break;
 648
 649                 /* continue and update... */
 650         case CMD_SCREEN_UPDATE:
 651                 reload_lists(c);
 652                 return false;
 653
 654         case CMD_LIST_FIND:
 655         case CMD_LIST_RFIND:
 656         case CMD_LIST_FIND_NEXT:
 657         case CMD_LIST_RFIND_NEXT:
 658                 switch (mode) {
 659                 case LIST_ARTISTS:
 660                         screen_find(browser.lw, artist_list->len,
 661                                     cmd, artist_lw_callback, artist_list);
 662                         artist_repaint();
 663                         return true;
 664
 665                 case LIST_ALBUMS:
 666                         screen_find(browser.lw, album_list->len + 2,
 667                                     cmd, artist_lw_callback, album_list);
 668                         artist_repaint();
 669                         return true;
 670
 671                 case LIST_SONGS:
 672                         /* handled by browser_cmd() */
 673                         break;
 674                 }
 675
 676                 break;
 677
 678         default:
 679                 break;
 680         }
 681
 682         if (artist_lw_cmd(c, cmd)) {
 683                 if (screen_is_visible(&screen_artist))
 684                         artist_repaint();
 685                 return true;
 686         }
 687
 688         return false;
 689 }
 690
 691 const struct screen_functions screen_artist = {
 692         .init = init,
 693         .exit = quit,
 694         .open = open,
 695         .resize = resize,
 696         .paint = paint,
 697         .cmd = artist_cmd,
 698         .get_title = get_title,
 699 };