src/screen_lyrics.c

   1 /*
   2  * (c) 2006 by Kalle Wallin <kaw@linux.se>
   3  * Copyright (C) 2008 Max Kellermann <max@duempel.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  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  *
  18  */
  19
  20 #include "config.h"
  21 #ifndef DISABLE_LYRICS_SCREEN
  22 #include <sys/stat.h>
  23 #include "ncmpc.h"
  24 #include "options.h"
  25 #include "mpdclient.h"
  26 #include "command.h"
  27 #include "screen.h"
  28 #include "screen_utils.h"
  29 #include "strfsong.h"
  30 #include "lyrics.h"
  31 #include "gcc.h"
  32
  33 #define _GNU_SOURCE
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <glib.h>
  37 #include <ncurses.h>
  38 #include <unistd.h>
  39 #include <stdio.h>
  40
  41 static list_window_t *lw = NULL;
  42 static int lyrics_text_rows = -1;
  43
  44 static struct {
  45         const struct mpd_song *song;
  46
  47         char *artist, *title;
  48
  49         struct lyrics_loader *loader;
  50
  51         GPtrArray *lines;
  52 } current;
  53
  54 static void
  55 screen_lyrics_abort(void)
  56 {
  57         if (current.loader != NULL) {
  58                 lyrics_free(current.loader);
  59                 current.loader = NULL;
  60         }
  61
  62         if (current.artist != NULL) {
  63                 g_free(current.artist);
  64                 current.artist = NULL;
  65         }
  66
  67         if (current.title != NULL) {
  68                 g_free(current.title);
  69                 current.artist = NULL;
  70         }
  71
  72         current.song = NULL;
  73 }
  74
  75 static void
  76 screen_lyrics_clear(void)
  77 {
  78         guint i;
  79
  80         assert(current.loader == NULL ||
  81                lyrics_result(current.loader) == LYRICS_SUCCESS);
  82
  83         current.song = NULL;
  84
  85         for (i = 0; i < current.lines->len; ++i)
  86                 g_free(g_ptr_array_index(current.lines, i));
  87
  88         g_ptr_array_set_size(current.lines, 0);
  89 }
  90
  91 static void
  92 screen_lyrics_set(const GString *str)
  93 {
  94         const char *p, *eol, *next;
  95
  96         screen_lyrics_clear();
  97
  98         p = str->str;
  99         while ((eol = strchr(p, '\n')) != NULL) {
 100                 char *line;
 101
 102                 next = eol + 1;
 103
 104                 /* strip whitespace at end */
 105
 106                 while (eol > p && (unsigned char)eol[-1] <= 0x20)
 107                         --eol;
 108
 109                 /* create copy and append it to current.lines*/
 110
 111                 line = g_malloc(eol - p + 1);
 112                 memcpy(line, p, eol - p);
 113                 line[eol - p] = 0;
 114
 115                 g_ptr_array_add(current.lines, line);
 116
 117                 /* reset control characters */
 118
 119                 for (eol = line + (eol - p); line < eol; ++line)
 120                         if ((unsigned char)*line < 0x20)
 121                                 *line = ' ';
 122
 123                 p = next;
 124         }
 125
 126         if (*p != 0)
 127                 g_ptr_array_add(current.lines, g_strdup(p));
 128 }
 129
 130 static int
 131 screen_lyrics_poll(void)
 132 {
 133         assert(current.loader != NULL);
 134
 135         switch (lyrics_result(current.loader)) {
 136         case LYRICS_BUSY:
 137                 return 0;
 138
 139         case LYRICS_SUCCESS:
 140                 screen_lyrics_set(lyrics_get(current.loader));
 141                 lyrics_free(current.loader);
 142                 current.loader = NULL;
 143                 return 1;
 144
 145         case LYRICS_FAILED:
 146                 lyrics_free(current.loader);
 147                 current.loader = NULL;
 148                 screen_status_message (_("No lyrics"));
 149                 return -1;
 150         }
 151
 152         assert(0);
 153         return -1;
 154 }
 155
 156 static void
 157 screen_lyrics_load(struct mpd_song *song)
 158 {
 159         char buffer[MAX_SONGNAME_LENGTH];
 160
 161         assert(song != NULL);
 162
 163         screen_lyrics_abort();
 164         screen_lyrics_clear();
 165
 166         strfsong(buffer, sizeof(buffer), "%artist%", song);
 167         current.artist = g_strdup(buffer);
 168
 169         strfsong(buffer, sizeof(buffer), "%title%", song);
 170         current.title = g_strdup(buffer);
 171
 172         current.loader = lyrics_load(current.artist, current.title);
 173 }
 174
 175 static void lyrics_paint(screen_t *screen, mpdclient_t *c);
 176
 177 static FILE *create_lyr_file(const char *artist, const char *title)
 178 {
 179         char path[1024];
 180
 181         snprintf(path, 1024, "%s/.lyrics",
 182                  getenv("HOME"));
 183         mkdir(path, S_IRWXU);
 184
 185         snprintf(path, 1024, "%s/.lyrics/%s - %s.txt",
 186                  getenv("HOME"), artist, title);
 187
 188         return fopen(path, "w");
 189 }
 190
 191 static int store_lyr_hd(void)
 192 {
 193         FILE *lyr_file;
 194         unsigned i;
 195
 196         lyr_file = create_lyr_file(current.artist, current.title);
 197         if (lyr_file == NULL)
 198                 return -1;
 199
 200         for (i = 0; i < current.lines->len; ++i)
 201                 fprintf(lyr_file, "%s\n",
 202                         (const char*)g_ptr_array_index(current.lines, i));
 203
 204         fclose(lyr_file);
 205         return 0;
 206 }
 207
 208 static const char *
 209 list_callback(unsigned idx, mpd_unused int *highlight, mpd_unused void *data)
 210 {
 211         if (current.lines == NULL || idx >= current.lines->len)
 212                 return "";
 213
 214         return g_ptr_array_index(current.lines, idx);
 215 }
 216
 217
 218 static void
 219 lyrics_screen_init(WINDOW *w, int cols, int rows)
 220 {
 221         current.lines = g_ptr_array_new();
 222         lw = list_window_init(w, cols, rows);
 223         lw->flags = LW_HIDE_CURSOR;
 224 }
 225
 226 static void
 227 lyrics_resize(int cols, int rows)
 228 {
 229         lw->cols = cols;
 230         lw->rows = rows;
 231 }
 232
 233 static void
 234 lyrics_exit(void)
 235 {
 236         list_window_free(lw);
 237
 238         screen_lyrics_abort();
 239         screen_lyrics_clear();
 240
 241         g_ptr_array_free(current.lines, TRUE);
 242         current.lines = NULL;
 243 }
 244
 245 static void
 246 lyrics_open(mpd_unused screen_t *screen, mpdclient_t *c)
 247 {
 248         if (c->song != NULL && c->song != current.song)
 249                 screen_lyrics_load(c->song);
 250         else if (current.loader != NULL)
 251                 screen_lyrics_poll();
 252 }
 253
 254
 255 static const char *
 256 lyrics_title(char *str, size_t size)
 257 {
 258         if (current.loader != NULL)
 259                 return "Lyrics (loading)";
 260         else if (current.artist != NULL && current.title != NULL &&
 261                  current.lines->len > 0) {
 262                 snprintf(str, size, "Lyrics: %s - %s",
 263                          current.artist, current.title);
 264                 return str;
 265         } else
 266                 return "Lyrics";
 267 }
 268
 269 static void
 270 lyrics_paint(mpd_unused screen_t *screen, mpd_unused mpdclient_t *c)
 271 {
 272         lw->clear = 1;
 273         list_window_paint(lw, list_callback, NULL);
 274         wrefresh(lw->w);
 275 }
 276
 277
 278 static void
 279 lyrics_update(mpd_unused screen_t *screen, mpd_unused mpdclient_t *c)
 280 {
 281         if( lw->repaint ) {
 282                 list_window_paint(lw, list_callback, NULL);
 283                 wrefresh(lw->w);
 284                 lw->repaint = 0;
 285         }
 286 }
 287
 288
 289 static int
 290 lyrics_cmd(screen_t *screen, mpdclient_t *c, command_t cmd)
 291 {
 292         if (list_window_scroll_cmd(lw, current.lines->len, cmd))
 293                 return 1;
 294
 295         switch(cmd) {
 296         case CMD_SELECT:
 297                 /* XXX */
 298                 if (current.loader != NULL) {
 299                         int ret = screen_lyrics_poll();
 300                         if (ret != 0)
 301                                 lyrics_paint(NULL, NULL);
 302                 }
 303                 return 1;
 304         case CMD_INTERRUPT:
 305                 if (current.loader != NULL) {
 306                         screen_lyrics_abort();
 307                         screen_lyrics_clear();
 308                 }
 309                 return 1;
 310         case CMD_ADD:
 311                 if (current.loader == NULL && current.artist != NULL &&
 312                     current.title != NULL && store_lyr_hd() == 0)
 313                         screen_status_message (_("Lyrics saved!"));
 314                 return 1;
 315         case CMD_LYRICS_UPDATE:
 316                 if (c->song != NULL) {
 317                         screen_lyrics_load(c->song);
 318                         lyrics_paint(NULL, NULL);
 319                 }
 320                 return 1;
 321         default:
 322                 break;
 323         }
 324
 325         lw->selected = lw->start+lw->rows;
 326         if (screen_find(screen,
 327                         lw,  lyrics_text_rows,
 328                         cmd, list_callback, NULL)) {
 329                 /* center the row */
 330                 list_window_center(lw, current.lines->len, lw->selected);
 331                 return 1;
 332         }
 333
 334         return 0;
 335 }
 336
 337 const struct screen_functions screen_lyrics = {
 338         .init = lyrics_screen_init,
 339         .exit = lyrics_exit,
 340         .open = lyrics_open,
 341         .close = NULL,
 342         .resize = lyrics_resize,
 343         .paint = lyrics_paint,
 344         .update = lyrics_update,
 345         .cmd = lyrics_cmd,
 346         .get_title = lyrics_title,
 347 };
 348
 349 #endif /* ENABLE_LYRICS_SCREEN */