src/screen_artist.c

   1 /*
   2  * $Id$
   3  *
   4  * (c) 2005 by Kalle Wallin <kaw@linux.se>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include "config.h"
  22
  23 #ifndef DISABLE_ARTIST_SCREEN
  24 #include "ncmpc.h"
  25 #include "options.h"
  26 #include "support.h"
  27 #include "mpdclient.h"
  28 #include "utils.h"
  29 #include "strfsong.h"
  30 #include "command.h"
  31 #include "screen.h"
  32 #include "screen_utils.h"
  33 #include "screen_browse.h"
  34
  35 #include <ctype.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <glib.h>
  39 #include <ncurses.h>
  40
  41 #define BUFSIZE 1024
  42
  43 typedef enum { LIST_ARTISTS, LIST_ALBUMS, LIST_SONGS } artist_mode_t;
  44
  45 static artist_mode_t mode = LIST_ARTISTS;
  46 static char *artist = NULL;
  47 static char *album  = NULL;
  48 static list_window_t *lw = NULL;
  49 static mpdclient_filelist_t *filelist = NULL;
  50 static int metalist_length = 0;
  51 static GList *metalist = NULL;
  52 static list_window_state_t *lw_state = NULL;
  53
  54 static gint
  55 compare_utf8(gconstpointer s1, gconstpointer s2)
  56 {
  57   char *key1, *key2;
  58   int n;
  59
  60   key1 = g_utf8_collate_key(s1,-1);
  61   key2 = g_utf8_collate_key(s2,-1);
  62   n = strcmp(key1,key2);
  63   g_free(key1);
  64   g_free(key2);
  65   return n;
  66 }
  67
  68 /* list_window callback */
  69 static char *
  70 artist_lw_callback(int index, int *highlight, void *data)
  71 {
  72   static char buf[BUFSIZE];
  73   char *str, *str_utf8;
  74
  75   *highlight = 0;
  76   if( (str_utf8=(char *) g_list_nth_data(metalist,index))==NULL )
  77     return NULL;
  78
  79   str = utf8_to_locale(str_utf8);
  80   g_snprintf(buf, BUFSIZE, "[%s]", str);
  81   g_free(str);
  82
  83   return buf;
  84 }
  85
  86 /* the playlist have been updated -> fix highlights */
  87 static void
  88 playlist_changed_callback(mpdclient_t *c, int event, gpointer data)
  89 {
  90   if( filelist==NULL )
  91     return;
  92   D("screen_artist.c> playlist_callback() [%d]\n", event);
  93   switch(event)
  94     {
  95     case PLAYLIST_EVENT_CLEAR:
  96       clear_highlights(filelist);
  97       break;
  98     default:
  99       sync_highlights(c, filelist);
 100       break;
 101     }
 102 }
 103
 104 /* fetch artists/albums/songs from mpd */
 105 static void
 106 update_metalist(mpdclient_t *c, char *m_artist, char *m_album)
 107 {
 108   g_free(artist);
 109   g_free(album);
 110   artist = NULL;
 111   album = NULL;
 112   if( metalist )
 113     metalist = string_list_free(metalist);
 114   if (filelist ) {
 115     mpdclient_remove_playlist_callback(c, playlist_changed_callback);
 116     filelist = mpdclient_filelist_free(filelist);
 117   }
 118   if( m_album ) /* retreive songs... */
 119     {
 120       artist = m_artist;
 121       album = m_album;
 122       if( album[0] == 0 )
 123         {
 124           album = g_strdup(_("All tracks"));
 125           filelist = mpdclient_filelist_search_utf8(c,
 126                                                     TRUE,
 127                                                     MPD_TABLE_ARTIST,
 128                                                     artist);
 129         }
 130       else
 131         filelist = mpdclient_filelist_search_utf8(c,
 132                                                   TRUE,
 133                                                   MPD_TABLE_ALBUM,
 134                                                   album);
 135       /* add a dummy entry for ".." */
 136       filelist_entry_t *entry = g_malloc0(sizeof(filelist_entry_t));
 137       entry->entity = NULL;
 138       filelist->list = g_list_insert(filelist->list, entry, 0);
 139       filelist->length++;
 140       /* install playlist callback and fix highlights */
 141       sync_highlights(c, filelist);
 142       mpdclient_install_playlist_callback(c, playlist_changed_callback);
 143       mode = LIST_SONGS;
 144     }
 145   else if( m_artist ) /* retreive albums... */
 146     {
 147       artist = m_artist;
 148       metalist = mpdclient_get_albums_utf8(c, m_artist);
 149       /* sort list */
 150       metalist = g_list_sort(metalist, compare_utf8);
 151       /* add a dummy entry for ".." */
 152       metalist = g_list_insert(metalist, g_strdup(".."), 0);
 153       /* add a dummy entry for all songs */
 154       metalist = g_list_insert(metalist, g_strdup(_("All tracks")), -1);
 155       mode = LIST_ALBUMS;
 156     }
 157   else /* retreive artists... */
 158     {
 159       metalist = mpdclient_get_artists_utf8(c);
 160       /* sort list */
 161       metalist = g_list_sort(metalist, compare_utf8);
 162       mode = LIST_ARTISTS;
 163     }
 164   metalist_length = g_list_length(metalist);
 165   lw->clear = TRUE;
 166 }
 167
 168 /* db updated */
 169 static void
 170 browse_callback(mpdclient_t *c, int event, gpointer data)
 171 {
 172   switch(event)
 173     {
 174     case BROWSE_DB_UPDATED:
 175       D("screen_artist.c> browse_callback() [BROWSE_DB_UPDATED]\n");
 176       lw->clear = 1;
 177       lw->repaint = 1;
 178       update_metalist(c, g_strdup(artist), g_strdup(album));
 179       break;
 180     default:
 181       break;
 182     }
 183 }
 184
 185 static void
 186 init(WINDOW *w, int cols, int rows)
 187 {
 188   lw = list_window_init(w, cols, rows);
 189   lw_state = list_window_init_state();
 190   artist = NULL;
 191   album = NULL;
 192 }
 193
 194 static void
 195 quit(void)
 196 {
 197   if( filelist )
 198     filelist = mpdclient_filelist_free(filelist);
 199   if( metalist )
 200     metalist = string_list_free(metalist);
 201   g_free(artist);
 202   g_free(album);
 203   artist = NULL;
 204   album = NULL;
 205   lw = list_window_free(lw);
 206   lw_state = list_window_free_state(lw_state);
 207 }
 208
 209 static void
 210 open(screen_t *screen, mpdclient_t *c)
 211 {
 212   static gboolean callback_installed = FALSE;
 213
 214   if( metalist==NULL && filelist ==NULL)
 215     update_metalist(c, NULL, NULL);
 216   if( !callback_installed )
 217     {
 218       mpdclient_install_browse_callback(c, browse_callback);
 219       callback_installed = TRUE;
 220     }
 221 }
 222
 223 static void
 224 resize(int cols, int rows)
 225 {
 226   lw->cols = cols;
 227   lw->rows = rows;
 228 }
 229
 230 static void
 231 close(void)
 232 {
 233 }
 234
 235 static void
 236 paint(screen_t *screen, mpdclient_t *c)
 237 {
 238   lw->clear = 1;
 239
 240   if( filelist )
 241     {
 242       list_window_paint(lw, browse_lw_callback, (void *) filelist);
 243       filelist->updated = FALSE;
 244     }
 245   else if( metalist )
 246     {
 247       list_window_paint(lw, artist_lw_callback, (void *) metalist);
 248     }
 249   else
 250     {
 251       wmove(lw->w, 0, 0);
 252       wclrtobot(lw->w);
 253     }
 254   wnoutrefresh(lw->w);
 255 }
 256
 257 static void
 258 update(screen_t *screen, mpdclient_t *c)
 259 {
 260   if( filelist && !filelist->updated )
 261     {
 262       list_window_paint(lw, browse_lw_callback, (void *) filelist);
 263     }
 264   else if( metalist )
 265     {
 266       list_window_paint(lw, artist_lw_callback, (void *) metalist);
 267     }
 268   else
 269     {
 270       paint(screen, c);
 271     }
 272   wnoutrefresh(lw->w);
 273 }
 274
 275 static char *
 276 get_title(char *str, size_t size)
 277 {
 278   char *s1 = artist ? utf8_to_locale(artist) : NULL;
 279   char *s2 = album ? utf8_to_locale(album) : NULL;
 280
 281   switch(mode)
 282     {
 283     case LIST_ARTISTS:
 284       g_snprintf(str, size,  _("Artist: [db browser - EXPERIMENTAL]"));
 285       break;
 286     case LIST_ALBUMS:
 287       g_snprintf(str, size,  _("Artist: %s"), s1);
 288       break;
 289     case LIST_SONGS:
 290       g_snprintf(str, size,  _("Artist: %s - %s"), s1, s2);
 291       break;
 292     }
 293   g_free(s1);
 294   g_free(s2);
 295   return str;
 296 }
 297
 298 static list_window_t *
 299 get_filelist_window()
 300 {
 301   return lw;
 302 }
 303
 304 static void
 305 add_query(mpdclient_t *c, int table, char *filter)
 306 {
 307   char *str;
 308   mpdclient_filelist_t *addlist;
 309
 310   str = utf8_to_locale(filter);
 311   if( table== MPD_TABLE_ALBUM )
 312     screen_status_printf("Adding album %s...", str);
 313   else
 314     screen_status_printf("Adding %s...", str);
 315   g_free(str);
 316   addlist = mpdclient_filelist_search_utf8(c, TRUE, table, filter);
 317   if( addlist )
 318     {
 319       mpdclient_filelist_add_all(c, addlist);
 320       addlist = mpdclient_filelist_free(addlist);
 321     }
 322 }
 323
 324 static int
 325 artist_cmd(screen_t *screen, mpdclient_t *c, command_t cmd)
 326 {
 327   char *selected;
 328
 329   switch(cmd)
 330     {
 331     case CMD_PLAY:
 332       switch(mode)
 333         {
 334         case LIST_ARTISTS:
 335           selected = (char *) g_list_nth_data(metalist, lw->selected);
 336           update_metalist(c, g_strdup(selected), NULL);
 337           list_window_push_state(lw_state,lw);
 338           break;
 339         case LIST_ALBUMS:
 340           if( lw->selected == 0 )  /* handle ".." */
 341             {
 342               update_metalist(c, NULL, NULL);
 343               list_window_reset(lw);
 344               /* restore previous list window state */
 345               list_window_pop_state(lw_state,lw);
 346             }
 347           else if( lw->selected == metalist_length-1) /* handle "show all" */
 348             {
 349               update_metalist(c, g_strdup(artist), g_strdup("\0"));
 350               list_window_push_state(lw_state,lw);
 351             }
 352           else /* select album */
 353             {
 354               selected = (char *) g_list_nth_data(metalist, lw->selected);
 355               update_metalist(c, g_strdup(artist), g_strdup(selected));
 356               list_window_push_state(lw_state,lw);
 357             }
 358           break;
 359         case LIST_SONGS:
 360           if( lw->selected==0 )  /* handle ".." */
 361             {
 362               update_metalist(c, g_strdup(artist), NULL);
 363               list_window_reset(lw);
 364               /* restore previous list window state */
 365               list_window_pop_state(lw_state,lw);
 366             }
 367           else
 368             browse_handle_enter(screen, c, lw, filelist);
 369           break;
 370         }
 371       return 1;
 372
 373
 374     /* FIXME? CMD_GO_* handling duplicates code from CMD_PLAY */
 375
 376     case CMD_GO_PARENT_DIRECTORY:
 377       switch(mode)
 378         {
 379         case LIST_ALBUMS:
 380           update_metalist(c, NULL, NULL);
 381           list_window_reset(lw);
 382           /* restore previous list window state */
 383           list_window_pop_state(lw_state,lw);
 384           break;
 385         case LIST_SONGS:
 386           update_metalist(c, g_strdup(artist), NULL);
 387           list_window_reset(lw);
 388           /* restore previous list window state */
 389           list_window_pop_state(lw_state,lw);
 390           break;
 391         }
 392       break;
 393
 394     case CMD_GO_ROOT_DIRECTORY:
 395       switch(mode)
 396         {
 397         case LIST_ALBUMS:
 398         case LIST_SONGS:
 399           update_metalist(c, NULL, NULL);
 400           list_window_reset(lw);
 401           /* restore first list window state (pop while returning true) */
 402           while(list_window_pop_state(lw_state,lw));
 403           break;
 404         }
 405       break;
 406
 407     case CMD_SELECT:
 408       switch(mode)
 409         {
 410         case LIST_ARTISTS:
 411           selected = (char *) g_list_nth_data(metalist, lw->selected);
 412           add_query(c, MPD_TABLE_ARTIST, selected);
 413           cmd = CMD_LIST_NEXT; /* continue and select next item... */
 414           break;
 415         case LIST_ALBUMS:
 416           if( lw->selected && lw->selected == metalist_length-1)
 417             {
 418               add_query(c, MPD_TABLE_ARTIST, artist);
 419             }
 420           else if( lw->selected > 0 )
 421             {
 422               selected = (char *) g_list_nth_data(metalist, lw->selected);
 423               add_query(c, MPD_TABLE_ALBUM, selected);
 424               cmd = CMD_LIST_NEXT; /* continue and select next item... */
 425             }
 426           break;
 427         case LIST_SONGS:
 428           if( browse_handle_select(screen, c, lw, filelist) == 0 )
 429             {
 430               cmd = CMD_LIST_NEXT; /* continue and select next item... */
 431             }
 432           break;
 433         }
 434       break;
 435
 436       /* continue and update... */
 437     case CMD_SCREEN_UPDATE:
 438       screen->painted = 0;
 439       lw->clear = 1;
 440       lw->repaint = 1;
 441       update_metalist(c, g_strdup(artist), g_strdup(album));
 442       screen_status_printf(_("Screen updated!"));
 443       return 0;
 444
 445     case CMD_LIST_FIND:
 446     case CMD_LIST_RFIND:
 447     case CMD_LIST_FIND_NEXT:
 448     case CMD_LIST_RFIND_NEXT:
 449       if( filelist )
 450         return screen_find(screen,
 451                            lw, filelist->length,
 452                            cmd, browse_lw_callback, (void *) filelist);
 453       else if ( metalist )
 454         return screen_find(screen,
 455                            lw, metalist_length,
 456                            cmd, artist_lw_callback, (void *) metalist);
 457       else
 458         return 1;
 459
 460     case CMD_MOUSE_EVENT:
 461       return browse_handle_mouse_event(screen,c,lw,filelist);
 462
 463     default:
 464       break;
 465     }
 466
 467   if( filelist )
 468     return list_window_cmd(lw, filelist->length, cmd);
 469   else if( metalist )
 470     return list_window_cmd(lw, metalist_length, cmd);
 471
 472
 473   return 0;
 474 }
 475
 476 screen_functions_t *
 477 get_screen_artist(void)
 478 {
 479   static screen_functions_t functions;
 480
 481   memset(&functions, 0, sizeof(screen_functions_t));
 482   functions.init   = init;
 483   functions.exit   = quit;
 484   functions.open   = open;
 485   functions.close  = close;
 486   functions.resize = resize;
 487   functions.paint  = paint;
 488   functions.update = update;
 489   functions.cmd    = artist_cmd;
 490   functions.get_lw = get_filelist_window;
 491   functions.get_title = get_title;
 492
 493   return &functions;
 494 }
 495
 496
 497 #endif /* ENABLE_ARTIST_SCREEN */