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