diff options
Diffstat (limited to 'apps')
-rw-r--r-- | apps/SOURCES | 9 | ||||
-rw-r--r-- | apps/dbtree.c | 67 | ||||
-rw-r--r-- | apps/filetree.c | 47 | ||||
-rw-r--r-- | apps/gui/buttonbar.c | 126 | ||||
-rw-r--r-- | apps/gui/buttonbar.h | 81 | ||||
-rw-r--r-- | apps/gui/icon.c | 49 | ||||
-rw-r--r-- | apps/gui/icon.h | 51 | ||||
-rw-r--r-- | apps/gui/list.c | 499 | ||||
-rw-r--r-- | apps/gui/list.h | 232 | ||||
-rw-r--r-- | apps/gui/scrollbar.c | 106 | ||||
-rw-r--r-- | apps/gui/scrollbar.h | 49 | ||||
-rw-r--r-- | apps/gui/splash.c | 216 | ||||
-rw-r--r-- | apps/gui/splash.h | 39 | ||||
-rw-r--r-- | apps/gui/statusbar.c | 508 | ||||
-rw-r--r-- | apps/gui/statusbar.h | 107 | ||||
-rw-r--r-- | apps/status.c | 16 | ||||
-rw-r--r-- | apps/status.h | 19 | ||||
-rw-r--r-- | apps/tree.c | 942 | ||||
-rw-r--r-- | apps/tree.h | 33 | ||||
-rw-r--r-- | apps/wps.h | 12 |
20 files changed, 2506 insertions, 702 deletions
diff --git a/apps/SOURCES b/apps/SOURCES index 26af159d5a..07c121f5a3 100644 --- a/apps/SOURCES +++ b/apps/SOURCES | |||
@@ -31,6 +31,15 @@ database.c | |||
31 | filetree.c | 31 | filetree.c |
32 | wps-display.c | 32 | wps-display.c |
33 | wps.c | 33 | wps.c |
34 | |||
35 | screen_access.c | ||
36 | gui/buttonbar.c | ||
37 | gui/icon.c | ||
38 | gui/list.c | ||
39 | gui/scrollbar.c | ||
40 | gui/splash.c | ||
41 | gui/statusbar.c | ||
42 | |||
34 | #ifdef HAVE_LCD_CHARCELLS | 43 | #ifdef HAVE_LCD_CHARCELLS |
35 | player/icons.c | 44 | player/icons.c |
36 | player/keyboard.c | 45 | player/keyboard.c |
diff --git a/apps/dbtree.c b/apps/dbtree.c index e3704ac381..9ea0706245 100644 --- a/apps/dbtree.c +++ b/apps/dbtree.c | |||
@@ -43,6 +43,7 @@ | |||
43 | #include "lang.h" | 43 | #include "lang.h" |
44 | #include "keyboard.h" | 44 | #include "keyboard.h" |
45 | #include "autoconf.h" | 45 | #include "autoconf.h" |
46 | #include "list.h" | ||
46 | 47 | ||
47 | static int db_play_folder(struct tree_context* c); | 48 | static int db_play_folder(struct tree_context* c); |
48 | static int db_search(struct tree_context* c, char* string); | 49 | static int db_search(struct tree_context* c, char* string); |
@@ -69,17 +70,18 @@ int db_load(struct tree_context* c) | |||
69 | c->filesindir = 0; | 70 | c->filesindir = 0; |
70 | return 0; | 71 | return 0; |
71 | } | 72 | } |
72 | 73 | ||
73 | c->dentry_size = 2; | 74 | c->dentry_size = 2; |
74 | c->dirfull = false; | 75 | c->dirfull = false; |
75 | 76 | ||
76 | DEBUGF("db_load() table: %d extra: 0x%x firstpos: %d\n", table, extra, c->firstpos); | 77 | DEBUGF("db_load() table: %d extra: 0x%x firstpos: %d\n", table, extra, |
78 | c->firstpos); | ||
77 | 79 | ||
78 | if (!table) { | 80 | if (!table) { |
79 | table = root; | 81 | table = root; |
80 | c->currtable = table; | 82 | c->currtable = table; |
81 | } | 83 | } |
82 | 84 | ||
83 | switch (table) { | 85 | switch (table) { |
84 | case root: { | 86 | case root: { |
85 | static const int tables[] = {allartists, allalbums, allsongs, | 87 | static const int tables[] = {allartists, allalbums, allsongs, |
@@ -138,28 +140,28 @@ int db_load(struct tree_context* c) | |||
138 | return i; | 140 | return i; |
139 | 141 | ||
140 | case allsongs: | 142 | case allsongs: |
141 | DEBUGF("dbload table allsongs\n"); | 143 | DEBUGF("dbload table allsongs\n"); |
142 | offset = tagdbheader.songstart + c->firstpos * SONGENTRY_SIZE; | 144 | offset = tagdbheader.songstart + c->firstpos * SONGENTRY_SIZE; |
143 | itemcount = tagdbheader.songcount; | 145 | itemcount = tagdbheader.songcount; |
144 | stringlen = tagdbheader.songlen; | 146 | stringlen = tagdbheader.songlen; |
145 | break; | 147 | break; |
146 | 148 | ||
147 | case allalbums: | 149 | case allalbums: |
148 | DEBUGF("dbload table allalbums\n"); | 150 | DEBUGF("dbload table allalbums\n"); |
149 | offset = tagdbheader.albumstart + c->firstpos * ALBUMENTRY_SIZE; | 151 | offset = tagdbheader.albumstart + c->firstpos * ALBUMENTRY_SIZE; |
150 | itemcount = tagdbheader.albumcount; | 152 | itemcount = tagdbheader.albumcount; |
151 | stringlen = tagdbheader.albumlen; | 153 | stringlen = tagdbheader.albumlen; |
152 | break; | 154 | break; |
153 | 155 | ||
154 | case allartists: | 156 | case allartists: |
155 | DEBUGF("dbload table allartists\n"); | 157 | DEBUGF("dbload table allartists\n"); |
156 | offset = tagdbheader.artiststart + c->firstpos * ARTISTENTRY_SIZE; | 158 | offset = tagdbheader.artiststart + c->firstpos * ARTISTENTRY_SIZE; |
157 | itemcount = tagdbheader.artistcount; | 159 | itemcount = tagdbheader.artistcount; |
158 | stringlen = tagdbheader.artistlen; | 160 | stringlen = tagdbheader.artistlen; |
159 | break; | 161 | break; |
160 | 162 | ||
161 | case albums4artist: | 163 | case albums4artist: |
162 | DEBUGF("dbload table albums4artist\n"); | 164 | DEBUGF("dbload table albums4artist\n"); |
163 | /* 'extra' is offset to the artist */ | 165 | /* 'extra' is offset to the artist */ |
164 | safeplacelen = tagdbheader.albumarraylen * 4; | 166 | safeplacelen = tagdbheader.albumarraylen * 4; |
165 | safeplace = (void*)(end_of_nbuf - safeplacelen); | 167 | safeplace = (void*)(end_of_nbuf - safeplacelen); |
@@ -199,13 +201,13 @@ int db_load(struct tree_context* c) | |||
199 | break; | 201 | break; |
200 | 202 | ||
201 | case songs4artist: | 203 | case songs4artist: |
202 | DEBUGF("dbload table songs4artist\n"); | 204 | DEBUGF("dbload table songs4artist\n"); |
203 | /* 'extra' is offset to the artist, used as filter */ | 205 | /* 'extra' is offset to the artist, used as filter */ |
204 | offset = tagdbheader.songstart + c->firstpos * SONGENTRY_SIZE; | 206 | offset = tagdbheader.songstart + c->firstpos * SONGENTRY_SIZE; |
205 | itemcount = tagdbheader.songcount; | 207 | itemcount = tagdbheader.songcount; |
206 | stringlen = tagdbheader.songlen; | 208 | stringlen = tagdbheader.songlen; |
207 | break; | 209 | break; |
208 | 210 | ||
209 | default: | 211 | default: |
210 | DEBUGF("Unsupported table %d\n", table); | 212 | DEBUGF("Unsupported table %d\n", table); |
211 | return -1; | 213 | return -1; |
@@ -248,7 +250,8 @@ int db_load(struct tree_context* c) | |||
248 | case songs4album: | 250 | case songs4album: |
249 | case songs4artist: | 251 | case songs4artist: |
250 | rc = read(tagdb_fd, intbuf, 12); | 252 | rc = read(tagdb_fd, intbuf, 12); |
251 | skip = SONGENTRY_SIZE-stringlen-12; /* skip the rest of the song info */ | 253 | /* skip the rest of the song info */ |
254 | skip = SONGENTRY_SIZE-stringlen-12; | ||
252 | if (rc < 12) { | 255 | if (rc < 12) { |
253 | DEBUGF("%d read(%d) returned %d\n", i, 12, rc); | 256 | DEBUGF("%d read(%d) returned %d\n", i, 12, rc); |
254 | return -1; | 257 | return -1; |
@@ -287,7 +290,7 @@ int db_load(struct tree_context* c) | |||
287 | 290 | ||
288 | if(table==songs4artist) | 291 | if(table==songs4artist) |
289 | c->dirlength=hits; | 292 | c->dirlength=hits; |
290 | 293 | ||
291 | /* next name is stored immediately after this */ | 294 | /* next name is stored immediately after this */ |
292 | nptr = (void*)nptr + strlen((char*)nptr) + 1; | 295 | nptr = (void*)nptr + strlen((char*)nptr) + 1; |
293 | if ((void*)nptr + stringlen > (void*)end_of_nbuf) { | 296 | if ((void*)nptr + stringlen > (void*)end_of_nbuf) { |
@@ -314,7 +317,7 @@ int db_load(struct tree_context* c) | |||
314 | dptr[1] = extra; /* offset to artist */ | 317 | dptr[1] = extra; /* offset to artist */ |
315 | hits++; | 318 | hits++; |
316 | } | 319 | } |
317 | 320 | ||
318 | c->filesindir = hits; | 321 | c->filesindir = hits; |
319 | 322 | ||
320 | return hits; | 323 | return hits; |
@@ -350,7 +353,7 @@ static int db_search(struct tree_context* c, char* string) | |||
350 | count = tagdbheader.songcount; | 353 | count = tagdbheader.songcount; |
351 | size = SONGENTRY_SIZE; | 354 | size = SONGENTRY_SIZE; |
352 | break; | 355 | break; |
353 | 356 | ||
354 | default: | 357 | default: |
355 | DEBUGF("Invalid table %d\n", c->currtable); | 358 | DEBUGF("Invalid table %d\n", c->currtable); |
356 | return 0; | 359 | return 0; |
@@ -384,7 +387,7 @@ static int db_search(struct tree_context* c, char* string) | |||
384 | c->dirfull = true; | 387 | c->dirfull = true; |
385 | break; | 388 | break; |
386 | } | 389 | } |
387 | 390 | ||
388 | nptr += strlen(nptr) + 1; | 391 | nptr += strlen(nptr) + 1; |
389 | while ((unsigned long)nptr & 3) | 392 | while ((unsigned long)nptr & 3) |
390 | nptr++; | 393 | nptr++; |
@@ -403,25 +406,24 @@ static int db_search(struct tree_context* c, char* string) | |||
403 | int db_enter(struct tree_context* c) | 406 | int db_enter(struct tree_context* c) |
404 | { | 407 | { |
405 | int rc = 0; | 408 | int rc = 0; |
406 | int offset = (c->dircursor + c->dirstart) * c->dentry_size + 1; | 409 | int offset = (c->selected_item) * c->dentry_size + 1; |
407 | int newextra = ((int*)c->dircache)[offset]; | 410 | int newextra = ((int*)c->dircache)[offset]; |
408 | 411 | ||
409 | if (c->dirlevel >= MAX_DIR_LEVELS) | 412 | if (c->dirlevel >= MAX_DIR_LEVELS) |
410 | return 0; | 413 | return 0; |
411 | 414 | ||
412 | c->dirpos[c->dirlevel] = c->dirstart; | 415 | c->selected_item_history[c->dirlevel]=c->selected_item; |
413 | c->cursorpos[c->dirlevel] = c->dircursor; | ||
414 | c->table_history[c->dirlevel] = c->currtable; | 416 | c->table_history[c->dirlevel] = c->currtable; |
415 | c->extra_history[c->dirlevel] = c->currextra; | 417 | c->extra_history[c->dirlevel] = c->currextra; |
416 | c->pos_history[c->dirlevel] = c->firstpos; | 418 | c->pos_history[c->dirlevel] = c->firstpos; |
417 | c->dirlevel++; | 419 | c->dirlevel++; |
418 | 420 | ||
419 | switch (c->currtable) { | 421 | switch (c->currtable) { |
420 | case root: | 422 | case root: |
421 | c->currtable = newextra; | 423 | c->currtable = newextra; |
422 | c->currextra = newextra; | 424 | c->currextra = newextra; |
423 | break; | 425 | break; |
424 | 426 | ||
425 | case allartists: | 427 | case allartists: |
426 | case searchartists: | 428 | case searchartists: |
427 | c->currtable = albums4artist; | 429 | c->currtable = albums4artist; |
@@ -457,13 +459,13 @@ int db_enter(struct tree_context* c) | |||
457 | else | 459 | else |
458 | c->currtable = newextra; | 460 | c->currtable = newextra; |
459 | break; | 461 | break; |
460 | 462 | ||
461 | default: | 463 | default: |
462 | c->dirlevel--; | 464 | c->dirlevel--; |
463 | break; | 465 | break; |
464 | } | 466 | } |
465 | 467 | c->selected_item=0; | |
466 | c->dirstart = c->dircursor = c->firstpos = 0; | 468 | gui_synclist_select_item(&tree_lists, c->selected_item); |
467 | 469 | ||
468 | return rc; | 470 | return rc; |
469 | } | 471 | } |
@@ -471,8 +473,8 @@ int db_enter(struct tree_context* c) | |||
471 | void db_exit(struct tree_context* c) | 473 | void db_exit(struct tree_context* c) |
472 | { | 474 | { |
473 | c->dirlevel--; | 475 | c->dirlevel--; |
474 | c->dirstart = c->dirpos[c->dirlevel]; | 476 | c->selected_item=c->selected_item_history[c->dirlevel]; |
475 | c->dircursor = c->cursorpos[c->dirlevel]; | 477 | gui_synclist_select_item(&tree_lists, c->selected_item); |
476 | c->currtable = c->table_history[c->dirlevel]; | 478 | c->currtable = c->table_history[c->dirlevel]; |
477 | c->currextra = c->extra_history[c->dirlevel]; | 479 | c->currextra = c->extra_history[c->dirlevel]; |
478 | c->firstpos = c->pos_history[c->dirlevel]; | 480 | c->firstpos = c->pos_history[c->dirlevel]; |
@@ -481,9 +483,8 @@ void db_exit(struct tree_context* c) | |||
481 | int db_get_filename(struct tree_context* c, char *buf, int buflen) | 483 | int db_get_filename(struct tree_context* c, char *buf, int buflen) |
482 | { | 484 | { |
483 | int rc; | 485 | int rc; |
484 | int filenum = c->dircursor + c->dirstart; | 486 | int pathoffset = ((int*)c->dircache)[c->selected_item * c->dentry_size + 1]; |
485 | int pathoffset = ((int*)c->dircache)[filenum * c->dentry_size + 1]; | 487 | |
486 | |||
487 | lseek(tagdb_fd, pathoffset, SEEK_SET); | 488 | lseek(tagdb_fd, pathoffset, SEEK_SET); |
488 | rc = read(tagdb_fd, buf, buflen); | 489 | rc = read(tagdb_fd, buf, buflen); |
489 | 490 | ||
@@ -498,7 +499,6 @@ static int db_play_folder(struct tree_context* c) | |||
498 | { | 499 | { |
499 | char buf[MAX_PATH]; | 500 | char buf[MAX_PATH]; |
500 | int rc, i; | 501 | int rc, i; |
501 | int filenum = c->dircursor + c->dirstart; | ||
502 | 502 | ||
503 | if (playlist_create(NULL, NULL) < 0) { | 503 | if (playlist_create(NULL, NULL) < 0) { |
504 | DEBUGF("Failed creating playlist\n"); | 504 | DEBUGF("Failed creating playlist\n"); |
@@ -506,7 +506,7 @@ static int db_play_folder(struct tree_context* c) | |||
506 | } | 506 | } |
507 | 507 | ||
508 | /* TODO: add support for very long tables */ | 508 | /* TODO: add support for very long tables */ |
509 | 509 | ||
510 | for (i=0; i < c->filesindir; i++) { | 510 | for (i=0; i < c->filesindir; i++) { |
511 | int pathoffset = ((int*)c->dircache)[i * c->dentry_size + 1]; | 511 | int pathoffset = ((int*)c->dircache)[i * c->dentry_size + 1]; |
512 | lseek(tagdb_fd, pathoffset, SEEK_SET); | 512 | lseek(tagdb_fd, pathoffset, SEEK_SET); |
@@ -520,11 +520,12 @@ static int db_play_folder(struct tree_context* c) | |||
520 | } | 520 | } |
521 | 521 | ||
522 | if (global_settings.playlist_shuffle) | 522 | if (global_settings.playlist_shuffle) |
523 | filenum = playlist_shuffle(current_tick, filenum); | 523 | c->selected_item = playlist_shuffle(current_tick, c->selected_item); |
524 | if (!global_settings.play_selected) | 524 | if (!global_settings.play_selected) |
525 | filenum = 0; | 525 | c->selected_item = 0; |
526 | gui_synclist_select_item(&tree_lists, c->selected_item); | ||
526 | 527 | ||
527 | playlist_start(filenum,0); | 528 | playlist_start(c->selected_item,0); |
528 | 529 | ||
529 | return 0; | 530 | return 0; |
530 | } | 531 | } |
diff --git a/apps/filetree.c b/apps/filetree.c index 37a66c60ee..e8b8df73ad 100644 --- a/apps/filetree.c +++ b/apps/filetree.c | |||
@@ -79,12 +79,12 @@ static void check_file_thumbnails(struct tree_context* c) | |||
79 | struct dircache_entry *entry; | 79 | struct dircache_entry *entry; |
80 | struct entry* dircache = c->dircache; | 80 | struct entry* dircache = c->dircache; |
81 | DIRCACHED *dir; | 81 | DIRCACHED *dir; |
82 | 82 | ||
83 | dir = opendir_cached(c->currdir); | 83 | dir = opendir_cached(c->currdir); |
84 | if(!dir) | 84 | if(!dir) |
85 | return; | 85 | return; |
86 | 86 | /* mark all files as non talking, except the .talk ones */ | |
87 | for (i=0; i < c->filesindir; i++) /* mark all files as non talking, except the .talk ones */ | 87 | for (i=0; i < c->filesindir; i++) |
88 | { | 88 | { |
89 | if (dircache[i].attr & ATTR_DIRECTORY) | 89 | if (dircache[i].attr & ATTR_DIRECTORY) |
90 | continue; /* we're not touching directories */ | 90 | continue; /* we're not touching directories */ |
@@ -100,7 +100,7 @@ static void check_file_thumbnails(struct tree_context* c) | |||
100 | dircache[i].attr |= TREE_ATTR_THUMBNAIL; /* set */ | 100 | dircache[i].attr |= TREE_ATTR_THUMBNAIL; /* set */ |
101 | } | 101 | } |
102 | } | 102 | } |
103 | 103 | ||
104 | while((entry = readdir_cached(dir)) != 0) /* walk directory */ | 104 | while((entry = readdir_cached(dir)) != 0) /* walk directory */ |
105 | { | 105 | { |
106 | int ext_pos; | 106 | int ext_pos; |
@@ -110,13 +110,13 @@ static void check_file_thumbnails(struct tree_context* c) | |||
110 | || (entry->attribute & ATTR_DIRECTORY) /* no file */ | 110 | || (entry->attribute & ATTR_DIRECTORY) /* no file */ |
111 | || strcasecmp(&entry->d_name[ext_pos], file_thumbnail_ext)) | 111 | || strcasecmp(&entry->d_name[ext_pos], file_thumbnail_ext)) |
112 | { /* or doesn't end with ".talk", no candidate */ | 112 | { /* or doesn't end with ".talk", no candidate */ |
113 | continue; | 113 | continue; |
114 | } | 114 | } |
115 | 115 | ||
116 | /* terminate the (disposable) name in dir buffer, | 116 | /* terminate the (disposable) name in dir buffer, |
117 | this truncates off the ".talk" without needing an extra buffer */ | 117 | this truncates off the ".talk" without needing an extra buffer */ |
118 | entry->d_name[ext_pos] = '\0'; | 118 | entry->d_name[ext_pos] = '\0'; |
119 | 119 | ||
120 | /* search corresponding file in dir cache */ | 120 | /* search corresponding file in dir cache */ |
121 | for (i=0; i < c->filesindir; i++) | 121 | for (i=0; i < c->filesindir; i++) |
122 | { | 122 | { |
@@ -187,7 +187,7 @@ static int compare(const void* p1, const void* p2) | |||
187 | return 0; /* never reached */ | 187 | return 0; /* never reached */ |
188 | } | 188 | } |
189 | 189 | ||
190 | /* load and sort directory into dircache. returns NULL on failure. */ | 190 | /* load and sort directory into dircache. returns NULL on failure. */ |
191 | int ft_load(struct tree_context* c, const char* tempdir) | 191 | int ft_load(struct tree_context* c, const char* tempdir) |
192 | { | 192 | { |
193 | int i; | 193 | int i; |
@@ -256,7 +256,7 @@ int ft_load(struct tree_context* c, const char* tempdir) | |||
256 | boot_cluster = entry->startcluster; | 256 | boot_cluster = entry->startcluster; |
257 | } | 257 | } |
258 | #endif | 258 | #endif |
259 | 259 | ||
260 | /* filter out non-visible files */ | 260 | /* filter out non-visible files */ |
261 | if ((!(dptr->attr & ATTR_DIRECTORY) && ( | 261 | if ((!(dptr->attr & ATTR_DIRECTORY) && ( |
262 | (*c->dirfilter == SHOW_PLAYLIST && | 262 | (*c->dirfilter == SHOW_PLAYLIST && |
@@ -289,7 +289,7 @@ int ft_load(struct tree_context* c, const char* tempdir) | |||
289 | name_buffer_used += len + 1; | 289 | name_buffer_used += len + 1; |
290 | 290 | ||
291 | if (dptr->attr & ATTR_DIRECTORY) /* count the remaining dirs */ | 291 | if (dptr->attr & ATTR_DIRECTORY) /* count the remaining dirs */ |
292 | c->dirsindir++; | 292 | c->dirsindir++; |
293 | } | 293 | } |
294 | c->filesindir = i; | 294 | c->filesindir = i; |
295 | c->dirlength = i; | 295 | c->dirlength = i; |
@@ -297,7 +297,7 @@ int ft_load(struct tree_context* c, const char* tempdir) | |||
297 | 297 | ||
298 | qsort(c->dircache,i,sizeof(struct entry),compare); | 298 | qsort(c->dircache,i,sizeof(struct entry),compare); |
299 | 299 | ||
300 | /* If thumbnail talking is enabled, make an extra run to mark files with | 300 | /* If thumbnail talking is enabled, make an extra run to mark files with |
301 | associated thumbnails, so we don't do unsuccessful spinups later. */ | 301 | associated thumbnails, so we don't do unsuccessful spinups later. */ |
302 | if (global_settings.talk_file == 3) | 302 | if (global_settings.talk_file == 3) |
303 | check_file_thumbnails(c); /* map .talk to ours */ | 303 | check_file_thumbnails(c); /* map .talk to ours */ |
@@ -310,7 +310,7 @@ int ft_enter(struct tree_context* c) | |||
310 | int rc = 0; | 310 | int rc = 0; |
311 | char buf[MAX_PATH]; | 311 | char buf[MAX_PATH]; |
312 | struct entry *dircache = c->dircache; | 312 | struct entry *dircache = c->dircache; |
313 | struct entry* file = &dircache[c->dircursor + c->dirstart]; | 313 | struct entry* file = &dircache[c->selected_item]; |
314 | bool reload_dir = false; | 314 | bool reload_dir = false; |
315 | bool start_wps = false; | 315 | bool start_wps = false; |
316 | bool exit_func = false; | 316 | bool exit_func = false; |
@@ -322,13 +322,10 @@ int ft_enter(struct tree_context* c) | |||
322 | 322 | ||
323 | if (file->attr & ATTR_DIRECTORY) { | 323 | if (file->attr & ATTR_DIRECTORY) { |
324 | memcpy(c->currdir, buf, sizeof(c->currdir)); | 324 | memcpy(c->currdir, buf, sizeof(c->currdir)); |
325 | if ( c->dirlevel < MAX_DIR_LEVELS ) { | 325 | if ( c->dirlevel < MAX_DIR_LEVELS ) |
326 | c->dirpos[c->dirlevel] = c->dirstart; | 326 | c->selected_item_history[c->dirlevel] = c->selected_item; |
327 | c->cursorpos[c->dirlevel] = c->dircursor; | ||
328 | } | ||
329 | c->dirlevel++; | 327 | c->dirlevel++; |
330 | c->dircursor=0; | 328 | c->selected_item=0; |
331 | c->dirstart=0; | ||
332 | } | 329 | } |
333 | else { | 330 | else { |
334 | int seed = current_tick; | 331 | int seed = current_tick; |
@@ -357,8 +354,7 @@ int ft_enter(struct tree_context* c) | |||
357 | 354 | ||
358 | if (playlist_create(c->currdir, NULL) != -1) | 355 | if (playlist_create(c->currdir, NULL) != -1) |
359 | { | 356 | { |
360 | start_index = | 357 | start_index = ft_build_playlist(c, c->selected_item); |
361 | ft_build_playlist(c, c->dircursor + c->dirstart); | ||
362 | if (global_settings.playlist_shuffle) | 358 | if (global_settings.playlist_shuffle) |
363 | { | 359 | { |
364 | start_index = playlist_shuffle(seed, start_index); | 360 | start_index = playlist_shuffle(seed, start_index); |
@@ -497,14 +493,13 @@ int ft_exit(struct tree_context* c) | |||
497 | exit_func = true; | 493 | exit_func = true; |
498 | 494 | ||
499 | c->dirlevel--; | 495 | c->dirlevel--; |
500 | if ( c->dirlevel < MAX_DIR_LEVELS ) { | 496 | if ( c->dirlevel < MAX_DIR_LEVELS ) |
501 | c->dirstart = c->dirpos[c->dirlevel]; | 497 | c->selected_item=c->selected_item_history[c->dirlevel]; |
502 | c->dircursor = c->cursorpos[c->dirlevel]; | ||
503 | } | ||
504 | else | 498 | else |
505 | c->dirstart = c->dircursor = 0; | 499 | c->selected_item=0; |
506 | 500 | ||
507 | if (c->dirstart == -1) | 501 | /* if undefined position */ |
502 | if (c->selected_item == -1) | ||
508 | strcpy(lastfile, buf); | 503 | strcpy(lastfile, buf); |
509 | } | 504 | } |
510 | else | 505 | else |
diff --git a/apps/gui/buttonbar.c b/apps/gui/buttonbar.c new file mode 100644 index 0000000000..be87b1b81f --- /dev/null +++ b/apps/gui/buttonbar.c | |||
@@ -0,0 +1,126 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) Linus Nielsen Feltzing (2002), Kévin FERRARE (2005) | ||
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 | |||
20 | #include "config.h" | ||
21 | #include "buttonbar.h" | ||
22 | |||
23 | #ifdef HAS_BUTTONBAR | ||
24 | |||
25 | #include "lcd.h" | ||
26 | #include "font.h" | ||
27 | #include "string.h" | ||
28 | #include "settings.h" | ||
29 | |||
30 | void gui_buttonbar_init(struct gui_buttonbar * buttonbar) | ||
31 | { | ||
32 | gui_buttonbar_unset(buttonbar); | ||
33 | } | ||
34 | |||
35 | void gui_buttonbar_set_display(struct gui_buttonbar * buttonbar, | ||
36 | struct screen * display) | ||
37 | { | ||
38 | buttonbar->display = display; | ||
39 | } | ||
40 | |||
41 | void gui_buttonbar_draw_button(struct gui_buttonbar * buttonbar, int num) | ||
42 | { | ||
43 | int xpos, ypos, button_width, text_width; | ||
44 | int fw, fh; | ||
45 | struct screen * display = buttonbar->display; | ||
46 | |||
47 | display->setfont(FONT_SYSFIXED); | ||
48 | display->getstringsize("M", &fw, &fh); | ||
49 | |||
50 | button_width = display->width/BUTTONBAR_MAX_BUTTONS; | ||
51 | xpos = num * button_width; | ||
52 | ypos = display->height - fh; | ||
53 | |||
54 | if(buttonbar->caption[num][0] != 0) | ||
55 | { | ||
56 | /* center the text */ | ||
57 | text_width = fw * strlen(buttonbar->caption[num]); | ||
58 | display->putsxy(xpos + (button_width - text_width)/2, | ||
59 | ypos, buttonbar->caption[num]); | ||
60 | } | ||
61 | |||
62 | display->set_drawmode(DRMODE_COMPLEMENT); | ||
63 | display->fillrect(xpos, ypos, button_width - 1, fh); | ||
64 | display->set_drawmode(DRMODE_SOLID); | ||
65 | display->setfont(FONT_UI); | ||
66 | } | ||
67 | |||
68 | void gui_buttonbar_set(struct gui_buttonbar * buttonbar, | ||
69 | const char *caption1, | ||
70 | const char *caption2, | ||
71 | const char *caption3) | ||
72 | { | ||
73 | gui_buttonbar_unset(buttonbar); | ||
74 | if(caption1) | ||
75 | { | ||
76 | strncpy(buttonbar->caption[0], caption1, 7); | ||
77 | buttonbar->caption[0][7] = 0; | ||
78 | } | ||
79 | if(caption2) | ||
80 | { | ||
81 | strncpy(buttonbar->caption[1], caption2, 7); | ||
82 | buttonbar->caption[1][7] = 0; | ||
83 | } | ||
84 | if(caption3) | ||
85 | { | ||
86 | strncpy(buttonbar->caption[2], caption3, 7); | ||
87 | buttonbar->caption[2][7] = 0; | ||
88 | } | ||
89 | } | ||
90 | |||
91 | void gui_buttonbar_unset(struct gui_buttonbar * buttonbar) | ||
92 | { | ||
93 | int i; | ||
94 | for(i = 0;i < BUTTONBAR_MAX_BUTTONS;++i) | ||
95 | buttonbar->caption[i][0] = 0; | ||
96 | } | ||
97 | |||
98 | void gui_buttonbar_draw(struct gui_buttonbar * buttonbar) | ||
99 | { | ||
100 | struct screen * display = buttonbar->display; | ||
101 | int i; | ||
102 | |||
103 | display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
104 | display->fillrect(0, display->height - BUTTONBAR_HEIGHT, | ||
105 | display->width, BUTTONBAR_HEIGHT); | ||
106 | display->set_drawmode(DRMODE_SOLID); | ||
107 | |||
108 | for(i = 0;i < BUTTONBAR_MAX_BUTTONS;++i) | ||
109 | gui_buttonbar_draw_button(buttonbar, i); | ||
110 | display->update_rect(0, display->height - BUTTONBAR_HEIGHT, | ||
111 | display->width, BUTTONBAR_HEIGHT); | ||
112 | } | ||
113 | |||
114 | bool gui_buttonbar_isset(struct gui_buttonbar * buttonbar) | ||
115 | { | ||
116 | /* If all buttons are unset, the button bar is considered disabled */ | ||
117 | if(!global_settings.buttonbar) | ||
118 | return(false); | ||
119 | int i; | ||
120 | for(i = 0;i < BUTTONBAR_MAX_BUTTONS;++i) | ||
121 | if(buttonbar->caption[i] != 0) | ||
122 | return true; | ||
123 | return false; | ||
124 | } | ||
125 | |||
126 | #endif /* HAS_BUTTONBAR */ | ||
diff --git a/apps/gui/buttonbar.h b/apps/gui/buttonbar.h new file mode 100644 index 0000000000..ee7b8d02c4 --- /dev/null +++ b/apps/gui/buttonbar.h | |||
@@ -0,0 +1,81 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2005 by Kévin FERRARE | ||
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 | |||
20 | #ifndef _GUI_BUTTONBAR_H_ | ||
21 | #define _GUI_BUTTONBAR_H_ | ||
22 | #include "config.h" | ||
23 | #include "button.h" | ||
24 | #if CONFIG_KEYPAD == RECORDER_PAD | ||
25 | |||
26 | #define HAS_BUTTONBAR | ||
27 | #define BUTTONBAR_HEIGHT 8 | ||
28 | #define BUTTONBAR_MAX_BUTTONS 3 | ||
29 | #define BUTTONBAR_CAPTION_LENGTH 8 | ||
30 | #include "screen_access.h" | ||
31 | |||
32 | struct gui_buttonbar | ||
33 | { | ||
34 | char caption[BUTTONBAR_MAX_BUTTONS][BUTTONBAR_CAPTION_LENGTH]; | ||
35 | struct screen * display; | ||
36 | }; | ||
37 | |||
38 | /* | ||
39 | * Initializes the buttonbar | ||
40 | * - buttonbar : the buttonbar | ||
41 | */ | ||
42 | extern void gui_buttonbar_init(struct gui_buttonbar * buttonbar); | ||
43 | |||
44 | /* | ||
45 | * Attach the buttonbar to a screen | ||
46 | * - buttonbar : the buttonbar | ||
47 | * - display : the display to attach the buttonbar | ||
48 | */ | ||
49 | extern void gui_buttonbar_set_display(struct gui_buttonbar * buttonbar, | ||
50 | struct screen * display); | ||
51 | |||
52 | /* | ||
53 | * Set the caption of the items of the buttonbar | ||
54 | * - buttonbar : the buttonbar | ||
55 | * - caption1,2,3 : the first, second and thirds items of the bar | ||
56 | */ | ||
57 | extern void gui_buttonbar_set(struct gui_buttonbar * buttonbar, | ||
58 | const char *caption1, | ||
59 | const char *caption2, | ||
60 | const char *caption3); | ||
61 | |||
62 | /* | ||
63 | * Disable the buttonbar | ||
64 | * - buttonbar : the buttonbar | ||
65 | */ | ||
66 | extern void gui_buttonbar_unset(struct gui_buttonbar * buttonbar); | ||
67 | |||
68 | /* | ||
69 | * Draw the buttonbar on it's attached screen | ||
70 | * - buttonbar : the buttonbar | ||
71 | */ | ||
72 | extern void gui_buttonbar_draw(struct gui_buttonbar * buttonbar); | ||
73 | |||
74 | /* | ||
75 | * Returns true if the buttonbar has something to display, false otherwise | ||
76 | * - buttonbar : the buttonbar | ||
77 | */ | ||
78 | extern bool gui_buttonbar_isset(struct gui_buttonbar * buttonbar); | ||
79 | |||
80 | #endif /* CONFIG_KEYPAD == RECORDER_PAD */ | ||
81 | #endif /* _GUI_BUTTONBAR_H_ */ | ||
diff --git a/apps/gui/icon.c b/apps/gui/icon.c new file mode 100644 index 0000000000..4d174d3427 --- /dev/null +++ b/apps/gui/icon.c | |||
@@ -0,0 +1,49 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) Robert E. Hak(2002), Kévin FERRARE (2005) | ||
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 | |||
20 | #include "config.h" | ||
21 | #include "icon.h" | ||
22 | #include "screen_access.h" | ||
23 | #include "icons.h" | ||
24 | |||
25 | /* Count in letter positions, NOT pixels */ | ||
26 | void screen_put_iconxy(struct screen * display, int x, int y, ICON icon) | ||
27 | { | ||
28 | #ifdef HAVE_LCD_BITMAP | ||
29 | if(icon==0)/* Don't display invalid icons */ | ||
30 | return; | ||
31 | int xpos, ypos; | ||
32 | xpos = x*CURSOR_WIDTH; | ||
33 | ypos = y*display->char_height + display->getymargin(); | ||
34 | if ( display->char_height > CURSOR_HEIGHT )/* center the cursor */ | ||
35 | ypos += (display->char_height - CURSOR_HEIGHT) / 2; | ||
36 | display->mono_bitmap(icon, xpos, ypos, CURSOR_WIDTH, CURSOR_HEIGHT); | ||
37 | #else | ||
38 | display->putc(x, y, icon); | ||
39 | #endif | ||
40 | } | ||
41 | |||
42 | void screen_put_cursorxy(struct screen * display, int x, int y) | ||
43 | { | ||
44 | #ifdef HAVE_LCD_BITMAP | ||
45 | screen_put_iconxy(display, x, y, bitmap_icons_6x8[Icon_Cursor]); | ||
46 | #else | ||
47 | screen_put_iconxy(display, x, y, CURSOR_CHAR); | ||
48 | #endif | ||
49 | } | ||
diff --git a/apps/gui/icon.h b/apps/gui/icon.h new file mode 100644 index 0000000000..46faf0972f --- /dev/null +++ b/apps/gui/icon.h | |||
@@ -0,0 +1,51 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2005 by Kévin FERRARE | ||
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 | |||
20 | #ifndef _GUI_ICON_H_ | ||
21 | #define _GUI_ICON_H_ | ||
22 | #include "lcd.h" | ||
23 | #include "screen_access.h" | ||
24 | /* Defines a type for the icons since it's not the same thing on | ||
25 | * char-based displays and bitmap displays */ | ||
26 | #ifdef HAVE_LCD_BITMAP | ||
27 | #define ICON const unsigned char * | ||
28 | #else | ||
29 | #define ICON unsigned short | ||
30 | #endif | ||
31 | |||
32 | #define CURSOR_CHAR 0x92 | ||
33 | #define CURSOR_WIDTH 6 | ||
34 | #define CURSOR_HEIGHT 8 | ||
35 | /* | ||
36 | * Draws a cursor at a given position | ||
37 | * - screen : the screen where we put the cursor | ||
38 | * - x, y : the position, in character, not in pixel !! | ||
39 | */ | ||
40 | extern void screen_put_cursorxy(struct screen * screen, int x, int y); | ||
41 | |||
42 | /* | ||
43 | * Put an icon on a screen at a given position | ||
44 | * (the position is given in characters) | ||
45 | * - screen : the screen where we put our icon | ||
46 | * - x, y : the position, in character, not in pixel !! | ||
47 | * - icon : the icon to put | ||
48 | */ | ||
49 | extern void screen_put_iconxy(struct screen * screen, int x, int y, ICON icon); | ||
50 | |||
51 | #endif /*_GUI_ICON_H_*/ | ||
diff --git a/apps/gui/list.c b/apps/gui/list.c new file mode 100644 index 0000000000..bb3eb7caaa --- /dev/null +++ b/apps/gui/list.c | |||
@@ -0,0 +1,499 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2005 by Kévin FERRARE | ||
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 | |||
20 | #include "config.h" | ||
21 | #include "lcd.h" | ||
22 | #include "font.h" | ||
23 | #include "button.h" | ||
24 | #include "sprintf.h" | ||
25 | #include "settings.h" | ||
26 | #include "kernel.h" | ||
27 | |||
28 | #include "screen_access.h" | ||
29 | #include "list.h" | ||
30 | #include "scrollbar.h" | ||
31 | #include "statusbar.h" | ||
32 | |||
33 | #ifdef HAVE_LCD_CHARCELLS | ||
34 | #define SCROLL_LIMIT 1 | ||
35 | #else | ||
36 | #define SCROLL_LIMIT 2 | ||
37 | #endif | ||
38 | |||
39 | |||
40 | |||
41 | void gui_list_init(struct gui_list * gui_list, | ||
42 | void (*callback_get_item_icon)(int selected_item, ICON * icon), | ||
43 | char * (*callback_get_item_name)(int selected_item, char *buffer)) | ||
44 | { | ||
45 | gui_list->callback_get_item_icon = callback_get_item_icon; | ||
46 | gui_list->callback_get_item_name = callback_get_item_name; | ||
47 | gui_list->display = NULL; | ||
48 | gui_list_set_nb_items(gui_list, 0); | ||
49 | gui_list->selected_item = 0; | ||
50 | gui_list->start_item = 0; | ||
51 | } | ||
52 | |||
53 | void gui_list_set_nb_items(struct gui_list * gui_list, int nb_items) | ||
54 | { | ||
55 | gui_list->nb_items = nb_items; | ||
56 | } | ||
57 | |||
58 | void gui_list_set_display(struct gui_list * gui_list, struct screen * display) | ||
59 | { | ||
60 | if(gui_list->display != 0) /* we switched from a previous display */ | ||
61 | gui_list->display->stop_scroll(); | ||
62 | gui_list->display = display; | ||
63 | #ifdef HAVE_LCD_CHARCELLS | ||
64 | display->double_height(false); | ||
65 | #endif | ||
66 | gui_list_put_selection_in_screen(gui_list, false); | ||
67 | } | ||
68 | |||
69 | void gui_list_put_selection_in_screen(struct gui_list * gui_list, | ||
70 | bool put_from_end) | ||
71 | { | ||
72 | struct screen * display = gui_list->display; | ||
73 | if(put_from_end) | ||
74 | { | ||
75 | int list_end = gui_list->selected_item + SCROLL_LIMIT - 1; | ||
76 | if(list_end > gui_list->nb_items) | ||
77 | list_end = gui_list->nb_items; | ||
78 | gui_list->start_item = list_end - display->nb_lines; | ||
79 | } | ||
80 | else | ||
81 | { | ||
82 | int list_start = gui_list->selected_item - SCROLL_LIMIT + 1; | ||
83 | if(list_start + display->nb_lines > gui_list->nb_items) | ||
84 | list_start = gui_list->nb_items - display->nb_lines; | ||
85 | gui_list->start_item = list_start; | ||
86 | } | ||
87 | if(gui_list->start_item < 0) | ||
88 | gui_list->start_item = 0; | ||
89 | } | ||
90 | |||
91 | void gui_list_get_selected_item_name(struct gui_list * gui_list, char *buffer) | ||
92 | { | ||
93 | gui_list->callback_get_item_name(gui_list->selected_item, buffer); | ||
94 | } | ||
95 | |||
96 | int gui_list_get_selected_item_position(struct gui_list * gui_list) | ||
97 | { | ||
98 | return gui_list->selected_item; | ||
99 | } | ||
100 | |||
101 | void gui_list_draw(struct gui_list * gui_list) | ||
102 | { | ||
103 | struct screen * display=gui_list->display; | ||
104 | int cursor_pos = 0; | ||
105 | int icon_pos = 1; | ||
106 | int text_pos; | ||
107 | bool draw_icons = (gui_list->callback_get_item_icon != NULL && | ||
108 | global_settings.show_icons) ; | ||
109 | bool draw_cursor; | ||
110 | int i; | ||
111 | |||
112 | /* Adjust the position of icon, cursor, text */ | ||
113 | #ifdef HAVE_LCD_BITMAP | ||
114 | bool draw_scrollbar = (global_settings.scrollbar && | ||
115 | display->nb_lines < gui_list->nb_items); | ||
116 | |||
117 | int list_y_start = screen_get_text_y_start(gui_list->display); | ||
118 | int list_y_end = screen_get_text_y_end(gui_list->display); | ||
119 | |||
120 | draw_cursor = !global_settings.invert_cursor; | ||
121 | text_pos = 0; /* here it's in pixels */ | ||
122 | if(draw_scrollbar) | ||
123 | { | ||
124 | ++cursor_pos; | ||
125 | ++icon_pos; | ||
126 | text_pos += SCROLLBAR_WIDTH; | ||
127 | } | ||
128 | if(!draw_cursor) | ||
129 | { | ||
130 | --icon_pos; | ||
131 | } | ||
132 | else | ||
133 | text_pos += CURSOR_WIDTH; | ||
134 | |||
135 | if(draw_icons) | ||
136 | text_pos += 8; | ||
137 | #else | ||
138 | draw_cursor = true; | ||
139 | if(draw_icons) | ||
140 | text_pos = 2; /* here it's in chars */ | ||
141 | else | ||
142 | text_pos = 1; | ||
143 | #endif | ||
144 | /* The drawing part */ | ||
145 | #ifdef HAVE_LCD_BITMAP | ||
146 | /* clear the drawing area */ | ||
147 | display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
148 | display->fillrect(0, list_y_start, | ||
149 | display->width, list_y_end - list_y_start); | ||
150 | display->set_drawmode(DRMODE_SOLID); | ||
151 | |||
152 | /* FIXME: should not be handled here, but rather in the | ||
153 | * code that changes fonts */ | ||
154 | screen_update_nblines(display); | ||
155 | |||
156 | display->stop_scroll(); | ||
157 | display->setmargins(text_pos, list_y_start); | ||
158 | #else | ||
159 | display->clear_display(); | ||
160 | #endif | ||
161 | |||
162 | for(i = 0;i < display->nb_lines;++i) | ||
163 | { | ||
164 | char entry_buffer[MAX_PATH]; | ||
165 | char * entry_name; | ||
166 | int current_item = gui_list->start_item + i; | ||
167 | |||
168 | /* When there are less items to display than the | ||
169 | * current available space on the screen, we stop*/ | ||
170 | if(current_item >= gui_list->nb_items) | ||
171 | break; | ||
172 | entry_name = gui_list->callback_get_item_name(current_item, | ||
173 | entry_buffer); | ||
174 | if(current_item == gui_list->selected_item) | ||
175 | { | ||
176 | /* The selected item must be displayed scrolling */ | ||
177 | #ifdef HAVE_LCD_BITMAP | ||
178 | if (global_settings.invert_cursor)/* Display inverted-line-style*/ | ||
179 | display->puts_scroll_style(0, i, entry_name, STYLE_INVERT); | ||
180 | else | ||
181 | display->puts_scroll(0, i, entry_name); | ||
182 | #else | ||
183 | display->puts_scroll(text_pos, i, entry_name); | ||
184 | #endif | ||
185 | |||
186 | if(draw_cursor) | ||
187 | screen_put_cursorxy(display, cursor_pos, i); | ||
188 | } | ||
189 | else | ||
190 | {/* normal item */ | ||
191 | #ifdef HAVE_LCD_BITMAP | ||
192 | display->puts(0, i, entry_name); | ||
193 | #else | ||
194 | display->puts(text_pos, i, entry_name); | ||
195 | #endif | ||
196 | } | ||
197 | /* Icons display */ | ||
198 | if(draw_icons) | ||
199 | { | ||
200 | ICON icon; | ||
201 | gui_list->callback_get_item_icon(current_item, &icon); | ||
202 | screen_put_iconxy(display, icon_pos, i, icon); | ||
203 | } | ||
204 | } | ||
205 | #ifdef HAVE_LCD_BITMAP | ||
206 | /* Draw the scrollbar if needed*/ | ||
207 | if(draw_scrollbar) | ||
208 | { | ||
209 | int scrollbar_y_end = display->char_height * | ||
210 | display->nb_lines + list_y_start; | ||
211 | gui_scrollbar_draw(display, 0, list_y_start, SCROLLBAR_WIDTH-1, | ||
212 | scrollbar_y_end - list_y_start, gui_list->nb_items, | ||
213 | gui_list->start_item, | ||
214 | gui_list->start_item + display->nb_lines, VERTICAL); | ||
215 | } | ||
216 | display->update_rect(0, list_y_start, display->width, | ||
217 | list_y_end - list_y_start); | ||
218 | #else | ||
219 | #ifdef SIMULATOR | ||
220 | display->update(); | ||
221 | #endif | ||
222 | #endif | ||
223 | } | ||
224 | |||
225 | void gui_list_select_item(struct gui_list * gui_list, int item_number) | ||
226 | { | ||
227 | if( item_number > gui_list->nb_items-1 || item_number < 0 ) | ||
228 | return; | ||
229 | gui_list->selected_item = item_number; | ||
230 | gui_list_put_selection_in_screen(gui_list, false); | ||
231 | } | ||
232 | |||
233 | void gui_list_select_next(struct gui_list * gui_list) | ||
234 | { | ||
235 | int item_pos; | ||
236 | int end_item; | ||
237 | int nb_lines = gui_list->display->nb_lines; | ||
238 | |||
239 | ++gui_list->selected_item; | ||
240 | |||
241 | if( gui_list->selected_item >= gui_list->nb_items ) | ||
242 | { | ||
243 | /* we have already reached the bottom of the list */ | ||
244 | gui_list->selected_item = 0; | ||
245 | gui_list->start_item = 0; | ||
246 | } | ||
247 | else | ||
248 | { | ||
249 | item_pos = gui_list->selected_item - gui_list->start_item; | ||
250 | end_item = gui_list->start_item + nb_lines; | ||
251 | /* we start scrolling vertically when reaching the line | ||
252 | * (nb_lines-SCROLL_LIMIT) | ||
253 | * and when we are not in the last part of the list*/ | ||
254 | if( item_pos > nb_lines-SCROLL_LIMIT && end_item < gui_list->nb_items ) | ||
255 | ++gui_list->start_item; | ||
256 | } | ||
257 | } | ||
258 | |||
259 | void gui_list_select_previous(struct gui_list * gui_list) | ||
260 | { | ||
261 | int item_pos; | ||
262 | int nb_lines = gui_list->display->nb_lines; | ||
263 | |||
264 | --gui_list->selected_item; | ||
265 | if( gui_list->selected_item < 0 ) | ||
266 | { | ||
267 | /* we have aleady reached the top of the list */ | ||
268 | int start; | ||
269 | gui_list->selected_item = gui_list->nb_items-1; | ||
270 | start = gui_list->nb_items-nb_lines; | ||
271 | if( start < 0 ) | ||
272 | gui_list->start_item = 0; | ||
273 | else | ||
274 | gui_list->start_item = start; | ||
275 | } | ||
276 | else | ||
277 | { | ||
278 | item_pos = gui_list->selected_item - gui_list->start_item; | ||
279 | if( item_pos < SCROLL_LIMIT-1 && gui_list->start_item > 0 ) | ||
280 | --gui_list->start_item; | ||
281 | } | ||
282 | } | ||
283 | |||
284 | void gui_list_select_next_page(struct gui_list * gui_list, int nb_lines) | ||
285 | { | ||
286 | if(gui_list->selected_item == gui_list->nb_items-1) | ||
287 | gui_list->selected_item = 0; | ||
288 | else | ||
289 | { | ||
290 | gui_list->selected_item += nb_lines; | ||
291 | if(gui_list->selected_item > gui_list->nb_items-1) | ||
292 | gui_list->selected_item = gui_list->nb_items-1; | ||
293 | } | ||
294 | gui_list_put_selection_in_screen(gui_list, true); | ||
295 | } | ||
296 | |||
297 | void gui_list_select_previous_page(struct gui_list * gui_list, int nb_lines) | ||
298 | { | ||
299 | if(gui_list->selected_item == 0) | ||
300 | gui_list->selected_item = gui_list->nb_items - 1; | ||
301 | else | ||
302 | { | ||
303 | gui_list->selected_item -= nb_lines; | ||
304 | if(gui_list->selected_item < 0) | ||
305 | gui_list->selected_item = 0; | ||
306 | } | ||
307 | gui_list_put_selection_in_screen(gui_list, false); | ||
308 | } | ||
309 | |||
310 | void gui_list_add_item(struct gui_list * gui_list) | ||
311 | { | ||
312 | ++gui_list->nb_items; | ||
313 | /* if only one item in the list, select it */ | ||
314 | if(gui_list->nb_items == 1) | ||
315 | gui_list->selected_item = 0; | ||
316 | } | ||
317 | |||
318 | void gui_list_del_item(struct gui_list * gui_list) | ||
319 | { | ||
320 | int nb_lines = gui_list->display->nb_lines; | ||
321 | |||
322 | if(gui_list->nb_items > 0) | ||
323 | { | ||
324 | int dist_selected_from_end = gui_list->nb_items | ||
325 | - gui_list->selected_item - 1; | ||
326 | int dist_start_from_end = gui_list->nb_items | ||
327 | - gui_list->start_item - 1; | ||
328 | if(dist_selected_from_end == 0) | ||
329 | { | ||
330 | /* Oops we are removing the selected item, | ||
331 | select the previous one */ | ||
332 | --gui_list->selected_item; | ||
333 | } | ||
334 | --gui_list->nb_items; | ||
335 | |||
336 | /* scroll the list if needed */ | ||
337 | if( (dist_start_from_end < nb_lines) && (gui_list->start_item != 0) ) | ||
338 | --gui_list->start_item; | ||
339 | } | ||
340 | } | ||
341 | |||
342 | /* | ||
343 | * Synchronized lists stuffs | ||
344 | */ | ||
345 | void gui_synclist_init( | ||
346 | struct gui_synclist * lists, | ||
347 | void (*callback_get_item_icon)(int selected_item, ICON * icon), | ||
348 | char * (*callback_get_item_name)(int selected_item, char *buffer) | ||
349 | ) | ||
350 | { | ||
351 | int i; | ||
352 | for(i = 0;i < NB_SCREENS;i++) | ||
353 | { | ||
354 | gui_list_init(&(lists->gui_list[i]), callback_get_item_icon, | ||
355 | callback_get_item_name); | ||
356 | gui_list_set_display(&(lists->gui_list[i]), &(screens[i])); | ||
357 | } | ||
358 | } | ||
359 | |||
360 | void gui_synclist_set_nb_items(struct gui_synclist * lists, int nb_items) | ||
361 | { | ||
362 | int i; | ||
363 | for(i = 0;i < NB_SCREENS;i++) | ||
364 | { | ||
365 | gui_list_set_nb_items(&(lists->gui_list[i]), nb_items); | ||
366 | } | ||
367 | } | ||
368 | |||
369 | void gui_synclist_get_selected_item_name(struct gui_synclist * lists, | ||
370 | char *buffer) | ||
371 | { | ||
372 | gui_list_get_selected_item_name(&(lists->gui_list[0]), buffer); | ||
373 | } | ||
374 | |||
375 | int gui_synclist_get_selected_item_position(struct gui_synclist * lists) | ||
376 | { | ||
377 | return gui_list_get_selected_item_position(&(lists->gui_list[0])); | ||
378 | } | ||
379 | |||
380 | void gui_synclist_draw(struct gui_synclist * lists) | ||
381 | { | ||
382 | int i; | ||
383 | for(i = 0;i < NB_SCREENS;i++) | ||
384 | gui_list_draw(&(lists->gui_list[i])); | ||
385 | } | ||
386 | |||
387 | void gui_synclist_select_item(struct gui_synclist * lists, int item_number) | ||
388 | { | ||
389 | int i; | ||
390 | for(i = 0;i < NB_SCREENS;i++) | ||
391 | gui_list_select_item(&(lists->gui_list[i]), item_number); | ||
392 | } | ||
393 | |||
394 | void gui_synclist_select_next(struct gui_synclist * lists) | ||
395 | { | ||
396 | int i; | ||
397 | for(i = 0;i < NB_SCREENS;i++) | ||
398 | gui_list_select_next(&(lists->gui_list[i])); | ||
399 | } | ||
400 | |||
401 | void gui_synclist_select_previous(struct gui_synclist * lists) | ||
402 | { | ||
403 | int i; | ||
404 | for(i = 0;i < NB_SCREENS;i++) | ||
405 | gui_list_select_previous(&(lists->gui_list[i])); | ||
406 | } | ||
407 | |||
408 | void gui_synclist_select_next_page(struct gui_synclist * lists, | ||
409 | enum screen_type screen) | ||
410 | { | ||
411 | int i; | ||
412 | for(i = 0;i < NB_SCREENS;i++) | ||
413 | gui_list_select_next_page(&(lists->gui_list[i]), | ||
414 | screens[screen].nb_lines); | ||
415 | } | ||
416 | |||
417 | void gui_synclist_select_previous_page(struct gui_synclist * lists, | ||
418 | enum screen_type screen) | ||
419 | { | ||
420 | int i; | ||
421 | for(i = 0;i < NB_SCREENS;i++) | ||
422 | gui_list_select_previous_page(&(lists->gui_list[i]), | ||
423 | screens[screen].nb_lines); | ||
424 | } | ||
425 | |||
426 | void gui_synclist_add_item(struct gui_synclist * lists) | ||
427 | { | ||
428 | int i; | ||
429 | for(i = 0;i < NB_SCREENS;i++) | ||
430 | gui_list_add_item(&(lists->gui_list[i])); | ||
431 | } | ||
432 | |||
433 | void gui_synclist_del_item(struct gui_synclist * lists) | ||
434 | { | ||
435 | int i; | ||
436 | for(i = 0;i < NB_SCREENS;i++) | ||
437 | gui_list_del_item(&(lists->gui_list[i])); | ||
438 | } | ||
439 | |||
440 | bool gui_synclist_do_button(struct gui_synclist * lists, unsigned button) | ||
441 | { | ||
442 | switch(button) | ||
443 | { | ||
444 | case LIST_PREV: | ||
445 | case LIST_PREV | BUTTON_REPEAT: | ||
446 | #ifdef LIST_RC_PREV | ||
447 | case LIST_RC_PREV: | ||
448 | case LIST_RC_PREV | BUTTON_REPEAT: | ||
449 | #endif | ||
450 | gui_synclist_select_previous(lists); | ||
451 | gui_synclist_draw(lists); | ||
452 | return true; | ||
453 | |||
454 | case LIST_NEXT: | ||
455 | case LIST_NEXT | BUTTON_REPEAT: | ||
456 | #ifdef LIST_RC_NEXT | ||
457 | case LIST_RC_NEXT: | ||
458 | case LIST_RC_NEXT | BUTTON_REPEAT: | ||
459 | #endif | ||
460 | gui_synclist_select_next(lists); | ||
461 | gui_synclist_draw(lists); | ||
462 | return true; | ||
463 | /* for pgup / pgdown, we are obliged to have a different behaviour depending on the screen | ||
464 | * for which the user pressed the key since for example, remote and main screen doesn't | ||
465 | * have the same number of lines*/ | ||
466 | #ifdef LIST_PGUP | ||
467 | case LIST_PGUP: | ||
468 | case LIST_PGUP | BUTTON_REPEAT: | ||
469 | gui_synclist_select_previous_page(lists, SCREEN_MAIN); | ||
470 | gui_synclist_draw(lists); | ||
471 | return true; | ||
472 | #endif | ||
473 | |||
474 | #ifdef LIST_RC_PGUP | ||
475 | case LIST_RC_PGUP: | ||
476 | case LIST_RC_PGUP | BUTTON_REPEAT: | ||
477 | gui_synclist_select_previous_page(lists, SCREEN_REMOTE); | ||
478 | gui_synclist_draw(lists); | ||
479 | return true; | ||
480 | #endif | ||
481 | |||
482 | #ifdef LIST_PGDN | ||
483 | case LIST_PGDN: | ||
484 | case LIST_PGDN | BUTTON_REPEAT: | ||
485 | gui_synclist_select_next_page(lists, SCREEN_MAIN); | ||
486 | gui_synclist_draw(lists); | ||
487 | return true; | ||
488 | #endif | ||
489 | |||
490 | #ifdef LIST_RC_PGDN | ||
491 | case LIST_RC_PGDN: | ||
492 | case LIST_RC_PGDN | BUTTON_REPEAT: | ||
493 | gui_synclist_select_next_page(lists, SCREEN_REMOTE); | ||
494 | gui_synclist_draw(lists); | ||
495 | return true; | ||
496 | #endif | ||
497 | } | ||
498 | return false; | ||
499 | } | ||
diff --git a/apps/gui/list.h b/apps/gui/list.h new file mode 100644 index 0000000000..fd553f381c --- /dev/null +++ b/apps/gui/list.h | |||
@@ -0,0 +1,232 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2005 by Kévin FERRARE | ||
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 | |||
20 | #ifndef _GUI_LIST_H_ | ||
21 | #define _GUI_LIST_H_ | ||
22 | |||
23 | #include "config.h" | ||
24 | #include "icon.h" | ||
25 | #include "screen_access.h" | ||
26 | |||
27 | #define SCROLLBAR_WIDTH 6 | ||
28 | |||
29 | /* Key assignement */ | ||
30 | #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || \ | ||
31 | (CONFIG_KEYPAD == IRIVER_H300_PAD) | ||
32 | #define LIST_NEXT BUTTON_DOWN | ||
33 | #define LIST_PREV BUTTON_UP | ||
34 | #define LIST_PGUP (BUTTON_ON | BUTTON_UP) | ||
35 | #define LIST_PGDN (BUTTON_ON | BUTTON_DOWN) | ||
36 | #define LIST_RC_NEXT BUTTON_RC_FF | ||
37 | #define LIST_RC_PREV BUTTON_RC_REW | ||
38 | #define LIST_RC_PGUP BUTTON_RC_SOURCE | ||
39 | #define LIST_RC_PGDN BUTTON_RC_BITRATE | ||
40 | |||
41 | #elif CONFIG_KEYPAD == RECORDER_PAD | ||
42 | #define LIST_NEXT BUTTON_DOWN | ||
43 | #define LIST_PREV BUTTON_UP | ||
44 | #define LIST_PGUP (BUTTON_ON | BUTTON_UP) | ||
45 | #define LIST_PGDN (BUTTON_ON | BUTTON_DOWN) | ||
46 | #define LIST_RC_NEXT BUTTON_RC_RIGHT | ||
47 | #define LIST_RC_PREV BUTTON_RC_LEFT | ||
48 | |||
49 | #elif CONFIG_KEYPAD == PLAYER_PAD | ||
50 | #define LIST_NEXT BUTTON_RIGHT | ||
51 | #define LIST_PREV BUTTON_LEFT | ||
52 | #define LIST_RC_NEXT BUTTON_RC_RIGHT | ||
53 | #define LIST_RC_PREV BUTTON_RC_LEFT | ||
54 | |||
55 | #elif CONFIG_KEYPAD == ONDIO_PAD | ||
56 | #define LIST_NEXT BUTTON_DOWN | ||
57 | #define LIST_PREV BUTTON_UP | ||
58 | |||
59 | #elif CONFIG_KEYPAD == GMINI100_PAD | ||
60 | #define LIST_NEXT BUTTON_DOWN | ||
61 | #define LIST_PREV BUTTON_UP | ||
62 | #define LIST_PGUP (BUTTON_ON | BUTTON_UP) | ||
63 | #define LIST_PGDN (BUTTON_ON | BUTTON_DOWN) | ||
64 | #endif | ||
65 | |||
66 | |||
67 | struct gui_list | ||
68 | { | ||
69 | int nb_items; | ||
70 | int selected_item; | ||
71 | int start_item; /* the item that is displayed at the top of the screen */ | ||
72 | |||
73 | void (*callback_get_item_icon)(int selected_item, ICON * icon); | ||
74 | char * (*callback_get_item_name)(int selected_item, char *buffer); | ||
75 | |||
76 | struct screen * display; | ||
77 | int line_scroll_limit; | ||
78 | }; | ||
79 | |||
80 | /* | ||
81 | * Initializes a scrolling list | ||
82 | * - gui_list : the list structure to initialize | ||
83 | * - callback_get_item_icon : pointer to a function that associates an icon | ||
84 | * to a given item number | ||
85 | * - callback_get_item_name : pointer to a function that associates a label | ||
86 | * to a given item number | ||
87 | */ | ||
88 | extern void gui_list_init(struct gui_list * gui_list, | ||
89 | void (*callback_get_item_icon)(int selected_item, ICON * icon), | ||
90 | char * (*callback_get_item_name)(int selected_item, char *buffer) | ||
91 | ); | ||
92 | |||
93 | /* | ||
94 | * Sets the numburs of items the list can currently display | ||
95 | * note that the list's context like the currently pointed item is resetted | ||
96 | * - gui_list : the list structure to initialize | ||
97 | * - nb_items : the numbers of items you want | ||
98 | */ | ||
99 | extern void gui_list_set_nb_items(struct gui_list * gui_list, int nb_items); | ||
100 | |||
101 | /* | ||
102 | * Puts the selection in the screen | ||
103 | * - gui_list : the list structure | ||
104 | * - put_from_end : if true, selection will be put as close from | ||
105 | * the end of the list as possible, else, it's | ||
106 | * from the beginning | ||
107 | */ | ||
108 | extern void gui_list_put_selection_in_screen(struct gui_list * gui_list, | ||
109 | bool put_from_end); | ||
110 | |||
111 | /* | ||
112 | * Attach the scrolling list to a screen | ||
113 | * (The previous screen attachement is lost) | ||
114 | * - gui_list : the list structure | ||
115 | * - display : the screen to attach | ||
116 | */ | ||
117 | extern void gui_list_set_display(struct gui_list * gui_list, | ||
118 | struct screen * display); | ||
119 | |||
120 | /* | ||
121 | * Gives the name of the selected object | ||
122 | * - gui_list : the list structure | ||
123 | * - buffer : a buffer which is filled with the name | ||
124 | */ | ||
125 | extern void gui_list_get_selected_item_name(struct gui_list * gui_list, | ||
126 | char *buffer); | ||
127 | |||
128 | /* | ||
129 | * Gives the position of the selected item | ||
130 | * - gui_list : the list structure | ||
131 | * Returns the position | ||
132 | */ | ||
133 | extern int gui_list_get_selected_item_position(struct gui_list * gui_list); | ||
134 | |||
135 | /* | ||
136 | * Selects an item in the list | ||
137 | * - gui_list : the list structure | ||
138 | * - item_number : the number of the item which will be selected | ||
139 | */ | ||
140 | extern void gui_list_select_item(struct gui_list * gui_list, int item_number); | ||
141 | |||
142 | /* | ||
143 | * Draws the list on the attached screen | ||
144 | * - gui_list : the list structure | ||
145 | */ | ||
146 | extern void gui_list_draw(struct gui_list * gui_list); | ||
147 | |||
148 | /* | ||
149 | * Selects the next item in the list | ||
150 | * (Item 0 gets selected if the end of the list is reached) | ||
151 | * - gui_list : the list structure | ||
152 | */ | ||
153 | extern void gui_list_select_next(struct gui_list * gui_list); | ||
154 | |||
155 | /* | ||
156 | * Selects the previous item in the list | ||
157 | * (Last item in the list gets selected if the list beginning is reached) | ||
158 | * - gui_list : the list structure | ||
159 | */ | ||
160 | extern void gui_list_select_previous(struct gui_list * gui_list); | ||
161 | |||
162 | /* | ||
163 | * Go to next page if any, else selects the last item in the list | ||
164 | * - gui_list : the list structure | ||
165 | * - nb_lines : the number of lines to try to move the cursor | ||
166 | */ | ||
167 | extern void gui_list_select_next_page(struct gui_list * gui_list, | ||
168 | int nb_lines); | ||
169 | |||
170 | /* | ||
171 | * Go to previous page if any, else selects the first item in the list | ||
172 | * - gui_list : the list structure | ||
173 | * - nb_lines : the number of lines to try to move the cursor | ||
174 | */ | ||
175 | extern void gui_list_select_previous_page(struct gui_list * gui_list, | ||
176 | int nb_lines); | ||
177 | |||
178 | /* | ||
179 | * Adds an item to the list (the callback will be asked for one more item) | ||
180 | * - gui_list : the list structure | ||
181 | */ | ||
182 | extern void gui_list_add_item(struct gui_list * gui_list); | ||
183 | |||
184 | /* | ||
185 | * Removes an item to the list (the callback will be asked for one less item) | ||
186 | * - gui_list : the list structure | ||
187 | */ | ||
188 | extern void gui_list_del_item(struct gui_list * gui_list); | ||
189 | |||
190 | |||
191 | /* | ||
192 | * This part handles as many lists as there are connected screens | ||
193 | * (the api is similar to the ones above) | ||
194 | * The lists on the screens are synchronized ; | ||
195 | * theirs items and selected items are the same, but of course, | ||
196 | * they can be displayed on screens with different sizes | ||
197 | * The final aim is to let the programmer handle many lists in one | ||
198 | * function call and make its code independant from the number of screens | ||
199 | */ | ||
200 | struct gui_synclist | ||
201 | { | ||
202 | struct gui_list gui_list[NB_SCREENS]; | ||
203 | }; | ||
204 | |||
205 | extern void gui_synclist_init(struct gui_synclist * lists, | ||
206 | void (*callback_get_item_icon)(int selected_item, ICON * icon), | ||
207 | char * (*callback_get_item_name)(int selected_item, char *buffer) | ||
208 | ); | ||
209 | extern void gui_synclist_set_nb_items(struct gui_synclist * lists, int nb_items); | ||
210 | extern void gui_synclist_get_selected_item_name(struct gui_synclist * lists, | ||
211 | char *buffer); | ||
212 | extern int gui_synclist_get_selected_item_position(struct gui_synclist * lists); | ||
213 | extern void gui_synclist_draw(struct gui_synclist * lists); | ||
214 | extern void gui_synclist_select_item(struct gui_synclist * lists, | ||
215 | int item_number); | ||
216 | extern void gui_synclist_select_next(struct gui_synclist * lists); | ||
217 | extern void gui_synclist_select_previous(struct gui_synclist * lists); | ||
218 | extern void gui_synclist_select_next_page(struct gui_synclist * lists, | ||
219 | enum screen_type screen); | ||
220 | extern void gui_synclist_select_previous_page(struct gui_synclist * lists, | ||
221 | enum screen_type screen); | ||
222 | extern void gui_synclist_add_item(struct gui_synclist * lists); | ||
223 | extern void gui_synclist_del_item(struct gui_synclist * lists); | ||
224 | /* | ||
225 | * Do the action implied by the given button, | ||
226 | * returns true if something has been done, false otherwise | ||
227 | * - lists : the synchronized lists | ||
228 | * - button : the keycode of a pressed button | ||
229 | */ | ||
230 | extern bool gui_synclist_do_button(struct gui_synclist * lists, unsigned button); | ||
231 | |||
232 | #endif /* _GUI_LIST_H_ */ | ||
diff --git a/apps/gui/scrollbar.c b/apps/gui/scrollbar.c new file mode 100644 index 0000000000..9d5717f1a7 --- /dev/null +++ b/apps/gui/scrollbar.c | |||
@@ -0,0 +1,106 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) Markus Braun (2002), Kévin FERRARE (2005) | ||
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 | |||
20 | #include "config.h" | ||
21 | #include "lcd.h" | ||
22 | #ifdef HAVE_LCD_BITMAP | ||
23 | #include "limits.h" | ||
24 | #include "scrollbar.h" | ||
25 | #include "screen_access.h" | ||
26 | |||
27 | void gui_scrollbar_draw(struct screen * screen, int x, int y, | ||
28 | int width, int height, int items, | ||
29 | int min_shown, int max_shown, | ||
30 | enum orientation orientation) | ||
31 | { | ||
32 | int min; | ||
33 | int max; | ||
34 | int inner_len; | ||
35 | int start; | ||
36 | int size; | ||
37 | |||
38 | /* draw box */ | ||
39 | screen->drawrect(x, y, width, height); | ||
40 | |||
41 | screen->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
42 | |||
43 | /* clear edge pixels */ | ||
44 | screen->drawpixel(x, y); | ||
45 | screen->drawpixel((x + width - 1), y); | ||
46 | screen->drawpixel(x, (y + height - 1)); | ||
47 | screen->drawpixel((x + width - 1), (y + height - 1)); | ||
48 | |||
49 | /* clear pixels in progress bar */ | ||
50 | screen->fillrect(x + 1, y + 1, width - 2, height - 2); | ||
51 | |||
52 | /* min should be min */ | ||
53 | if(min_shown < max_shown) { | ||
54 | min = min_shown; | ||
55 | max = max_shown; | ||
56 | } | ||
57 | else { | ||
58 | min = max_shown; | ||
59 | max = min_shown; | ||
60 | } | ||
61 | |||
62 | /* limit min and max */ | ||
63 | if(min < 0) | ||
64 | min = 0; | ||
65 | if(min > items) | ||
66 | min = items; | ||
67 | |||
68 | if(max < 0) | ||
69 | max = 0; | ||
70 | if(max > items) | ||
71 | max = items; | ||
72 | |||
73 | if (orientation == VERTICAL) | ||
74 | inner_len = height - 2; | ||
75 | else | ||
76 | inner_len = width - 2; | ||
77 | |||
78 | /* avoid overflows */ | ||
79 | while (items > (INT_MAX / inner_len)) { | ||
80 | items >>= 1; | ||
81 | min >>= 1; | ||
82 | max >>= 1; | ||
83 | } | ||
84 | |||
85 | /* calc start and end of the knob */ | ||
86 | if (items > 0 && items > (max - min)) { | ||
87 | size = inner_len * (max - min) / items; | ||
88 | if (size == 0) { /* width of knob is null */ | ||
89 | size = 1; | ||
90 | start = (inner_len - 1) * min / items; | ||
91 | } else { | ||
92 | start = (inner_len - size) * min / (items - (max - min)); | ||
93 | } | ||
94 | } else { /* if null draw full bar */ | ||
95 | size = inner_len; | ||
96 | start = 0; | ||
97 | } | ||
98 | |||
99 | screen->set_drawmode(DRMODE_SOLID); | ||
100 | |||
101 | if(orientation == VERTICAL) | ||
102 | screen->fillrect(x + 1, y + start + 1, width - 2, size); | ||
103 | else | ||
104 | screen->fillrect(x + start + 1, y + 1, size, height - 2); | ||
105 | } | ||
106 | #endif /* HAVE_LCD_BITMAP */ | ||
diff --git a/apps/gui/scrollbar.h b/apps/gui/scrollbar.h new file mode 100644 index 0000000000..51c08352ba --- /dev/null +++ b/apps/gui/scrollbar.h | |||
@@ -0,0 +1,49 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2005 Kévin FERRARE | ||
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 | |||
20 | #ifndef _GUI_SCROLLBAR_H_ | ||
21 | #define _GUI_SCROLLBAR_H_ | ||
22 | #include <lcd.h> | ||
23 | #ifdef HAVE_LCD_BITMAP | ||
24 | |||
25 | struct screen; | ||
26 | |||
27 | enum orientation { | ||
28 | VERTICAL, | ||
29 | HORIZONTAL | ||
30 | }; | ||
31 | |||
32 | /* | ||
33 | * Draws a scrollbar on the given screen | ||
34 | * - screen : the screen to put the scrollbar on | ||
35 | * - x : x start position of the scrollbar | ||
36 | * - y : y start position of the scrollbar | ||
37 | * - width : you won't guess =(^o^)= | ||
38 | * - height : I won't tell you either ! | ||
39 | * - items : total number of items on the screen | ||
40 | * - min_shown : index of the starting item on the screen | ||
41 | * - max_shown : index of the last item on the screen | ||
42 | * - orientation : either VERTICAL or HORIZONTAL | ||
43 | */ | ||
44 | extern void gui_scrollbar_draw(struct screen * screen, int x, int y, | ||
45 | int width, int height, int items, | ||
46 | int min_shown, int max_shown, | ||
47 | enum orientation orientation); | ||
48 | #endif /* HAVE_LCD_BITMAP */ | ||
49 | #endif /* _GUI_SCROLLBAR_H_ */ | ||
diff --git a/apps/gui/splash.c b/apps/gui/splash.c new file mode 100644 index 0000000000..a3cbb198df --- /dev/null +++ b/apps/gui/splash.c | |||
@@ -0,0 +1,216 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) Daniel Stenberg (2002), Kévin FERRARE (2005) | ||
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 "stdarg.h" | ||
20 | #include "string.h" | ||
21 | #include "stdio.h" | ||
22 | #include "kernel.h" | ||
23 | #include "screen_access.h" | ||
24 | |||
25 | |||
26 | #ifdef HAVE_LCD_BITMAP | ||
27 | |||
28 | #define SPACE 3 /* pixels between words */ | ||
29 | #define MAXLETTERS 128 /* 16*8 */ | ||
30 | #define MAXLINES 10 | ||
31 | |||
32 | #else | ||
33 | |||
34 | #define SPACE 1 /* one letter space */ | ||
35 | #define MAXLETTERS 22 /* 11 * 2 */ | ||
36 | #define MAXLINES 2 | ||
37 | |||
38 | #endif | ||
39 | |||
40 | |||
41 | void internal_splash(struct screen * screen, | ||
42 | bool center, const char *fmt, va_list ap) | ||
43 | { | ||
44 | char *next; | ||
45 | char *store=NULL; | ||
46 | int x=0; | ||
47 | int y=0; | ||
48 | int w, h; | ||
49 | unsigned char splash_buf[MAXLETTERS]; | ||
50 | unsigned char widths[MAXLINES]; | ||
51 | int line=0; | ||
52 | bool first=true; | ||
53 | #ifdef HAVE_LCD_BITMAP | ||
54 | int maxw=0; | ||
55 | #endif | ||
56 | |||
57 | #ifdef HAVE_LCD_CHARCELLS | ||
58 | screen->double_height (false); | ||
59 | #endif | ||
60 | vsnprintf( splash_buf, sizeof(splash_buf), fmt, ap ); | ||
61 | |||
62 | if(center) { | ||
63 | /* first a pass to measure sizes */ | ||
64 | next = strtok_r(splash_buf, " ", &store); | ||
65 | while (next) { | ||
66 | #ifdef HAVE_LCD_BITMAP | ||
67 | screen->getstringsize(next, &w, &h); | ||
68 | #else | ||
69 | w = strlen(next); | ||
70 | h = 1; /* store height in characters */ | ||
71 | #endif | ||
72 | if(!first) { | ||
73 | if(x+w> screen->width) { | ||
74 | /* Too wide, wrap */ | ||
75 | y+=h; | ||
76 | line++; | ||
77 | if((y > (screen->height-h)) || (line > screen->nb_lines)) | ||
78 | /* STOP */ | ||
79 | break; | ||
80 | x=0; | ||
81 | first=true; | ||
82 | } | ||
83 | } | ||
84 | else | ||
85 | first = false; | ||
86 | |||
87 | /* think of it as if the text was written here at position x,y | ||
88 | being w pixels/chars wide and h high */ | ||
89 | |||
90 | x += w+SPACE; | ||
91 | widths[line]=x-SPACE; /* don't count the trailing space */ | ||
92 | #ifdef HAVE_LCD_BITMAP | ||
93 | /* store the widest line */ | ||
94 | if(widths[line]>maxw) | ||
95 | maxw = widths[line]; | ||
96 | #endif | ||
97 | next = strtok_r(NULL, " ", &store); | ||
98 | } | ||
99 | |||
100 | #ifdef HAVE_LCD_BITMAP | ||
101 | /* Start displaying the message at position y. The reason for the | ||
102 | added h here is that it isn't added until the end of lines in the | ||
103 | loop above and we always break the loop in the middle of a line. */ | ||
104 | y = (screen->height - (y+h) )/2; | ||
105 | #else | ||
106 | y = 0; /* vertical center on 2 lines would be silly */ | ||
107 | #endif | ||
108 | first=true; | ||
109 | |||
110 | /* Now recreate the string again since the strtok_r() above has ruined | ||
111 | the one we already have! Here's room for improvements! */ | ||
112 | vsnprintf( splash_buf, sizeof(splash_buf), fmt, ap ); | ||
113 | } | ||
114 | va_end( ap ); | ||
115 | |||
116 | if(center) | ||
117 | { | ||
118 | x = (screen->width-widths[0])/2; | ||
119 | if(x < 0) | ||
120 | x = 0; | ||
121 | } | ||
122 | |||
123 | #ifdef HAVE_LCD_BITMAP | ||
124 | /* If we center the display, then just clear the box we need and put | ||
125 | a nice little frame and put the text in there! */ | ||
126 | if(center && (y > 2)) { | ||
127 | int xx = (screen->width-maxw)/2 - 2; | ||
128 | /* The new graphics routines handle clipping, so no need to check */ | ||
129 | #if LCD_DEPTH > 1 | ||
130 | #ifdef HAVE_LCD_COLOR | ||
131 | screen->set_background((struct rgb){LCD_MAX_RED-1, LCD_MAX_GREEN-1, | ||
132 | LCD_MAX_BLUE-1}); | ||
133 | #else | ||
134 | if(screen->depth>1) | ||
135 | screen->set_background(LCD_MAX_LEVEL-1); | ||
136 | #endif | ||
137 | #endif | ||
138 | screen->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
139 | screen->fillrect(xx, y-2, maxw+4, screen->height-y*2+4); | ||
140 | screen->set_drawmode(DRMODE_SOLID); | ||
141 | screen->drawrect(xx, y-2, maxw+4, screen->height-y*2+4); | ||
142 | } | ||
143 | else | ||
144 | #endif | ||
145 | screen->clear_display(); | ||
146 | line=0; | ||
147 | next = strtok_r(splash_buf, " ", &store); | ||
148 | while (next) { | ||
149 | #ifdef HAVE_LCD_BITMAP | ||
150 | screen->getstringsize(next, &w, &h); | ||
151 | #else | ||
152 | w = strlen(next); | ||
153 | h = 1; | ||
154 | #endif | ||
155 | if(!first) { | ||
156 | if(x+w> screen->width) { | ||
157 | /* too wide */ | ||
158 | y+=h; | ||
159 | line++; /* goto next line */ | ||
160 | first=true; | ||
161 | if(y > (screen->height-h)) | ||
162 | /* STOP */ | ||
163 | break; | ||
164 | if(center) { | ||
165 | x = (screen->width-widths[line])/2; | ||
166 | if(x < 0) | ||
167 | x = 0; | ||
168 | } | ||
169 | else | ||
170 | x=0; | ||
171 | } | ||
172 | } | ||
173 | else | ||
174 | first=false; | ||
175 | #ifdef HAVE_LCD_BITMAP | ||
176 | screen->putsxy(x, y, next); | ||
177 | #else | ||
178 | screen->puts(x, y, next); | ||
179 | #endif | ||
180 | x += w+SPACE; /* pixels space! */ | ||
181 | next = strtok_r(NULL, " ", &store); | ||
182 | } | ||
183 | |||
184 | #if defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1) | ||
185 | if(screen->depth > 1) | ||
186 | screen->set_background(LCD_WHITE); | ||
187 | #endif | ||
188 | #if defined(HAVE_LCD_BITMAP) || defined(SIMULATOR) | ||
189 | screen->update(); | ||
190 | #endif | ||
191 | } | ||
192 | |||
193 | void gui_splash(struct screen * screen, int ticks, | ||
194 | bool center, const char *fmt, ...) | ||
195 | { | ||
196 | va_list ap; | ||
197 | va_start( ap, fmt ); | ||
198 | internal_splash(screen, center, fmt, ap); | ||
199 | va_end( ap ); | ||
200 | |||
201 | if(ticks) | ||
202 | sleep(ticks); | ||
203 | } | ||
204 | |||
205 | void gui_syncsplash(int ticks, bool center, const char *fmt, ...) | ||
206 | { | ||
207 | va_list ap; | ||
208 | int i; | ||
209 | va_start( ap, fmt ); | ||
210 | for(i=0;i<NB_SCREENS;++i) | ||
211 | internal_splash(&(screens[i]), center, fmt, ap); | ||
212 | va_end( ap ); | ||
213 | |||
214 | if(ticks) | ||
215 | sleep(ticks); | ||
216 | } | ||
diff --git a/apps/gui/splash.h b/apps/gui/splash.h new file mode 100644 index 0000000000..b0d55db890 --- /dev/null +++ b/apps/gui/splash.h | |||
@@ -0,0 +1,39 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2005 by Kévin FERRARE | ||
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 | |||
20 | /* | ||
21 | * Puts a splash message on the given screen for a given period | ||
22 | * - screen : the screen to put the splash on | ||
23 | * - ticks : how long the splash is displayed (in rb ticks) | ||
24 | * - center : FALSE means left-justified, TRUE means | ||
25 | * horizontal and vertical center | ||
26 | * - fmt : what to say *printf style | ||
27 | */ | ||
28 | extern void gui_splash(struct screen * screen, int ticks, | ||
29 | bool center, const char *fmt, ...); | ||
30 | |||
31 | /* | ||
32 | * Puts a splash message on all the screens for a given period | ||
33 | * - ticks : how long the splash is displayed (in rb ticks) | ||
34 | * - center : FALSE means left-justified, TRUE means | ||
35 | * horizontal and vertical center | ||
36 | * - fmt : what to say *printf style | ||
37 | */ | ||
38 | extern void gui_syncsplash(int ticks, bool center, | ||
39 | const char *fmt, ...); | ||
diff --git a/apps/gui/statusbar.c b/apps/gui/statusbar.c new file mode 100644 index 0000000000..5ddc194610 --- /dev/null +++ b/apps/gui/statusbar.c | |||
@@ -0,0 +1,508 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) Robert E. Hak (2002), Linus Nielsen Feltzing (2002), Kévin FERRARE (2005) | ||
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 | |||
20 | #include "config.h" | ||
21 | #include "screen_access.h" | ||
22 | #include "lcd.h" | ||
23 | #include "font.h" | ||
24 | #include "kernel.h" | ||
25 | #include "string.h" /* for memcmp oO*/ | ||
26 | #include "sprintf.h" | ||
27 | #include "sound.h" | ||
28 | #include "power.h" | ||
29 | #include "settings.h" | ||
30 | #include "icons.h" | ||
31 | #include "powermgmt.h" | ||
32 | #include "button.h" | ||
33 | |||
34 | #include "status.h" /* needed for battery_state global var */ | ||
35 | #include "wps.h" /* for keys_locked */ | ||
36 | #include "statusbar.h" | ||
37 | |||
38 | |||
39 | /* FIXME: should be removed from icon.h to avoid redefinition, | ||
40 | but still needed for compatibility with old system */ | ||
41 | #define STATUSBAR_X_POS 0 | ||
42 | #define STATUSBAR_Y_POS 0 /* MUST be a multiple of 8 */ | ||
43 | #define STATUSBAR_HEIGHT 8 | ||
44 | #define STATUSBAR_BATTERY_X_POS 0 | ||
45 | #define STATUSBAR_BATTERY_WIDTH 18 | ||
46 | #define STATUSBAR_PLUG_X_POS STATUSBAR_X_POS + \ | ||
47 | STATUSBAR_BATTERY_WIDTH +2 | ||
48 | #define STATUSBAR_PLUG_WIDTH 7 | ||
49 | #define STATUSBAR_VOLUME_X_POS STATUSBAR_X_POS + \ | ||
50 | STATUSBAR_BATTERY_WIDTH + \ | ||
51 | STATUSBAR_PLUG_WIDTH +2+2 | ||
52 | #define STATUSBAR_VOLUME_WIDTH 16 | ||
53 | #define STATUSBAR_PLAY_STATE_X_POS STATUSBAR_X_POS + \ | ||
54 | STATUSBAR_BATTERY_WIDTH + \ | ||
55 | STATUSBAR_PLUG_WIDTH + \ | ||
56 | STATUSBAR_VOLUME_WIDTH+2+2+2 | ||
57 | #define STATUSBAR_PLAY_STATE_WIDTH 7 | ||
58 | #define STATUSBAR_PLAY_MODE_X_POS STATUSBAR_X_POS + \ | ||
59 | STATUSBAR_BATTERY_WIDTH + \ | ||
60 | STATUSBAR_PLUG_WIDTH + \ | ||
61 | STATUSBAR_VOLUME_WIDTH + \ | ||
62 | STATUSBAR_PLAY_STATE_WIDTH + \ | ||
63 | 2+2+2+2 | ||
64 | #define STATUSBAR_PLAY_MODE_WIDTH 7 | ||
65 | #define STATUSBAR_SHUFFLE_X_POS STATUSBAR_X_POS + \ | ||
66 | STATUSBAR_BATTERY_WIDTH + \ | ||
67 | STATUSBAR_PLUG_WIDTH + \ | ||
68 | STATUSBAR_VOLUME_WIDTH + \ | ||
69 | STATUSBAR_PLAY_STATE_WIDTH + \ | ||
70 | STATUSBAR_PLAY_MODE_WIDTH + \ | ||
71 | 2+2+2+2+2 | ||
72 | #define STATUSBAR_SHUFFLE_WIDTH 7 | ||
73 | #define STATUSBAR_LOCK_X_POS STATUSBAR_X_POS + \ | ||
74 | STATUSBAR_BATTERY_WIDTH + \ | ||
75 | STATUSBAR_PLUG_WIDTH + \ | ||
76 | STATUSBAR_VOLUME_WIDTH + \ | ||
77 | STATUSBAR_PLAY_STATE_WIDTH + \ | ||
78 | STATUSBAR_PLAY_MODE_WIDTH + \ | ||
79 | STATUSBAR_SHUFFLE_WIDTH + \ | ||
80 | 2+2+2+2+2+2 | ||
81 | #define STATUSBAR_LOCK_WIDTH 5 | ||
82 | #define STATUSBAR_DISK_WIDTH 12 | ||
83 | #define STATUSBAR_DISK_X_POS(statusbar_width) statusbar_width - \ | ||
84 | STATUSBAR_DISK_WIDTH | ||
85 | #define STATUSBAR_TIME_X_END(statusbar_width) statusbar_width-1 | ||
86 | |||
87 | void gui_statusbar_init(struct gui_statusbar * bar) | ||
88 | { | ||
89 | bar->last_volume = -1; /* -1 means "first update ever" */ | ||
90 | bar->battery_icon_switch_tick = 0; | ||
91 | #ifdef HAVE_USB_POWER | ||
92 | bar->battery_charge_step = 0; | ||
93 | #endif | ||
94 | } | ||
95 | |||
96 | void gui_statusbar_set_screen(struct gui_statusbar * bar, | ||
97 | struct screen * display) | ||
98 | { | ||
99 | bar->display = display; | ||
100 | gui_statusbar_draw(bar, false); | ||
101 | } | ||
102 | |||
103 | void gui_statusbar_draw(struct gui_statusbar * bar, bool force_redraw) | ||
104 | { | ||
105 | #ifdef HAVE_LCD_BITMAP | ||
106 | if(!global_settings.statusbar) | ||
107 | return; | ||
108 | #endif | ||
109 | |||
110 | struct screen * display = bar->display; | ||
111 | |||
112 | #ifdef HAVE_LCD_BITMAP | ||
113 | struct tm* tm; /* For Time */ | ||
114 | #else | ||
115 | (void)force_redraw; /* players always "redraw" */ | ||
116 | #endif | ||
117 | |||
118 | bar->info.volume = sound_val2phys(SOUND_VOLUME, global_settings.volume); | ||
119 | bar->info.inserted = charger_inserted(); | ||
120 | bar->info.battlevel = battery_level(); | ||
121 | bar->info.battery_safe = battery_level_safe(); | ||
122 | |||
123 | #ifdef HAVE_LCD_BITMAP | ||
124 | tm = get_time(); | ||
125 | bar->info.hour = tm->tm_hour; | ||
126 | bar->info.minute = tm->tm_min; | ||
127 | bar->info.shuffle = global_settings.playlist_shuffle; | ||
128 | #if CONFIG_KEYPAD == IRIVER_H100_PAD | ||
129 | bar->info.keylock = button_hold(); | ||
130 | #else | ||
131 | bar->info.keylock = keys_locked; | ||
132 | #endif | ||
133 | bar->info.repeat = global_settings.repeat_mode; | ||
134 | bar->info.playmode = current_playmode(); | ||
135 | #if CONFIG_LED == LED_VIRTUAL | ||
136 | bar->info.led = led_read(HZ/2); /* delay should match polling interval */ | ||
137 | #endif | ||
138 | #ifdef HAVE_USB_POWER | ||
139 | bar->info.usb_power = usb_powered(); | ||
140 | #endif | ||
141 | |||
142 | /* only redraw if forced to, or info has changed */ | ||
143 | if (force_redraw || | ||
144 | bar->info.inserted || | ||
145 | !bar->info.battery_safe || | ||
146 | bar->info.redraw_volume || | ||
147 | memcmp(&(bar->info), &(bar->lastinfo), sizeof(struct status_info))) | ||
148 | { | ||
149 | display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | ||
150 | display->fillrect(0,0,display->width,8); | ||
151 | display->set_drawmode(DRMODE_SOLID); | ||
152 | |||
153 | #else | ||
154 | |||
155 | /* players always "redraw" */ | ||
156 | { | ||
157 | #endif | ||
158 | |||
159 | #ifdef HAVE_CHARGING | ||
160 | if (bar->info.inserted) { | ||
161 | battery_state = true; | ||
162 | #if defined(HAVE_CHARGE_CTRL) || CONFIG_BATTERY == BATT_LIION2200 | ||
163 | /* zero battery run time if charging */ | ||
164 | if (charge_state > 0) { | ||
165 | global_settings.runtime = 0; | ||
166 | lasttime = current_tick; | ||
167 | } | ||
168 | |||
169 | /* animate battery if charging */ | ||
170 | if ((charge_state == 1) || | ||
171 | (charge_state == 2)) { | ||
172 | #else | ||
173 | global_settings.runtime = 0; | ||
174 | lasttime = current_tick; | ||
175 | { | ||
176 | #endif | ||
177 | /* animate in three steps (34% per step for a better look) */ | ||
178 | bar->info.battlevel = bar->battery_charge_step * 34; | ||
179 | if (bar->info.battlevel > 100) | ||
180 | bar->info.battlevel = 100; | ||
181 | if(TIME_AFTER(current_tick, bar->battery_icon_switch_tick)) { | ||
182 | bar->battery_charge_step=(bar->battery_charge_step+1)%4; | ||
183 | bar->battery_icon_switch_tick = current_tick + HZ; | ||
184 | } | ||
185 | } | ||
186 | } | ||
187 | else | ||
188 | #endif /* HAVE_CHARGING */ | ||
189 | { | ||
190 | if (bar->info.battery_safe) | ||
191 | battery_state = true; | ||
192 | else { | ||
193 | /* blink battery if level is low */ | ||
194 | if(TIME_AFTER(current_tick, bar->battery_icon_switch_tick) && | ||
195 | (bar->info.battlevel > -1)) { | ||
196 | bar->battery_icon_switch_tick = current_tick+HZ; | ||
197 | battery_state = !battery_state; | ||
198 | } | ||
199 | } | ||
200 | } | ||
201 | #ifdef HAVE_LCD_BITMAP | ||
202 | if (battery_state) | ||
203 | gui_statusbar_icon_battery(display, bar->info.battlevel); | ||
204 | /* draw power plug if charging */ | ||
205 | if (bar->info.inserted) | ||
206 | display->mono_bitmap(bitmap_icons_7x8[Icon_Plug], | ||
207 | STATUSBAR_PLUG_X_POS, | ||
208 | STATUSBAR_Y_POS, STATUSBAR_PLUG_WIDTH, | ||
209 | STATUSBAR_HEIGHT); | ||
210 | #ifdef HAVE_USB_POWER | ||
211 | else if (bar->info.usb_power) | ||
212 | display->mono_bitmap(bitmap_icons_7x8[Icon_USBPlug], | ||
213 | STATUSBAR_PLUG_X_POS, | ||
214 | STATUSBAR_Y_POS, STATUSBAR_PLUG_WIDTH, | ||
215 | STATUSBAR_HEIGHT); | ||
216 | #endif | ||
217 | |||
218 | bar->info.redraw_volume = gui_statusbar_icon_volume(bar, | ||
219 | bar->info.volume); | ||
220 | gui_statusbar_icon_play_state(display, current_playmode() + | ||
221 | Icon_Play); | ||
222 | switch (bar->info.repeat) { | ||
223 | #ifdef AB_REPEAT_ENABLE | ||
224 | case REPEAT_AB: | ||
225 | gui_statusbar_icon_play_mode(display, Icon_RepeatAB); | ||
226 | break; | ||
227 | #endif | ||
228 | |||
229 | case REPEAT_ONE: | ||
230 | gui_statusbar_icon_play_mode(display, Icon_RepeatOne); | ||
231 | break; | ||
232 | |||
233 | case REPEAT_ALL: | ||
234 | case REPEAT_SHUFFLE: | ||
235 | gui_statusbar_icon_play_mode(display, Icon_Repeat); | ||
236 | break; | ||
237 | } | ||
238 | if (bar->info.shuffle) | ||
239 | gui_statusbar_icon_shuffle(display); | ||
240 | if (bar->info.keylock) | ||
241 | gui_statusbar_icon_lock(display); | ||
242 | #ifdef HAVE_RTC | ||
243 | gui_statusbar_time(display, bar->info.hour, bar->info.minute); | ||
244 | #endif | ||
245 | #if CONFIG_LED == LED_VIRTUAL | ||
246 | if (bar->info.led) | ||
247 | statusbar_led(); | ||
248 | #endif | ||
249 | display->update_rect(0, 0, display->width, STATUSBAR_HEIGHT); | ||
250 | bar->lastinfo = bar->info; | ||
251 | #endif | ||
252 | } | ||
253 | |||
254 | |||
255 | #ifndef HAVE_LCD_BITMAP | ||
256 | if (bar->info.battlevel > -1) | ||
257 | display->icon(ICON_BATTERY, battery_state); | ||
258 | display->icon(ICON_BATTERY_1, bar->info.battlevel > 25); | ||
259 | display->icon(ICON_BATTERY_2, bar->info.battlevel > 50); | ||
260 | display->icon(ICON_BATTERY_3, bar->info.battlevel > 75); | ||
261 | |||
262 | display->icon(ICON_VOLUME, true); | ||
263 | display->icon(ICON_VOLUME_1, bar->info.volume > 10); | ||
264 | display->icon(ICON_VOLUME_2, bar->info.volume > 30); | ||
265 | display->icon(ICON_VOLUME_3, bar->info.volume > 50); | ||
266 | display->icon(ICON_VOLUME_4, bar->info.volume > 70); | ||
267 | display->icon(ICON_VOLUME_5, bar->info.volume > 90); | ||
268 | |||
269 | display->icon(ICON_PLAY, current_playmode() == STATUS_PLAY); | ||
270 | display->icon(ICON_PAUSE, current_playmode() == STATUS_PAUSE); | ||
271 | |||
272 | display->icon(ICON_REPEAT, global_settings.repeat_mode != REPEAT_OFF); | ||
273 | display->icon(ICON_1, global_settings.repeat_mode == REPEAT_ONE); | ||
274 | |||
275 | display->icon(ICON_RECORD, record); | ||
276 | display->icon(ICON_AUDIO, audio); | ||
277 | display->icon(ICON_PARAM, param); | ||
278 | display->icon(ICON_USB, usb); | ||
279 | #endif | ||
280 | } | ||
281 | |||
282 | #ifdef HAVE_LCD_BITMAP | ||
283 | /* from icon.c */ | ||
284 | /* | ||
285 | * Print battery icon to status bar | ||
286 | */ | ||
287 | void gui_statusbar_icon_battery(struct screen * display, int percent) | ||
288 | { | ||
289 | int fill; | ||
290 | char buffer[5]; | ||
291 | unsigned int width, height; | ||
292 | |||
293 | /* fill battery */ | ||
294 | fill = percent; | ||
295 | if (fill < 0) | ||
296 | fill = 0; | ||
297 | if (fill > 100) | ||
298 | fill = 100; | ||
299 | |||
300 | #if defined(HAVE_CHARGE_CTRL) && !defined(SIMULATOR) /* Rec v1 target only */ | ||
301 | /* show graphical animation when charging instead of numbers */ | ||
302 | if ((global_settings.battery_display) && | ||
303 | (charge_state != 1) && | ||
304 | (percent > -1)) { | ||
305 | #else /* all others */ | ||
306 | if (global_settings.battery_display && (percent > -1)) { | ||
307 | #endif | ||
308 | /* Numeric display */ | ||
309 | display->setfont(FONT_SYSFIXED); | ||
310 | snprintf(buffer, sizeof(buffer), "%3d", fill); | ||
311 | display->getstringsize(buffer, &width, &height); | ||
312 | if (height <= STATUSBAR_HEIGHT) | ||
313 | display->putsxy(STATUSBAR_BATTERY_X_POS | ||
314 | + STATUSBAR_BATTERY_WIDTH / 2 | ||
315 | - width/2, STATUSBAR_Y_POS, buffer); | ||
316 | display->setfont(FONT_UI); | ||
317 | |||
318 | } | ||
319 | else { | ||
320 | /* draw battery */ | ||
321 | display->drawrect(STATUSBAR_BATTERY_X_POS, STATUSBAR_Y_POS, 17, 7); | ||
322 | display->vline(STATUSBAR_BATTERY_X_POS + 17, STATUSBAR_Y_POS + 2, | ||
323 | STATUSBAR_Y_POS + 4); | ||
324 | |||
325 | fill = fill * 15 / 100; | ||
326 | display->fillrect(STATUSBAR_BATTERY_X_POS + 1, STATUSBAR_Y_POS + 1, | ||
327 | fill, 5); | ||
328 | } | ||
329 | |||
330 | if (percent == -1) { | ||
331 | display->setfont(FONT_SYSFIXED); | ||
332 | display->putsxy(STATUSBAR_BATTERY_X_POS + STATUSBAR_BATTERY_WIDTH / 2 | ||
333 | - 4, STATUSBAR_Y_POS, "?"); | ||
334 | display->setfont(FONT_UI); | ||
335 | } | ||
336 | } | ||
337 | |||
338 | /* | ||
339 | * Print volume gauge to status bar | ||
340 | */ | ||
341 | bool gui_statusbar_icon_volume(struct gui_statusbar * bar, int percent) | ||
342 | { | ||
343 | int i; | ||
344 | int volume; | ||
345 | int vol; | ||
346 | char buffer[4]; | ||
347 | unsigned int width, height; | ||
348 | bool needs_redraw = false; | ||
349 | int type = global_settings.volume_type; | ||
350 | struct screen * display=bar->display; | ||
351 | |||
352 | volume = percent; | ||
353 | if (volume < 0) | ||
354 | volume = 0; | ||
355 | if (volume > 100) | ||
356 | volume = 100; | ||
357 | |||
358 | if (volume == 0) { | ||
359 | display->mono_bitmap(bitmap_icons_7x8[Icon_Mute], | ||
360 | STATUSBAR_VOLUME_X_POS + STATUSBAR_VOLUME_WIDTH / 2 - 4, | ||
361 | STATUSBAR_Y_POS, 7, STATUSBAR_HEIGHT); | ||
362 | } | ||
363 | else { | ||
364 | /* We want to redraw the icon later on */ | ||
365 | if (bar->last_volume != volume && bar->last_volume >= 0) { | ||
366 | bar->volume_icon_switch_tick = current_tick + HZ; | ||
367 | } | ||
368 | |||
369 | /* If the timeout hasn't yet been reached, we show it numerically | ||
370 | and tell the caller that we want to be called again */ | ||
371 | if (TIME_BEFORE(current_tick,bar->volume_icon_switch_tick)) { | ||
372 | type = 1; | ||
373 | needs_redraw = true; | ||
374 | } | ||
375 | |||
376 | /* display volume level numerical? */ | ||
377 | if (type) | ||
378 | { | ||
379 | display->setfont(FONT_SYSFIXED); | ||
380 | snprintf(buffer, sizeof(buffer), "%2d", percent); | ||
381 | display->getstringsize(buffer, &width, &height); | ||
382 | if (height <= STATUSBAR_HEIGHT) | ||
383 | { | ||
384 | display->putsxy(STATUSBAR_VOLUME_X_POS | ||
385 | + STATUSBAR_VOLUME_WIDTH / 2 | ||
386 | - width/2, STATUSBAR_Y_POS, buffer); | ||
387 | } | ||
388 | display->setfont(FONT_UI); | ||
389 | } else { | ||
390 | /* display volume bar */ | ||
391 | vol = volume * 14 / 100; | ||
392 | for(i=0; i < vol; i++) { | ||
393 | display->vline(STATUSBAR_VOLUME_X_POS + i, | ||
394 | STATUSBAR_Y_POS + 6 - i / 2, | ||
395 | STATUSBAR_Y_POS + 6); | ||
396 | } | ||
397 | } | ||
398 | } | ||
399 | bar->last_volume = volume; | ||
400 | |||
401 | return needs_redraw; | ||
402 | } | ||
403 | |||
404 | /* | ||
405 | * Print play state to status bar | ||
406 | */ | ||
407 | void gui_statusbar_icon_play_state(struct screen * display, int state) | ||
408 | { | ||
409 | display->mono_bitmap(bitmap_icons_7x8[state], STATUSBAR_PLAY_STATE_X_POS, | ||
410 | STATUSBAR_Y_POS, STATUSBAR_PLAY_STATE_WIDTH, | ||
411 | STATUSBAR_HEIGHT); | ||
412 | } | ||
413 | |||
414 | /* | ||
415 | * Print play mode to status bar | ||
416 | */ | ||
417 | void gui_statusbar_icon_play_mode(struct screen * display, int mode) | ||
418 | { | ||
419 | display->mono_bitmap(bitmap_icons_7x8[mode], STATUSBAR_PLAY_MODE_X_POS, | ||
420 | STATUSBAR_Y_POS, STATUSBAR_PLAY_MODE_WIDTH, | ||
421 | STATUSBAR_HEIGHT); | ||
422 | } | ||
423 | |||
424 | /* | ||
425 | * Print shuffle mode to status bar | ||
426 | */ | ||
427 | void gui_statusbar_icon_shuffle(struct screen * display) | ||
428 | { | ||
429 | display->mono_bitmap(bitmap_icons_7x8[Icon_Shuffle], | ||
430 | STATUSBAR_SHUFFLE_X_POS, STATUSBAR_Y_POS, | ||
431 | STATUSBAR_SHUFFLE_WIDTH, STATUSBAR_HEIGHT); | ||
432 | } | ||
433 | |||
434 | /* | ||
435 | * Print lock when keys are locked | ||
436 | */ | ||
437 | void gui_statusbar_icon_lock(struct screen * display) | ||
438 | { | ||
439 | display->mono_bitmap(bitmap_icons_5x8[Icon_Lock], STATUSBAR_LOCK_X_POS, | ||
440 | STATUSBAR_Y_POS, 5, 8); | ||
441 | } | ||
442 | |||
443 | #if CONFIG_LED == LED_VIRTUAL | ||
444 | /* | ||
445 | * no real LED: disk activity in status bar | ||
446 | */ | ||
447 | void gui_statusbar_led(struct screen * display) | ||
448 | { | ||
449 | display->mono_bitmap(bitmap_icon_disk, STATUSBAR_DISK_X_POS, | ||
450 | STATUSBAR_Y_POS, STATUSBAR_DISK_WIDTH(screen->width), | ||
451 | STATUSBAR_HEIGHT); | ||
452 | } | ||
453 | #endif | ||
454 | |||
455 | |||
456 | #ifdef HAVE_RTC | ||
457 | /* | ||
458 | * Print time to status bar | ||
459 | */ | ||
460 | void gui_statusbar_time(struct screen * display, int hour, int minute) | ||
461 | { | ||
462 | unsigned char buffer[6]; | ||
463 | unsigned int width, height; | ||
464 | if ( hour >= 0 && | ||
465 | hour <= 23 && | ||
466 | minute >= 0 && | ||
467 | minute <= 59 ) { | ||
468 | if ( global_settings.timeformat ) { /* 12 hour clock */ | ||
469 | hour %= 12; | ||
470 | if ( hour == 0 ) { | ||
471 | hour += 12; | ||
472 | } | ||
473 | } | ||
474 | snprintf(buffer, sizeof(buffer), "%02d:%02d", hour, minute); | ||
475 | } | ||
476 | else { | ||
477 | strncpy(buffer, "--:--", sizeof buffer); | ||
478 | } | ||
479 | display->setfont(FONT_SYSFIXED); | ||
480 | display->getstringsize(buffer, &width, &height); | ||
481 | if (height <= STATUSBAR_HEIGHT) { | ||
482 | display->putsxy(STATUSBAR_TIME_X_END(display->width) - width, | ||
483 | STATUSBAR_Y_POS, buffer); | ||
484 | } | ||
485 | display->setfont(FONT_UI); | ||
486 | |||
487 | } | ||
488 | #endif | ||
489 | |||
490 | #endif /* HAVE_LCD_BITMAP */ | ||
491 | |||
492 | void gui_syncstatusbar_init(struct gui_syncstatusbar * bars) | ||
493 | { | ||
494 | int i; | ||
495 | for(i = 0;i < NB_SCREENS;++i) { | ||
496 | gui_statusbar_init( &(bars->statusbars[i]) ); | ||
497 | gui_statusbar_set_screen( &(bars->statusbars[i]), &(screens[i]) ); | ||
498 | } | ||
499 | } | ||
500 | |||
501 | void gui_syncstatusbar_draw(struct gui_syncstatusbar * bars, | ||
502 | bool force_redraw) | ||
503 | { | ||
504 | int i; | ||
505 | for(i = 0;i < NB_SCREENS;++i) { | ||
506 | gui_statusbar_draw( &(bars->statusbars[i]), force_redraw ); | ||
507 | } | ||
508 | } | ||
diff --git a/apps/gui/statusbar.h b/apps/gui/statusbar.h new file mode 100644 index 0000000000..434d679e29 --- /dev/null +++ b/apps/gui/statusbar.h | |||
@@ -0,0 +1,107 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2005 by Kévin FERRARE | ||
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 | |||
20 | #ifndef _GUI_STATUSBAR_H_ | ||
21 | #define _GUI_STATUSBAR_H_ | ||
22 | |||
23 | #include "config.h" | ||
24 | #include "status.h" | ||
25 | |||
26 | struct status_info { | ||
27 | int battlevel; | ||
28 | int volume; | ||
29 | int hour; | ||
30 | int minute; | ||
31 | int playmode; | ||
32 | int repeat; | ||
33 | bool inserted; | ||
34 | bool shuffle; | ||
35 | bool keylock; | ||
36 | bool battery_safe; | ||
37 | bool redraw_volume; /* true if the volume gauge needs updating */ | ||
38 | #if CONFIG_LED == LED_VIRTUAL | ||
39 | bool led; /* disk LED simulation in the status bar */ | ||
40 | #endif | ||
41 | #ifdef HAVE_USB_POWER | ||
42 | bool usb_power; | ||
43 | #endif | ||
44 | }; | ||
45 | |||
46 | struct gui_statusbar | ||
47 | { | ||
48 | /* Volume icon stuffs */ | ||
49 | long volume_icon_switch_tick; | ||
50 | int last_volume; | ||
51 | |||
52 | long battery_icon_switch_tick; | ||
53 | |||
54 | #ifdef HAVE_CHARGING | ||
55 | int battery_charge_step; | ||
56 | #endif | ||
57 | |||
58 | struct status_info info; | ||
59 | struct status_info lastinfo; | ||
60 | |||
61 | struct screen * display; | ||
62 | }; | ||
63 | |||
64 | /* | ||
65 | * Initializes a status bar | ||
66 | * - bar : the bar to initialize | ||
67 | */ | ||
68 | extern void gui_statusbar_init(struct gui_statusbar * bar); | ||
69 | |||
70 | /* | ||
71 | * Attach the status bar to a screen | ||
72 | * (The previous screen attachement is lost) | ||
73 | * - bar : the statusbar structure | ||
74 | * - display : the screen to attach | ||
75 | */ | ||
76 | extern void gui_statusbar_set_screen(struct gui_statusbar * bar, struct screen * display); | ||
77 | |||
78 | /* | ||
79 | * Draws the status bar on the attached screen | ||
80 | * - bar : the statusbar structure | ||
81 | */ | ||
82 | extern void gui_statusbar_draw(struct gui_statusbar * bar, bool force_redraw); | ||
83 | |||
84 | void gui_statusbar_icon_battery(struct screen * display, int percent); | ||
85 | bool gui_statusbar_icon_volume(struct gui_statusbar * bar, int percent); | ||
86 | void gui_statusbar_icon_play_state(struct screen * display, int state); | ||
87 | void gui_statusbar_icon_play_mode(struct screen * display, int mode); | ||
88 | void gui_statusbar_icon_shuffle(struct screen * display); | ||
89 | void gui_statusbar_icon_lock(struct screen * display); | ||
90 | #if CONFIG_LED == LED_VIRTUAL | ||
91 | void gui_statusbar_led(struct screen * display); | ||
92 | #endif | ||
93 | |||
94 | #ifdef HAVE_RTC | ||
95 | void gui_statusbar_time(struct screen * display, int hour, int minute); | ||
96 | #endif | ||
97 | |||
98 | |||
99 | struct gui_syncstatusbar | ||
100 | { | ||
101 | struct gui_statusbar statusbars[NB_SCREENS]; | ||
102 | }; | ||
103 | |||
104 | extern void gui_syncstatusbar_init(struct gui_syncstatusbar * bars); | ||
105 | extern void gui_syncstatusbar_draw(struct gui_syncstatusbar * bars, bool force_redraw); | ||
106 | |||
107 | #endif /*_GUI_STATUSBAR_H_*/ | ||
diff --git a/apps/status.c b/apps/status.c index ca4b21833e..9f43c6551d 100644 --- a/apps/status.c +++ b/apps/status.c | |||
@@ -43,12 +43,12 @@ | |||
43 | #endif | 43 | #endif |
44 | #include "usb.h" | 44 | #include "usb.h" |
45 | 45 | ||
46 | static enum playmode ff_mode; | 46 | enum playmode ff_mode; |
47 | 47 | ||
48 | static long switch_tick; | 48 | long switch_tick; |
49 | static bool battery_state = true; | 49 | bool battery_state = true; |
50 | #ifdef HAVE_CHARGING | 50 | #ifdef HAVE_CHARGING |
51 | static int battery_charge_step = 0; | 51 | int battery_charge_step = 0; |
52 | #endif | 52 | #endif |
53 | 53 | ||
54 | struct status_info { | 54 | struct status_info { |
@@ -123,10 +123,10 @@ int current_playmode(void) | |||
123 | } | 123 | } |
124 | 124 | ||
125 | #if defined(HAVE_LCD_CHARCELLS) | 125 | #if defined(HAVE_LCD_CHARCELLS) |
126 | static bool record = false; | 126 | bool record = false; |
127 | static bool audio = false; | 127 | bool audio = false; |
128 | static bool param = false; | 128 | bool param = false; |
129 | static bool usb = false; | 129 | bool usb = false; |
130 | 130 | ||
131 | void status_set_record(bool b) | 131 | void status_set_record(bool b) |
132 | { | 132 | { |
diff --git a/apps/status.h b/apps/status.h index 0d8c80d7a8..29316f98b1 100644 --- a/apps/status.h +++ b/apps/status.h | |||
@@ -19,6 +19,21 @@ | |||
19 | #ifndef _STATUS_H | 19 | #ifndef _STATUS_H |
20 | #define _STATUS_H | 20 | #define _STATUS_H |
21 | 21 | ||
22 | extern enum playmode ff_mode; | ||
23 | |||
24 | extern long switch_tick; | ||
25 | extern bool battery_state; | ||
26 | #ifdef HAVE_CHARGING | ||
27 | extern int battery_charge_step; | ||
28 | #endif | ||
29 | |||
30 | #if defined(HAVE_LCD_CHARCELLS) | ||
31 | extern bool record; | ||
32 | extern bool audio; | ||
33 | extern bool param; | ||
34 | extern bool usb; | ||
35 | #endif | ||
36 | |||
22 | enum playmode | 37 | enum playmode |
23 | { | 38 | { |
24 | STATUS_PLAY, | 39 | STATUS_PLAY, |
@@ -33,10 +48,12 @@ enum playmode | |||
33 | void status_init(void); | 48 | void status_init(void); |
34 | void status_set_ffmode(enum playmode mode); | 49 | void status_set_ffmode(enum playmode mode); |
35 | enum playmode status_get_ffmode(void); | 50 | enum playmode status_get_ffmode(void); |
51 | int current_playmode(void); | ||
52 | |||
36 | #ifdef HAVE_LCD_BITMAP | 53 | #ifdef HAVE_LCD_BITMAP |
37 | bool statusbar(bool state); | 54 | bool statusbar(bool state); |
38 | #if CONFIG_KEYPAD == RECORDER_PAD | 55 | #if CONFIG_KEYPAD == RECORDER_PAD |
39 | void buttonbar_set(const char* caption1, const char* caption2, | 56 | void buttonbar_set(const char* caption1, const char* caption2, |
40 | const char* caption3); | 57 | const char* caption3); |
41 | void buttonbar_unset(void); | 58 | void buttonbar_unset(void); |
42 | bool buttonbar_isset(void); | 59 | bool buttonbar_isset(void); |
diff --git a/apps/tree.c b/apps/tree.c index 8d68814315..7d4ee7f703 100644 --- a/apps/tree.c +++ b/apps/tree.c | |||
@@ -63,6 +63,12 @@ | |||
63 | #include "rtc.h" | 63 | #include "rtc.h" |
64 | #include "dircache.h" | 64 | #include "dircache.h" |
65 | 65 | ||
66 | /* gui api */ | ||
67 | #include "list.h" | ||
68 | #include "statusbar.h" | ||
69 | #include "splash.h" | ||
70 | #include "buttonbar.h" | ||
71 | |||
66 | #ifdef HAVE_LCD_BITMAP | 72 | #ifdef HAVE_LCD_BITMAP |
67 | #include "widgets.h" | 73 | #include "widgets.h" |
68 | #endif | 74 | #endif |
@@ -99,6 +105,14 @@ const struct filetype filetypes[] = { | |||
99 | #endif /* #ifndef SIMULATOR */ | 105 | #endif /* #ifndef SIMULATOR */ |
100 | }; | 106 | }; |
101 | 107 | ||
108 | struct gui_synclist tree_lists; | ||
109 | |||
110 | /* I put it here because other files doesn't use it yet, | ||
111 | * but should be elsewhere since it will be used mostly everywhere */ | ||
112 | struct gui_syncstatusbar statusbars; | ||
113 | #ifdef HAS_BUTTONBAR | ||
114 | struct gui_buttonbar tree_buttonbar; | ||
115 | #endif | ||
102 | static struct tree_context tc; | 116 | static struct tree_context tc; |
103 | 117 | ||
104 | bool boot_changed = false; | 118 | bool boot_changed = false; |
@@ -112,17 +126,77 @@ static bool reload_dir = false; | |||
112 | 126 | ||
113 | static bool start_wps = false; | 127 | static bool start_wps = false; |
114 | static bool dirbrowse(void); | 128 | static bool dirbrowse(void); |
115 | static int curr_context = false; | 129 | static int curr_context = false;/* id3db or tree*/ |
130 | |||
131 | /* | ||
132 | * removes the extension of filename (if it doesn't start with a .) | ||
133 | * puts the result in buffer | ||
134 | */ | ||
135 | char * strip_extension(char * filename, char * buffer) | ||
136 | { | ||
137 | int dotpos; | ||
138 | char * dot=strrchr(filename, '.'); | ||
139 | if(dot!=0 && filename[0]!='.') | ||
140 | { | ||
141 | dotpos = dot-filename; | ||
142 | strncpy(buffer, filename, dotpos); | ||
143 | buffer[dotpos]='\0'; | ||
144 | return(buffer); | ||
145 | } | ||
146 | else | ||
147 | return(filename); | ||
148 | } | ||
149 | char * tree_get_filename(int selected_item, char *buffer) | ||
150 | { | ||
151 | char *name; | ||
152 | int attr=0; | ||
153 | bool id3db = *tc.dirfilter == SHOW_ID3DB; | ||
154 | if (id3db) { | ||
155 | name = ((char**)tc.dircache)[selected_item * tc.dentry_size]; | ||
156 | } | ||
157 | else { | ||
158 | struct entry* dc = tc.dircache; | ||
159 | struct entry* e = &dc[selected_item]; | ||
160 | name = e->name; | ||
161 | attr = e->attr; | ||
162 | } | ||
163 | /* if any file filter is on, and if it's not a directory, | ||
164 | * strip the extension */ | ||
165 | |||
166 | if ( (*tc.dirfilter != SHOW_ID3DB) && !(attr & ATTR_DIRECTORY) | ||
167 | && (*tc.dirfilter != SHOW_ALL) ) | ||
168 | { | ||
169 | return(strip_extension(name, buffer)); | ||
170 | } | ||
171 | return(name); | ||
172 | } | ||
173 | |||
174 | |||
175 | void tree_get_fileicon(int selected_item, ICON * icon) | ||
176 | { | ||
177 | bool id3db = *tc.dirfilter == SHOW_ID3DB; | ||
178 | if (id3db) { | ||
179 | *icon = db_get_icon(&tc); | ||
180 | } | ||
181 | else { | ||
182 | struct entry* dc = tc.dircache; | ||
183 | struct entry* e = &dc[selected_item]; | ||
184 | *icon = filetype_get_icon(e->attr); | ||
185 | } | ||
186 | } | ||
116 | 187 | ||
117 | bool check_rockboxdir(void) | 188 | bool check_rockboxdir(void) |
118 | { | 189 | { |
119 | DIR *dir = opendir(ROCKBOX_DIR); | 190 | DIR *dir = opendir(ROCKBOX_DIR); |
120 | if(!dir) | 191 | if(!dir) |
121 | { | 192 | { |
122 | lcd_clear_display(); | 193 | int i; |
123 | splash(HZ*2, true, str(LANG_NO_ROCKBOX_DIR)); | 194 | for(i = 0;i < NB_SCREENS;++i) |
124 | lcd_clear_display(); | 195 | screens[i].clear_display(); |
125 | splash(HZ*2, true, str(LANG_INSTALLATION_INCOMPLETE)); | 196 | gui_syncsplash(HZ*2, true, str(LANG_NO_ROCKBOX_DIR)); |
197 | for(i = 0;i < NB_SCREENS;++i) | ||
198 | screens[i].clear_display(); | ||
199 | gui_syncsplash(HZ*2, true, str(LANG_INSTALLATION_INCOMPLETE)); | ||
126 | return false; | 200 | return false; |
127 | } | 201 | } |
128 | closedir(dir); | 202 | closedir(dir); |
@@ -131,16 +205,28 @@ bool check_rockboxdir(void) | |||
131 | 205 | ||
132 | void browse_root(void) | 206 | void browse_root(void) |
133 | { | 207 | { |
208 | /* essential to all programs that wants to display things */ | ||
209 | screen_access_init(); | ||
210 | |||
134 | filetype_init(); | 211 | filetype_init(); |
135 | check_rockboxdir(); | 212 | check_rockboxdir(); |
136 | 213 | ||
137 | strcpy(tc.currdir, "/"); | 214 | strcpy(tc.currdir, "/"); |
215 | |||
138 | #ifdef HAVE_LCD_CHARCELLS | 216 | #ifdef HAVE_LCD_CHARCELLS |
139 | lcd_double_height(false); | 217 | int i; |
218 | for(i = 0;i < NB_SCREENS;++i) | ||
219 | screens[i].double_height(false); | ||
140 | #endif | 220 | #endif |
221 | #ifdef HAS_BUTTONBAR | ||
222 | gui_buttonbar_init(&tree_buttonbar); | ||
223 | /* since archos only have one screen, no need to create more than that */ | ||
224 | gui_buttonbar_set_display(&tree_buttonbar, &(screens[SCREEN_MAIN]) ); | ||
225 | #endif | ||
226 | gui_syncstatusbar_init(&statusbars); | ||
227 | gui_synclist_init(&tree_lists, &tree_get_fileicon, &tree_get_filename); | ||
141 | #ifndef SIMULATOR | 228 | #ifndef SIMULATOR |
142 | dirbrowse(); | 229 | dirbrowse(); |
143 | |||
144 | #else | 230 | #else |
145 | if (!dirbrowse()) { | 231 | if (!dirbrowse()) { |
146 | DEBUGF("No filesystem found. Have you forgotten to create it?\n"); | 232 | DEBUGF("No filesystem found. Have you forgotten to create it?\n"); |
@@ -159,126 +245,35 @@ struct tree_context* tree_get_context(void) | |||
159 | return &tc; | 245 | return &tc; |
160 | } | 246 | } |
161 | 247 | ||
162 | #ifdef HAVE_LCD_BITMAP | ||
163 | |||
164 | /* pixel margins */ | ||
165 | #define MARGIN_X (global_settings.scrollbar && \ | ||
166 | tc.filesindir > tree_max_on_screen ? SCROLLBAR_WIDTH : 0) + \ | ||
167 | CURSOR_WIDTH + (global_settings.show_icons && ICON_WIDTH > 0 ? ICON_WIDTH :0) | ||
168 | #define MARGIN_Y (global_settings.statusbar ? STATUSBAR_HEIGHT : 0) | ||
169 | |||
170 | /* position the entry-list starts at */ | ||
171 | #define LINE_X 0 | ||
172 | #define LINE_Y (global_settings.statusbar ? 1 : 0) | ||
173 | |||
174 | #define CURSOR_X (global_settings.scrollbar && \ | ||
175 | tc.filesindir > tree_max_on_screen ? 1 : 0) | ||
176 | #define CURSOR_Y 0 /* the cursor is not positioned in regard to | ||
177 | the margins, so this is the amount of lines | ||
178 | we add to the cursor Y position to position | ||
179 | it on a line */ | ||
180 | #define CURSOR_WIDTH (global_settings.invert_cursor ? 0 : 4) | ||
181 | |||
182 | #define ICON_WIDTH 6 | ||
183 | |||
184 | #define SCROLLBAR_X 0 | ||
185 | #define SCROLLBAR_Y lcd_getymargin() | ||
186 | #define SCROLLBAR_WIDTH 6 | ||
187 | |||
188 | #else /* HAVE_LCD_BITMAP */ | ||
189 | |||
190 | #define TREE_MAX_ON_SCREEN 2 | ||
191 | #define TREE_MAX_LEN_DISPLAY 11 /* max length that fits on screen */ | ||
192 | #define LINE_X 2 /* X position the entry-list starts at */ | ||
193 | #define LINE_Y 0 /* Y position the entry-list starts at */ | ||
194 | |||
195 | #define CURSOR_X 0 | ||
196 | #define CURSOR_Y 0 /* not really used for players */ | ||
197 | |||
198 | #endif /* HAVE_LCD_BITMAP */ | ||
199 | |||
200 | /* talkbox hovering delay, to avoid immediate disk activity */ | 248 | /* talkbox hovering delay, to avoid immediate disk activity */ |
201 | #define HOVER_DELAY (HZ/2) | 249 | #define HOVER_DELAY (HZ/2) |
202 | 250 | /* | |
203 | static void showfileline(int line, char* name, int attr, bool scroll) | 251 | * Returns the position of a given file in the current directory |
252 | * returns -1 if not found | ||
253 | */ | ||
254 | int tree_get_file_position(char * filename) | ||
204 | { | 255 | { |
205 | int xpos = LINE_X; | 256 | int i; |
206 | char* dotpos = NULL; | 257 | /* use lastfile to determine the selected item (default=0) */ |
207 | 258 | for (i=0; i < tc.filesindir; i++) | |
208 | #ifdef HAVE_LCD_CHARCELLS | ||
209 | if (!global_settings.show_icons) | ||
210 | xpos--; | ||
211 | #endif | ||
212 | |||
213 | /* if any file filter is on, strip the extension */ | ||
214 | if (*tc.dirfilter != SHOW_ID3DB && | ||
215 | *tc.dirfilter != SHOW_ALL && | ||
216 | !(attr & ATTR_DIRECTORY)) | ||
217 | { | 259 | { |
218 | dotpos = strrchr(name, '.'); | 260 | struct entry* dc = tc.dircache; |
219 | if (dotpos) { | 261 | struct entry* e = &dc[i]; |
220 | *dotpos = 0; | 262 | if (!strcasecmp(e->name, filename)) |
221 | } | 263 | return(i); |
222 | } | 264 | } |
223 | 265 | return(-1);/* no file can match, returns undefined */ | |
224 | if(scroll) { | ||
225 | #ifdef HAVE_LCD_BITMAP | ||
226 | lcd_setfont(FONT_UI); | ||
227 | if (global_settings.invert_cursor) | ||
228 | lcd_puts_scroll_style(xpos, line, name, STYLE_INVERT); | ||
229 | else | ||
230 | #endif | ||
231 | lcd_puts_scroll(xpos, line, name); | ||
232 | } else | ||
233 | lcd_puts(xpos, line, name); | ||
234 | |||
235 | /* Restore the dot before the extension if it was removed */ | ||
236 | if (dotpos) | ||
237 | *dotpos = '.'; | ||
238 | } | ||
239 | |||
240 | #ifdef HAVE_LCD_BITMAP | ||
241 | static int recalc_screen_height(void) | ||
242 | { | ||
243 | int fw, fh; | ||
244 | int height = LCD_HEIGHT; | ||
245 | |||
246 | lcd_setfont(FONT_UI); | ||
247 | lcd_getstringsize("A", &fw, &fh); | ||
248 | if(global_settings.statusbar) | ||
249 | height -= STATUSBAR_HEIGHT; | ||
250 | |||
251 | #if CONFIG_KEYPAD == RECORDER_PAD | ||
252 | if(global_settings.buttonbar) | ||
253 | height -= BUTTONBAR_HEIGHT; | ||
254 | #endif | ||
255 | |||
256 | return height / fh; | ||
257 | } | 266 | } |
258 | #endif | ||
259 | 267 | ||
260 | static int showdir(void) | 268 | /* |
269 | * Called when a new dir is loaded (for example when returning from other apps ...) | ||
270 | * also completely redraws the tree | ||
271 | */ | ||
272 | static int update_dir(void) | ||
261 | { | 273 | { |
262 | struct entry *dircache = tc.dircache; | ||
263 | int i; | ||
264 | int tree_max_on_screen; | ||
265 | int start = tc.dirstart; | ||
266 | bool id3db = *tc.dirfilter == SHOW_ID3DB; | 274 | bool id3db = *tc.dirfilter == SHOW_ID3DB; |
267 | bool newdir = false; | 275 | bool changed = false; |
268 | #ifdef HAVE_LCD_BITMAP | 276 | /* Checks for changes */ |
269 | const char* icon; | ||
270 | int line_height; | ||
271 | int fw, fh; | ||
272 | lcd_setfont(FONT_UI); | ||
273 | lcd_getstringsize("A", &fw, &fh); | ||
274 | tree_max_on_screen = recalc_screen_height(); | ||
275 | line_height = fh; | ||
276 | #else | ||
277 | int icon; | ||
278 | tree_max_on_screen = TREE_MAX_ON_SCREEN; | ||
279 | #endif | ||
280 | |||
281 | /* new file dir? load it */ | ||
282 | if (id3db) { | 277 | if (id3db) { |
283 | if (tc.currtable != lasttable || | 278 | if (tc.currtable != lasttable || |
284 | tc.currextra != lastextra || | 279 | tc.currextra != lastextra || |
@@ -286,151 +281,73 @@ static int showdir(void) | |||
286 | { | 281 | { |
287 | if (db_load(&tc) < 0) | 282 | if (db_load(&tc) < 0) |
288 | return -1; | 283 | return -1; |
284 | |||
289 | lasttable = tc.currtable; | 285 | lasttable = tc.currtable; |
290 | lastextra = tc.currextra; | 286 | lastextra = tc.currextra; |
291 | lastfirstpos = tc.firstpos; | 287 | lastfirstpos = tc.firstpos; |
292 | newdir = true; | 288 | changed = true; |
293 | } | 289 | } |
294 | } | 290 | } |
295 | else { | 291 | else { |
292 | /* if the tc.currdir has been changed, reload it ...*/ | ||
296 | if (strncmp(tc.currdir, lastdir, sizeof(lastdir)) || reload_dir) { | 293 | if (strncmp(tc.currdir, lastdir, sizeof(lastdir)) || reload_dir) { |
297 | if (ft_load(&tc, NULL) < 0) | 294 | |
295 | if (ft_load(&tc, NULL) < 0) | ||
298 | return -1; | 296 | return -1; |
299 | strcpy(lastdir, tc.currdir); | 297 | strcpy(lastdir, tc.currdir); |
300 | newdir = true; | 298 | changed = true; |
301 | } | 299 | } |
302 | } | 300 | } |
303 | 301 | /* if selected item is undefined */ | |
304 | if (newdir && !id3db && | 302 | if (tc.selected_item == -1) |
305 | (tc.dirfull || tc.filesindir == global_settings.max_files_in_dir) ) | ||
306 | { | 303 | { |
307 | #ifdef HAVE_LCD_CHARCELLS | 304 | /* use lastfile to determine the selected item */ |
308 | lcd_double_height(false); | 305 | tc.selected_item = tree_get_file_position(lastfile); |
309 | #endif | ||
310 | lcd_clear_display(); | ||
311 | lcd_puts(0,0,str(LANG_SHOWDIR_ERROR_BUFFER)); | ||
312 | lcd_puts(0,1,str(LANG_SHOWDIR_ERROR_FULL)); | ||
313 | lcd_update(); | ||
314 | sleep(HZ*2); | ||
315 | lcd_clear_display(); | ||
316 | } | ||
317 | |||
318 | if (start == -1) | ||
319 | { | ||
320 | int diff_files; | ||
321 | |||
322 | /* use lastfile to determine start (default=0) */ | ||
323 | start = 0; | ||
324 | |||
325 | for (i=0; i < tc.filesindir; i++) | ||
326 | { | ||
327 | struct entry *dircache = tc.dircache; | ||
328 | |||
329 | if (!strcasecmp(dircache[i].name, lastfile)) | ||
330 | { | ||
331 | start = i; | ||
332 | break; | ||
333 | } | ||
334 | } | ||
335 | |||
336 | diff_files = tc.filesindir - start; | ||
337 | if (diff_files < tree_max_on_screen) | ||
338 | { | ||
339 | int oldstart = start; | ||
340 | |||
341 | start -= (tree_max_on_screen - diff_files); | ||
342 | if (start < 0) | ||
343 | start = 0; | ||
344 | 306 | ||
345 | tc.dircursor = oldstart - start; | 307 | /* If the file doesn't exists, select the first one (default) */ |
346 | } | 308 | if(tc.selected_item < 0) |
347 | 309 | tc.selected_item = 0; | |
348 | tc.dirstart = start; | 310 | changed = true; |
349 | } | 311 | } |
350 | 312 | if (changed) | |
351 | /* The cursor might point to an invalid line, for example if someone | ||
352 | deleted the last file in the dir */ | ||
353 | if (tc.filesindir) | ||
354 | { | 313 | { |
355 | while (start + tc.dircursor >= tc.filesindir) | 314 | if(!id3db && (tc.dirfull || |
315 | tc.filesindir == global_settings.max_files_in_dir) ) | ||
356 | { | 316 | { |
357 | if (start) | 317 | /* dir full */ |
358 | start--; | 318 | int i; |
359 | else | 319 | for(i = 0;i < NB_SCREENS;++i) |
360 | if (tc.dircursor) | 320 | { |
361 | tc.dircursor--; | ||
362 | } | ||
363 | tc.dirstart = start; | ||
364 | } | ||
365 | |||
366 | #ifdef HAVE_LCD_CHARCELLS | 321 | #ifdef HAVE_LCD_CHARCELLS |
367 | lcd_stop_scroll(); | 322 | screens[i].double_height(false); |
368 | lcd_double_height(false); | ||
369 | #endif | ||
370 | lcd_clear_display(); | ||
371 | #ifdef HAVE_LCD_BITMAP | ||
372 | lcd_setmargins(MARGIN_X,MARGIN_Y); /* leave room for cursor and icon */ | ||
373 | lcd_setfont(FONT_UI); | ||
374 | #endif | 323 | #endif |
375 | 324 | screens[i].clear_display(); | |
376 | 325 | screens[i].puts(0,0,str(LANG_SHOWDIR_ERROR_BUFFER)); | |
377 | for ( i=start; i < start+tree_max_on_screen && i < tc.filesindir; i++ ) { | 326 | screens[i].puts(0,1,str(LANG_SHOWDIR_ERROR_FULL)); |
378 | int line = i - start; | 327 | #if defined(HAVE_LCD_BITMAP) || defined(SIMULATOR) |
379 | char* name; | 328 | screens[i].update(); |
380 | int attr = 0; | ||
381 | |||
382 | if (id3db) { | ||
383 | name = ((char**)tc.dircache)[i * tc.dentry_size]; | ||
384 | icon = db_get_icon(&tc); | ||
385 | } | ||
386 | else { | ||
387 | struct entry* dc = tc.dircache; | ||
388 | struct entry* e = &dc[i]; | ||
389 | name = e->name; | ||
390 | attr = e->attr; | ||
391 | icon = filetype_get_icon(dircache[i].attr); | ||
392 | } | ||
393 | |||
394 | |||
395 | if (icon && global_settings.show_icons) { | ||
396 | #ifdef HAVE_LCD_BITMAP | ||
397 | int offset=0; | ||
398 | if ( line_height > 8 ) | ||
399 | offset = (line_height - 8) / 2; | ||
400 | lcd_mono_bitmap(icon, | ||
401 | CURSOR_X * 6 + CURSOR_WIDTH, | ||
402 | MARGIN_Y+(i-start)*line_height + offset, 6, 8); | ||
403 | #else | ||
404 | if (icon < 0 ) | ||
405 | icon = Icon_Unknown; | ||
406 | lcd_putc(LINE_X-1, i-start, icon); | ||
407 | #endif | 329 | #endif |
330 | } | ||
331 | sleep(HZ*2); | ||
332 | for(i = 0;i < NB_SCREENS;++i) | ||
333 | screens[i].clear_display(); | ||
408 | } | 334 | } |
409 | |||
410 | showfileline(line, name, attr, false); /* no scroll */ | ||
411 | } | 335 | } |
412 | 336 | gui_synclist_set_nb_items(&tree_lists, tc.filesindir); | |
413 | #ifdef HAVE_LCD_BITMAP | 337 | gui_synclist_select_item(&tree_lists, tc.selected_item); |
414 | if (global_settings.scrollbar && (tc.dirlength > tree_max_on_screen)) | 338 | gui_synclist_draw(&tree_lists); |
415 | scrollbar(SCROLLBAR_X, SCROLLBAR_Y, SCROLLBAR_WIDTH - 1, | 339 | gui_syncstatusbar_draw(&statusbars, true); |
416 | tree_max_on_screen * line_height, tc.dirlength, | 340 | #ifdef HAS_BUTTONBAR |
417 | start + tc.firstpos, | ||
418 | start + tc.firstpos + tree_max_on_screen, VERTICAL); | ||
419 | |||
420 | #if CONFIG_KEYPAD == RECORDER_PAD | ||
421 | if (global_settings.buttonbar) { | 341 | if (global_settings.buttonbar) { |
422 | if (*tc.dirfilter < NUM_FILTER_MODES) | 342 | if (*tc.dirfilter < NUM_FILTER_MODES) |
423 | buttonbar_set(str(LANG_DIRBROWSE_F1), | 343 | gui_buttonbar_set(&tree_buttonbar, str(LANG_DIRBROWSE_F1), |
424 | str(LANG_DIRBROWSE_F2), | 344 | str(LANG_DIRBROWSE_F2), |
425 | str(LANG_DIRBROWSE_F3)); | 345 | str(LANG_DIRBROWSE_F3)); |
426 | else | 346 | else |
427 | buttonbar_set("<<<", "", ""); | 347 | gui_buttonbar_set(&tree_buttonbar, "<<<", "", ""); |
428 | buttonbar_draw(); | 348 | gui_buttonbar_draw(&tree_buttonbar); |
429 | } | 349 | } |
430 | #endif | 350 | #endif |
431 | #endif | ||
432 | status_draw(true); | ||
433 | |||
434 | return tc.filesindir; | 351 | return tc.filesindir; |
435 | } | 352 | } |
436 | 353 | ||
@@ -468,7 +385,6 @@ void reload_directory(void) | |||
468 | static void start_resume(bool just_powered_on) | 385 | static void start_resume(bool just_powered_on) |
469 | { | 386 | { |
470 | bool do_resume = false; | 387 | bool do_resume = false; |
471 | |||
472 | if ( global_settings.resume_index != -1 ) { | 388 | if ( global_settings.resume_index != -1 ) { |
473 | DEBUGF("Resume index %X offset %X\n", | 389 | DEBUGF("Resume index %X offset %X\n", |
474 | global_settings.resume_index, | 390 | global_settings.resume_index, |
@@ -486,7 +402,7 @@ static void start_resume(bool just_powered_on) | |||
486 | do_resume = true; | 402 | do_resume = true; |
487 | 403 | ||
488 | if (! do_resume) return; | 404 | if (! do_resume) return; |
489 | 405 | ||
490 | if (playlist_resume() != -1) | 406 | if (playlist_resume() != -1) |
491 | { | 407 | { |
492 | playlist_start(global_settings.resume_index, | 408 | playlist_start(global_settings.resume_index, |
@@ -496,23 +412,23 @@ static void start_resume(bool just_powered_on) | |||
496 | } | 412 | } |
497 | else return; | 413 | else return; |
498 | } else if (! just_powered_on) { | 414 | } else if (! just_powered_on) { |
499 | splash(HZ*2, true, str(LANG_NOTHING_TO_RESUME)); | 415 | gui_syncsplash(HZ*2, true, str(LANG_NOTHING_TO_RESUME)); |
500 | } | 416 | } |
501 | } | 417 | } |
502 | 418 | ||
419 | /* Selects a file and update tree context properly */ | ||
503 | void set_current_file(char *path) | 420 | void set_current_file(char *path) |
504 | { | 421 | { |
505 | char *name; | 422 | char *name; |
506 | unsigned int i; | 423 | int i; |
507 | 424 | ||
508 | /* in ID3DB mode it is a bad idea to call this function */ | 425 | /* in ID3DB mode it is a bad idea to call this function */ |
509 | /* (only happens with `follow playlist') */ | 426 | /* (only happens with `follow playlist') */ |
510 | if( *tc.dirfilter == SHOW_ID3DB ) | 427 | if( *tc.dirfilter == SHOW_ID3DB ) |
511 | { | ||
512 | return; | 428 | return; |
513 | } | ||
514 | 429 | ||
515 | /* separate directory from filename */ | 430 | /* separate directory from filename */ |
431 | /* gets the directory's name and put it into tc.currdir */ | ||
516 | name = strrchr(path+1,'/'); | 432 | name = strrchr(path+1,'/'); |
517 | if (name) | 433 | if (name) |
518 | { | 434 | { |
@@ -528,24 +444,27 @@ void set_current_file(char *path) | |||
528 | } | 444 | } |
529 | 445 | ||
530 | strcpy(lastfile, name); | 446 | strcpy(lastfile, name); |
447 | |||
448 | /* undefined item selected */ | ||
449 | tc.selected_item = -1; | ||
531 | 450 | ||
532 | tc.dircursor = 0; | 451 | /* If we changed dir we must recalculate the dirlevel |
533 | tc.dirstart = -1; | 452 | and adjust the selected history properly */ |
534 | |||
535 | if (strncmp(tc.currdir,lastdir,sizeof(lastdir))) | 453 | if (strncmp(tc.currdir,lastdir,sizeof(lastdir))) |
536 | { | 454 | { |
537 | tc.dirlevel = 0; | 455 | tc.dirlevel = 0; |
538 | tc.dirpos[tc.dirlevel] = -1; | 456 | tc.selected_item_history[tc.dirlevel] = -1; |
539 | tc.cursorpos[tc.dirlevel] = 0; | ||
540 | 457 | ||
541 | /* use '/' to calculate dirlevel */ | 458 | /* use '/' to calculate dirlevel */ |
542 | for (i=1; i<strlen(path)+1; i++) | 459 | /* FIXME : strlen(path) : crazy oO better to store it at |
460 | the beginning */ | ||
461 | int path_len = strlen(path) + 1; | ||
462 | for (i = 1; i < path_len; i++) | ||
543 | { | 463 | { |
544 | if (path[i] == '/') | 464 | if (path[i] == '/') |
545 | { | 465 | { |
546 | tc.dirlevel++; | 466 | tc.dirlevel++; |
547 | tc.dirpos[tc.dirlevel] = -1; | 467 | tc.selected_item_history[tc.dirlevel] = -1; |
548 | tc.cursorpos[tc.dirlevel] = 0; | ||
549 | } | 468 | } |
550 | } | 469 | } |
551 | } | 470 | } |
@@ -567,24 +486,20 @@ static bool check_changed_id3mode(bool currmode) | |||
567 | } | 486 | } |
568 | return currmode; | 487 | return currmode; |
569 | } | 488 | } |
570 | 489 | /* main loop, handles key events */ | |
571 | static bool dirbrowse(void) | 490 | static bool dirbrowse(void) |
572 | { | 491 | { |
573 | int numentries=0; | 492 | int numentries=0; |
574 | char buf[MAX_PATH]; | 493 | char buf[MAX_PATH]; |
575 | int i; | 494 | int lasti = -1; |
576 | int lasti=-1; | ||
577 | unsigned button; | 495 | unsigned button; |
578 | int tree_max_on_screen; | ||
579 | bool reload_root = false; | 496 | bool reload_root = false; |
580 | int lastfilter = *tc.dirfilter; | 497 | int lastfilter = *tc.dirfilter; |
581 | bool lastsortcase = global_settings.sort_case; | 498 | bool lastsortcase = global_settings.sort_case; |
582 | int lastdircursor=-1; | ||
583 | bool need_update = true; | 499 | bool need_update = true; |
584 | bool exit_func = false; | 500 | bool exit_func = false; |
585 | long thumbnail_time = -1; /* for delaying a thumbnail */ | 501 | long thumbnail_time = -1; /* for delaying a thumbnail */ |
586 | bool update_all = false; /* set this to true when the whole file list | 502 | |
587 | has been refreshed on screen */ | ||
588 | unsigned lastbutton = 0; | 503 | unsigned lastbutton = 0; |
589 | char* currdir = tc.currdir; /* just a shortcut */ | 504 | char* currdir = tc.currdir; /* just a shortcut */ |
590 | bool id3db = *tc.dirfilter == SHOW_ID3DB; | 505 | bool id3db = *tc.dirfilter == SHOW_ID3DB; |
@@ -593,15 +508,10 @@ static bool dirbrowse(void) | |||
593 | curr_context=CONTEXT_ID3DB; | 508 | curr_context=CONTEXT_ID3DB; |
594 | else | 509 | else |
595 | curr_context=CONTEXT_TREE; | 510 | curr_context=CONTEXT_TREE; |
596 | |||
597 | #ifdef HAVE_LCD_BITMAP | 511 | #ifdef HAVE_LCD_BITMAP |
598 | tree_max_on_screen = recalc_screen_height(); | 512 | screen_access_update_nb_lines(); |
599 | #else | ||
600 | tree_max_on_screen = TREE_MAX_ON_SCREEN; | ||
601 | #endif | 513 | #endif |
602 | 514 | tc.selected_item = 0; | |
603 | tc.dircursor=0; | ||
604 | tc.dirstart=0; | ||
605 | tc.dirlevel=0; | 515 | tc.dirlevel=0; |
606 | tc.firstpos=0; | 516 | tc.firstpos=0; |
607 | lasttable = -1; | 517 | lasttable = -1; |
@@ -624,25 +534,21 @@ static bool dirbrowse(void) | |||
624 | start_resume(true); | 534 | start_resume(true); |
625 | 535 | ||
626 | } | 536 | } |
627 | 537 | /* If we don't need to show the wps, draw the dir */ | |
628 | if (!start_wps) { | 538 | if (!start_wps) { |
629 | numentries = showdir(); | 539 | numentries = update_dir(); |
630 | if (numentries == -1) | 540 | if (numentries == -1) |
631 | return false; /* currdir is not a directory */ | 541 | return false; /* currdir is not a directory */ |
632 | 542 | ||
633 | if (*tc.dirfilter > NUM_FILTER_MODES && numentries==0) | 543 | if (*tc.dirfilter > NUM_FILTER_MODES && numentries==0) |
634 | { | 544 | { |
635 | splash(HZ*2, true, str(LANG_NO_FILES)); | 545 | gui_syncsplash(HZ*2, true, str(LANG_NO_FILES)); |
636 | return false; /* No files found for rockbox_browser() */ | 546 | return false; /* No files found for rockbox_browser() */ |
637 | } | 547 | } |
638 | update_all = true; | ||
639 | |||
640 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, true); | ||
641 | } | 548 | } |
642 | 549 | ||
643 | while(1) { | 550 | while(1) { |
644 | struct entry *dircache = tc.dircache; | 551 | struct entry *dircache = tc.dircache; |
645 | |||
646 | bool restore = false; | 552 | bool restore = false; |
647 | 553 | ||
648 | button = button_get_w_tmo(HZ/5); | 554 | button = button_get_w_tmo(HZ/5); |
@@ -651,15 +557,18 @@ static bool dirbrowse(void) | |||
651 | if (boot_changed) { | 557 | if (boot_changed) { |
652 | bool stop = false; | 558 | bool stop = false; |
653 | unsigned int button; | 559 | unsigned int button; |
654 | 560 | int i; | |
655 | lcd_clear_display(); | 561 | for(i = 0;i < NB_SCREENS;++i) |
656 | lcd_puts(0,0,str(LANG_BOOT_CHANGED)); | 562 | { |
657 | lcd_puts(0,1,str(LANG_REBOOT_NOW)); | 563 | screens[i].clear_display(); |
564 | screens[i].puts(0,0,str(LANG_BOOT_CHANGED)); | ||
565 | screens[i].puts(0,1,str(LANG_REBOOT_NOW)); | ||
658 | #ifdef HAVE_LCD_BITMAP | 566 | #ifdef HAVE_LCD_BITMAP |
659 | lcd_puts(0,3,str(LANG_CONFIRM_WITH_PLAY_RECORDER)); | 567 | screens[i].puts(0,3,str(LANG_CONFIRM_WITH_PLAY_RECORDER)); |
660 | lcd_puts(0,4,str(LANG_CANCEL_WITH_ANY_RECORDER)); | 568 | screens[i].puts(0,4,str(LANG_CANCEL_WITH_ANY_RECORDER)); |
661 | lcd_update(); | 569 | screens[i].update(); |
662 | #endif | 570 | #endif |
571 | } | ||
663 | while (!stop) { | 572 | while (!stop) { |
664 | button = button_get(true); | 573 | button = button_get(true); |
665 | switch (button) { | 574 | switch (button) { |
@@ -683,6 +592,7 @@ static bool dirbrowse(void) | |||
683 | boot_changed = false; | 592 | boot_changed = false; |
684 | } | 593 | } |
685 | #endif | 594 | #endif |
595 | need_update = gui_synclist_do_button(&tree_lists, button); | ||
686 | 596 | ||
687 | switch ( button ) { | 597 | switch ( button ) { |
688 | #ifdef TREE_ENTER | 598 | #ifdef TREE_ENTER |
@@ -702,33 +612,17 @@ static bool dirbrowse(void) | |||
702 | && (lastbutton != TREE_RUN_PRE))) | 612 | && (lastbutton != TREE_RUN_PRE))) |
703 | break; | 613 | break; |
704 | #endif | 614 | #endif |
705 | if ( !numentries ) | 615 | /* nothing to do if no files to display */ |
616 | if ( numentries == 0 ) | ||
706 | break; | 617 | break; |
707 | 618 | ||
708 | if (id3db) | 619 | switch (id3db?db_enter(&tc):ft_enter(&tc)) |
709 | i = db_enter(&tc); | ||
710 | else | ||
711 | i = ft_enter(&tc); | ||
712 | |||
713 | switch (i) | ||
714 | { | 620 | { |
715 | case 1: reload_dir = true; break; | 621 | case 1: reload_dir = true; break; |
716 | case 2: start_wps = true; break; | 622 | case 2: start_wps = true; break; |
717 | case 3: exit_func = true; break; | 623 | case 3: exit_func = true; break; |
718 | default: break; | 624 | default: break; |
719 | } | 625 | } |
720 | |||
721 | #ifdef HAVE_LCD_BITMAP | ||
722 | /* maybe we have a new font */ | ||
723 | tree_max_on_screen = recalc_screen_height(); | ||
724 | #endif | ||
725 | /* make sure cursor is on screen */ | ||
726 | while ( tc.dircursor > tree_max_on_screen ) | ||
727 | { | ||
728 | tc.dircursor--; | ||
729 | tc.dirstart++; | ||
730 | } | ||
731 | |||
732 | restore = true; | 626 | restore = true; |
733 | break; | 627 | break; |
734 | 628 | ||
@@ -741,8 +635,8 @@ static bool dirbrowse(void) | |||
741 | exit_func = true; | 635 | exit_func = true; |
742 | break; | 636 | break; |
743 | } | 637 | } |
744 | 638 | /* if we are in /, nothing to do */ | |
745 | if (!tc.dirlevel) | 639 | if (tc.dirlevel == 0) |
746 | break; | 640 | break; |
747 | 641 | ||
748 | if (id3db) | 642 | if (id3db) |
@@ -783,169 +677,6 @@ static bool dirbrowse(void) | |||
783 | break; | 677 | break; |
784 | #endif | 678 | #endif |
785 | #endif | 679 | #endif |
786 | |||
787 | case TREE_PREV: | ||
788 | case TREE_PREV | BUTTON_REPEAT: | ||
789 | #ifdef TREE_RC_PREV | ||
790 | case TREE_RC_PREV: | ||
791 | case TREE_RC_PREV | BUTTON_REPEAT: | ||
792 | #endif | ||
793 | if (!tc.filesindir) | ||
794 | break; | ||
795 | |||
796 | /* start scrolling when at 1/3 of the screen */ | ||
797 | if (tc.dircursor >= | ||
798 | tree_max_on_screen - (2 * tree_max_on_screen) / 3 | ||
799 | || (tc.dirstart == 0 && tc.dircursor > 0)) { | ||
800 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, false); | ||
801 | tc.dircursor--; | ||
802 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, true); | ||
803 | } | ||
804 | else { | ||
805 | if (tc.dirstart || tc.firstpos) { | ||
806 | if (tc.dirstart) | ||
807 | tc.dirstart--; | ||
808 | else { | ||
809 | if (tc.firstpos > max_files/2) { | ||
810 | tc.firstpos -= max_files/2; | ||
811 | tc.dirstart += max_files/2; | ||
812 | tc.dirstart--; | ||
813 | } | ||
814 | else { | ||
815 | tc.dirstart = tc.firstpos - 1; | ||
816 | tc.firstpos = 0; | ||
817 | } | ||
818 | } | ||
819 | restore = true; | ||
820 | } | ||
821 | else { | ||
822 | if (button & BUTTON_REPEAT) | ||
823 | break; | ||
824 | if (numentries < tree_max_on_screen) { | ||
825 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, | ||
826 | false); | ||
827 | tc.dircursor = numentries - 1; | ||
828 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, | ||
829 | true); | ||
830 | } | ||
831 | else if (id3db && tc.dirfull) { | ||
832 | /* load last dir segment */ | ||
833 | /* use max_files/2 in case names are longer than | ||
834 | AVERAGE_FILE_LENGTH */ | ||
835 | tc.firstpos = tc.dirlength - max_files/2; | ||
836 | tc.dirstart = tc.firstpos; | ||
837 | tc.dircursor = tree_max_on_screen - 1; | ||
838 | numentries = showdir(); | ||
839 | update_all = true; | ||
840 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, | ||
841 | true); | ||
842 | } | ||
843 | else { | ||
844 | tc.dirstart = numentries - tree_max_on_screen; | ||
845 | tc.dircursor = tree_max_on_screen - 1; | ||
846 | restore = true; | ||
847 | } | ||
848 | } | ||
849 | } | ||
850 | need_update = true; | ||
851 | break; | ||
852 | |||
853 | case TREE_NEXT: | ||
854 | case TREE_NEXT | BUTTON_REPEAT: | ||
855 | #ifdef TREE_RC_NEXT | ||
856 | case TREE_RC_NEXT: | ||
857 | case TREE_RC_NEXT | BUTTON_REPEAT: | ||
858 | #endif | ||
859 | if (!tc.filesindir) | ||
860 | break; | ||
861 | |||
862 | if (tc.dircursor + tc.dirstart + 1 < numentries ) { | ||
863 | /* start scrolling when at 2/3 of the screen */ | ||
864 | if(tc.dircursor < (2 * tree_max_on_screen) / 3 || | ||
865 | numentries - tc.dirstart <= tree_max_on_screen) { | ||
866 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, false); | ||
867 | tc.dircursor++; | ||
868 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, true); | ||
869 | } | ||
870 | else { | ||
871 | tc.dirstart++; | ||
872 | restore = true; | ||
873 | } | ||
874 | } | ||
875 | else if (id3db && (tc.firstpos || tc.dirfull)) { | ||
876 | if (tc.dircursor + tc.dirstart + tc.firstpos + 1 >= tc.dirlength) { | ||
877 | /* wrap and load first dir segment */ | ||
878 | if (button & BUTTON_REPEAT) | ||
879 | break; | ||
880 | tc.firstpos = tc.dirstart = tc.dircursor = 0; | ||
881 | } | ||
882 | else { | ||
883 | /* load next dir segment */ | ||
884 | tc.firstpos += tc.dirstart; | ||
885 | tc.dirstart = 0; | ||
886 | } | ||
887 | restore = true; | ||
888 | } | ||
889 | else { | ||
890 | if (button & BUTTON_REPEAT) | ||
891 | break; | ||
892 | if(numentries < tree_max_on_screen) { | ||
893 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, false); | ||
894 | tc.dirstart = tc.dircursor = 0; | ||
895 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, true); | ||
896 | } | ||
897 | else { | ||
898 | tc.dirstart = tc.dircursor = 0; | ||
899 | numentries = showdir(); | ||
900 | update_all=true; | ||
901 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, true); | ||
902 | } | ||
903 | } | ||
904 | need_update = true; | ||
905 | break; | ||
906 | |||
907 | #ifdef TREE_PGUP | ||
908 | case TREE_PGUP: | ||
909 | case TREE_PGUP | BUTTON_REPEAT: | ||
910 | if (tc.dirstart) { | ||
911 | tc.dirstart -= tree_max_on_screen; | ||
912 | if ( tc.dirstart < 0 ) | ||
913 | tc.dirstart = 0; | ||
914 | } | ||
915 | else if (tc.firstpos) { | ||
916 | if (tc.firstpos > max_files/2) { | ||
917 | tc.firstpos -= max_files/2; | ||
918 | tc.dirstart += max_files/2; | ||
919 | tc.dirstart -= tree_max_on_screen; | ||
920 | } | ||
921 | else { | ||
922 | tc.dirstart = tc.firstpos - tree_max_on_screen; | ||
923 | tc.firstpos = 0; | ||
924 | } | ||
925 | } | ||
926 | else | ||
927 | tc.dircursor = 0; | ||
928 | restore = true; | ||
929 | break; | ||
930 | |||
931 | case TREE_PGDN: | ||
932 | case TREE_PGDN | BUTTON_REPEAT: | ||
933 | if ( tc.dirstart < numentries - tree_max_on_screen ) { | ||
934 | tc.dirstart += tree_max_on_screen; | ||
935 | if ( tc.dirstart > numentries - tree_max_on_screen ) | ||
936 | tc.dirstart = numentries - tree_max_on_screen; | ||
937 | } | ||
938 | else if (id3db && tc.dirfull) { | ||
939 | /* load next dir segment */ | ||
940 | tc.firstpos += tc.dirstart; | ||
941 | tc.dirstart = 0; | ||
942 | } | ||
943 | else | ||
944 | tc.dircursor = numentries - tc.dirstart - 1; | ||
945 | restore = true; | ||
946 | break; | ||
947 | #endif | ||
948 | |||
949 | case TREE_MENU: | 680 | case TREE_MENU: |
950 | #ifdef TREE_RC_MENU | 681 | #ifdef TREE_RC_MENU |
951 | case TREE_RC_MENU: | 682 | case TREE_RC_MENU: |
@@ -957,7 +688,9 @@ static bool dirbrowse(void) | |||
957 | /* don't enter menu from plugin browser */ | 688 | /* don't enter menu from plugin browser */ |
958 | if (*tc.dirfilter < NUM_FILTER_MODES) | 689 | if (*tc.dirfilter < NUM_FILTER_MODES) |
959 | { | 690 | { |
960 | lcd_stop_scroll(); | 691 | int i; |
692 | for(i = 0;i < NB_SCREENS;++i) | ||
693 | screens[i].stop_scroll(); | ||
961 | if (main_menu()) | 694 | if (main_menu()) |
962 | reload_dir = true; | 695 | reload_dir = true; |
963 | restore = true; | 696 | restore = true; |
@@ -1017,7 +750,7 @@ static bool dirbrowse(void) | |||
1017 | { | 750 | { |
1018 | if (quick_screen(curr_context, BUTTON_F3)) | 751 | if (quick_screen(curr_context, BUTTON_F3)) |
1019 | reload_dir = true; | 752 | reload_dir = true; |
1020 | tree_max_on_screen = recalc_screen_height(); | 753 | screen_access_update_nb_lines(); |
1021 | restore = true; | 754 | restore = true; |
1022 | } | 755 | } |
1023 | break; | 756 | break; |
@@ -1052,20 +785,19 @@ static bool dirbrowse(void) | |||
1052 | } | 785 | } |
1053 | else | 786 | else |
1054 | { | 787 | { |
1055 | attr = dircache[tc.dircursor+tc.dirstart].attr; | 788 | attr = dircache[tc.selected_item].attr; |
1056 | 789 | ||
1057 | if (currdir[1]) | 790 | if (currdir[1]) /* Not in / */ |
1058 | snprintf(buf, sizeof buf, "%s/%s", | 791 | snprintf(buf, sizeof buf, "%s/%s", |
1059 | currdir, | 792 | currdir, |
1060 | dircache[tc.dircursor+tc.dirstart].name); | 793 | dircache[tc.selected_item].name); |
1061 | else | 794 | else /* In / */ |
1062 | snprintf(buf, sizeof buf, "/%s", | 795 | snprintf(buf, sizeof buf, "/%s", |
1063 | dircache[tc.dircursor+tc.dirstart].name); | 796 | dircache[tc.selected_item].name); |
1064 | } | 797 | } |
1065 | |||
1066 | onplay_result = onplay(buf, attr, curr_context); | 798 | onplay_result = onplay(buf, attr, curr_context); |
1067 | } | 799 | } |
1068 | 800 | ||
1069 | switch (onplay_result) | 801 | switch (onplay_result) |
1070 | { | 802 | { |
1071 | case ONPLAY_OK: | 803 | case ONPLAY_OK: |
@@ -1099,22 +831,22 @@ static bool dirbrowse(void) | |||
1099 | } | 831 | } |
1100 | } | 832 | } |
1101 | else | 833 | else |
1102 | { | 834 | { |
1103 | DEBUGF("Playing file thumbnail: %s/%s%s\n", | 835 | DEBUGF("Playing file thumbnail: %s/%s%s\n", |
1104 | currdir, dircache[lasti].name, file_thumbnail_ext); | 836 | currdir, dircache[lasti].name, file_thumbnail_ext); |
1105 | /* no fallback necessary, we knew in advance | 837 | /* no fallback necessary, we knew in advance |
1106 | that the file exists */ | 838 | that the file exists */ |
1107 | ft_play_filename(currdir, dircache[lasti].name); | 839 | ft_play_filename(currdir, dircache[lasti].name); |
1108 | } | 840 | } |
1109 | thumbnail_time = -1; /* job done */ | 841 | thumbnail_time = -1; /* job done */ |
1110 | } | 842 | } |
1111 | status_draw(false); | 843 | gui_syncstatusbar_draw(&statusbars, false); |
1112 | break; | 844 | break; |
1113 | 845 | ||
1114 | #ifdef HAVE_HOTSWAP | 846 | #ifdef HAVE_HOTSWAP |
1115 | case SYS_FS_CHANGED: | 847 | case SYS_FS_CHANGED: |
1116 | if (!id3db) | 848 | if (!id3db) |
1117 | reload_dir = true; | 849 | reload_dir = true; |
1118 | /* The 'dir no longer valid' situation will be caught later | 850 | /* The 'dir no longer valid' situation will be caught later |
1119 | * by checking the showdir() result. */ | 851 | * by checking the showdir() result. */ |
1120 | break; | 852 | break; |
@@ -1139,18 +871,20 @@ static bool dirbrowse(void) | |||
1139 | lastbutton = button; | 871 | lastbutton = button; |
1140 | } | 872 | } |
1141 | 873 | ||
1142 | if (start_wps) | 874 | if (start_wps && audio_status() ) |
1143 | { | 875 | { |
1144 | lcd_stop_scroll(); | 876 | int i; |
877 | for(i = 0;i < NB_SCREENS;++i) | ||
878 | screens[i].stop_scroll(); | ||
1145 | if (wps_show() == SYS_USB_CONNECTED) | 879 | if (wps_show() == SYS_USB_CONNECTED) |
1146 | reload_dir = true; | 880 | reload_dir = true; |
1147 | #ifdef HAVE_HOTSWAP | 881 | #ifdef HAVE_HOTSWAP |
1148 | else | 882 | else |
1149 | if (!id3db) /* Try reload to catch 'no longer valid' case. */ | 883 | if (!id3db) /* Try reload to catch 'no longer valid' case. */ |
1150 | reload_dir = true; | 884 | reload_dir = true; |
1151 | #endif | 885 | #endif |
1152 | #ifdef HAVE_LCD_BITMAP | 886 | #ifdef HAVE_LCD_BITMAP |
1153 | tree_max_on_screen = recalc_screen_height(); | 887 | screen_access_update_nb_lines(); |
1154 | #endif | 888 | #endif |
1155 | id3db = check_changed_id3mode(id3db); | 889 | id3db = check_changed_id3mode(id3db); |
1156 | restore = true; | 890 | restore = true; |
@@ -1174,8 +908,9 @@ static bool dirbrowse(void) | |||
1174 | } | 908 | } |
1175 | if (! reload_dir ) | 909 | if (! reload_dir ) |
1176 | { | 910 | { |
1177 | tc.dircursor = 0; | 911 | gui_synclist_select_item(&tree_lists, 0); |
1178 | tc.dirstart = 0; | 912 | gui_synclist_draw(&tree_lists); |
913 | tc.selected_item = 0; | ||
1179 | lastdir[0] = 0; | 914 | lastdir[0] = 0; |
1180 | } | 915 | } |
1181 | 916 | ||
@@ -1190,132 +925,88 @@ static bool dirbrowse(void) | |||
1190 | 925 | ||
1191 | if (restore || reload_dir) { | 926 | if (restore || reload_dir) { |
1192 | /* restore display */ | 927 | /* restore display */ |
1193 | |||
1194 | #ifdef HAVE_LCD_BITMAP | 928 | #ifdef HAVE_LCD_BITMAP |
1195 | tree_max_on_screen = recalc_screen_height(); | 929 | screen_access_update_nb_lines(); |
1196 | #endif | 930 | #endif |
1197 | 931 | numentries = update_dir(); | |
1198 | /* We need to adjust if the number of lines on screen have | ||
1199 | changed because of a status bar change */ | ||
1200 | if(CURSOR_Y+LINE_Y+tc.dircursor>tree_max_on_screen) { | ||
1201 | tc.dirstart++; | ||
1202 | tc.dircursor--; | ||
1203 | } | ||
1204 | #ifdef HAVE_LCD_BITMAP | ||
1205 | /* the sub-screen might've ruined the margins */ | ||
1206 | lcd_setmargins(MARGIN_X,MARGIN_Y); /* leave room for cursor and | ||
1207 | icon */ | ||
1208 | lcd_setfont(FONT_UI); | ||
1209 | #endif | ||
1210 | numentries = showdir(); | ||
1211 | if (currdir[1] && (numentries < 0)) | 932 | if (currdir[1] && (numentries < 0)) |
1212 | { /* not in root and reload failed */ | 933 | { /* not in root and reload failed */ |
1213 | reload_root = true; /* try root */ | 934 | reload_root = true; /* try root */ |
1214 | reload_dir = false; | 935 | reload_dir = false; |
1215 | goto check_rescan; | 936 | goto check_rescan; |
1216 | } | 937 | } |
1217 | update_all = true; | ||
1218 | put_cursorxy(CURSOR_X, CURSOR_Y + tc.dircursor, true); | ||
1219 | |||
1220 | need_update = true; | 938 | need_update = true; |
1221 | reload_dir = false; | 939 | reload_dir = false; |
1222 | } | 940 | } |
941 | if(need_update) { | ||
942 | tc.selected_item = gui_synclist_get_selected_item_position(&tree_lists); | ||
943 | need_update=false; | ||
944 | if ( numentries > 0 ) { | ||
945 | /* Voice the file if changed */ | ||
946 | if(lasti != tc.selected_item || restore) { | ||
947 | lasti = tc.selected_item; | ||
948 | thumbnail_time = -1; /* Cancel whatever we were | ||
949 | about to say */ | ||
950 | |||
951 | /* Directory? */ | ||
952 | if (dircache[tc.selected_item].attr & ATTR_DIRECTORY) | ||
953 | { | ||
954 | /* play directory thumbnail */ | ||
955 | switch (global_settings.talk_dir) { | ||
956 | case 1: /* dirs as numbers */ | ||
957 | talk_id(VOICE_DIR, false); | ||
958 | talk_number(tc.selected_item+1, true); | ||
959 | break; | ||
1223 | 960 | ||
1224 | if ( (numentries > 0) && need_update) { | 961 | case 2: /* dirs spelled */ |
1225 | i = tc.dirstart+tc.dircursor; | 962 | talk_spell(dircache[tc.selected_item].name, |
1226 | 963 | false); | |
1227 | /* if MP3 filter is on, cut off the extension */ | 964 | break; |
1228 | if(lasti!=i || restore) { | ||
1229 | char* name; | ||
1230 | int attr = 0; | ||
1231 | |||
1232 | if (id3db) | ||
1233 | name = ((char**)tc.dircache)[lasti * tc.dentry_size]; | ||
1234 | else { | ||
1235 | struct entry* dc = tc.dircache; | ||
1236 | struct entry* e = &dc[lasti]; | ||
1237 | name = e->name; | ||
1238 | attr = e->attr; | ||
1239 | } | ||
1240 | |||
1241 | lcd_stop_scroll(); | ||
1242 | |||
1243 | /* So if lastdircursor and dircursor differ, and then full | ||
1244 | screen was not refreshed, restore the previous line */ | ||
1245 | if ((lastdircursor != tc.dircursor) && !update_all ) { | ||
1246 | showfileline(lastdircursor, name, attr, false); /* no scroll */ | ||
1247 | } | ||
1248 | lasti=i; | ||
1249 | lastdircursor=tc.dircursor; | ||
1250 | thumbnail_time = -1; /* cancel whatever we were about to say */ | ||
1251 | |||
1252 | if (id3db) | ||
1253 | name = ((char**)tc.dircache)[lasti * tc.dentry_size]; | ||
1254 | else { | ||
1255 | struct entry* dc = tc.dircache; | ||
1256 | struct entry* e = &dc[lasti]; | ||
1257 | name = e->name; | ||
1258 | attr = e->attr; | ||
1259 | } | ||
1260 | showfileline(tc.dircursor, name, attr, true); /* scroll please */ | ||
1261 | need_update = true; | ||
1262 | |||
1263 | if (dircache[i].attr & ATTR_DIRECTORY) /* directory? */ | ||
1264 | { | ||
1265 | /* play directory thumbnail */ | ||
1266 | switch (global_settings.talk_dir) { | ||
1267 | case 1: /* dirs as numbers */ | ||
1268 | talk_id(VOICE_DIR, false); | ||
1269 | talk_number(i+1, true); | ||
1270 | break; | ||
1271 | |||
1272 | case 2: /* dirs spelled */ | ||
1273 | talk_spell(dircache[i].name, false); | ||
1274 | break; | ||
1275 | 965 | ||
1276 | case 3: /* thumbnail clip */ | 966 | case 3: /* thumbnail clip */ |
1277 | /* "schedule" a thumbnail, to have a little dalay */ | 967 | /* "schedule" a thumbnail, to have a little |
1278 | thumbnail_time = current_tick + HOVER_DELAY; | 968 | delay */ |
1279 | break; | 969 | thumbnail_time = current_tick + HOVER_DELAY; |
970 | break; | ||
1280 | 971 | ||
1281 | default: | 972 | default: |
1282 | break; | 973 | break; |
974 | } | ||
1283 | } | 975 | } |
1284 | } | 976 | else /* file */ |
1285 | else /* file */ | 977 | { |
1286 | { | 978 | switch (global_settings.talk_file) { |
1287 | switch (global_settings.talk_file) { | 979 | case 1: /* files as numbers */ |
1288 | case 1: /* files as numbers */ | 980 | ft_play_filenumber( |
1289 | ft_play_filenumber(i-tc.dirsindir+1, | 981 | tc.selected_item-tc.dirsindir+1, |
1290 | dircache[i].attr & TREE_ATTR_MASK); | 982 | dircache[tc.selected_item].attr & |
1291 | break; | 983 | TREE_ATTR_MASK); |
984 | break; | ||
1292 | 985 | ||
1293 | case 2: /* files spelled */ | 986 | case 2: /* files spelled */ |
1294 | talk_spell(dircache[i].name, false); | 987 | talk_spell(dircache[tc.selected_item].name, |
1295 | break; | 988 | false); |
989 | break; | ||
1296 | 990 | ||
1297 | case 3: /* thumbnail clip */ | 991 | case 3: /* thumbnail clip */ |
1298 | /* "schedule" a thumbnail, to have a little delay */ | 992 | /* "schedule" a thumbnail, to have a little |
1299 | if (dircache[i].attr & TREE_ATTR_THUMBNAIL) | 993 | delay */ |
1300 | thumbnail_time = current_tick + HOVER_DELAY; | 994 | if (dircache[tc.selected_item].attr & |
1301 | else | 995 | TREE_ATTR_THUMBNAIL) |
1302 | /* spell the number as fallback */ | 996 | thumbnail_time = current_tick + HOVER_DELAY; |
1303 | talk_spell(dircache[i].name, false); | 997 | else |
1304 | break; | 998 | /* spell the number as fallback */ |
999 | talk_spell(dircache[tc.selected_item].name, | ||
1000 | false); | ||
1001 | break; | ||
1305 | 1002 | ||
1306 | default: | 1003 | default: |
1307 | break; | 1004 | break; |
1005 | } | ||
1308 | } | 1006 | } |
1309 | } | 1007 | } |
1310 | } | 1008 | } |
1311 | } | 1009 | } |
1312 | |||
1313 | if(need_update) { | ||
1314 | lcd_update(); | ||
1315 | |||
1316 | need_update = false; | ||
1317 | update_all = false; | ||
1318 | } | ||
1319 | } | 1010 | } |
1320 | 1011 | ||
1321 | return true; | 1012 | return true; |
@@ -1369,7 +1060,7 @@ static bool add_dir(char* dirname, int len, int fd) | |||
1369 | int x = strlen(entry->d_name); | 1060 | int x = strlen(entry->d_name); |
1370 | unsigned int i; | 1061 | unsigned int i; |
1371 | char *cp = strrchr(entry->d_name,'.'); | 1062 | char *cp = strrchr(entry->d_name,'.'); |
1372 | 1063 | ||
1373 | if (cp) { | 1064 | if (cp) { |
1374 | cp++; | 1065 | cp++; |
1375 | 1066 | ||
@@ -1379,6 +1070,7 @@ static bool add_dir(char* dirname, int len, int fd) | |||
1379 | if (!strcasecmp(cp, filetypes[i].extension)) | 1070 | if (!strcasecmp(cp, filetypes[i].extension)) |
1380 | { | 1071 | { |
1381 | char buf[8]; | 1072 | char buf[8]; |
1073 | int i; | ||
1382 | write(fd, dirname, strlen(dirname)); | 1074 | write(fd, dirname, strlen(dirname)); |
1383 | write(fd, "/", 1); | 1075 | write(fd, "/", 1); |
1384 | write(fd, entry->d_name, x); | 1076 | write(fd, entry->d_name, x); |
@@ -1387,8 +1079,11 @@ static bool add_dir(char* dirname, int len, int fd) | |||
1387 | plsize++; | 1079 | plsize++; |
1388 | snprintf(buf, sizeof buf, "%d", plsize); | 1080 | snprintf(buf, sizeof buf, "%d", plsize); |
1389 | #ifdef HAVE_LCD_BITMAP | 1081 | #ifdef HAVE_LCD_BITMAP |
1390 | lcd_puts(0,4,buf); | 1082 | for(i = 0;i < NB_SCREENS;++i) |
1391 | lcd_update(); | 1083 | { |
1084 | screens[i].puts(0,4,buf); | ||
1085 | screens[i].update(); | ||
1086 | } | ||
1392 | #else | 1087 | #else |
1393 | x = 10; | 1088 | x = 10; |
1394 | if (plsize > 999) | 1089 | if (plsize > 999) |
@@ -1401,7 +1096,8 @@ static bool add_dir(char* dirname, int len, int fd) | |||
1401 | x=9; | 1096 | x=9; |
1402 | } | 1097 | } |
1403 | } | 1098 | } |
1404 | lcd_puts(x,0,buf); | 1099 | for(i = 0;i < NB_SCREENS;++i) |
1100 | screens[i].puts(x,0,buf); | ||
1405 | #endif | 1101 | #endif |
1406 | break; | 1102 | break; |
1407 | } | 1103 | } |
@@ -1418,16 +1114,20 @@ static bool add_dir(char* dirname, int len, int fd) | |||
1418 | bool create_playlist(void) | 1114 | bool create_playlist(void) |
1419 | { | 1115 | { |
1420 | int fd; | 1116 | int fd; |
1117 | int i; | ||
1421 | char filename[MAX_PATH]; | 1118 | char filename[MAX_PATH]; |
1422 | 1119 | ||
1423 | snprintf(filename, sizeof filename, "%s.m3u", | 1120 | snprintf(filename, sizeof filename, "%s.m3u", |
1424 | tc.currdir[1] ? tc.currdir : "/root"); | 1121 | tc.currdir[1] ? tc.currdir : "/root"); |
1425 | 1122 | for(i = 0;i < NB_SCREENS;++i) | |
1426 | lcd_clear_display(); | 1123 | { |
1427 | lcd_puts(0,0,str(LANG_CREATING)); | 1124 | screens[i].clear_display(); |
1428 | lcd_puts_scroll(0,1,filename); | 1125 | screens[i].puts(0,0,str(LANG_CREATING)); |
1429 | lcd_update(); | 1126 | screens[i].puts_scroll(0,1,filename); |
1430 | 1127 | #if defined(HAVE_LCD_BITMAP) || defined(SIMULATOR) | |
1128 | screens[i].update(); | ||
1129 | #endif | ||
1130 | } | ||
1431 | fd = creat(filename,0); | 1131 | fd = creat(filename,0); |
1432 | if (fd < 0) | 1132 | if (fd < 0) |
1433 | return false; | 1133 | return false; |
@@ -1435,7 +1135,7 @@ bool create_playlist(void) | |||
1435 | #ifdef HAVE_ADJUSTABLE_CPU_FREQ | 1135 | #ifdef HAVE_ADJUSTABLE_CPU_FREQ |
1436 | cpu_boost(true); | 1136 | cpu_boost(true); |
1437 | #endif | 1137 | #endif |
1438 | 1138 | ||
1439 | snprintf(filename, sizeof(filename), "%s", | 1139 | snprintf(filename, sizeof(filename), "%s", |
1440 | tc.currdir[1] ? tc.currdir : "/"); | 1140 | tc.currdir[1] ? tc.currdir : "/"); |
1441 | plsize = 0; | 1141 | plsize = 0; |
@@ -1445,7 +1145,7 @@ bool create_playlist(void) | |||
1445 | #ifdef HAVE_ADJUSTABLE_CPU_FREQ | 1145 | #ifdef HAVE_ADJUSTABLE_CPU_FREQ |
1446 | cpu_boost(false); | 1146 | cpu_boost(false); |
1447 | #endif | 1147 | #endif |
1448 | 1148 | ||
1449 | sleep(HZ); | 1149 | sleep(HZ); |
1450 | 1150 | ||
1451 | return true; | 1151 | return true; |
@@ -1460,12 +1160,10 @@ bool rockbox_browse(const char *root, int dirfilter) | |||
1460 | memcpy(tc.currdir, root, sizeof(tc.currdir)); | 1160 | memcpy(tc.currdir, root, sizeof(tc.currdir)); |
1461 | start_wps = false; | 1161 | start_wps = false; |
1462 | tc.dirfilter = &dirfilter; | 1162 | tc.dirfilter = &dirfilter; |
1463 | 1163 | ||
1464 | dirbrowse(); | 1164 | dirbrowse(); |
1465 | 1165 | ||
1466 | tc = backup; | 1166 | tc = backup; |
1467 | reload_dir = true; | ||
1468 | |||
1469 | return false; | 1167 | return false; |
1470 | } | 1168 | } |
1471 | 1169 | ||
@@ -1474,7 +1172,7 @@ void tree_init(void) | |||
1474 | /* We copy the settings value in case it is changed by the user. We can't | 1172 | /* We copy the settings value in case it is changed by the user. We can't |
1475 | use it until the next reboot. */ | 1173 | use it until the next reboot. */ |
1476 | max_files = global_settings.max_files_in_dir; | 1174 | max_files = global_settings.max_files_in_dir; |
1477 | 1175 | ||
1478 | /* initialize tree context struct */ | 1176 | /* initialize tree context struct */ |
1479 | memset(&tc, 0, sizeof(tc)); | 1177 | memset(&tc, 0, sizeof(tc)); |
1480 | tc.dirfilter = &global_settings.dirfilter; | 1178 | tc.dirfilter = &global_settings.dirfilter; |
@@ -1498,7 +1196,7 @@ void bookmark_play(char *resume_file, int index, int offset, int seed, | |||
1498 | { | 1196 | { |
1499 | /* Playlist playback */ | 1197 | /* Playlist playback */ |
1500 | char* slash; | 1198 | char* slash; |
1501 | // check that the file exists | 1199 | /* check that the file exists */ |
1502 | int fd = open(resume_file, O_RDONLY); | 1200 | int fd = open(resume_file, O_RDONLY); |
1503 | if(fd<0) | 1201 | if(fd<0) |
1504 | return; | 1202 | return; |
@@ -1538,7 +1236,7 @@ void bookmark_play(char *resume_file, int index, int offset, int seed, | |||
1538 | if ((strcmp(strrchr(playlist_peek(index) + 1,'/') + 1, | 1236 | if ((strcmp(strrchr(playlist_peek(index) + 1,'/') + 1, |
1539 | filename))) | 1237 | filename))) |
1540 | { | 1238 | { |
1541 | for ( i=0; i < playlist_amount(); i++ ) | 1239 | for ( i=0; i < playlist_amount(); i++ ) |
1542 | { | 1240 | { |
1543 | if ((strcmp(strrchr(playlist_peek(i) + 1,'/') + 1, | 1241 | if ((strcmp(strrchr(playlist_peek(i) + 1,'/') + 1, |
1544 | filename)) == 0) | 1242 | filename)) == 0) |
@@ -1599,7 +1297,7 @@ int ft_play_dirname(int start_index) | |||
1599 | } | 1297 | } |
1600 | 1298 | ||
1601 | close(fd); | 1299 | close(fd); |
1602 | 1300 | ||
1603 | DEBUGF("Found: %s\n", dirname_mp3_filename); | 1301 | DEBUGF("Found: %s\n", dirname_mp3_filename); |
1604 | 1302 | ||
1605 | talk_file(dirname_mp3_filename, false); | 1303 | talk_file(dirname_mp3_filename, false); |
@@ -1639,9 +1337,7 @@ void tree_flush(void) | |||
1639 | if (global_settings.dircache) | 1337 | if (global_settings.dircache) |
1640 | { | 1338 | { |
1641 | if (dircache_is_enabled()) | 1339 | if (dircache_is_enabled()) |
1642 | { | ||
1643 | global_settings.dircache_size = dircache_get_cache_size(); | 1340 | global_settings.dircache_size = dircache_get_cache_size(); |
1644 | } | ||
1645 | dircache_disable(); | 1341 | dircache_disable(); |
1646 | } | 1342 | } |
1647 | else | 1343 | else |
@@ -1659,21 +1355,27 @@ void tree_restore(void) | |||
1659 | #ifdef HAVE_DIRCACHE | 1355 | #ifdef HAVE_DIRCACHE |
1660 | if (global_settings.dircache) | 1356 | if (global_settings.dircache) |
1661 | { | 1357 | { |
1662 | int font_w, font_h; | ||
1663 | |||
1664 | /* Print "Scanning disk..." to the display. */ | 1358 | /* Print "Scanning disk..." to the display. */ |
1665 | lcd_getstringsize("A", &font_w, &font_h); | 1359 | int i; |
1666 | lcd_putsxy((LCD_WIDTH/2) - ((strlen(str(LANG_DIRCACHE_BUILDING))*font_w)/2), | 1360 | for(i = 0;i < NB_SCREENS;++i) |
1667 | LCD_HEIGHT-font_h*3, str(LANG_DIRCACHE_BUILDING)); | 1361 | { |
1668 | lcd_update(); | 1362 | screens[i].putsxy((LCD_WIDTH/2) - |
1669 | 1363 | ((strlen(str(LANG_DIRCACHE_BUILDING)) * | |
1364 | screens[i].char_width)/2), | ||
1365 | LCD_HEIGHT-screens[i].char_height*3, | ||
1366 | str(LANG_DIRCACHE_BUILDING)); | ||
1367 | screens[i].update(); | ||
1368 | } | ||
1670 | dircache_build(global_settings.dircache_size); | 1369 | dircache_build(global_settings.dircache_size); |
1671 | |||
1672 | /* Clean the text when we are done. */ | 1370 | /* Clean the text when we are done. */ |
1673 | lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); | 1371 | for(i=0;i<NB_SCREENS;++i) |
1674 | lcd_fillrect(0, LCD_HEIGHT-font_h*3, LCD_WIDTH, font_h); | 1372 | { |
1675 | lcd_set_drawmode(DRMODE_SOLID); | 1373 | screens[i].set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID); |
1676 | lcd_update(); | 1374 | screens[i].fillrect(0, LCD_HEIGHT-screens[i].char_height*3, |
1375 | LCD_WIDTH, screens[i].char_height); | ||
1376 | screens[i].set_drawmode(DRMODE_SOLID); | ||
1377 | screens[i].update(); | ||
1378 | } | ||
1677 | } | 1379 | } |
1678 | #endif | 1380 | #endif |
1679 | } | 1381 | } |
diff --git a/apps/tree.h b/apps/tree.h index a6c41f2af5..04532c887d 100644 --- a/apps/tree.h +++ b/apps/tree.h | |||
@@ -23,6 +23,8 @@ | |||
23 | #include <applimits.h> | 23 | #include <applimits.h> |
24 | #include <file.h> | 24 | #include <file.h> |
25 | 25 | ||
26 | /*FIXME: don't forget to remove PGUP, PGDOW, NEXT, PREV | ||
27 | * when everything will be working with gui_list */ | ||
26 | #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || \ | 28 | #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || \ |
27 | (CONFIG_KEYPAD == IRIVER_H300_PAD) | 29 | (CONFIG_KEYPAD == IRIVER_H300_PAD) |
28 | #define TREE_NEXT BUTTON_DOWN | 30 | #define TREE_NEXT BUTTON_DOWN |
@@ -43,8 +45,11 @@ | |||
43 | #define TREE_POWER_BTN BUTTON_ON | 45 | #define TREE_POWER_BTN BUTTON_ON |
44 | #define TREE_QUICK (BUTTON_MODE | BUTTON_REPEAT) | 46 | #define TREE_QUICK (BUTTON_MODE | BUTTON_REPEAT) |
45 | 47 | ||
48 | /* Remote keys */ | ||
46 | #define TREE_RC_NEXT BUTTON_RC_FF | 49 | #define TREE_RC_NEXT BUTTON_RC_FF |
47 | #define TREE_RC_PREV BUTTON_RC_REW | 50 | #define TREE_RC_PREV BUTTON_RC_REW |
51 | #define TREE_RC_PGUP BUTTON_RC_SOURCE | ||
52 | #define TREE_RC_PGDN BUTTON_RC_BITRATE | ||
48 | #define TREE_RC_EXIT BUTTON_RC_STOP | 53 | #define TREE_RC_EXIT BUTTON_RC_STOP |
49 | #define TREE_RC_RUN (BUTTON_RC_MENU | BUTTON_REL) | 54 | #define TREE_RC_RUN (BUTTON_RC_MENU | BUTTON_REL) |
50 | #define TREE_RC_RUN_PRE BUTTON_RC_MENU | 55 | #define TREE_RC_RUN_PRE BUTTON_RC_MENU |
@@ -137,27 +142,36 @@ struct filetype { | |||
137 | int icon; | 142 | int icon; |
138 | int voiceclip; | 143 | int voiceclip; |
139 | }; | 144 | }; |
140 | 145 | ||
141 | /* browser context for file or db */ | 146 | /* browser context for file or db */ |
142 | struct tree_context { | 147 | struct tree_context { |
148 | /* The directory we are browsing */ | ||
149 | char currdir[MAX_PATH]; | ||
150 | /* the number of directories we have crossed from / */ | ||
143 | int dirlevel; | 151 | int dirlevel; |
144 | int dircursor; | 152 | /* The currently selected file/id3dbitem index (old dircursor+dirfile) */ |
145 | int dirstart; | 153 | int selected_item; |
154 | /* The selected item in each directory crossed | ||
155 | * (used when we want to return back to a previouws directory)*/ | ||
156 | int selected_item_history[MAX_DIR_LEVELS]; | ||
157 | |||
146 | int firstpos; /* which dir entry is on first | 158 | int firstpos; /* which dir entry is on first |
147 | position in dir buffer */ | 159 | position in dir buffer */ |
148 | int pos_history[MAX_DIR_LEVELS]; | 160 | int pos_history[MAX_DIR_LEVELS]; |
149 | int dirpos[MAX_DIR_LEVELS]; | 161 | int dirpos[MAX_DIR_LEVELS]; /* the dirstart history */ |
150 | int cursorpos[MAX_DIR_LEVELS]; | 162 | int cursorpos[MAX_DIR_LEVELS]; /* the dircursor history */ |
151 | char currdir[MAX_PATH]; /* file use */ | 163 | |
152 | int *dirfilter; /* file use */ | 164 | int *dirfilter; /* file use */ |
153 | int filesindir; | 165 | int filesindir; /* The number of files in the dircache */ |
154 | int dirsindir; /* file use */ | 166 | int dirsindir; /* file use */ |
155 | int dirlength; /* total number of entries in dir, incl. those not loaded */ | 167 | int dirlength; /* total number of entries in dir, incl. those not loaded */ |
156 | int table_history[MAX_DIR_LEVELS]; /* db use */ | 168 | int table_history[MAX_DIR_LEVELS]; /* db use */ |
157 | int extra_history[MAX_DIR_LEVELS]; /* db use */ | 169 | int extra_history[MAX_DIR_LEVELS]; /* db use */ |
158 | int currtable; /* db use */ | 170 | int currtable; /* db use */ |
159 | int currextra; /* db use */ | 171 | int currextra; /* db use */ |
160 | 172 | /* A big buffer with plenty of entry structs, | |
173 | * contains all files and dirs in the current | ||
174 | * dir (with filters applied) */ | ||
161 | void* dircache; | 175 | void* dircache; |
162 | int dircache_size; | 176 | int dircache_size; |
163 | char* name_buffer; | 177 | char* name_buffer; |
@@ -196,4 +210,7 @@ struct tree_context* tree_get_context(void); | |||
196 | void tree_flush(void); | 210 | void tree_flush(void); |
197 | void tree_restore(void); | 211 | void tree_restore(void); |
198 | 212 | ||
213 | |||
214 | extern struct gui_synclist tree_lists; | ||
215 | extern struct gui_syncstatusbar statusbars; | ||
199 | #endif | 216 | #endif |
diff --git a/apps/wps.h b/apps/wps.h index 6f0d601876..e32bd3c815 100644 --- a/apps/wps.h +++ b/apps/wps.h | |||
@@ -19,7 +19,7 @@ | |||
19 | #ifndef _WPS_H | 19 | #ifndef _WPS_H |
20 | #define _WPS_H | 20 | #define _WPS_H |
21 | #include "id3.h" | 21 | #include "id3.h" |
22 | #include "playlist.h" | 22 | #include "playlist.h" |
23 | 23 | ||
24 | /* button definitions */ | 24 | /* button definitions */ |
25 | #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || \ | 25 | #if (CONFIG_KEYPAD == IRIVER_H100_PAD) || \ |
@@ -33,7 +33,7 @@ | |||
33 | #define WPS_INCVOL BUTTON_UP | 33 | #define WPS_INCVOL BUTTON_UP |
34 | #define WPS_DECVOL BUTTON_DOWN | 34 | #define WPS_DECVOL BUTTON_DOWN |
35 | #define WPS_PAUSE (BUTTON_ON | BUTTON_REL) | 35 | #define WPS_PAUSE (BUTTON_ON | BUTTON_REL) |
36 | #define WPS_PAUSE_PRE BUTTON_ON | 36 | #define WPS_PAUSE_PRE BUTTON_ON |
37 | #define WPS_MENU (BUTTON_MODE | BUTTON_REL) | 37 | #define WPS_MENU (BUTTON_MODE | BUTTON_REL) |
38 | #define WPS_MENU_PRE BUTTON_MODE | 38 | #define WPS_MENU_PRE BUTTON_MODE |
39 | #define WPS_BROWSE (BUTTON_SELECT | BUTTON_REL) | 39 | #define WPS_BROWSE (BUTTON_SELECT | BUTTON_REL) |
@@ -53,10 +53,10 @@ | |||
53 | #define WPS_RC_INCVOL BUTTON_RC_VOL_UP | 53 | #define WPS_RC_INCVOL BUTTON_RC_VOL_UP |
54 | #define WPS_RC_DECVOL BUTTON_RC_VOL_DOWN | 54 | #define WPS_RC_DECVOL BUTTON_RC_VOL_DOWN |
55 | #define WPS_RC_EXIT BUTTON_RC_STOP | 55 | #define WPS_RC_EXIT BUTTON_RC_STOP |
56 | #define WPS_RC_MENU (BUTTON_RC_MENU | BUTTON_REL) | 56 | #define WPS_RC_MENU (BUTTON_RC_MODE | BUTTON_REL) |
57 | #define WPS_RC_MENU_PRE BUTTON_RC_MENU | 57 | #define WPS_RC_MENU_PRE BUTTON_RC_MODE |
58 | #define WPS_RC_BROWSE (BUTTON_RC_MODE | BUTTON_REL) | 58 | #define WPS_RC_BROWSE (BUTTON_RC_MENU | BUTTON_REL) |
59 | #define WPS_RC_BROWSE_PRE BUTTON_RC_MODE | 59 | #define WPS_RC_BROWSE_PRE BUTTON_RC_MENU |
60 | 60 | ||
61 | #elif CONFIG_KEYPAD == RECORDER_PAD | 61 | #elif CONFIG_KEYPAD == RECORDER_PAD |
62 | #define WPS_NEXT (BUTTON_RIGHT | BUTTON_REL) | 62 | #define WPS_NEXT (BUTTON_RIGHT | BUTTON_REL) |