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 "screen_artist.h"
  21 #include "screen_interface.h"
  22 #include "screen_message.h"
  23 #include "screen_find.h"
  24 #include "screen_browser.h"
  25 #include "screen.h"
  26 #include "i18n.h"
  27 #include "charset.h"
  28 #include "mpdclient.h"
  29 #include "screen_browser.h"
  30 #include "filelist.h"
  31
  32 #include <assert.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         const char *const*t1 = s1, *const*t2 = s2;
  51         char *key1, *key2;
  52         int n;
  53
  54         key1 = g_utf8_collate_key(*t1,-1);
  55         key2 = g_utf8_collate_key(*t2,-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 screen_artist_lw_callback(unsigned idx, 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                         return _("All tracks");
  75
  76                 --idx;
  77         }
  78
  79         assert(idx < list->len);
  80
  81         str_utf8 = g_ptr_array_index(list, idx);
  82         assert(str_utf8 != NULL);
  83
  84         str = utf8_to_locale(str_utf8);
  85         g_strlcpy(buf, str, sizeof(buf));
  86         g_free(str);
  87
  88         return buf;
  89 }
  90
  91 static void
  92 screen_artist_paint(void);
  93
  94 static void
  95 artist_repaint(void)
  96 {
  97         screen_artist_paint();
  98         wrefresh(browser.lw->w);
  99 }
 100
 101 static void
 102 string_array_free(GPtrArray *array)
 103 {
 104         unsigned i;
 105
 106         for (i = 0; i < array->len; ++i) {
 107                 char *value = g_ptr_array_index(array, i);
 108                 g_free(value);
 109         }
 110
 111         g_ptr_array_free(array, TRUE);
 112 }
 113
 114 static void
 115 free_lists(void)
 116 {
 117         if (artist_list != NULL) {
 118                 string_array_free(artist_list);
 119                 artist_list = NULL;
 120         }
 121
 122         if (album_list != NULL) {
 123                 string_array_free(album_list);
 124                 album_list = NULL;
 125         }
 126
 127         if (browser.filelist) {
 128                 filelist_free(browser.filelist);
 129                 browser.filelist = NULL;
 130         }
 131 }
 132
 133 static void
 134 recv_tag_values(struct mpd_connection *connection, enum mpd_tag_type tag,
 135                 GPtrArray *list)
 136 {
 137         struct mpd_pair *pair;
 138
 139         while ((pair = mpd_recv_pair_tag(connection, tag)) != NULL) {
 140                 g_ptr_array_add(list, g_strdup(pair->value));
 141                 mpd_return_pair(connection, pair);
 142         }
 143 }
 144
 145 static void
 146 load_artist_list(struct mpdclient *c)
 147 {
 148         struct mpd_connection *connection = mpdclient_get_connection(c);
 149
 150         assert(mode == LIST_ARTISTS);
 151         assert(artist == NULL);
 152         assert(album == NULL);
 153         assert(artist_list == NULL);
 154         assert(album_list == NULL);
 155         assert(browser.filelist == NULL);
 156
 157         artist_list = g_ptr_array_new();
 158
 159         if (connection != NULL) {
 160                 mpd_search_db_tags(connection, MPD_TAG_ARTIST);
 161                 mpd_search_commit(connection);
 162                 recv_tag_values(connection, MPD_TAG_ARTIST, artist_list);
 163
 164                 if (!mpd_response_finish(connection))
 165                         mpdclient_handle_error(c);
 166         }
 167
 168         /* sort list */
 169         g_ptr_array_sort(artist_list, compare_utf8);
 170         list_window_set_length(browser.lw, artist_list->len);
 171 }
 172
 173 static void
 174 load_album_list(struct mpdclient *c)
 175 {
 176         struct mpd_connection *connection = mpdclient_get_connection(c);
 177
 178         assert(mode == LIST_ALBUMS);
 179         assert(artist != NULL);
 180         assert(album == NULL);
 181         assert(album_list == NULL);
 182         assert(browser.filelist == NULL);
 183
 184         album_list = g_ptr_array_new();
 185
 186         if (connection != NULL) {
 187                 mpd_search_db_tags(connection, MPD_TAG_ALBUM);
 188                 mpd_search_add_tag_constraint(connection,
 189                                               MPD_OPERATOR_DEFAULT,
 190                                               MPD_TAG_ARTIST, artist);
 191                 mpd_search_commit(connection);
 192
 193                 recv_tag_values(connection, MPD_TAG_ALBUM, album_list);
 194
 195                 if (!mpd_response_finish(connection))
 196                         mpdclient_handle_error(c);
 197         }
 198
 199         /* sort list */
 200         g_ptr_array_sort(album_list, compare_utf8);
 201
 202         list_window_set_length(browser.lw, album_list->len + 2);
 203 }
 204
 205 static void
 206 load_song_list(struct mpdclient *c)
 207 {
 208         struct mpd_connection *connection = mpdclient_get_connection(c);
 209
 210         assert(mode == LIST_SONGS);
 211         assert(artist != NULL);
 212         assert(album != NULL);
 213         assert(browser.filelist == NULL);
 214
 215         browser.filelist = filelist_new();
 216         /* add a dummy entry for ".." */
 217         filelist_append(browser.filelist, NULL);
 218
 219         if (connection != NULL) {
 220                 mpd_search_db_songs(connection, true);
 221                 mpd_search_add_tag_constraint(connection, MPD_OPERATOR_DEFAULT,
 222                                               MPD_TAG_ARTIST, artist);
 223                 if (album[0] != 0)
 224                         mpd_search_add_tag_constraint(connection, MPD_OPERATOR_DEFAULT,
 225                                                       MPD_TAG_ALBUM, album);
 226                 mpd_search_commit(connection);
 227
 228                 filelist_recv(browser.filelist, connection);
 229
 230                 if (!mpd_response_finish(connection))
 231                         mpdclient_handle_error(c);
 232         }
 233
 234         /* fix highlights */
 235         screen_browser_sync_highlights(browser.filelist, &c->playlist);
 236         list_window_set_length(browser.lw, filelist_length(browser.filelist));
 237 }
 238
 239 static void
 240 free_state(void)
 241 {
 242         g_free(artist);
 243         g_free(album);
 244         artist = NULL;
 245         album = NULL;
 246
 247         free_lists();
 248 }
 249
 250 static void
 251 open_artist_list(struct mpdclient *c)
 252 {
 253         free_state();
 254
 255         mode = LIST_ARTISTS;
 256         load_artist_list(c);
 257 }
 258
 259 static void
 260 open_album_list(struct mpdclient *c, char *_artist)
 261 {
 262         assert(_artist != NULL);
 263
 264         free_state();
 265
 266         mode = LIST_ALBUMS;
 267         artist = _artist;
 268         load_album_list(c);
 269 }
 270
 271 static void
 272 open_song_list(struct mpdclient *c, char *_artist, char *_album)
 273 {
 274         assert(_artist != NULL);
 275         assert(_album != NULL);
 276
 277         free_state();
 278
 279         mode = LIST_SONGS;
 280         artist = _artist;
 281         album = _album;
 282         load_song_list(c);
 283 }
 284
 285 static void
 286 reload_lists(struct mpdclient *c)
 287 {
 288         free_lists();
 289
 290         switch (mode) {
 291         case LIST_ARTISTS:
 292                 load_artist_list(c);
 293                 break;
 294
 295         case LIST_ALBUMS:
 296                 load_album_list(c);
 297                 break;
 298
 299         case LIST_SONGS:
 300                 load_song_list(c);
 301                 break;
 302         }
 303 }
 304
 305 static void
 306 screen_artist_init(WINDOW *w, int cols, int rows)
 307 {
 308         browser.lw = list_window_init(w, cols, rows);
 309         artist = NULL;
 310         album = NULL;
 311 }
 312
 313 static void
 314 screen_artist_quit(void)
 315 {
 316         free_state();
 317         list_window_free(browser.lw);
 318 }
 319
 320 static void
 321 screen_artist_open(struct mpdclient *c)
 322 {
 323         if (artist_list == NULL && album_list == NULL &&
 324             browser.filelist == NULL)
 325                 reload_lists(c);
 326 }
 327
 328 static void
 329 screen_artist_resize(int cols, int rows)
 330 {
 331         list_window_resize(browser.lw, cols, rows);
 332 }
 333
 334 /**
 335  * Paint one item in the artist list.
 336  */
 337 static void
 338 paint_artist_callback(WINDOW *w, unsigned i,
 339                       G_GNUC_UNUSED unsigned y, unsigned width,
 340                       bool selected, void *data)
 341 {
 342         GPtrArray *list = data;
 343         char *p = utf8_to_locale(g_ptr_array_index(list, i));
 344
 345         screen_browser_paint_directory(w, width, selected, p);
 346         g_free(p);
 347 }
 348
 349 /**
 350  * Paint one item in the album list.  There are two virtual items
 351  * inserted: at the beginning, there's the special item ".." to go to
 352  * the parent directory, and at the end, there's the item "All tracks"
 353  * to view the tracks of all albums.
 354  */
 355 static void
 356 paint_album_callback(WINDOW *w, unsigned i,
 357                      G_GNUC_UNUSED unsigned y, unsigned width,
 358                      bool selected, void *data)
 359 {
 360         GPtrArray *list = data;
 361         const char *p;
 362         char *q = NULL;
 363
 364         if (i == 0)
 365                 p = "..";
 366         else if (i == list->len + 1)
 367                 p = _("All tracks");
 368         else
 369                 p = q = utf8_to_locale(g_ptr_array_index(list, i - 1));
 370
 371         screen_browser_paint_directory(w, width, selected, p);
 372         g_free(q);
 373 }
 374
 375 static void
 376 screen_artist_paint(void)
 377 {
 378         if (browser.filelist) {
 379                 screen_browser_paint(&browser);
 380         } else if (album_list != NULL)
 381                 list_window_paint2(browser.lw,
 382                                    paint_album_callback, album_list);
 383         else if (artist_list != NULL)
 384                 list_window_paint2(browser.lw,
 385                                    paint_artist_callback, artist_list);
 386         else {
 387                 wmove(browser.lw->w, 0, 0);
 388                 wclrtobot(browser.lw->w);
 389         }
 390 }
 391
 392 static const char *
 393 screen_artist_get_title(char *str, size_t size)
 394 {
 395         char *s1, *s2;
 396
 397         switch(mode) {
 398         case LIST_ARTISTS:
 399                 g_snprintf(str, size, _("All artists"));
 400                 break;
 401
 402         case LIST_ALBUMS:
 403                 s1 = utf8_to_locale(artist);
 404                 g_snprintf(str, size, _("Albums of artist: %s"), s1);
 405                 g_free(s1);
 406                 break;
 407
 408         case LIST_SONGS:
 409                 s1 = utf8_to_locale(artist);
 410                 if (*album != 0) {
 411                         s2 = utf8_to_locale(album);
 412                         g_snprintf(str, size,
 413                                    _("Album: %s - %s"), s1, s2);
 414                         g_free(s2);
 415                 } else
 416                         g_snprintf(str, size,
 417                                    _("All tracks of artist: %s"), s1);
 418                 g_free(s1);
 419                 break;
 420         }
 421
 422         return str;
 423 }
 424
 425 static void
 426 screen_artist_update(struct mpdclient *c)
 427 {
 428         if (browser.filelist == NULL)
 429                 return;
 430
 431         if (c->events & MPD_IDLE_DATABASE)
 432                 /* the db has changed -> update the list */
 433                 reload_lists(c);
 434
 435         if (c->events & (MPD_IDLE_DATABASE | MPD_IDLE_QUEUE))
 436                 screen_browser_sync_highlights(browser.filelist, &c->playlist);
 437
 438         if (c->events & (MPD_IDLE_DATABASE
 439 #ifndef NCMPC_MINI
 440                          | MPD_IDLE_QUEUE
 441 #endif
 442                          ))
 443                 artist_repaint();
 444 }
 445
 446 static void
 447 add_query(struct mpdclient *c, enum mpd_tag_type table, char *_filter)
 448 {
 449         struct mpd_connection *connection = mpdclient_get_connection(c);
 450         char *str;
 451         struct filelist *addlist;
 452
 453         assert(filter != NULL);
 454
 455         if (connection == NULL)
 456                 return;
 457
 458         str = utf8_to_locale(_filter);
 459         if (table == MPD_TAG_ALBUM)
 460                 screen_status_printf("Adding album %s...", str);
 461         else
 462                 screen_status_printf("Adding %s...", str);
 463         g_free(str);
 464
 465         mpd_search_db_songs(connection, true);
 466         mpd_search_add_tag_constraint(connection, MPD_OPERATOR_DEFAULT,
 467                                       table, _filter);
 468         mpd_search_commit(connection);
 469
 470         addlist = filelist_new_recv(connection);
 471
 472         if (mpd_response_finish(connection))
 473                 mpdclient_filelist_add_all(c, addlist);
 474         else
 475                 mpdclient_handle_error(c);
 476
 477         filelist_free(addlist);
 478 }
 479
 480 static int
 481 screen_artist_lw_cmd(struct mpdclient *c, command_t cmd)
 482 {
 483         switch (mode) {
 484         case LIST_ARTISTS:
 485         case LIST_ALBUMS:
 486                 return list_window_cmd(browser.lw, cmd);
 487
 488         case LIST_SONGS:
 489                 return browser_cmd(&browser, c, cmd);
 490         }
 491
 492         assert(0);
 493         return 0;
 494 }
 495
 496 static int
 497 string_array_find(GPtrArray *array, const char *value)
 498 {
 499         guint i;
 500
 501         for (i = 0; i < array->len; ++i)
 502                 if (strcmp((const char*)g_ptr_array_index(array, i),
 503                            value) == 0)
 504                         return i;
 505
 506         return -1;
 507 }
 508
 509 static bool
 510 screen_artist_cmd(struct mpdclient *c, command_t cmd)
 511 {
 512         struct list_window_range range;
 513         char *selected;
 514         char *old;
 515         int idx;
 516
 517         switch(cmd) {
 518         case CMD_PLAY:
 519                 switch (mode) {
 520                 case LIST_ARTISTS:
 521                         if (browser.lw->selected >= artist_list->len)
 522                                 return true;
 523
 524                         selected = g_ptr_array_index(artist_list,
 525                                                      browser.lw->selected);
 526                         open_album_list(c, g_strdup(selected));
 527                         list_window_reset(browser.lw);
 528
 529                         artist_repaint();
 530                         return true;
 531
 532                 case LIST_ALBUMS:
 533                         if (browser.lw->selected == 0) {
 534                                 /* handle ".." */
 535                                 old = g_strdup(artist);
 536
 537                                 open_artist_list(c);
 538                                 list_window_reset(browser.lw);
 539                                 /* restore previous list window state */
 540                                 idx = string_array_find(artist_list, old);
 541                                 g_free(old);
 542
 543                                 if (idx >= 0) {
 544                                         list_window_set_cursor(browser.lw, idx);
 545                                         list_window_center(browser.lw, idx);
 546                                 }
 547                         } else if (browser.lw->selected == album_list->len + 1) {
 548                                 /* handle "show all" */
 549                                 open_song_list(c, g_strdup(artist), g_strdup("\0"));
 550                                 list_window_reset(browser.lw);
 551                         } else {
 552                                 /* select album */
 553                                 selected = g_ptr_array_index(album_list,
 554                                                              browser.lw->selected - 1);
 555                                 open_song_list(c, g_strdup(artist), g_strdup(selected));
 556                                 list_window_reset(browser.lw);
 557                         }
 558
 559                         artist_repaint();
 560                         return true;
 561
 562                 case LIST_SONGS:
 563                         if (browser.lw->selected == 0) {
 564                                 /* handle ".." */
 565                                 old = g_strdup(album);
 566
 567                                 open_album_list(c, g_strdup(artist));
 568                                 list_window_reset(browser.lw);
 569                                 /* restore previous list window state */
 570                                 idx = *old == 0
 571                                         ? (int)album_list->len
 572                                         : string_array_find(album_list, old);
 573                                 g_free(old);
 574
 575                                 if (idx >= 0) {
 576                                         ++idx;
 577                                         list_window_set_cursor(browser.lw, idx);
 578                                         list_window_center(browser.lw, idx);
 579                                 }
 580
 581                                 artist_repaint();
 582                                 return true;
 583                         }
 584                         break;
 585                 }
 586                 break;
 587
 588                 /* FIXME? CMD_GO_* handling duplicates code from CMD_PLAY */
 589
 590         case CMD_GO_PARENT_DIRECTORY:
 591                 switch (mode) {
 592                 case LIST_ARTISTS:
 593                         break;
 594
 595                 case LIST_ALBUMS:
 596                         old = g_strdup(artist);
 597
 598                         open_artist_list(c);
 599                         list_window_reset(browser.lw);
 600                         /* restore previous list window state */
 601                         idx = string_array_find(artist_list, old);
 602                         g_free(old);
 603
 604                         if (idx >= 0) {
 605                                 list_window_set_cursor(browser.lw, idx);
 606                                 list_window_center(browser.lw, idx);
 607                         }
 608                         break;
 609
 610                 case LIST_SONGS:
 611                         old = g_strdup(album);
 612
 613                         open_album_list(c, g_strdup(artist));
 614                         list_window_reset(browser.lw);
 615                         /* restore previous list window state */
 616                         idx = *old == 0
 617                                 ? (int)album_list->len
 618                                 : string_array_find(album_list, old);
 619                         g_free(old);
 620
 621                         if (idx >= 0) {
 622                                 ++idx;
 623                                 list_window_set_cursor(browser.lw, idx);
 624                                 list_window_center(browser.lw, idx);
 625                         }
 626                         break;
 627                 }
 628
 629                 artist_repaint();
 630                 break;
 631
 632         case CMD_GO_ROOT_DIRECTORY:
 633                 switch (mode) {
 634                 case LIST_ARTISTS:
 635                         break;
 636
 637                 case LIST_ALBUMS:
 638                 case LIST_SONGS:
 639                         open_artist_list(c);
 640                         list_window_reset(browser.lw);
 641                         /* restore first list window state (pop while returning true) */
 642                         /* XXX */
 643                         break;
 644                 }
 645
 646                 artist_repaint();
 647                 break;
 648
 649         case CMD_SELECT:
 650         case CMD_ADD:
 651                 switch(mode) {
 652                 case LIST_ARTISTS:
 653                         if (browser.lw->selected >= artist_list->len)
 654                                 return true;
 655
 656                         list_window_get_range(browser.lw, &range);
 657                         for (unsigned i = range.start; i < range.end; ++i) {
 658                                 selected = g_ptr_array_index(artist_list, i);
 659                                 add_query(c, MPD_TAG_ARTIST, selected);
 660                                 cmd = CMD_LIST_NEXT; /* continue and select next item... */
 661                         }
 662                         break;
 663
 664                 case LIST_ALBUMS:
 665                         list_window_get_range(browser.lw, &range);
 666                         for (unsigned i = range.start; i < range.end; ++i) {
 667                                 if(i == album_list->len + 1)
 668                                         add_query(c, MPD_TAG_ARTIST, artist);
 669                                 else if (i > 0)
 670                                 {
 671                                         selected = g_ptr_array_index(album_list,
 672                                                                      browser.lw->selected - 1);
 673                                         add_query(c, MPD_TAG_ALBUM, selected);
 674                                         cmd = CMD_LIST_NEXT; /* continue and select next item... */
 675                                 }
 676                         }
 677                         break;
 678
 679                 case LIST_SONGS:
 680                         /* handled by browser_cmd() */
 681                         break;
 682                 }
 683                 break;
 684
 685                 /* continue and update... */
 686         case CMD_SCREEN_UPDATE:
 687                 reload_lists(c);
 688                 return false;
 689
 690         case CMD_LIST_FIND:
 691         case CMD_LIST_RFIND:
 692         case CMD_LIST_FIND_NEXT:
 693         case CMD_LIST_RFIND_NEXT:
 694                 switch (mode) {
 695                 case LIST_ARTISTS:
 696                         screen_find(browser.lw, cmd,
 697                                     screen_artist_lw_callback, artist_list);
 698                         artist_repaint();
 699                         return true;
 700
 701                 case LIST_ALBUMS:
 702                         screen_find(browser.lw, cmd,
 703                                     screen_artist_lw_callback, album_list);
 704                         artist_repaint();
 705                         return true;
 706
 707                 case LIST_SONGS:
 708                         /* handled by browser_cmd() */
 709                         break;
 710                 }
 711         case CMD_LIST_JUMP:
 712                 switch (mode) {
 713                 case LIST_ARTISTS:
 714                         screen_jump(browser.lw, screen_artist_lw_callback,
 715                                     paint_artist_callback, artist_list);
 716                         artist_repaint();
 717                         return true;
 718
 719                 case LIST_ALBUMS:
 720                         screen_jump(browser.lw, screen_artist_lw_callback,
 721                                     paint_album_callback, album_list);
 722                         artist_repaint();
 723                         return true;
 724
 725                 case LIST_SONGS:
 726                         /* handled by browser_cmd() */
 727                         break;
 728                 }
 729
 730                 break;
 731
 732         default:
 733                 break;
 734         }
 735
 736         if (screen_artist_lw_cmd(c, cmd)) {
 737                 if (screen_is_visible(&screen_artist))
 738                         artist_repaint();
 739                 return true;
 740         }
 741
 742         return false;
 743 }
 744
 745 const struct screen_functions screen_artist = {
 746         .init = screen_artist_init,
 747         .exit = screen_artist_quit,
 748         .open = screen_artist_open,
 749         .resize = screen_artist_resize,
 750         .paint = screen_artist_paint,
 751         .update = screen_artist_update,
 752         .cmd = screen_artist_cmd,
 753         .get_title = screen_artist_get_title,
 754 };