a8b2ce56f600585ad587cba5cfd5ae6433c9c303
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 : MPD_STATUS_NO_VOLUME;
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 == MPD_STATUS_NO_VOLUME)
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 double p;
286 int width;
287 int elapsedTime;
289 if (c->status==NULL || IS_STOPPED(mpd_status_get_state(c->status))) {
290 mvwhline(screen.progress_window.w, 0, 0, ACS_HLINE,
291 screen.progress_window.cols);
292 wnoutrefresh(screen.progress_window.w);
293 return;
294 }
296 if (c->song != NULL && seek_id == (int)mpd_song_get_id(c->song))
297 elapsedTime = seek_target_time;
298 else
299 elapsedTime = mpd_status_get_elapsed_time(c->status);
301 p = ((double) elapsedTime) / ((double) mpd_status_get_total_time(c->status));
303 width = (int) (p * (double) screen.progress_window.cols);
304 mvwhline(screen.progress_window.w,
305 0, 0,
306 ACS_HLINE,
307 screen.progress_window.cols);
308 whline(screen.progress_window.w, '=', width-1);
309 mvwaddch(screen.progress_window.w, 0, width-1, 'O');
310 wnoutrefresh(screen.progress_window.w);
311 }
313 static void
314 paint_status_window(struct mpdclient *c)
315 {
316 WINDOW *w = screen.status_window.w;
317 const struct mpd_status *status = c->status;
318 enum mpd_state state;
319 const struct mpd_song *song = c->song;
320 int elapsedTime = 0;
321 #ifdef NCMPC_MINI
322 static char bitrate[1];
323 #else
324 char bitrate[16];
325 #endif
326 const char *str = NULL;
327 int x = 0;
329 if( time(NULL) - screen.status_timestamp <= options.status_message_time )
330 return;
332 wmove(w, 0, 0);
333 wclrtoeol(w);
334 colors_use(w, COLOR_STATUS_BOLD);
336 state = status == NULL ? MPD_STATE_UNKNOWN
337 : mpd_status_get_state(status);
339 switch (state) {
340 case MPD_STATE_PLAY:
341 str = _("Playing:");
342 break;
343 case MPD_STATE_PAUSE:
344 str = _("[Paused]");
345 break;
346 case MPD_STATE_STOP:
347 default:
348 break;
349 }
351 if (str) {
352 waddstr(w, str);
353 x += utf8_width(str) + 1;
354 }
356 /* create time string */
357 memset(screen.buf, 0, screen.buf_size);
358 if (IS_PLAYING(state) || IS_PAUSED(state)) {
359 int total_time = mpd_status_get_total_time(status);
360 if (total_time > 0) {
361 /*checks the conf to see whether to display elapsed or remaining time */
362 if(!strcmp(options.timedisplay_type,"elapsed"))
363 elapsedTime = mpd_status_get_elapsed_time(c->status);
364 else if(!strcmp(options.timedisplay_type,"remaining"))
365 elapsedTime = total_time -
366 mpd_status_get_elapsed_time(c->status);
368 if (c->song != NULL &&
369 seek_id == (int)mpd_song_get_id(c->song))
370 elapsedTime = seek_target_time;
372 /* display bitrate if visible-bitrate is true */
373 #ifndef NCMPC_MINI
374 if (options.visible_bitrate) {
375 g_snprintf(bitrate, 16,
376 " [%d kbps]",
377 mpd_status_get_kbit_rate(status));
378 } else {
379 bitrate[0] = '\0';
380 }
381 #endif
383 /*write out the time, using hours if time over 60 minutes*/
384 if (total_time > 3600) {
385 g_snprintf(screen.buf, screen.buf_size,
386 "%s [%i:%02i:%02i/%i:%02i:%02i]",
387 bitrate, elapsedTime/3600, (elapsedTime%3600)/60, elapsedTime%60,
388 total_time / 3600,
389 (total_time % 3600)/60,
390 total_time % 60);
391 } else {
392 g_snprintf(screen.buf, screen.buf_size,
393 "%s [%i:%02i/%i:%02i]",
394 bitrate, elapsedTime/60, elapsedTime%60,
395 total_time / 60, total_time % 60);
396 }
397 #ifndef NCMPC_MINI
398 } else {
399 g_snprintf(screen.buf, screen.buf_size,
400 " [%d kbps]",
401 mpd_status_get_kbit_rate(status));
402 #endif
403 }
404 #ifndef NCMPC_MINI
405 } else {
406 if (options.display_time) {
407 time_t timep;
409 time(&timep);
410 strftime(screen.buf, screen.buf_size, "%X ",localtime(&timep));
411 }
412 #endif
413 }
415 /* display song */
416 if (IS_PLAYING(state) || IS_PAUSED(state)) {
417 char songname[MAX_SONGNAME_LENGTH];
418 #ifndef NCMPC_MINI
419 int width = COLS - x - utf8_width(screen.buf);
420 #endif
422 if (song)
423 strfsong(songname, MAX_SONGNAME_LENGTH,
424 options.status_format, song);
425 else
426 songname[0] = '\0';
428 colors_use(w, COLOR_STATUS);
429 /* scroll if the song name is to long */
430 #ifndef NCMPC_MINI
431 if (options.scroll && utf8_width(songname) > (unsigned)width) {
432 static scroll_state_t st = { 0, 0 };
433 char *tmp = strscroll(songname, options.scroll_sep, width, &st);
435 g_strlcpy(songname, tmp, MAX_SONGNAME_LENGTH);
436 g_free(tmp);
437 }
438 #endif
439 //mvwaddnstr(w, 0, x, songname, width);
440 mvwaddstr(w, 0, x, songname);
441 }
443 /* display time string */
444 if (screen.buf[0]) {
445 x = screen.status_window.cols - strlen(screen.buf);
446 colors_use(w, COLOR_STATUS_TIME);
447 mvwaddstr(w, 0, x, screen.buf);
448 }
450 wnoutrefresh(w);
451 }
453 void
454 screen_exit(void)
455 {
456 if (mode_fn->close != NULL)
457 mode_fn->close();
459 screen_list_exit();
461 string_list_free(screen.find_history);
462 g_free(screen.buf);
463 g_free(screen.findbuf);
465 delwin(screen.top_window.w);
466 delwin(screen.main_window.w);
467 delwin(screen.progress_window.w);
468 delwin(screen.status_window.w);
469 }
471 void
472 screen_resize(struct mpdclient *c)
473 {
474 if (COLS<SCREEN_MIN_COLS || LINES<SCREEN_MIN_ROWS) {
475 screen_exit();
476 fprintf(stderr, "%s", _("Error: Screen too small"));
477 exit(EXIT_FAILURE);
478 }
480 resizeterm(LINES, COLS);
482 screen.cols = COLS;
483 screen.rows = LINES;
485 /* top window */
486 screen.top_window.cols = screen.cols;
487 wresize(screen.top_window.w, 2, screen.cols);
489 /* main window */
490 screen.main_window.cols = screen.cols;
491 screen.main_window.rows = screen.rows-4;
492 wresize(screen.main_window.w, screen.main_window.rows, screen.cols);
493 wclear(screen.main_window.w);
495 /* progress window */
496 screen.progress_window.cols = screen.cols;
497 wresize(screen.progress_window.w, 1, screen.cols);
498 mvwin(screen.progress_window.w, screen.rows-2, 0);
500 /* status window */
501 screen.status_window.cols = screen.cols;
502 wresize(screen.status_window.w, 1, screen.cols);
503 mvwin(screen.status_window.w, screen.rows-1, 0);
505 screen.buf_size = screen.cols;
506 g_free(screen.buf);
507 screen.buf = g_malloc(screen.cols);
509 /* resize all screens */
510 screen_list_resize(screen.main_window.cols, screen.main_window.rows);
512 /* ? - without this the cursor becomes visible with aterm & Eterm */
513 curs_set(1);
514 curs_set(0);
516 screen_paint(c);
517 }
519 void
520 screen_status_message(const char *msg)
521 {
522 WINDOW *w = screen.status_window.w;
524 wmove(w, 0, 0);
525 wclrtoeol(w);
526 colors_use(w, COLOR_STATUS_ALERT);
527 waddstr(w, msg);
528 wnoutrefresh(w);
529 screen.status_timestamp = time(NULL);
530 }
532 void
533 screen_status_printf(const char *format, ...)
534 {
535 char *msg;
536 va_list ap;
538 va_start(ap,format);
539 msg = g_strdup_vprintf(format,ap);
540 va_end(ap);
541 screen_status_message(msg);
542 g_free(msg);
543 }
545 void
546 screen_init(struct mpdclient *c)
547 {
548 if (COLS < SCREEN_MIN_COLS || LINES < SCREEN_MIN_ROWS) {
549 fprintf(stderr, "%s\n", _("Error: Screen too small"));
550 exit(EXIT_FAILURE);
551 }
553 screen.cols = COLS;
554 screen.rows = LINES;
556 screen.buf = g_malloc(screen.cols);
557 screen.buf_size = screen.cols;
558 screen.findbuf = NULL;
559 screen.start_timestamp = time(NULL);
561 /* create top window */
562 window_init(&screen.top_window, 2, screen.cols, 0, 0);
563 leaveok(screen.top_window.w, TRUE);
564 keypad(screen.top_window.w, TRUE);
566 /* create main window */
567 window_init(&screen.main_window, screen.rows - 4, screen.cols, 2, 0);
569 // leaveok(screen.main_window.w, TRUE); temporary disabled
570 keypad(screen.main_window.w, TRUE);
572 /* create progress window */
573 window_init(&screen.progress_window, 1, screen.cols,
574 screen.rows - 2, 0);
575 leaveok(screen.progress_window.w, TRUE);
577 /* create status window */
578 window_init(&screen.status_window, 1, screen.cols,
579 screen.rows - 1, 0);
581 leaveok(screen.status_window.w, FALSE);
582 keypad(screen.status_window.w, TRUE);
584 #ifdef ENABLE_COLORS
585 if (options.enable_colors) {
586 /* set background attributes */
587 wbkgd(stdscr, COLOR_PAIR(COLOR_LIST));
588 wbkgd(screen.main_window.w, COLOR_PAIR(COLOR_LIST));
589 wbkgd(screen.top_window.w, COLOR_PAIR(COLOR_TITLE));
590 wbkgd(screen.progress_window.w, COLOR_PAIR(COLOR_PROGRESSBAR));
591 wbkgd(screen.status_window.w, COLOR_PAIR(COLOR_STATUS));
592 colors_use(screen.progress_window.w, COLOR_PROGRESSBAR);
593 }
594 #endif
596 refresh();
598 /* initialize screens */
599 screen_list_init(screen.main_window.w,
600 screen.main_window.cols, screen.main_window.rows);
602 if (mode_fn->open != NULL)
603 mode_fn->open(c);
604 }
606 void
607 screen_paint(struct mpdclient *c)
608 {
609 const char *title = NULL;
611 if (mode_fn->get_title != NULL)
612 title = mode_fn->get_title(screen.buf, screen.buf_size);
614 /* paint the title/header window */
615 if( title )
616 paint_top_window(title, c, 1);
617 else
618 paint_top_window("", c, 1);
620 /* paint the bottom window */
622 paint_progress_window(c);
623 paint_status_window(c);
625 /* paint the main window */
627 wclear(screen.main_window.w);
628 if (mode_fn->paint != NULL)
629 mode_fn->paint();
631 /* move the cursor to the origin */
633 if (!options.hardware_cursor)
634 wmove(screen.main_window.w, 0, 0);
636 wnoutrefresh(screen.main_window.w);
638 /* tell curses to update */
639 doupdate();
640 }
642 void
643 screen_update(struct mpdclient *c)
644 {
645 #ifndef NCMPC_MINI
646 static bool initialized = false;
647 static bool repeat;
648 static bool random_enabled;
649 static bool single;
650 static bool consume;
651 static unsigned crossfade;
652 static unsigned dbupdate;
654 /* print a message if mpd status has changed */
655 if (c->status != NULL) {
656 if (!initialized) {
657 repeat = mpd_status_get_repeat(c->status);
658 random_enabled = mpd_status_get_random(c->status);
659 single = mpd_status_get_single(c->status);
660 consume = mpd_status_get_consume(c->status);
661 crossfade = mpd_status_get_crossfade(c->status);
662 dbupdate = mpd_status_get_update_id(c->status);
663 initialized = true;
664 }
666 if (repeat != mpd_status_get_repeat(c->status))
667 screen_status_printf(mpd_status_get_repeat(c->status) ?
668 _("Repeat mode is on") :
669 _("Repeat mode is off"));
671 if (random_enabled != mpd_status_get_random(c->status))
672 screen_status_printf(mpd_status_get_random(c->status) ?
673 _("Random mode is on") :
674 _("Random mode is off"));
676 if (single != mpd_status_get_single(c->status))
677 screen_status_printf(mpd_status_get_single(c->status) ?
678 /* "single" mode means
679 that MPD will
680 automatically stop
681 after playing one
682 single song */
683 _("Single mode is on") :
684 _("Single mode is off"));
686 if (consume != mpd_status_get_consume(c->status))
687 screen_status_printf(mpd_status_get_consume(c->status) ?
688 /* "consume" mode means
689 that MPD removes each
690 song which has
691 finished playing */
692 _("Consume mode is on") :
693 _("Consume mode is off"));
695 if (crossfade != mpd_status_get_crossfade(c->status))
696 screen_status_printf(_("Crossfade %d seconds"),
697 mpd_status_get_crossfade(c->status));
699 if (dbupdate != 0 &&
700 dbupdate != mpd_status_get_update_id(c->status)) {
701 screen_status_printf(_("Database updated"));
702 }
704 repeat = mpd_status_get_repeat(c->status);
705 random_enabled = mpd_status_get_random(c->status);
706 single = mpd_status_get_single(c->status);
707 consume = mpd_status_get_consume(c->status);
708 crossfade = mpd_status_get_crossfade(c->status);
709 dbupdate = mpd_status_get_update_id(c->status);
710 }
712 /* update title/header window */
713 if (welcome && options.welcome_screen_list &&
714 time(NULL)-screen.start_timestamp <= SCREEN_WELCOME_TIME)
715 paint_top_window("", c, 0);
716 else
717 #endif
718 if (mode_fn->get_title != NULL) {
719 paint_top_window(mode_fn->get_title(screen.buf,screen.buf_size), c, 0);
720 #ifndef NCMPC_MINI
721 welcome = FALSE;
722 #endif
723 } else
724 paint_top_window("", c, 0);
726 /* update progress window */
727 paint_progress_window(c);
729 /* update status window */
730 paint_status_window(c);
732 /* update the main window */
733 if (mode_fn->update != NULL)
734 mode_fn->update(c);
736 /* move the cursor to the origin */
738 if (!options.hardware_cursor)
739 wmove(screen.main_window.w, 0, 0);
741 wnoutrefresh(screen.main_window.w);
743 /* tell curses to update */
744 doupdate();
745 }
747 #ifdef HAVE_GETMOUSE
748 int
749 screen_get_mouse_event(struct mpdclient *c, unsigned long *bstate, int *row)
750 {
751 MEVENT event;
753 /* retrieve the mouse event from ncurses */
754 getmouse(&event);
755 /* calculate the selected row in the list window */
756 *row = event.y - screen.top_window.rows;
757 /* copy button state bits */
758 *bstate = event.bstate;
759 /* if button 2 was pressed switch screen */
760 if (event.bstate & BUTTON2_CLICKED) {
761 screen_cmd(c, CMD_SCREEN_NEXT);
762 return 1;
763 }
765 return 0;
766 }
767 #endif
769 void
770 screen_cmd(struct mpdclient *c, command_t cmd)
771 {
772 #ifndef NCMPC_MINI
773 welcome = FALSE;
774 #endif
776 if (mode_fn->cmd != NULL && mode_fn->cmd(c, cmd))
777 return;
779 if (handle_player_command(c, cmd))
780 return;
782 switch(cmd) {
783 case CMD_TOGGLE_FIND_WRAP:
784 options.find_wrap = !options.find_wrap;
785 screen_status_printf(options.find_wrap ?
786 _("Find mode: Wrapped") :
787 _("Find mode: Normal"));
788 break;
789 case CMD_TOGGLE_AUTOCENTER:
790 options.auto_center = !options.auto_center;
791 screen_status_printf(options.auto_center ?
792 _("Auto center mode: On") :
793 _("Auto center mode: Off"));
794 break;
795 case CMD_SCREEN_UPDATE:
796 screen_paint(c);
797 break;
798 case CMD_SCREEN_PREVIOUS:
799 screen_next_mode(c, -1);
800 break;
801 case CMD_SCREEN_NEXT:
802 screen_next_mode(c, 1);
803 break;
804 case CMD_SCREEN_PLAY:
805 screen_switch(&screen_playlist, c);
806 break;
807 case CMD_SCREEN_FILE:
808 screen_switch(&screen_browse, c);
809 break;
810 #ifdef ENABLE_HELP_SCREEN
811 case CMD_SCREEN_HELP:
812 screen_switch(&screen_help, c);
813 break;
814 #endif
815 #ifdef ENABLE_SEARCH_SCREEN
816 case CMD_SCREEN_SEARCH:
817 screen_switch(&screen_search, c);
818 break;
819 #endif
820 #ifdef ENABLE_ARTIST_SCREEN
821 case CMD_SCREEN_ARTIST:
822 screen_switch(&screen_artist, c);
823 break;
824 #endif
825 #ifdef ENABLE_SONG_SCREEN
826 case CMD_SCREEN_SONG:
827 screen_switch(&screen_song, c);
828 break;
829 #endif
830 #ifdef ENABLE_KEYDEF_SCREEN
831 case CMD_SCREEN_KEYDEF:
832 screen_switch(&screen_keydef, c);
833 break;
834 #endif
835 #ifdef ENABLE_LYRICS_SCREEN
836 case CMD_SCREEN_LYRICS:
837 screen_switch(&screen_lyrics, c);
838 break;
839 #endif
840 #ifdef ENABLE_OUTPUTS_SCREEN
841 case CMD_SCREEN_OUTPUTS:
842 screen_switch(&screen_outputs, c);
843 break;
844 case CMD_SCREEN_SWAP:
845 screen_swap(c, NULL);
846 break;
847 #endif
849 default:
850 break;
851 }
852 }