?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Corrected copyright year
[kugel-rb.git] / apps / screens.c
blobe4f44dd601e88a39616e792d7156158ea3d149d2
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2002 Björn Stenberg
11 *
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
14 *
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
17 *
18 ****************************************************************************/
19 #include <stdbool.h>
20 #include <string.h>
21 #include <stdio.h>
22 #include "backlight.h"
23 #include "button.h"
24 #include "lcd.h"
25 #include "lang.h"
26 #include "icons.h"
27 #include "font.h"
28 #include "mpeg.h"
29 #include "mp3_playback.h"
30 #include "usb.h"
31 #include "settings.h"
32 #include "status.h"
33 #include "playlist.h"
34 #include "sprintf.h"
35 #include "kernel.h"
36 #include "power.h"
37 #include "system.h"
38 #include "powermgmt.h"
39 #include "adc.h"
40 #include "action.h"
41 #include "talk.h"
42 #include "misc.h"
43 #include "id3.h"
44 #include "screens.h"
45 #include "debug.h"
46
47 #ifdef HAVE_LCD_BITMAP
48 #define BMPHEIGHT_usb_logo 32
49 #define BMPWIDTH_usb_logo 100
50 static const unsigned char usb_logo[] = {
51 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
52 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
53 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0x20, 0x10, 0x08,
54 0x04, 0x04, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
55 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x81, 0x81, 0x81, 0x81,
56 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
57 0x01, 0x01, 0x01, 0x01, 0xf1, 0x4f, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
58 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0xc0,
59 0x00, 0x00, 0xe0, 0x1c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
60 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
61 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x06, 0x81, 0xc0, 0xe0, 0xe0, 0xe0, 0xe0,
62 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0x70, 0x38, 0x1c, 0x1c,
63 0x0c, 0x0e, 0x0e, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0f, 0x1f, 0x1f, 0x1f, 0x1f,
64 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xc0, 0xc0, 0x80, 0x80, 0x00, 0x00,
65 0x00, 0x00, 0xe0, 0x1f, 0x00, 0xf8, 0x06, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
66 0x02, 0x02, 0x02, 0x82, 0x7e, 0x00, 0xc0, 0x3e, 0x01,
67 0x70, 0x4f, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
68 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
69 0x40, 0x40, 0x40, 0x40, 0x40, 0x80, 0x00, 0x07, 0x0f, 0x1f, 0x1f, 0x1f, 0x1f,
70 0x0f, 0x07, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x0f,
71 0x1f, 0x3f, 0x7b, 0xf3, 0xe3, 0xc3, 0x83, 0x83, 0x83, 0x83, 0xe3, 0xe3, 0xe3,
72 0xe3, 0xe3, 0xe3, 0x03, 0x03, 0x03, 0x3f, 0x1f, 0x1f, 0x0f, 0x0f, 0x07, 0x02,
73 0xc0, 0x3e, 0x01, 0xe0, 0x9f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
74 0x80, 0x80, 0xf0, 0x0f, 0x80, 0x78, 0x07, 0x00, 0x00,
75 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
76 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
77 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0c, 0x10, 0x20, 0x40, 0x40, 0x80, 0x80,
78 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
79 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81, 0x81, 0x87, 0x87, 0x87,
80 0x87, 0x87, 0x87, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xf0,
81 0x0f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
82 0x04, 0x04, 0x04, 0x04, 0x07, 0x00, 0x00, 0x00, 0x00,
83 };
84 #endif
85
86 void usb_display_info(void)
87 {
88 lcd_clear_display();
89
90 #ifdef HAVE_LCD_BITMAP
91 lcd_bitmap(usb_logo, 6, 16, BMPWIDTH_usb_logo, BMPHEIGHT_usb_logo, false);
92 status_draw(true);
93 lcd_update();
94 #else
95 lcd_puts(0, 0, "[USB Mode]");
96 status_set_param(false);
97 status_set_audio(false);
98 status_set_usb(true);
99 status_draw(false);
100 #endif
101 }
102
103 void usb_screen(void)
104 {
105 #ifdef USB_NONE
106 /* nothing here! */
107 #else
108 #ifndef SIMULATOR
109 backlight_on();
110 usb_acknowledge(SYS_USB_CONNECTED_ACK);
111 usb_display_info();
112 while(usb_wait_for_disconnect_w_tmo(&button_queue, HZ)) {
113 if(usb_inserted()) {
114 status_draw(false);
115 }
116 }
117 #ifdef HAVE_LCD_CHARCELLS
118 status_set_usb(false);
119 #endif
120
121 backlight_on();
122 #endif
123 #endif /* USB_NONE */
124 }
125
126 #ifdef HAVE_MMC
127 int mmc_remove_request(void)
128 {
129 struct event ev;
130
131 lcd_clear_display();
132 splash(1, true, str(LANG_REMOVE_MMC));
133 if (global_settings.talk_menu)
134 talk_id(LANG_REMOVE_MMC, false);
135
136 while (1)
137 {
138 queue_wait_w_tmo(&button_queue, &ev, HZ/2);
139 switch (ev.id)
140 {
141 case SYS_MMC_EXTRACTED:
142 return SYS_MMC_EXTRACTED;
143
144 case SYS_USB_DISCONNECTED:
145 return SYS_USB_DISCONNECTED;
146 }
147 }
148 }
149 #endif
150
151
152 /* some simulator dummies */
153 #ifdef SIMULATOR
154 #define BATTERY_SCALE_FACTOR 7000
155 unsigned short adc_read(int channel)
156 {
157 (void)channel;
158 return 100;
159 }
160 #endif
161
162 #ifdef HAVE_CHARGING
163
164 #ifdef HAVE_LCD_BITMAP
165 void charging_display_info(bool animate)
166 {
167 unsigned char charging_logo[36];
168 const int pox_x = (LCD_WIDTH - sizeof(charging_logo)) / 2;
169 const int pox_y = 32;
170 static unsigned phase = 3;
171 unsigned i;
172 char buf[32];
173 (void)buf;
174
175 #ifdef NEED_ATA_POWER_BATT_MEASURE
176 if (ide_powered()) /* FM and V2 can only measure when ATA power is on */
177 #endif
178 {
179 int battery_voltage;
180 int batt_int, batt_frac;
181
182 battery_voltage = (adc_read(ADC_UNREG_POWER) * BATTERY_SCALE_FACTOR) / 10000;
183 batt_int = battery_voltage / 100;
184 batt_frac = battery_voltage % 100;
185
186 snprintf(buf, 32, " Batt: %d.%02dV %d%% ", batt_int, batt_frac,
187 battery_level());
188 lcd_puts(0, 7, buf);
189 }
190
191 #ifdef HAVE_CHARGE_CTRL
192
193 snprintf(buf, 32, "Charge mode:");
194 lcd_puts(0, 2, buf);
195
196 if (charge_state == 1)
197 snprintf(buf, 32, str(LANG_BATTERY_CHARGE));
198 else if (charge_state == 2)
199 snprintf(buf, 32, str(LANG_BATTERY_TOPOFF_CHARGE));
200 else if (charge_state == 3)
201 snprintf(buf, 32, str(LANG_BATTERY_TRICKLE_CHARGE));
202 else
203 snprintf(buf, 32, "not charging");
204
205 lcd_puts(0, 3, buf);
206 if (!charger_enabled)
207 animate = false;
208 #endif /* HAVE_CHARGE_CTRL */
209
210
211 /* middle part */
212 memset(charging_logo+3, 0x00, 32);
213 charging_logo[0] = 0x3C;
214 charging_logo[1] = 0x24;
215 charging_logo[2] = charging_logo[35] = 0xFF;
216
217 if (!animate)
218 { /* draw the outline */
219 /* middle part */
220 lcd_bitmap(charging_logo, pox_x, pox_y + 8, sizeof(charging_logo), 8, true);
221 /* upper line */
222 charging_logo[0] = charging_logo[1] = 0x00;
223 memset(charging_logo+2, 0x80, 34);
224 lcd_bitmap(charging_logo, pox_x, pox_y, sizeof(charging_logo), 8, false);
225 /* lower line */
226 memset(charging_logo+2, 0x01, 34);
227 lcd_bitmap(charging_logo, pox_x, pox_y + 16, sizeof(charging_logo), 8, false);
228 }
229 else
230 { /* animate the middle part */
231 for (i = 3; i<MIN(sizeof(charging_logo)-1, phase); i++)
232 {
233 if ((i-phase) % 8 == 0)
234 { /* draw a "bubble" here */
235 unsigned bitpos;
236 bitpos = (phase + i/8) % 15; /* "bounce" effect */
237 if (bitpos > 7)
238 bitpos = 14 - bitpos;
239 charging_logo[i] = 0x01 << bitpos;
240 }
241 }
242 lcd_bitmap(charging_logo, pox_x, pox_y + 8, sizeof(charging_logo), 8, true);
243 phase++;
244 }
245 lcd_update();
246 }
247 #else /* not HAVE_LCD_BITMAP */
248
249 static unsigned char logo_chars[5];
250 static const unsigned char logo_pattern[] = {
251 0x07, 0x04, 0x1c, 0x14, 0x1c, 0x04, 0x07, /* char 1 */
252 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, /* char 2 */
253 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, /* char 3 */
254 0x1f, 0x01, 0x01, 0x01, 0x01, 0x01, 0x1f, /* char 4 */
255 };
256
257 static void logo_lock_patterns(bool on)
258 {
259 int i;
260
261 if (on)
262 {
263 for (i = 0; i < 4; i++)
264 logo_chars[i] = lcd_get_locked_pattern();
265 logo_chars[4] = '\0';
266 }
267 else
268 {
269 for (i = 0; i < 4; i++)
270 lcd_unlock_pattern(logo_chars[i]);
271 }
272 }
273
274 void charging_display_info(bool animate)
275 {
276 int battery_voltage;
277 unsigned i, ypos;
278 static unsigned phase = 3;
279 char buf[28];
280
281 battery_voltage = (adc_read(ADC_UNREG_POWER) * BATTERY_SCALE_FACTOR)
282 / 10000;
283 snprintf(buf, sizeof(buf), "%s %d.%02dV", logo_chars,
284 battery_voltage / 100, battery_voltage % 100);
285 lcd_puts(0, 1, buf);
286
287 memcpy(buf, logo_pattern, 28); /* copy logo patterns */
288
289 if (!animate) /* build the screen */
290 {
291 lcd_double_height(false);
292 lcd_puts(0, 0, "[Charging]");
293 }
294 else /* animate the logo */
295 {
296 for (i = 3; i < MIN(19, phase); i++)
297 {
298 if ((i - phase) % 5 == 0)
299 { /* draw a "bubble" here */
300 ypos = (phase + i/5) % 9; /* "bounce" effect */
301 if (ypos > 4)
302 ypos = 8 - ypos;
303 buf[5 - ypos + 7 * (i/5)] |= 0x10 >> (i%5);
304 }
305 }
306 phase++;
307 }
308
309 for (i = 0; i < 4; i++)
310 lcd_define_pattern(logo_chars[i], buf + 7 * i);
311 }
312 #endif /* (not) HAVE_LCD_BITMAP */
313
314 /* blocks while charging, returns on event:
315 1 if charger cable was removed
316 2 if Off/Stop key was pressed
317 3 if On key was pressed
318 4 if USB was connected */
319 int charging_screen(void)
320 {
321 int button;
322 int rc = 0;
323 #ifdef BUTTON_OFF
324 const int offbutton = BUTTON_OFF;
325 #else
326 const int offbutton = BUTTON_STOP;
327 #endif
328
329 ide_power_enable(false); /* power down the disk, else would be spinning */
330
331 lcd_clear_display();
332 backlight_set_timeout(global_settings.backlight_timeout);
333 backlight_set_on_when_charging(global_settings.backlight_on_when_charging);
334 status_draw(true);
335
336 #ifdef HAVE_LCD_CHARCELLS
337 logo_lock_patterns(true);
338 #endif
339 charging_display_info(false);
340
341 do
342 {
343 status_draw(false);
344 charging_display_info(true);
345 button = button_get_w_tmo(HZ/3);
346 #ifdef BUTTON_ON
347 if (button == (BUTTON_ON | BUTTON_REL))
348 #else
349 if (button == (BUTTON_RIGHT | BUTTON_REL))
350 #endif
351 rc = 3;
352 else if (button == offbutton)
353 rc = 2;
354 else
355 {
356 if (usb_detect())
357 rc = 4;
358 else if (!charger_inserted())
359 rc = 1;
360 }
361 } while (!rc);
362
363 #ifdef HAVE_LCD_CHARCELLS
364 logo_lock_patterns(false);
365 #endif
366 return rc;
367 }
368 #endif /* HAVE_CHARGING */
369
370
371 #if CONFIG_KEYPAD == RECORDER_PAD
372 /* returns:
373 0 if no key was pressed
374 1 if a key was pressed (or if ON was held down long enough to repeat)
375 2 if USB was connected */
376 int pitch_screen(void)
377 {
378 int button;
379 static int pitch = 1000;
380 bool exit = false;
381 bool used = false;
382
383 while (!exit) {
384
385 if ( used ) {
386 char* ptr;
387 char buf[32];
388 int w, h;
389
390 lcd_clear_display();
391 lcd_setfont(FONT_SYSFIXED);
392
393 ptr = str(LANG_PITCH_UP);
394 lcd_getstringsize(ptr,&w,&h);
395 lcd_putsxy((LCD_WIDTH-w)/2, 0, ptr);
396 lcd_bitmap(bitmap_icons_7x8[Icon_UpArrow],
397 LCD_WIDTH/2 - 3, h*2, 7, 8, true);
398
399 snprintf(buf, sizeof buf, "%d.%d%%", pitch / 10, pitch % 10 );
400 lcd_getstringsize(buf,&w,&h);
401 lcd_putsxy((LCD_WIDTH-w)/2, h, buf);
402
403 ptr = str(LANG_PITCH_DOWN);
404 lcd_getstringsize(ptr,&w,&h);
405 lcd_putsxy((LCD_WIDTH-w)/2, LCD_HEIGHT - h, ptr);
406 lcd_bitmap(bitmap_icons_7x8[Icon_DownArrow],
407 LCD_WIDTH/2 - 3, LCD_HEIGHT - h*3, 7, 8, true);
408
409 ptr = str(LANG_PAUSE);
410 lcd_getstringsize(ptr,&w,&h);
411 lcd_putsxy((LCD_WIDTH-(w/2))/2, LCD_HEIGHT/2 - h/2, ptr);
412 lcd_bitmap(bitmap_icons_7x8[Icon_Pause],
413 (LCD_WIDTH-(w/2))/2-10, LCD_HEIGHT/2 - h/2, 7, 8, true);
414
415 lcd_update();
416 }
417
418 /* use lastbutton, so the main loop can decide whether to
419 exit to browser or not */
420 button = button_get(true);
421 switch (button) {
422 case BUTTON_UP:
423 case BUTTON_ON | BUTTON_UP:
424 case BUTTON_ON | BUTTON_UP | BUTTON_REPEAT:
425 used = true;
426 pitch++;
427 if ( pitch > 2000 )
428 pitch = 2000;
429 mpeg_set_pitch(pitch);
430 break;
431
432 case BUTTON_DOWN:
433 case BUTTON_ON | BUTTON_DOWN:
434 case BUTTON_ON | BUTTON_DOWN | BUTTON_REPEAT:
435 used = true;
436 pitch--;
437 if ( pitch < 500 )
438 pitch = 500;
439 mpeg_set_pitch(pitch);
440 break;
441
442 case BUTTON_ON | BUTTON_PLAY:
443 mpeg_pause();
444 used = true;
445 break;
446
447 case BUTTON_PLAY | BUTTON_REL:
448 mpeg_resume();
449 used = true;
450 break;
451
452 case BUTTON_ON | BUTTON_PLAY | BUTTON_REL:
453 mpeg_resume();
454 exit = true;
455 break;
456
457 case BUTTON_ON | BUTTON_RIGHT:
458 if ( pitch < 2000 ) {
459 pitch += 20;
460 mpeg_set_pitch(pitch);
461 }
462 break;
463
464 case BUTTON_RIGHT | BUTTON_REL:
465 if ( pitch > 500 ) {
466 pitch -= 20;
467 mpeg_set_pitch(pitch);
468 }
469 break;
470
471 case BUTTON_ON | BUTTON_LEFT:
472 if ( pitch > 500 ) {
473 pitch -= 20;
474 mpeg_set_pitch(pitch);
475 }
476 break;
477
478 case BUTTON_LEFT | BUTTON_REL:
479 if ( pitch < 2000 ) {
480 pitch += 20;
481 mpeg_set_pitch(pitch);
482 }
483 break;
484
485 #ifdef SIMULATOR
486 case BUTTON_ON:
487 #else
488 case BUTTON_ON | BUTTON_REL:
489 case BUTTON_ON | BUTTON_UP | BUTTON_REL:
490 case BUTTON_ON | BUTTON_DOWN | BUTTON_REL:
491 #endif
492 exit = true;
493 break;
494
495 case BUTTON_ON | BUTTON_REPEAT:
496 used = true;
497 break;
498
499 default:
500 if(default_event_handler(button) == SYS_USB_CONNECTED)
501 return 2;
502 break;
503 }
504 }
505
506 lcd_setfont(FONT_UI);
507
508 if ( used )
509 return 1;
510 else
511 return 0;
512 }
513
514 bool quick_screen(int context, int button)
515 {
516 bool exit = false;
517 bool used = false;
518 int w, h, key;
519 char buf[32];
520 int oldrepeat = global_settings.repeat_mode;
521
522 /* just to stop compiler warning */
523 context = context;
524 lcd_setfont(FONT_SYSFIXED);
525
526 lcd_getstringsize("A",&w,&h);
527
528 while (!exit) {
529 char* ptr=NULL;
530
531 lcd_clear_display();
532
533 switch(button)
534 {
535 case BUTTON_F2:
536 /* Shuffle mode */
537 lcd_putsxy(0, LCD_HEIGHT/2 - h*2, str(LANG_SHUFFLE));
538 lcd_putsxy(0, LCD_HEIGHT/2 - h, str(LANG_F2_MODE));
539 lcd_putsxy(0, LCD_HEIGHT/2,
540 global_settings.playlist_shuffle ?
541 str(LANG_ON) : str(LANG_OFF));
542
543 /* Directory Filter */
544 switch ( global_settings.dirfilter ) {
545 case SHOW_ALL:
546 ptr = str(LANG_FILTER_ALL);
547 break;
548
549 case SHOW_SUPPORTED:
550 ptr = str(LANG_FILTER_SUPPORTED);
551 break;
552
553 case SHOW_MUSIC:
554 ptr = str(LANG_FILTER_MUSIC);
555 break;
556
557 case SHOW_PLAYLIST:
558 ptr = str(LANG_FILTER_PLAYLIST);
559 break;
560
561 case SHOW_ID3DB:
562 ptr = str(LANG_FILTER_ID3DB);
563 break;
564 }
565
566 snprintf(buf, sizeof buf, "%s:", str(LANG_FILTER));
567 lcd_getstringsize(buf,&w,&h);
568 lcd_putsxy((LCD_WIDTH-w)/2, LCD_HEIGHT - h*2, buf);
569 lcd_getstringsize(ptr,&w,&h);
570 lcd_putsxy((LCD_WIDTH-w)/2, LCD_HEIGHT - h, ptr);
571
572 /* Repeat Mode */
573 switch ( global_settings.repeat_mode ) {
574 case REPEAT_OFF:
575 ptr = str(LANG_OFF);
576 break;
577
578 case REPEAT_ALL:
579 ptr = str(LANG_REPEAT_ALL);
580 break;
581
582 case REPEAT_ONE:
583 ptr = str(LANG_REPEAT_ONE);
584 break;
585 }
586
587 lcd_getstringsize(str(LANG_REPEAT),&w,&h);
588 lcd_putsxy(LCD_WIDTH - w, LCD_HEIGHT/2 - h*2, str(LANG_REPEAT));
589 lcd_putsxy(LCD_WIDTH - w, LCD_HEIGHT/2 - h, str(LANG_F2_MODE));
590 lcd_putsxy(LCD_WIDTH - w, LCD_HEIGHT/2, ptr);
591 break;
592 case BUTTON_F3:
593 /* Scrollbar */
594 lcd_putsxy(0, LCD_HEIGHT/2 - h*2, str(LANG_F3_SCROLL));
595 lcd_putsxy(0, LCD_HEIGHT/2 - h, str(LANG_F3_BAR));
596 lcd_putsxy(0, LCD_HEIGHT/2,
597 global_settings.scrollbar ? str(LANG_ON) : str(LANG_OFF));
598
599 /* Status bar */
600 ptr = str(LANG_F3_STATUS);
601 lcd_getstringsize(ptr,&w,&h);
602 lcd_putsxy(LCD_WIDTH - w, LCD_HEIGHT/2 - h*2, ptr);
603 lcd_putsxy(LCD_WIDTH - w, LCD_HEIGHT/2 - h, str(LANG_F3_BAR));
604 lcd_putsxy(LCD_WIDTH - w, LCD_HEIGHT/2,
605 global_settings.statusbar ? str(LANG_ON) : str(LANG_OFF));
606
607 /* Flip */
608 ptr = str(LANG_FLIP_DISPLAY);
609 lcd_getstringsize(ptr,&w,&h);
610 lcd_putsxy((LCD_WIDTH-w)/2, LCD_HEIGHT - h*2, str(LANG_FLIP_DISPLAY));
611 ptr = global_settings.flip_display ?
612 str(LANG_SET_BOOL_YES) : str(LANG_SET_BOOL_NO);
613 lcd_getstringsize(ptr,&w,&h);
614 lcd_putsxy((LCD_WIDTH-w)/2, LCD_HEIGHT - h, ptr);
615 break;
616 }
617
618 lcd_bitmap(bitmap_icons_7x8[Icon_FastBackward],
619 LCD_WIDTH/2 - 16, LCD_HEIGHT/2 - 4, 7, 8, true);
620 lcd_bitmap(bitmap_icons_7x8[Icon_DownArrow],
621 LCD_WIDTH/2 - 3, LCD_HEIGHT - h*3, 7, 8, true);
622 lcd_bitmap(bitmap_icons_7x8[Icon_FastForward],
623 LCD_WIDTH/2 + 8, LCD_HEIGHT/2 - 4, 7, 8, true);
624
625 lcd_update();
626 key = button_get(true);
627
628 /*
629 * This is a temporary kludge so that the F2 & F3 menus operate in exactly
630 * the same manner up until the full F2/F3 configurable menus are complete
631 */
632
633 if( key == BUTTON_LEFT || key == BUTTON_RIGHT || key == BUTTON_DOWN || key == ( BUTTON_LEFT | BUTTON_REPEAT ) || key == ( BUTTON_RIGHT | BUTTON_REPEAT ) || key == ( BUTTON_DOWN | BUTTON_REPEAT ) )
634 key = button | key;
635
636 switch (key) {
637 case BUTTON_F2 | BUTTON_LEFT:
638 case BUTTON_F2 | BUTTON_LEFT | BUTTON_REPEAT:
639 global_settings.playlist_shuffle =
640 !global_settings.playlist_shuffle;
641
642 if(mpeg_status() & MPEG_STATUS_PLAY)
643 {
644 if (global_settings.playlist_shuffle)
645 playlist_randomise(NULL, current_tick, true);
646 else
647 playlist_sort(NULL, true);
648 }
649 used = true;
650 break;
651
652 case BUTTON_F2 | BUTTON_DOWN:
653 case BUTTON_F2 | BUTTON_DOWN | BUTTON_REPEAT:
654 global_settings.dirfilter++;
655 if ( global_settings.dirfilter >= NUM_FILTER_MODES )
656 global_settings.dirfilter = 0;
657 used = true;
658 break;
659
660 case BUTTON_F2 | BUTTON_RIGHT:
661 case BUTTON_F2 | BUTTON_RIGHT | BUTTON_REPEAT:
662 global_settings.repeat_mode++;
663 if ( global_settings.repeat_mode >= NUM_REPEAT_MODES )
664 global_settings.repeat_mode = 0;
665 used = true;
666 break;
667
668 case BUTTON_F3 | BUTTON_LEFT:
669 case BUTTON_F3 | BUTTON_LEFT | BUTTON_REPEAT:
670 global_settings.scrollbar = !global_settings.scrollbar;
671 used = true;
672 break;
673
674 case BUTTON_F3 | BUTTON_RIGHT:
675 case BUTTON_F3 | BUTTON_RIGHT | BUTTON_REPEAT:
676 global_settings.statusbar = !global_settings.statusbar;
677 used = true;
678 break;
679
680 case BUTTON_F3 | BUTTON_DOWN:
681 case BUTTON_F3 | BUTTON_DOWN | BUTTON_REPEAT:
682 case BUTTON_F3 | BUTTON_UP:
683 case BUTTON_F3 | BUTTON_UP | BUTTON_REPEAT:
684 global_settings.flip_display = !global_settings.flip_display;
685 button_set_flip(global_settings.flip_display);
686 lcd_set_flip(global_settings.flip_display);
687 used = true;
688 break;
689
690 case BUTTON_F3 | BUTTON_REL:
691 case BUTTON_F2 | BUTTON_REL:
692
693 if( used )
694 exit = true;
695
696 used = true;
697
698 break;
699
700 case BUTTON_OFF | BUTTON_REL:
701 lcd_setfont(FONT_UI);
702 return false;
703
704 default:
705 if(default_event_handler(key) == SYS_USB_CONNECTED)
706 return true;
707 break;
708 }
709 }
710
711 settings_save();
712
713 switch( button )
714 {
715 case BUTTON_F2:
716
717 if ( oldrepeat != global_settings.repeat_mode )
718 mpeg_flush_and_reload_tracks();
719
720 break;
721 case BUTTON_F3:
722
723 if (global_settings.statusbar)
724 lcd_setmargins(0, STATUSBAR_HEIGHT);
725 else
726 lcd_setmargins(0, 0);
727
728 break;
729 }
730
731 lcd_setfont(FONT_UI);
732
733 return false;
734 }
735 #endif
736
737 #ifdef HAVE_LCD_BITMAP
738 #define SPACE 3 /* pixels between words */
739 #define MAXLETTERS 128 /* 16*8 */
740 #define MAXLINES 10
741 #else
742 #define SPACE 1 /* one letter space */
743 #undef LCD_WIDTH
744 #define LCD_WIDTH 11
745 #undef LCD_HEIGHT
746 #define LCD_HEIGHT 2
747 #define MAXLETTERS 22 /* 11 * 2 */
748 #define MAXLINES 2
749 #endif
750
751 void splash(int ticks, /* how long the splash is displayed */
752 bool center, /* FALSE means left-justified, TRUE means
753 horizontal and vertical center */
754 const char *fmt, /* what to say *printf style */
755 ...)
756 {
757 char *next;
758 char *store=NULL;
759 int x=0;
760 int y=0;
761 int w, h;
762 unsigned char splash_buf[MAXLETTERS];
763 va_list ap;
764 unsigned char widths[MAXLINES];
765 int line=0;
766 bool first=true;
767 #ifdef HAVE_LCD_BITMAP
768 int maxw=0;
769 #endif
770
771 #ifdef HAVE_LCD_CHARCELLS
772 lcd_double_height (false);
773 #endif
774 va_start( ap, fmt );
775 vsnprintf( splash_buf, sizeof(splash_buf), fmt, ap );
776
777 if(center) {
778
779 /* first a pass to measure sizes */
780 next = strtok_r(splash_buf, " ", &store);
781 while (next) {
782 #ifdef HAVE_LCD_BITMAP
783 lcd_getstringsize(next, &w, &h);
784 #else
785 w = strlen(next);
786 h = 1; /* store height in characters */
787 #endif
788 if(!first) {
789 if(x+w> LCD_WIDTH) {
790 /* Too wide, wrap */
791 y+=h;
792 line++;
793 if((y > (LCD_HEIGHT-h)) || (line > MAXLINES))
794 /* STOP */
795 break;
796 x=0;
797 first=true;
798 }
799 }
800 else
801 first = false;
802
803 /* think of it as if the text was written here at position x,y
804 being w pixels/chars wide and h high */
805
806 x += w+SPACE;
807 widths[line]=x-SPACE; /* don't count the trailing space */
808 #ifdef HAVE_LCD_BITMAP
809 /* store the widest line */
810 if(widths[line]>maxw)
811 maxw = widths[line];
812 #endif
813 next = strtok_r(NULL, " ", &store);
814 }
815 #ifdef HAVE_LCD_BITMAP
816 /* Start displaying the message at position y. The reason for the
817 added h here is that it isn't added until the end of lines in the
818 loop above and we always break the loop in the middle of a line. */
819 y = (LCD_HEIGHT - (y+h) )/2;
820 #else
821 y = 0; /* vertical center on 2 lines would be silly */
822 #endif
823 first=true;
824
825 /* Now recreate the string again since the strtok_r() above has ruined
826 the one we already have! Here's room for improvements! */
827 vsnprintf( splash_buf, sizeof(splash_buf), fmt, ap );
828 }
829 va_end( ap );
830
831 if(center)
832 {
833 x = (LCD_WIDTH-widths[0])/2;
834 if(x < 0)
835 x = 0;
836 }
837
838 #ifdef HAVE_LCD_BITMAP
839 /* If we center the display and it wouldn't cover the full screen,
840 then just clear the box we need and put a nice little frame and
841 put the text in there! */
842 if(center && (y > 2)) {
843 if(maxw < (LCD_WIDTH -4)) {
844 int xx = (LCD_WIDTH-maxw)/2 - 2;
845 lcd_clearrect(xx, y-2, maxw+4, LCD_HEIGHT-y*2+4);
846 lcd_drawrect(xx, y-2, maxw+4, LCD_HEIGHT-y*2+4);
847 }
848 else {
849 lcd_clearrect(0, y-2, LCD_WIDTH, LCD_HEIGHT-y*2+4);
850 lcd_drawline(0, y-2, LCD_WIDTH-1, y-2);
851 lcd_drawline(0, LCD_HEIGHT-y+2, LCD_WIDTH-1, LCD_HEIGHT-y+2);
852 }
853 }
854 else
855 #endif
856 lcd_clear_display();
857 line=0;
858 next = strtok_r(splash_buf, " ", &store);
859 while (next) {
860 #ifdef HAVE_LCD_BITMAP
861 lcd_getstringsize(next, &w, &h);
862 #else
863 w = strlen(next);
864 h = 1;
865 #endif
866 if(!first) {
867 if(x+w> LCD_WIDTH) {
868 /* too wide */
869 y+=h;
870 line++; /* goto next line */
871 first=true;
872 if(y > (LCD_HEIGHT-h))
873 /* STOP */
874 break;
875 if(center) {
876 x = (LCD_WIDTH-widths[line])/2;
877 if(x < 0)
878 x = 0;
879 }
880 else
881 x=0;
882 }
883 }
884 else
885 first=false;
886 #ifdef HAVE_LCD_BITMAP
887 lcd_putsxy(x, y, next);
888 #else
889 lcd_puts(x, y, next);
890 #endif
891 x += w+SPACE; /* pixels space! */
892 next = strtok_r(NULL, " ", &store);
893 }
894 lcd_update();
895
896 if(ticks)
897 /* unbreakable! */
898 sleep(ticks);
899 }
900
901 void charging_splash(void)
902 {
903 splash(2*HZ, true, str(LANG_BATTERY_CHARGE));
904 while (button_get(false));
905 }
906
907
908 #ifdef HAVE_LCD_BITMAP
909
910 /* little helper function for voice output */
911 static void say_time(int cursorpos, const struct tm *tm)
912 {
913 static const int unit[] = { UNIT_HOUR, UNIT_MIN, UNIT_SEC, 0, 0, 0 };
914 int value = 0;
915
916 if (!global_settings.talk_menu)
917 return;
918
919 switch(cursorpos)
920 {
921 case 0:
922 value = tm->tm_hour;
923 break;
924 case 1:
925 value = tm->tm_min;
926 break;
927 case 2:
928 value = tm->tm_sec;
929 break;
930 case 3:
931 value = tm->tm_year + 1900;
932 break;
933 case 5:
934 value = tm->tm_mday;
935 break;
936 }
937
938 if (cursorpos == 4) /* month */
939 talk_id(LANG_MONTH_JANUARY + tm->tm_mon, false);
940 else
941 talk_value(value, unit[cursorpos], false);
942 }
943
944
945 #define INDEX_X 0
946 #define INDEX_Y 1
947 #define INDEX_WIDTH 2
948 bool set_time_screen(const char* string, struct tm *tm)
949 {
950 bool done = false;
951 int button;
952 int min = 0, steps = 0;
953 int cursorpos = 0;
954 int lastcursorpos = !cursorpos;
955 unsigned char buffer[19];
956 int realyear;
957 int julianday;
958 int i;
959 unsigned char reffub[5];
960 unsigned int width, height;
961 unsigned int separator_width, weekday_width;
962 unsigned int line_height, prev_line_height;
963
964 static const int dayname[] = {
965 LANG_WEEKDAY_SUNDAY,
966 LANG_WEEKDAY_MONDAY,
967 LANG_WEEKDAY_TUESDAY,
968 LANG_WEEKDAY_WEDNESDAY,
969 LANG_WEEKDAY_THURSDAY,
970 LANG_WEEKDAY_FRIDAY,
971 LANG_WEEKDAY_SATURDAY
972 };
973 static const int monthname[] = {
974 LANG_MONTH_JANUARY,
975 LANG_MONTH_FEBRUARY,
976 LANG_MONTH_MARCH,
977 LANG_MONTH_APRIL,
978 LANG_MONTH_MAY,
979 LANG_MONTH_JUNE,
980 LANG_MONTH_JULY,
981 LANG_MONTH_AUGUST,
982 LANG_MONTH_SEPTEMBER,
983 LANG_MONTH_OCTOBER,
984 LANG_MONTH_NOVEMBER,
985 LANG_MONTH_DECEMBER
986 };
987 char cursor[][3] = {{ 0, 8, 12}, {18, 8, 12}, {36, 8, 12},
988 {24, 16, 24}, {54, 16, 18}, {78, 16, 12}};
989 char daysinmonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
990
991 int monthname_len = 0, dayname_len = 0;
992
993 int *valptr = NULL;
994
995 #ifdef HAVE_LCD_BITMAP
996 if(global_settings.statusbar)
997 lcd_setmargins(0, STATUSBAR_HEIGHT);
998 else
999 lcd_setmargins(0, 0);
1000 #endif
1001 lcd_clear_display();
1002 lcd_puts_scroll(0, 0, string);
1003
1004 while ( !done ) {
1005 /* calculate the number of days in febuary */
1006 realyear = tm->tm_year + 1900;
1007 if((realyear % 4 == 0 && !(realyear % 100 == 0)) || realyear % 400 == 0)
1008 daysinmonth[1] = 29;
1009 else
1010 daysinmonth[1] = 28;
1011
1012 /* fix day if month or year changed */
1013 if (tm->tm_mday > daysinmonth[tm->tm_mon])
1014 tm->tm_mday = daysinmonth[tm->tm_mon];
1015
1016 /* calculate day of week */
1017 julianday = 0;
1018 for(i = 0; i < tm->tm_mon; i++) {
1019 julianday += daysinmonth[i];
1020 }
1021 julianday += tm->tm_mday;
1022 tm->tm_wday = (realyear + julianday + (realyear - 1) / 4 -
1023 (realyear - 1) / 100 + (realyear - 1) / 400 + 7 - 1) % 7;
1024
1025 snprintf(buffer, sizeof(buffer), "%02d:%02d:%02d ",
1026 tm->tm_hour, tm->tm_min, tm->tm_sec);
1027 lcd_puts(0, 1, buffer);
1028
1029 /* recalculate the positions and offsets */
1030 lcd_getstringsize(string, &width, &prev_line_height);
1031 lcd_getstringsize(buffer, &width, &line_height);
1032 lcd_getstringsize(":", &separator_width, &height);
1033
1034 /* hour */
1035 strncpy(reffub, buffer, 2);
1036 reffub[2] = '\0';
1037 lcd_getstringsize(reffub, &width, &height);
1038 cursor[0][INDEX_X] = 0;
1039 cursor[0][INDEX_Y] = prev_line_height;
1040 cursor[0][INDEX_WIDTH] = width;
1041
1042 /* minute */
1043 strncpy(reffub, buffer + 3, 2);
1044 reffub[2] = '\0';
1045 lcd_getstringsize(reffub, &width, &height);
1046 cursor[1][INDEX_X] = cursor[0][INDEX_WIDTH] + separator_width;
1047 cursor[1][INDEX_Y] = prev_line_height;
1048 cursor[1][INDEX_WIDTH] = width;
1049
1050 /* second */
1051 strncpy(reffub, buffer + 6, 2);
1052 reffub[2] = '\0';
1053 lcd_getstringsize(reffub, &width, &height);
1054 cursor[2][INDEX_X] = cursor[0][INDEX_WIDTH] + separator_width +
1055 cursor[1][INDEX_WIDTH] + separator_width;
1056 cursor[2][INDEX_Y] = prev_line_height;
1057 cursor[2][INDEX_WIDTH] = width;
1058
1059 lcd_getstringsize(buffer, &width, &prev_line_height);
1060
1061 snprintf(buffer, sizeof(buffer), "%s %04d %s %02d ",
1062 str(dayname[tm->tm_wday]), tm->tm_year+1900,
1063 str(monthname[tm->tm_mon]), tm->tm_mday);
1064 lcd_puts(0, 2, buffer);
1065
1066 /* recalculate the positions and offsets */
1067 lcd_getstringsize(buffer, &width, &line_height);
1068
1069 /* store these 2 to prevent _repeated_ strlen calls */
1070 monthname_len = strlen(str(monthname[tm->tm_mon]));
1071 dayname_len = strlen(str(dayname[tm->tm_wday]));
1072
1073 /* weekday */
1074 strncpy(reffub, buffer, dayname_len);
1075 reffub[dayname_len] = '\0';
1076 lcd_getstringsize(reffub, &weekday_width, &height);
1077 lcd_getstringsize(" ", &separator_width, &height);
1078
1079 /* year */
1080 strncpy(reffub, buffer + dayname_len + 1, 4);
1081 reffub[4] = '\0';
1082 lcd_getstringsize(reffub, &width, &height);
1083 cursor[3][INDEX_X] = weekday_width + separator_width;
1084 cursor[3][INDEX_Y] = cursor[0][INDEX_Y] + prev_line_height;
1085 cursor[3][INDEX_WIDTH] = width;
1086
1087 /* month */
1088 strncpy(reffub, buffer + dayname_len + 6, monthname_len);
1089 reffub[monthname_len] = '\0';
1090 lcd_getstringsize(reffub, &width, &height);
1091 cursor[4][INDEX_X] = weekday_width + separator_width +
1092 cursor[3][INDEX_WIDTH] + separator_width;
1093 cursor[4][INDEX_Y] = cursor[0][INDEX_Y] + prev_line_height;
1094 cursor[4][INDEX_WIDTH] = width;
1095
1096 /* day */
1097 strncpy(reffub, buffer + dayname_len + monthname_len + 7, 2);
1098 reffub[2] = '\0';
1099 lcd_getstringsize(reffub, &width, &height);
1100 cursor[5][INDEX_X] = weekday_width + separator_width +
1101 cursor[3][INDEX_WIDTH] + separator_width +
1102 cursor[4][INDEX_WIDTH] + separator_width;
1103 cursor[5][INDEX_Y] = cursor[0][INDEX_Y] + prev_line_height;
1104 cursor[5][INDEX_WIDTH] = width;
1105
1106 lcd_invertrect(cursor[cursorpos][INDEX_X],
1107 cursor[cursorpos][INDEX_Y] + lcd_getymargin(),
1108 cursor[cursorpos][INDEX_WIDTH],
1109 line_height);
1110
1111 lcd_puts(0, 4, str(LANG_TIME_SET));
1112 lcd_puts(0, 5, str(LANG_TIME_REVERT));
1113 #ifdef HAVE_LCD_BITMAP
1114 status_draw(true);
1115 #endif
1116 lcd_update();
1117
1118 /* calculate the minimum and maximum for the number under cursor */
1119 if(cursorpos!=lastcursorpos) {
1120 lastcursorpos=cursorpos;
1121 switch(cursorpos) {
1122 case 0: /* hour */
1123 min = 0;
1124 steps = 24;
1125 valptr = &tm->tm_hour;
1126 break;
1127 case 1: /* minute */
1128 min = 0;
1129 steps = 60;
1130 valptr = &tm->tm_min;
1131 break;
1132 case 2: /* second */
1133 min = 0;
1134 steps = 60;
1135 valptr = &tm->tm_sec;
1136 break;
1137 case 3: /* year */
1138 min = 1;
1139 steps = 200;
1140 valptr = &tm->tm_year;
1141 break;
1142 case 4: /* month */
1143 min = 0;
1144 steps = 12;
1145 valptr = &tm->tm_mon;
1146 break;
1147 case 5: /* day */
1148 min = 1;
1149 steps = daysinmonth[tm->tm_mon];
1150 valptr = &tm->tm_mday;
1151 break;
1152 }
1153 say_time(cursorpos, tm);
1154 }
1155
1156 button = button_get_w_tmo(HZ/2);
1157 switch ( button ) {
1158 case BUTTON_LEFT:
1159 cursorpos = (cursorpos + 6 - 1) % 6;
1160 break;
1161 case BUTTON_RIGHT:
1162 cursorpos = (cursorpos + 6 + 1) % 6;
1163 break;
1164 case BUTTON_UP:
1165 case BUTTON_UP | BUTTON_REPEAT:
1166 *valptr = (*valptr + steps - min + 1) %
1167 steps + min;
1168 if(*valptr == 0)
1169 *valptr = min;
1170 say_time(cursorpos, tm);
1171 break;
1172 case BUTTON_DOWN:
1173 case BUTTON_DOWN | BUTTON_REPEAT:
1174 *valptr = (*valptr + steps - min - 1) %
1175 steps + min;
1176 if(*valptr == 0)
1177 *valptr = min;
1178 say_time(cursorpos, tm);
1179 break;
1180
1181 #ifdef BUTTON_ON
1182 case BUTTON_ON:
1183 #elif defined BUTTON_MENU
1184 case BUTTON_MENU:
1185 #endif
1186 done = true;
1187 break;
1188
1189 case BUTTON_OFF:
1190 done = true;
1191 tm->tm_year = -1;
1192 break;
1193
1194 default:
1195 if (default_event_handler(button) == SYS_USB_CONNECTED)
1196 return true;
1197 break;
1198 }
1199 }
1200
1201 return false;
1202 }
1203 #endif
1204
1205 #if CONFIG_KEYPAD == RECORDER_PAD || CONFIG_KEYPAD == IRIVER_H100_PAD
1206 bool shutdown_screen(void)
1207 {
1208 int button;
1209 bool done = false;
1210
1211 lcd_stop_scroll();
1212
1213 splash(0, true, str(LANG_CONFIRM_SHUTDOWN));
1214
1215 while(!done)
1216 {
1217 button = button_get_w_tmo(HZ*2);
1218 switch(button)
1219 {
1220 case BUTTON_OFF:
1221 clean_shutdown();
1222 break;
1223
1224 default:
1225 if(default_event_handler(button) == SYS_USB_CONNECTED)
1226 return true;
1227
1228 /* Return if any other button was pushed, or if there
1229 was a timeout. We ignore RELEASE events, since we may
1230 have been called by a button down event, and the user might
1231 not have released the button yet.
1232 We also ignore REPEAT events, since we don't want to
1233 remove the splash when the user holds OFF to shut down. */
1234 if(!(button & (BUTTON_REL | BUTTON_REPEAT)))
1235 done = true;
1236 break;
1237 }
1238 }
1239 return false;
1240 }
1241 #endif
1242
1243 bool browse_id3(void)
1244 {
1245 struct mp3entry* id3 = mpeg_current_track();
1246 int button;
1247 int menu_pos = 0;
1248 int menu_max = 8;
1249 bool exit = false;
1250 char scroll_text[MAX_PATH];
1251
1252 if (!(mpeg_status() & MPEG_STATUS_PLAY))
1253 return false;
1254
1255 while (!exit)
1256 {
1257 lcd_clear_display();
1258
1259 switch (menu_pos)
1260 {
1261 case 0:
1262 lcd_puts(0, 0, str(LANG_ID3_TITLE));
1263 lcd_puts_scroll(0, 1, id3->title ? id3->title :
1264 (char*)str(LANG_ID3_NO_TITLE));
1265 break;
1266
1267 case 1:
1268 lcd_puts(0, 0, str(LANG_ID3_ARTIST));
1269 lcd_puts_scroll(0, 1,
1270 id3->artist ? id3->artist :
1271 (char*)str(LANG_ID3_NO_ARTIST));
1272 break;
1273
1274 case 2:
1275 lcd_puts(0, 0, str(LANG_ID3_ALBUM));
1276 lcd_puts_scroll(0, 1, id3->album ? id3->album :
1277 (char*)str(LANG_ID3_NO_ALBUM));
1278 break;
1279
1280 case 3:
1281 lcd_puts(0, 0, str(LANG_ID3_TRACKNUM));
1282
1283 if (id3->tracknum) {
1284 snprintf(scroll_text,sizeof(scroll_text), "%d",
1285 id3->tracknum);
1286 lcd_puts_scroll(0, 1, scroll_text);
1287 }
1288 else
1289 lcd_puts_scroll(0, 1, str(LANG_ID3_NO_TRACKNUM));
1290 break;
1291
1292 case 4:
1293 lcd_puts(0, 0, str(LANG_ID3_GENRE));
1294 lcd_puts_scroll(0, 1,
1295 id3_get_genre(id3) ?
1296 id3_get_genre(id3) :
1297 (char*)str(LANG_ID3_NO_INFO));
1298 break;
1299
1300 case 5:
1301 lcd_puts(0, 0, str(LANG_ID3_YEAR));
1302 if (id3->year) {
1303 snprintf(scroll_text,sizeof(scroll_text), "%d",
1304 id3->year);
1305 lcd_puts_scroll(0, 1, scroll_text);
1306 }
1307 else
1308 lcd_puts_scroll(0, 1, str(LANG_ID3_NO_INFO));
1309 break;
1310
1311 case 6:
1312 lcd_puts(0, 0, str(LANG_ID3_LENGHT));
1313 snprintf(scroll_text,sizeof(scroll_text), "%d:%02d",
1314 id3->length / 60000,
1315 id3->length % 60000 / 1000 );
1316 lcd_puts(0, 1, scroll_text);
1317 break;
1318
1319 case 7:
1320 lcd_puts(0, 0, str(LANG_ID3_PLAYLIST));
1321 snprintf(scroll_text,sizeof(scroll_text), "%d/%d",
1322 playlist_get_display_index(), playlist_amount());
1323 lcd_puts_scroll(0, 1, scroll_text);
1324 break;
1325
1326
1327 case 8:
1328 lcd_puts(0, 0, str(LANG_ID3_BITRATE));
1329 snprintf(scroll_text,sizeof(scroll_text), "%d kbps",
1330 id3->bitrate);
1331 lcd_puts(0, 1, scroll_text);
1332 break;
1333
1334 case 9:
1335 lcd_puts(0, 0, str(LANG_ID3_FRECUENCY));
1336 snprintf(scroll_text,sizeof(scroll_text), "%d Hz",
1337 id3->frequency);
1338 lcd_puts(0, 1, scroll_text);
1339 break;
1340
1341 case 10:
1342 lcd_puts(0, 0, str(LANG_ID3_PATH));
1343 lcd_puts_scroll(0, 1, id3->path);
1344 break;
1345 }
1346 lcd_update();
1347
1348 button = button_get(true);
1349
1350 switch(button)
1351 {
1352 case SETTINGS_DEC:
1353 if (menu_pos > 0)
1354 menu_pos--;
1355 else
1356 menu_pos = menu_max;
1357 break;
1358
1359 case SETTINGS_INC:
1360 if (menu_pos < menu_max)
1361 menu_pos++;
1362 else
1363 menu_pos = 0;
1364 break;
1365
1366 case SETTINGS_CANCEL:
1367 lcd_stop_scroll();
1368 /* eat release event */
1369 button_get(true);
1370 exit = true;
1371 break;
1372
1373 default:
1374 if(default_event_handler(button) == SYS_USB_CONNECTED)
1375 return true;
1376 break;
1377 }
1378 }
1379 return false;
1380 }
1381
My public Rockbox git repo