1 /* ncmpc (Ncurses MPD Client)
2 * (c) 2004-2009 The Music Player Daemon Project
3 * Project homepage: http://musicpd.org
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.
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.
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 */
20 #include "screen.h"
21 #include "screen_list.h"
22 #include "screen_utils.h"
23 #include "config.h"
24 #include "i18n.h"
25 #include "charset.h"
26 #include "mpdclient.h"
27 #include "utils.h"
28 #include "options.h"
29 #include "colors.h"
30 #include "strfsong.h"
31 #include "player_command.h"
33 #ifndef NCMPC_MINI
34 #include "hscroll.h"
35 #endif
37 #include <mpd/client.h>
39 #include <stdlib.h>
40 #include <unistd.h>
41 #include <stdarg.h>
42 #include <string.h>
43 #include <time.h>
44 #include <locale.h>
46 #ifndef NCMPC_MINI
47 /** welcome message time [s] */
48 static const GTime SCREEN_WELCOME_TIME = 10;
49 #endif
51 /* minimum window size */
52 static const int SCREEN_MIN_COLS = 14;
53 static const int SCREEN_MIN_ROWS = 5;
55 /* screens */
57 #ifndef NCMPC_MINI
58 static gboolean welcome = TRUE;
59 #endif
61 struct screen screen;
62 static const struct screen_functions *mode_fn = &screen_playlist;
63 static const struct screen_functions *mode_fn_prev = &screen_playlist;
65 gboolean
66 screen_is_visible(const struct screen_functions *sf)
67 {
68 return sf == mode_fn;
69 }
71 void
72 screen_switch(const struct screen_functions *sf, struct mpdclient *c)
73 {
74 assert(sf != NULL);
76 if (sf == mode_fn)
77 return;
79 mode_fn_prev = mode_fn;
81 /* close the old mode */
82 if (mode_fn->close != NULL)
83 mode_fn->close();
85 /* get functions for the new mode */
86 mode_fn = sf;
88 /* open the new mode */
89 if (mode_fn->open != NULL)
90 mode_fn->open(c);
92 screen_paint(c);
93 }
95 void
96 screen_swap(struct mpdclient *c, const struct mpd_song *song)
97 {
98 if (song != NULL)
99 {
100 if (false)
101 { /* just a hack to make the ifdefs less ugly */ }
102 #ifdef ENABLE_SONG_SCREEN
103 if (mode_fn_prev == &screen_song)
104 screen_song_switch(c, song);
105 #endif
106 #ifdef ENABLE_LYRICS_SCREEN
107 else if (mode_fn_prev == &screen_lyrics)
108 screen_lyrics_switch(c, song, true);
109 #endif
110 else
111 screen_switch(mode_fn_prev, c);
112 }
113 else
114 screen_switch(mode_fn_prev, c);
115 }
117 static int
118 find_configured_screen(const char *name)
119 {
120 unsigned i;
122 for (i = 0; options.screen_list[i] != NULL; ++i)
123 if (strcmp(options.screen_list[i], name) == 0)
124 return i;
126 return -1;
127 }
129 static void
130 screen_next_mode(struct mpdclient *c, int offset)
131 {
132 int max = g_strv_length(options.screen_list);
133 int current, next;
134 const struct screen_functions *sf;
136 /* find current screen */
137 current = find_configured_screen(screen_get_name(mode_fn));
138 next = current + offset;
139 if (next<0)
140 next = max-1;
141 else if (next>=max)
142 next = 0;
144 sf = screen_lookup_name(options.screen_list[next]);
145 if (sf != NULL)
146 screen_switch(sf, c);
147 }
149 #ifndef NCMPC_MINI
150 static void
151 print_hotkey(WINDOW *w, command_t cmd, const char *label)
152 {
153 colors_use(w, COLOR_TITLE_BOLD);
154 waddstr(w, get_key_names(cmd, FALSE));
155 colors_use(w, COLOR_TITLE);
156 waddch(w, ':');
157 waddstr(w, label);
158 waddch(w, ' ');
159 waddch(w, ' ');
160 }
161 #endif
163 static inline int
164 get_volume(const struct mpd_status *status)
165 {
166 return status != NULL
167 ? mpd_status_get_volume(status)
168 : -1;
169 }
171 static void
172 paint_top_window2(const char *header, struct mpdclient *c)
173 {
174 int volume;
175 char flags[5];
176 WINDOW *w = screen.top_window.w;
177 char buf[32];
179 if (header[0]) {
180 colors_use(w, COLOR_TITLE_BOLD);
181 mvwaddstr(w, 0, 0, header);
182 #ifndef NCMPC_MINI
183 } else {
184 #ifdef ENABLE_HELP_SCREEN
185 print_hotkey(w, CMD_SCREEN_HELP, _("Help"));
186 #endif
187 print_hotkey(w, CMD_SCREEN_PLAY, _("Playlist"));
188 print_hotkey(w, CMD_SCREEN_FILE, _("Browse"));
189 #ifdef ENABLE_ARTIST_SCREEN
190 print_hotkey(w, CMD_SCREEN_ARTIST, _("Artist"));
191 #endif
192 #ifdef ENABLE_SEARCH_SCREEN
193 print_hotkey(w, CMD_SCREEN_SEARCH, _("Search"));
194 #endif
195 #ifdef ENABLE_LYRICS_SCREEN
196 print_hotkey(w, CMD_SCREEN_LYRICS, _("Lyrics"));
197 #endif
198 #ifdef ENABLE_OUTPUTS_SCREEN
199 print_hotkey(w, CMD_SCREEN_OUTPUTS, _("Outputs"));
200 #endif
201 #endif
202 }
204 volume = get_volume(c->status);
205 if (volume < 0)
206 g_snprintf(buf, 32, _("Volume n/a"));
207 else
208 g_snprintf(buf, 32, _("Volume %d%%"), volume);
210 colors_use(w, COLOR_TITLE);
211 mvwaddstr(w, 0, screen.top_window.cols - utf8_width(buf), buf);
213 flags[0] = 0;
214 if (c->status != NULL) {
215 if (mpd_status_get_repeat(c->status))
216 g_strlcat(flags, "r", sizeof(flags));
217 if (mpd_status_get_random(c->status))
218 g_strlcat(flags, "z", sizeof(flags));
219 if (mpd_status_get_single(c->status))
220 g_strlcat(flags, "s", sizeof(flags));
221 if (mpd_status_get_consume(c->status))
222 g_strlcat(flags, "c", sizeof(flags));
223 if (mpd_status_get_crossfade(c->status))
224 g_strlcat(flags, "x", sizeof(flags));
225 if (mpd_status_get_update_id(c->status) != 0)
226 g_strlcat(flags, "U", sizeof(flags));
227 }
229 colors_use(w, COLOR_LINE);
230 mvwhline(w, 1, 0, ACS_HLINE, screen.top_window.cols);
231 if (flags[0]) {
232 wmove(w,1,screen.top_window.cols-strlen(flags)-3);
233 waddch(w, '[');
234 colors_use(w, COLOR_LINE_BOLD);
235 waddstr(w, flags);
236 colors_use(w, COLOR_LINE);
237 waddch(w, ']');
238 }
239 wnoutrefresh(w);
240 }
242 static inline int
243 volume_length(int volume)
244 {
245 if (volume == 100)
246 return 3;
247 if (volume >= 10 && volume < 100)
248 return 2;
249 if (volume >= 0 && volume < 10)
250 return 1;
251 return -1;
252 }
254 static void
255 paint_top_window(const char *header, struct mpdclient *c, int full_repaint)
256 {
257 static int prev_volume = -1;
258 static unsigned prev_header_len = -1;
259 WINDOW *w = screen.top_window.w;
261 if (prev_header_len != utf8_width(header)) {
262 prev_header_len = utf8_width(header);
263 full_repaint = 1;
264 }
266 if (c->status &&
267 volume_length(prev_volume) !=
268 volume_length(mpd_status_get_volume(c->status)))
269 full_repaint = 1;
271 if (full_repaint) {
272 wmove(w, 0, 0);
273 wclrtoeol(w);
274 }
276 if ((c->status != NULL &&
277 prev_volume != mpd_status_get_volume(c->status)) ||
278 full_repaint)
279 paint_top_window2(header, c);
280 }
282 static void
283 paint_progress_window(struct mpdclient *c)
284 {
285 unsigned elapsed, duration;
287 if (c->song != NULL && seek_id == (int)mpd_song_get_id(c->song))
288 elapsed = seek_target_time;
289 else if (c->status != NULL)
290 elapsed = mpd_status_get_elapsed_time(c->status);
291 else
292 elapsed = 0;
294 duration = c->status != NULL &&
295 !IS_STOPPED(mpd_status_get_state(c->status))
296 ? mpd_status_get_total_time(c->status)
297 : 0;
299 if (progress_bar_set(&screen.progress_bar, elapsed, duration))
300 progress_bar_paint(&screen.progress_bar);
301 }
303 static void
304 paint_status_window(struct mpdclient *c)
305 {
306 WINDOW *w = screen.status_window.w;
307 const struct mpd_status *status = c->status;
308 enum mpd_state state;
309 const struct mpd_song *song = c->song;
310 int elapsedTime = 0;
311 #ifdef NCMPC_MINI
312 static char bitrate[1];
313 #else
314 char bitrate[16];
315 #endif
316 const char *str = NULL;
317 int x = 0;
319 if( time(NULL) - screen.status_timestamp <= options.status_message_time )
320 return;
322 wmove(w, 0, 0);
323 wclrtoeol(w);
324 colors_use(w, COLOR_STATUS_BOLD);
326 state = status == NULL ? MPD_STATE_UNKNOWN
327 : mpd_status_get_state(status);
329 switch (state) {
330 case MPD_STATE_PLAY:
331 str = _("Playing:");
332 break;
333 case MPD_STATE_PAUSE:
334 str = _("[Paused]");
335 break;
336 case MPD_STATE_STOP:
337 default:
338 break;
339 }
341 if (str) {
342 waddstr(w, str);
343 x += utf8_width(str) + 1;
344 }
346 /* create time string */
347 memset(screen.buf, 0, screen.buf_size);
348 if (IS_PLAYING(state) || IS_PAUSED(state)) {
349 int total_time = mpd_status_get_total_time(status);
350 if (total_time > 0) {
351 /*checks the conf to see whether to display elapsed or remaining time */
352 if(!strcmp(options.timedisplay_type,"elapsed"))
353 elapsedTime = mpd_status_get_elapsed_time(c->status);
354 else if(!strcmp(options.timedisplay_type,"remaining"))
355 elapsedTime = total_time -
356 mpd_status_get_elapsed_time(c->status);
358 if (c->song != NULL &&
359 seek_id == (int)mpd_song_get_id(c->song))
360 elapsedTime = seek_target_time;
362 /* display bitrate if visible-bitrate is true */
363 #ifndef NCMPC_MINI
364 if (options.visible_bitrate) {
365 g_snprintf(bitrate, 16,
366 " [%d kbps]",
367 mpd_status_get_kbit_rate(status));
368 } else {
369 bitrate[0] = '\0';
370 }
371 #endif
373 /*write out the time, using hours if time over 60 minutes*/
374 if (total_time > 3600) {
375 g_snprintf(screen.buf, screen.buf_size,
376 "%s [%i:%02i:%02i/%i:%02i:%02i]",
377 bitrate, elapsedTime/3600, (elapsedTime%3600)/60, elapsedTime%60,
378 total_time / 3600,
379 (total_time % 3600)/60,
380 total_time % 60);
381 } else {
382 g_snprintf(screen.buf, screen.buf_size,
383 "%s [%i:%02i/%i:%02i]",
384 bitrate, elapsedTime/60, elapsedTime%60,
385 total_time / 60, total_time % 60);
386 }
387 #ifndef NCMPC_MINI
388 } else {
389 g_snprintf(screen.buf, screen.buf_size,
390 " [%d kbps]",
391 mpd_status_get_kbit_rate(status));
392 #endif
393 }
394 #ifndef NCMPC_MINI
395 } else {
396 if (options.display_time) {
397 time_t timep;
399 time(&timep);
400 strftime(screen.buf, screen.buf_size, "%X ",localtime(&timep));
401 }
402 #endif
403 }
405 /* display song */
406 if (IS_PLAYING(state) || IS_PAUSED(state)) {
407 char songname[MAX_SONGNAME_LENGTH];
408 #ifndef NCMPC_MINI
409 int width = COLS - x - utf8_width(screen.buf);
410 #endif
412 if (song)
413 strfsong(songname, MAX_SONGNAME_LENGTH,
414 options.status_format, song);
415 else
416 songname[0] = '\0';
418 colors_use(w, COLOR_STATUS);
419 /* scroll if the song name is to long */
420 #ifndef NCMPC_MINI
421 if (options.scroll && utf8_width(songname) > (unsigned)width) {
422 static scroll_state_t st = { 0, 0 };
423 char *tmp = strscroll(songname, options.scroll_sep, width, &st);
425 g_strlcpy(songname, tmp, MAX_SONGNAME_LENGTH);
426 g_free(tmp);
427 }
428 #endif
429 //mvwaddnstr(w, 0, x, songname, width);
430 mvwaddstr(w, 0, x, songname);
431 }
433 /* display time string */
434 if (screen.buf[0]) {
435 x = screen.status_window.cols - strlen(screen.buf);
436 colors_use(w, COLOR_STATUS_TIME);
437 mvwaddstr(w, 0, x, screen.buf);
438 }
440 wnoutrefresh(w);
441 }
443 void
444 screen_exit(void)
445 {
446 if (mode_fn->close != NULL)
447 mode_fn->close();
449 screen_list_exit();
451 string_list_free(screen.find_history);
452 g_free(screen.buf);
453 g_free(screen.findbuf);
455 delwin(screen.top_window.w);
456 delwin(screen.main_window.w);
457 progress_bar_deinit(&screen.progress_bar);
458 delwin(screen.status_window.w);
459 }
461 void
462 screen_resize(struct mpdclient *c)
463 {
464 if (COLS<SCREEN_MIN_COLS || LINES<SCREEN_MIN_ROWS) {
465 screen_exit();
466 fprintf(stderr, "%s", _("Error: Screen too small"));
467 exit(EXIT_FAILURE);
468 }
470 resizeterm(LINES, COLS);
472 screen.cols = COLS;
473 screen.rows = LINES;
475 /* top window */
476 screen.top_window.cols = screen.cols;
477 wresize(screen.top_window.w, 2, screen.cols);
479 /* main window */
480 screen.main_window.cols = screen.cols;
481 screen.main_window.rows = screen.rows-4;
482 wresize(screen.main_window.w, screen.main_window.rows, screen.cols);
483 wclear(screen.main_window.w);
485 /* progress window */
486 progress_bar_resize(&screen.progress_bar, screen.cols,
487 screen.rows - 2, 0);
488 progress_bar_paint(&screen.progress_bar);
490 /* status window */
491 screen.status_window.cols = screen.cols;
492 wresize(screen.status_window.w, 1, screen.cols);
493 mvwin(screen.status_window.w, screen.rows-1, 0);
495 screen.buf_size = screen.cols;
496 g_free(screen.buf);
497 screen.buf = g_malloc(screen.cols);
499 /* resize all screens */
500 screen_list_resize(screen.main_window.cols, screen.main_window.rows);
502 /* ? - without this the cursor becomes visible with aterm & Eterm */
503 curs_set(1);
504 curs_set(0);
506 screen_paint(c);
507 }
509 void
510 screen_status_message(const char *msg)
511 {
512 WINDOW *w = screen.status_window.w;
514 wmove(w, 0, 0);
515 wclrtoeol(w);
516 colors_use(w, COLOR_STATUS_ALERT);
517 waddstr(w, msg);
518 wnoutrefresh(w);
519 screen.status_timestamp = time(NULL);
520 }
522 void
523 screen_status_printf(const char *format, ...)
524 {
525 char *msg;
526 va_list ap;
528 va_start(ap,format);
529 msg = g_strdup_vprintf(format,ap);
530 va_end(ap);
531 screen_status_message(msg);
532 g_free(msg);
533 }
535 void
536 screen_init(struct mpdclient *c)
537 {
538 if (COLS < SCREEN_MIN_COLS || LINES < SCREEN_MIN_ROWS) {
539 fprintf(stderr, "%s\n", _("Error: Screen too small"));
540 exit(EXIT_FAILURE);
541 }
543 screen.cols = COLS;
544 screen.rows = LINES;
546 screen.buf = g_malloc(screen.cols);
547 screen.buf_size = screen.cols;
548 screen.findbuf = NULL;
549 screen.start_timestamp = time(NULL);
551 /* create top window */
552 window_init(&screen.top_window, 2, screen.cols, 0, 0);
553 leaveok(screen.top_window.w, TRUE);
554 keypad(screen.top_window.w, TRUE);
556 /* create main window */
557 window_init(&screen.main_window, screen.rows - 4, screen.cols, 2, 0);
559 // leaveok(screen.main_window.w, TRUE); temporary disabled
560 keypad(screen.main_window.w, TRUE);
562 /* create progress window */
563 progress_bar_init(&screen.progress_bar, screen.cols,
564 screen.rows - 2, 0);
565 progress_bar_paint(&screen.progress_bar);
567 /* create status window */
568 window_init(&screen.status_window, 1, screen.cols,
569 screen.rows - 1, 0);
571 leaveok(screen.status_window.w, FALSE);
572 keypad(screen.status_window.w, TRUE);
574 #ifdef ENABLE_COLORS
575 if (options.enable_colors) {
576 /* set background attributes */
577 wbkgd(stdscr, COLOR_PAIR(COLOR_LIST));
578 wbkgd(screen.main_window.w, COLOR_PAIR(COLOR_LIST));
579 wbkgd(screen.top_window.w, COLOR_PAIR(COLOR_TITLE));
580 wbkgd(screen.progress_bar.window.w,
581 COLOR_PAIR(COLOR_PROGRESSBAR));
582 wbkgd(screen.status_window.w, COLOR_PAIR(COLOR_STATUS));
583 colors_use(screen.progress_bar.window.w, COLOR_PROGRESSBAR);
584 }
585 #endif
587 doupdate();
589 /* initialize screens */
590 screen_list_init(screen.main_window.w,
591 screen.main_window.cols, screen.main_window.rows);
593 if (mode_fn->open != NULL)
594 mode_fn->open(c);
595 }
597 void
598 screen_paint(struct mpdclient *c)
599 {
600 const char *title = NULL;
602 if (mode_fn->get_title != NULL)
603 title = mode_fn->get_title(screen.buf, screen.buf_size);
605 /* paint the title/header window */
606 if( title )
607 paint_top_window(title, c, 1);
608 else
609 paint_top_window("", c, 1);
611 /* paint the bottom window */
613 paint_progress_window(c);
614 paint_status_window(c);
616 /* paint the main window */
618 wclear(screen.main_window.w);
619 if (mode_fn->paint != NULL)
620 mode_fn->paint();
622 /* move the cursor to the origin */
624 if (!options.hardware_cursor)
625 wmove(screen.main_window.w, 0, 0);
627 wnoutrefresh(screen.main_window.w);
629 /* tell curses to update */
630 doupdate();
631 }
633 void
634 screen_update(struct mpdclient *c)
635 {
636 #ifndef NCMPC_MINI
637 static bool initialized = false;
638 static bool repeat;
639 static bool random_enabled;
640 static bool single;
641 static bool consume;
642 static unsigned crossfade;
643 static unsigned dbupdate;
645 /* print a message if mpd status has changed */
646 if (c->status != NULL) {
647 if (!initialized) {
648 repeat = mpd_status_get_repeat(c->status);
649 random_enabled = mpd_status_get_random(c->status);
650 single = mpd_status_get_single(c->status);
651 consume = mpd_status_get_consume(c->status);
652 crossfade = mpd_status_get_crossfade(c->status);
653 dbupdate = mpd_status_get_update_id(c->status);
654 initialized = true;
655 }
657 if (repeat != mpd_status_get_repeat(c->status))
658 screen_status_printf(mpd_status_get_repeat(c->status) ?
659 _("Repeat mode is on") :
660 _("Repeat mode is off"));
662 if (random_enabled != mpd_status_get_random(c->status))
663 screen_status_printf(mpd_status_get_random(c->status) ?
664 _("Random mode is on") :
665 _("Random mode is off"));
667 if (single != mpd_status_get_single(c->status))
668 screen_status_printf(mpd_status_get_single(c->status) ?
669 /* "single" mode means
670 that MPD will
671 automatically stop
672 after playing one
673 single song */
674 _("Single mode is on") :
675 _("Single mode is off"));
677 if (consume != mpd_status_get_consume(c->status))
678 screen_status_printf(mpd_status_get_consume(c->status) ?
679 /* "consume" mode means
680 that MPD removes each
681 song which has
682 finished playing */
683 _("Consume mode is on") :
684 _("Consume mode is off"));
686 if (crossfade != mpd_status_get_crossfade(c->status))
687 screen_status_printf(_("Crossfade %d seconds"),
688 mpd_status_get_crossfade(c->status));
690 if (dbupdate != 0 &&
691 dbupdate != mpd_status_get_update_id(c->status)) {
692 screen_status_printf(_("Database updated"));
693 }
695 repeat = mpd_status_get_repeat(c->status);
696 random_enabled = mpd_status_get_random(c->status);
697 single = mpd_status_get_single(c->status);
698 consume = mpd_status_get_consume(c->status);
699 crossfade = mpd_status_get_crossfade(c->status);
700 dbupdate = mpd_status_get_update_id(c->status);
701 }
703 /* update title/header window */
704 if (welcome && options.welcome_screen_list &&
705 time(NULL)-screen.start_timestamp <= SCREEN_WELCOME_TIME)
706 paint_top_window("", c, 0);
707 else
708 #endif
709 if (mode_fn->get_title != NULL) {
710 paint_top_window(mode_fn->get_title(screen.buf,screen.buf_size), c, 0);
711 #ifndef NCMPC_MINI
712 welcome = FALSE;
713 #endif
714 } else
715 paint_top_window("", c, 0);
717 /* update progress window */
718 paint_progress_window(c);
720 /* update status window */
721 paint_status_window(c);
723 /* update the main window */
724 if (mode_fn->update != NULL)
725 mode_fn->update(c);
727 /* move the cursor to the origin */
729 if (!options.hardware_cursor)
730 wmove(screen.main_window.w, 0, 0);
732 wnoutrefresh(screen.main_window.w);
734 /* tell curses to update */
735 doupdate();
736 }
738 #ifdef HAVE_GETMOUSE
739 int
740 screen_get_mouse_event(struct mpdclient *c, unsigned long *bstate, int *row)
741 {
742 MEVENT event;
744 /* retrieve the mouse event from ncurses */
745 getmouse(&event);
746 /* calculate the selected row in the list window */
747 *row = event.y - screen.top_window.rows;
748 /* copy button state bits */
749 *bstate = event.bstate;
750 /* if button 2 was pressed switch screen */
751 if (event.bstate & BUTTON2_CLICKED) {
752 screen_cmd(c, CMD_SCREEN_NEXT);
753 return 1;
754 }
756 return 0;
757 }
758 #endif
760 void
761 screen_cmd(struct mpdclient *c, command_t cmd)
762 {
763 #ifndef NCMPC_MINI
764 welcome = FALSE;
765 #endif
767 if (mode_fn->cmd != NULL && mode_fn->cmd(c, cmd))
768 return;
770 if (handle_player_command(c, cmd))
771 return;
773 switch(cmd) {
774 case CMD_TOGGLE_FIND_WRAP:
775 options.find_wrap = !options.find_wrap;
776 screen_status_printf(options.find_wrap ?
777 _("Find mode: Wrapped") :
778 _("Find mode: Normal"));
779 break;
780 case CMD_TOGGLE_AUTOCENTER:
781 options.auto_center = !options.auto_center;
782 screen_status_printf(options.auto_center ?
783 _("Auto center mode: On") :
784 _("Auto center mode: Off"));
785 break;
786 case CMD_SCREEN_UPDATE:
787 screen_paint(c);
788 break;
789 case CMD_SCREEN_PREVIOUS:
790 screen_next_mode(c, -1);
791 break;
792 case CMD_SCREEN_NEXT:
793 screen_next_mode(c, 1);
794 break;
795 case CMD_SCREEN_PLAY:
796 screen_switch(&screen_playlist, c);
797 break;
798 case CMD_SCREEN_FILE:
799 screen_switch(&screen_browse, c);
800 break;
801 #ifdef ENABLE_HELP_SCREEN
802 case CMD_SCREEN_HELP:
803 screen_switch(&screen_help, c);
804 break;
805 #endif
806 #ifdef ENABLE_SEARCH_SCREEN
807 case CMD_SCREEN_SEARCH:
808 screen_switch(&screen_search, c);
809 break;
810 #endif
811 #ifdef ENABLE_ARTIST_SCREEN
812 case CMD_SCREEN_ARTIST:
813 screen_switch(&screen_artist, c);
814 break;
815 #endif
816 #ifdef ENABLE_SONG_SCREEN
817 case CMD_SCREEN_SONG:
818 screen_switch(&screen_song, c);
819 break;
820 #endif
821 #ifdef ENABLE_KEYDEF_SCREEN
822 case CMD_SCREEN_KEYDEF:
823 screen_switch(&screen_keydef, c);
824 break;
825 #endif
826 #ifdef ENABLE_LYRICS_SCREEN
827 case CMD_SCREEN_LYRICS:
828 screen_switch(&screen_lyrics, c);
829 break;
830 #endif
831 #ifdef ENABLE_OUTPUTS_SCREEN
832 case CMD_SCREEN_OUTPUTS:
833 screen_switch(&screen_outputs, c);
834 break;
835 case CMD_SCREEN_SWAP:
836 screen_swap(c, NULL);
837 break;
838 #endif
840 default:
841 break;
842 }
843 }