Rockbox open source high quality audio player as a Music Player Daemon
mpris
rockbox
mpd
libadwaita
audio
rust
zig
deno
[4/4] Remove HAVE_LCD_BITMAP, as it's now the only choice.
Note: I left behind lcd_bitmap in features.txt, because removing it
would require considerable work in the manual and the translations.
Change-Id: Ia8ca7761f610d9332a0d22a7d189775fb15ec88a
+288
-1759
+1
-8
apps/SOURCES
+1
-8
apps/SOURCES
···
71
71
#endif
72
72
#endif
73
73
screen_access.c
74
-
#ifdef HAVE_LCD_BITMAP
75
74
gui/icon.c
76
-
#endif
77
75
gui/list.c
78
76
gui/line.c
79
-
#ifdef HAVE_LCD_BITMAP
80
77
gui/bitmap/list.c
81
78
gui/bitmap/list-skinned.c
82
-
#endif
83
79
gui/option_select.c
84
80
#ifdef HAVE_PITCHCONTROL
85
81
gui/pitchscreen.c
···
96
92
gui/scrollbar.c
97
93
gui/splash.c
98
94
gui/statusbar.c
99
-
#ifdef HAVE_LCD_BITMAP
100
95
gui/statusbar-skinned.c
101
-
#endif
102
96
#if (CONFIG_PLATFORM&PLATFORM_ANDROID)
103
97
hosted/android/yesno.c
104
98
hosted/android/notification.c
···
121
115
gui/backdrop.c
122
116
#endif
123
117
124
-
#ifdef HAVE_LCD_BITMAP
125
118
recorder/bmp.c
126
119
recorder/icons.c
127
120
#if (CONFIG_PLATFORM&PLATFORM_ANDROID)
···
145
138
#ifdef HAVE_LCD_COLOR
146
139
gui/color_picker.c
147
140
#endif
148
-
#endif
141
+
149
142
#ifdef HAVE_RECORDING
150
143
recorder/recording.c
151
144
#endif
+3
-3
apps/action.c
+3
-3
apps/action.c
···
26
26
#include "config.h"
27
27
#include "lang.h"
28
28
29
-
#if defined(HAVE_LCD_BITMAP) && !defined(BOOTLOADER)
29
+
#if !defined(BOOTLOADER)
30
30
#include "language.h"
31
31
#endif
32
32
···
421
421
static inline void button_flip_horizontally(int context, int *button)
422
422
{
423
423
424
-
#if !defined(HAVE_LCD_BITMAP) || defined(BOOTLOADER)
424
+
#if defined(BOOTLOADER)
425
425
(void) context;
426
426
(void) *button;
427
427
return;
···
473
473
#endif /* !SIMULATOR */
474
474
475
475
*button = newbutton;
476
-
#endif /* !HAVE_LCD_BITMAP | BOOTLOADER */
476
+
#endif /* !BOOTLOADER */
477
477
} /* button_flip_horizontally */
478
478
479
479
/**********************************************************************
-2
apps/bitmaps/mono/SOURCES
-2
apps/bitmaps/mono/SOURCES
-4
apps/bitmaps/native/SOURCES
-4
apps/bitmaps/native/SOURCES
-2
apps/bitmaps/remote_mono/SOURCES
-2
apps/bitmaps/remote_mono/SOURCES
-6
apps/bookmark.c
-6
apps/bookmark.c
···
198
198
case BOOKMARK_RECENT_ONLY_YES:
199
199
return write_bookmark(false, bookmark);
200
200
}
201
-
#ifdef HAVE_LCD_BITMAP
202
201
const char *lines[]={ID2P(LANG_AUTO_BOOKMARK_QUERY)};
203
202
const struct text_message message={lines, 1};
204
-
#else
205
-
const char *lines[]={ID2P(LANG_AUTO_BOOKMARK_QUERY),
206
-
str(LANG_CONFIRM_WITH_BUTTON)};
207
-
const struct text_message message={lines, 2};
208
-
#endif
209
203
210
204
if(prompt_ok && gui_syncyesno_run(&message, NULL, NULL)==YESNO_YES)
211
205
{
+1
-3
apps/cuesheet.c
+1
-3
apps/cuesheet.c
···
482
482
483
483
}
484
484
485
-
#ifdef HAVE_LCD_BITMAP
486
485
static inline void draw_veritcal_line_mark(struct screen * screen,
487
486
int x, int y, int h)
488
487
{
···
498
497
{
499
498
int i,xi;
500
499
unsigned long tracklen_seconds = tracklen/1000; /* duration in seconds */
501
-
500
+
502
501
for (i=1; i < cue->track_count; i++)
503
502
{
504
503
/* Convert seconds prior to multiplication to avoid overflow. */
···
506
505
draw_veritcal_line_mark(screen, xi, y, h);
507
506
}
508
507
}
509
-
#endif
510
508
511
509
bool cuesheet_subtrack_changed(struct mp3entry *id3)
512
510
{
-2
apps/cuesheet.h
-2
apps/cuesheet.h
···
79
79
/* skip to next track in the cuesheet towards "direction" (which is 1 or -1) */
80
80
bool curr_cuesheet_skip(struct cuesheet *cue, int direction, unsigned long curr_pos);
81
81
82
-
#ifdef HAVE_LCD_BITMAP
83
82
/* draw track markers on the progressbar */
84
83
void cue_draw_markers(struct screen *screen, struct cuesheet *cue,
85
84
unsigned long tracklen,
86
85
int x, int y, int w, int h);
87
-
#endif
88
86
89
87
/* check if the subtrack has changed */
90
88
bool cuesheet_subtrack_changed(struct mp3entry *id3);
-2
apps/features.txt
-2
apps/features.txt
+1
-11
apps/filetree.c
+1
-11
apps/filetree.c
···
44
44
#include "filetree.h"
45
45
#include "misc.h"
46
46
#include "strnatcmp.h"
47
-
#ifdef HAVE_LCD_BITMAP
48
47
#include "keyboard.h"
49
-
#endif
50
48
51
49
#if CONFIG_TUNER
52
50
#include "radio.h"
···
339
337
(dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_M3U) ||
340
338
(*c->dirfilter == SHOW_SUPPORTED && !filetype_supported(dptr->attr)))) ||
341
339
(*c->dirfilter == SHOW_WPS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_WPS) ||
342
-
#ifdef HAVE_LCD_BITMAP
343
340
(*c->dirfilter == SHOW_FONT && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_FONT) ||
344
341
(*c->dirfilter == SHOW_SBS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_SBS) ||
345
342
#if CONFIG_TUNER
346
343
(*c->dirfilter == SHOW_FMS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_FMS) ||
347
-
#endif
348
344
#endif
349
345
#ifdef HAVE_REMOTE_LCD
350
346
(*c->dirfilter == SHOW_RWPS && (dptr->attr & FILE_ATTR_MASK) != FILE_ATTR_RWPS) ||
···
399
395
tree_unlock_cache(c);
400
396
return 0;
401
397
}
402
-
#ifdef HAVE_LCD_BITMAP
403
398
static void ft_load_font(char *file)
404
399
{
405
400
int current_font_id;
···
428
423
screens[screen].setuifont(
429
424
font_load_ex(file,0,global_settings.glyphs_to_cache));
430
425
viewportmanager_theme_changed(THEME_UI_VIEWPORT);
431
-
}
432
-
#endif
426
+
}
433
427
434
428
int ft_enter(struct tree_context* c)
435
429
{
···
550
544
#endif
551
545
#endif
552
546
553
-
#ifdef HAVE_LCD_BITMAP
554
547
case FILE_ATTR_SBS:
555
548
splash(0, ID2P(LANG_WAIT));
556
549
set_file(buf, (char *)global_settings.sbs_file, MAX_FILENAME);
557
550
settings_apply_skins();
558
551
break;
559
-
#endif
560
552
#ifdef HAVE_REMOTE_LCD
561
553
case FILE_ATTR_RSBS:
562
554
splash(0, ID2P(LANG_WAIT));
···
610
602
splash(HZ, ID2P(LANG_LANGUAGE_LOADED));
611
603
break;
612
604
613
-
#ifdef HAVE_LCD_BITMAP
614
605
case FILE_ATTR_FONT:
615
606
ft_load_font(buf);
616
607
break;
···
621
612
splash(HZ, ID2P(LANG_KEYBOARD_LOADED));
622
613
set_file(buf, (char *)global_settings.kbd_file, MAX_FILENAME);
623
614
break;
624
-
#endif
625
615
626
616
#if (CONFIG_PLATFORM & PLATFORM_NATIVE)
627
617
/* firmware file */
-12
apps/filetypes.c
-12
apps/filetypes.c
···
43
43
/* max filetypes (plugins & icons stored here) */
44
44
#define MAX_FILETYPES 192
45
45
/* max viewer plugins */
46
-
#ifdef HAVE_LCD_BITMAP
47
46
#define MAX_VIEWERS 56
48
-
#else
49
-
#define MAX_VIEWERS 24
50
-
#endif
51
47
52
48
/* a table for the known file types */
53
49
static const struct filetype inbuilt_filetypes[] = {
···
129
125
{ "lng", FILE_ATTR_LNG, Icon_Language, LANG_LANGUAGE },
130
126
{ "rock",FILE_ATTR_ROCK,Icon_Plugin, VOICE_EXT_ROCK },
131
127
{ "lua", FILE_ATTR_LUA, Icon_Plugin, VOICE_EXT_ROCK },
132
-
#ifdef HAVE_LCD_BITMAP
133
128
{ "fnt", FILE_ATTR_FONT,Icon_Font, VOICE_EXT_FONT },
134
129
{ "kbd", FILE_ATTR_KBD, Icon_Keyboard, VOICE_EXT_KBD },
135
-
#endif
136
130
{ "bmark",FILE_ATTR_BMARK, Icon_Bookmark, VOICE_EXT_BMARK },
137
131
{ "cue", FILE_ATTR_CUE, Icon_Bookmark, VOICE_EXT_CUESHEET },
138
-
#ifdef HAVE_LCD_BITMAP
139
132
{ "sbs", FILE_ATTR_SBS, Icon_Wps, VOICE_EXT_SBS },
140
-
#endif
141
133
#ifdef HAVE_REMOTE_LCD
142
134
{ "rsbs", FILE_ATTR_RSBS, Icon_Wps, VOICE_EXT_RSBS },
143
135
#if CONFIG_TUNER
···
289
281
close(fd);
290
282
}
291
283
#endif
292
-
#ifdef HAVE_LCD_BITMAP
293
284
void read_viewer_theme_file(void)
294
285
{
295
286
char buffer[MAX_PATH];
···
340
331
close(fd);
341
332
custom_icons_loaded = true;
342
333
}
343
-
#endif
344
334
345
335
void filetype_init(void)
346
336
{
···
368
358
read_builtin_types();
369
359
read_config(fd);
370
360
close(fd);
371
-
#ifdef HAVE_LCD_BITMAP
372
361
read_viewer_theme_file();
373
-
#endif
374
362
#ifdef HAVE_LCD_COLOR
375
363
read_color_theme_file();
376
364
#endif
+1
-5
apps/gui/bitmap/list-skinned.c
+1
-5
apps/gui/bitmap/list-skinned.c
···
236
236
int cols = (parent->width / listcfg[screen]->width);
237
237
current_column = (cur_line)%cols;
238
238
current_row = (cur_line)/cols;
239
-
239
+
240
240
skin_viewport->vp.x = parent->x + listcfg[screen]->width*current_column + original_x;
241
241
skin_viewport->vp.y = parent->y + listcfg[screen]->height*current_row + original_y;
242
242
}
···
249
249
(listcfg[screen]->height*cur_line);
250
250
}
251
251
display->set_viewport(&skin_viewport->vp);
252
-
#ifdef HAVE_LCD_BITMAP
253
252
/* Set images to not to be displayed */
254
253
struct skin_token_list *imglist = SKINOFFSETTOPTR(get_skin_buffer(wps.data), wps.data->images);
255
254
while (imglist)
···
259
258
img->display = -1;
260
259
imglist = SKINOFFSETTOPTR(get_skin_buffer(wps.data), imglist->next);
261
260
}
262
-
#endif
263
261
struct skin_element** children = SKINOFFSETTOPTR(get_skin_buffer(wps.data), viewport->children);
264
262
skin_render_viewport(SKINOFFSETTOPTR(get_skin_buffer(wps.data), (intptr_t)children[0]),
265
263
&wps, skin_viewport, SKIN_REFRESH_ALL);
266
-
#ifdef HAVE_LCD_BITMAP
267
264
wps_display_images(&wps, &skin_viewport->vp);
268
-
#endif
269
265
/* force disableing scroll because it breaks later */
270
266
if (!is_selected)
271
267
{
-4
apps/gui/icon.c
-4
apps/gui/icon.c
···
144
144
145
145
void screen_put_cursorxy(struct screen * display, int x, int y, bool on)
146
146
{
147
-
#ifdef HAVE_LCD_BITMAP
148
147
screen_put_icon(display, x, y, on?Icon_Cursor:0);
149
-
#else
150
-
screen_put_icon(display, x, y, on?CURSOR_CHAR:-1);
151
-
#endif
152
148
}
153
149
154
150
static int buflib_move_callback(int handle, void* current, void* new)
-4
apps/gui/icon.h
-4
apps/gui/icon.h
···
24
24
#include "screen_access.h"
25
25
/* Defines a type for the icons since it's not the same thing on
26
26
* char-based displays and bitmap displays */
27
-
#ifdef HAVE_LCD_BITMAP
28
27
typedef const unsigned char * ICON;
29
-
#else
30
-
typedef long ICON;
31
-
#endif
32
28
33
29
/* Don't #ifdef icon values, or we wont be able to use the same
34
30
bmp for every target. */
-2
apps/gui/line.c
-2
apps/gui/line.c
···
294
294
}
295
295
}
296
296
297
-
#ifdef HAVE_LCD_BITMAP
298
297
static void style_line(struct screen *display,
299
298
int x, int y, struct line_desc *line)
300
299
{
···
380
379
}
381
380
#endif
382
381
}
383
-
#endif /* HAVE_LCD_BITMAP */
384
382
385
383
void vput_line(struct screen *display,
386
384
int x, int y, struct line_desc *line,
-44
apps/gui/list.c
-44
apps/gui/list.c
···
47
47
*/
48
48
#define FRAMEDROP_TRIGGER 6
49
49
50
-
#ifdef HAVE_LCD_BITMAP
51
50
static int offset_step = 16; /* pixels per screen scroll step */
52
51
/* should lines scroll out of the screen */
53
52
static bool offset_out_of_view = false;
54
-
#endif
55
53
56
54
static void gui_list_select_at_offset(struct gui_synclist * gui_list,
57
55
int offset);
58
56
void list_draw(struct screen *display, struct gui_synclist *list);
59
57
60
-
#ifdef HAVE_LCD_BITMAP
61
58
static long last_dirty_tick;
62
59
static struct viewport parent[NB_SCREENS];
63
60
···
92
89
}
93
90
list->dirty_tick = current_tick;
94
91
}
95
-
#else
96
-
static struct viewport parent[NB_SCREENS] =
97
-
{
98
-
[SCREEN_MAIN] =
99
-
{
100
-
.x = 0,
101
-
.y = 0,
102
-
.width = LCD_WIDTH,
103
-
.height = LCD_HEIGHT
104
-
},
105
-
};
106
92
107
-
#define list_init_viewports(a)
108
-
#define list_is_dirty(a) false
109
-
#endif
110
-
111
-
#ifdef HAVE_LCD_BITMAP
112
93
static int list_nb_lines(struct gui_synclist *list, enum screen_type screen)
113
94
{
114
95
struct viewport *vp = list->parent[screen];
···
148
129
#endif
149
130
}
150
131
151
-
#else
152
-
#define list_display_title(l, i) false
153
-
#define list_get_nb_lines(list, screen) \
154
-
viewport_get_nb_lines((list)->parent[(screen)]);
155
-
#define list_init_item_height(l, i)
156
-
#endif
157
-
158
132
/*
159
133
* Initializes a scrolling list
160
134
* - gui_list : the list structure to initialize
···
181
155
FOR_NB_SCREENS(i)
182
156
{
183
157
gui_list->start_item[i] = 0;
184
-
#ifdef HAVE_LCD_BITMAP
185
158
gui_list->offset_position[i] = 0;
186
-
#endif
187
159
if (list_parent)
188
160
gui_list->parent[i] = &list_parent[i];
189
161
else
···
216
188
}
217
189
218
190
219
-
#ifdef HAVE_LCD_BITMAP
220
191
int gui_list_get_item_offset(struct gui_synclist * gui_list,
221
192
int item_width,
222
193
int text_pos,
···
248
219
249
220
return item_offset;
250
221
}
251
-
#endif
252
222
253
223
/*
254
224
* Force a full screen update.
···
264
234
}
265
235
FOR_NB_SCREENS(i)
266
236
{
267
-
#ifdef HAVE_LCD_BITMAP
268
237
if (!skinlist_draw(&screens[i], gui_list))
269
-
#endif
270
238
list_draw(&screens[i], gui_list);
271
239
}
272
240
}
···
481
449
}
482
450
}
483
451
484
-
#ifdef HAVE_LCD_BITMAP
485
452
void gui_list_screen_scroll_step(int ofs)
486
453
{
487
454
offset_step = ofs;
···
491
458
{
492
459
offset_out_of_view = enable;
493
460
}
494
-
#endif /* HAVE_LCD_BITMAP */
495
461
496
462
/*
497
463
* Set the title and title icon of the list. Setting title to NULL disables
···
502
468
{
503
469
gui_list->title = title;
504
470
gui_list->title_icon = icon;
505
-
#ifdef HAVE_LCD_BITMAP
506
471
FOR_NB_SCREENS(i)
507
472
sb_set_title_text(title, icon, i);
508
-
#endif
509
473
send_event(GUI_EVENT_ACTIONUPDATE, (void*)1);
510
474
}
511
475
512
476
void gui_synclist_set_nb_items(struct gui_synclist * lists, int nb_items)
513
477
{
514
478
lists->nb_items = nb_items;
515
-
#ifdef HAVE_LCD_BITMAP
516
479
FOR_NB_SCREENS(i)
517
480
{
518
481
lists->offset_position[i] = 0;
519
482
}
520
-
#endif
521
483
}
522
484
int gui_synclist_get_nb_items(struct gui_synclist * lists)
523
485
{
···
576
538
lists->limit_scroll = scroll;
577
539
}
578
540
579
-
#ifdef HAVE_LCD_BITMAP
580
541
/*
581
542
* Makes all the item in the list scroll by one step to the right.
582
543
* Should stop increasing the value when reaching the widest item value
···
608
569
lists->offset_position[i] = 0;
609
570
}
610
571
}
611
-
#endif /* HAVE_LCD_BITMAP */
612
572
613
573
bool gui_synclist_keyclick_callback(int action, void* data)
614
574
{
···
652
612
int *actionptr, enum list_wrap wrap)
653
613
{
654
614
int action = *actionptr;
655
-
#ifdef HAVE_LCD_BITMAP
656
615
static bool pgleft_allow_cancel = false;
657
-
#endif
658
616
659
617
#ifdef HAVE_WHEEL_ACCELERATION
660
618
int next_item_modifier = button_apply_acceleration(get_action_data());
···
753
711
*actionptr = ACTION_STD_NEXT;
754
712
return true;
755
713
756
-
#ifdef HAVE_LCD_BITMAP
757
714
case ACTION_TREE_PGRIGHT:
758
715
gui_synclist_scroll_right(lists);
759
716
gui_synclist_draw(lists);
···
784
741
pgleft_allow_cancel = false; /* stop ACTION_TREE_PAGE_LEFT
785
742
skipping to root */
786
743
return true;
787
-
#endif
788
744
/* for pgup / pgdown, we are obliged to have a different behaviour depending
789
745
* on the screen for which the user pressed the key since for example, remote
790
746
* and main screen doesn't have the same number of lines */
+2
-6
apps/gui/list.h
+2
-6
apps/gui/list.h
···
102
102
int selected_size;
103
103
/* the number of pixels each line occupies (including optional padding on touchscreen */
104
104
int line_height[NB_SCREENS];
105
-
#ifdef HAVE_LCD_BITMAP
106
105
int offset_position[NB_SCREENS]; /* the list's screen scroll placement in pixels */
107
-
#endif
108
106
long scheduled_talk_tick, last_talked_tick, dirty_tick;
109
107
110
108
list_get_icon *callback_get_item_icon;
···
127
125
};
128
126
129
127
130
-
#ifdef HAVE_LCD_BITMAP
131
128
extern void list_init(void);
132
129
/* parse global setting to static int */
133
130
extern void gui_list_screen_scroll_step(int ofs);
134
131
135
132
/* parse global setting to static bool */
136
133
extern void gui_list_screen_scroll_out_of_view(bool enable);
137
-
#endif /* HAVE_LCD_BITMAP */
138
134
139
135
extern void gui_synclist_init(
140
136
struct gui_synclist * lists,
···
179
175
extern bool gui_synclist_do_button(struct gui_synclist * lists,
180
176
int *action,
181
177
enum list_wrap);
182
-
#if defined(HAVE_LCD_BITMAP) && !defined(PLUGIN)
178
+
#if !defined(PLUGIN)
183
179
struct listitem_viewport_cfg {
184
180
struct wps_data *data;
185
181
OFFSETTYPE(char *) label;
···
204
200
bool skinlist_needs_scrollbar(enum screen_type screen);
205
201
void skinlist_get_scrollbar(int* nb_item, int* first_shown, int* last_shown);
206
202
int skinlist_get_line_count(enum screen_type screen, struct gui_synclist *list);
207
-
#endif
203
+
#endif /* !PLUGIN) */
208
204
209
205
#if defined(HAVE_TOUCHSCREEN)
210
206
/* this needs to be fixed if we ever get more than 1 touchscreen on a target */
-3
apps/gui/scrollbar.c
-3
apps/gui/scrollbar.c
···
20
20
****************************************************************************/
21
21
22
22
#include "scrollbar.h"
23
-
#ifdef HAVE_LCD_BITMAP
24
23
#include "config.h"
25
24
#include "limits.h"
26
25
#include "bmp.h"
···
264
263
dir = 1;
265
264
}
266
265
}
267
-
268
-
#endif /* HAVE_LCD_BITMAP */
-3
apps/gui/scrollbar.h
-3
apps/gui/scrollbar.h
···
23
23
#define _GUI_SCROLLBAR_H_
24
24
#include "screen_access.h"
25
25
26
-
#ifdef HAVE_LCD_BITMAP
27
-
28
26
enum orientation {
29
27
VERTICAL = 0x0000, /* Vertical orientation */
30
28
HORIZONTAL = 0x0001, /* Horizontal orientation */
···
64
62
unsigned flags);
65
63
extern void show_busy_slider(struct screen *s, int x, int y,
66
64
int width, int height);
67
-
#endif /* HAVE_LCD_BITMAP */
68
65
#endif /* _GUI_SCROLLBAR_H_ */
+1
-18
apps/gui/skin_engine/skin_display.c
+1
-18
apps/gui/skin_engine/skin_display.c
···
47
47
#include "list.h"
48
48
#include "option_select.h"
49
49
50
-
#ifdef HAVE_LCD_BITMAP
51
50
#include "peakmeter.h"
52
51
/* Image stuff */
53
52
#include "bmp.h"
54
53
#ifdef HAVE_ALBUMART
55
54
#include "albumart.h"
56
-
#endif
57
55
#endif
58
56
59
57
#include "cuesheet.h"
···
92
90
skin_render(gwps, skin_do_full_update(skin, screen) ?
93
91
SKIN_REFRESH_ALL : update_type);
94
92
}
95
-
96
-
#ifdef HAVE_LCD_BITMAP
97
-
98
93
99
94
#ifdef AB_REPEAT_ENABLE
100
95
···
171
166
int x = pb->x, y = pb->y, width = pb->width, height = pb->height;
172
167
unsigned long length, end;
173
168
int flags = HORIZONTAL;
174
-
169
+
175
170
if (height < 0)
176
171
height = font_get(vp->font)->height;
177
172
···
423
418
display->set_drawmode(DRMODE_SOLID);
424
419
}
425
420
426
-
#endif /* HAVE_LCD_BITMAP */
427
-
428
421
/* Evaluate the conditional that is at *token_index and return whether a skip
429
422
has ocurred. *token_index is updated with the new position.
430
423
*/
···
587
580
else
588
581
{
589
582
linedes->scroll = false;
590
-
#ifdef HAVE_LCD_BITMAP
591
583
/* clear the line first */
592
584
display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
593
585
display->fillrect(0, line*string_height, viewport_width, string_height);
594
586
display->set_drawmode(DRMODE_SOLID);
595
-
#endif
596
587
597
588
/* Nasty hack: we output an empty scrolling string,
598
589
which will reset the scroller for that line */
599
590
display->puts_scroll(0, line, (unsigned char *)"");
600
-
#ifdef HAVE_LCD_BITMAP
601
591
line *= string_height;
602
592
center_xpos = (viewport_width-center_width)/2;
603
593
right_xpos = viewport_width-right_width;
604
-
#endif
605
594
/* print aligned strings. print whole line at once so that %Vs works
606
595
* across the full viewport width */
607
596
char *left = format_align->left ?: "";
···
614
603
}
615
604
}
616
605
617
-
#ifdef HAVE_LCD_BITMAP
618
606
void draw_peakmeters(struct gui_wps *gwps, int line_number,
619
607
struct viewport *viewport)
620
608
{
···
645
633
(void)screen;
646
634
(void)data;
647
635
bool draw = false;
648
-
#ifdef HAVE_LCD_BITMAP
649
636
if (data->wps_sb_tag)
650
637
draw = data->show_sb_on_wps;
651
638
else if (statusbar_position(screen) != STATUSBAR_OFF)
652
639
draw = true;
653
-
#endif
654
640
return draw;
655
641
}
656
-
#endif
657
642
658
643
/* do the button loop as often as required for the peak meters to update
659
644
* with a good refresh rate.
···
661
646
int skin_wait_for_action(enum skinnable_screens skin, int context, int timeout)
662
647
{
663
648
int button = ACTION_NONE;
664
-
#ifdef HAVE_LCD_BITMAP
665
649
/* when the peak meter is enabled we want to have a
666
650
few extra updates to make it look smooth. On the
667
651
other hand we don't want to waste energy if it
···
700
684
/* The peak meter is disabled
701
685
-> no additional screen updates needed */
702
686
else
703
-
#endif
704
687
{
705
688
button = get_action(context, timeout);
706
689
}
-2
apps/gui/skin_engine/skin_display.h
-2
apps/gui/skin_engine/skin_display.h
···
29
29
#define _SKIN_DISPLAY_H_
30
30
31
31
32
-
#ifdef HAVE_LCD_BITMAP
33
32
void draw_progressbar(struct gui_wps *gwps, int line, struct progressbar *pb);
34
33
void draw_playlist_viewer_list(struct gui_wps *gwps, struct playlistviewer *viewer);
35
34
/* clears the area where the image was shown */
···
40
39
void skin_render_viewport(struct skin_element* viewport, struct gui_wps *gwps,
41
40
struct skin_viewport* skin_viewport, unsigned long refresh_type);
42
41
43
-
#endif
44
42
45
43
/* Evaluate the conditional that is at *token_index and return whether a skip
46
44
has ocurred. *token_index is updated with the new position.
-10
apps/gui/skin_engine/skin_engine.c
-10
apps/gui/skin_engine/skin_engine.c
···
56
56
char* (*default_skin)(enum screen_type screen);
57
57
bool load_on_boot;
58
58
} skin_helpers[SKINNABLE_SCREENS_COUNT] = {
59
-
#ifdef HAVE_LCD_BITMAP
60
59
[CUSTOM_STATUSBAR] = { sb_preproccess, sb_postproccess, sb_create_from_settings, true },
61
-
#endif
62
60
[WPS] = { NULL, NULL, wps_default_skin, true },
63
61
#if CONFIG_TUNER
64
62
[FM_SCREEN] = { NULL, NULL, default_radio_skin, false }
···
115
113
#ifdef HAVE_SKIN_VARIABLES
116
114
skin->data.skinvars = -1;
117
115
#endif
118
-
#ifdef HAVE_LCD_BITMAP
119
116
skin->data.font_ids = -1;
120
117
skin->data.images = -1;
121
-
#endif
122
118
#ifdef HAVE_ALBUMART
123
119
skin->data.albumart = -1;
124
120
skin->data.playback_aa_slot = -1;
···
157
153
char filename[MAX_PATH];
158
154
static bool first_run = true;
159
155
160
-
#ifdef HAVE_LCD_BITMAP
161
156
skin_backdrop_init();
162
-
#endif
163
157
skins_initialised = true;
164
158
165
159
/* Make sure each skin is loaded */
···
236
230
char *setting = NULL, *ext = NULL;
237
231
switch (skin)
238
232
{
239
-
#ifdef HAVE_LCD_BITMAP
240
233
case CUSTOM_STATUSBAR:
241
234
#if defined(HAVE_REMOTE_LCD) && NB_SCREENS > 1
242
235
if (screen == SCREEN_REMOTE)
···
251
244
ext = "sbs";
252
245
}
253
246
break;
254
-
#endif
255
247
case WPS:
256
248
#if defined(HAVE_REMOTE_LCD) && NB_SCREENS > 1
257
249
if (screen == SCREEN_REMOTE)
···
296
288
297
289
struct gui_wps *skin_get_gwps(enum skinnable_screens skin, enum screen_type screen)
298
290
{
299
-
#ifdef HAVE_LCD_BITMAP
300
291
if (skin == CUSTOM_STATUSBAR && !skins_initialised)
301
292
return &skins[skin][screen].gui_wps;
302
-
#endif
303
293
304
294
if (skins[skin][screen].data.wps_loaded == false)
305
295
{
+1
-4
apps/gui/skin_engine/skin_engine.h
+1
-4
apps/gui/skin_engine/skin_engine.h
···
30
30
#include "wps_internals.h" /* TODO: remove this line.. shoudlnt be needed */
31
31
32
32
enum skinnable_screens {
33
-
#ifdef HAVE_LCD_BITMAP
34
33
CUSTOM_STATUSBAR,
35
-
#endif
36
34
WPS,
37
35
#if CONFIG_TUNER
38
36
FM_SCREEN,
39
37
#endif
40
-
41
-
38
+
42
39
SKINNABLE_SCREENS_COUNT
43
40
};
44
41
+1
-52
apps/gui/skin_engine/skin_parser.c
+1
-52
apps/gui/skin_engine/skin_parser.c
···
66
66
#include "tuner.h"
67
67
#endif
68
68
69
-
#ifdef HAVE_LCD_BITMAP
70
69
#include "bmp.h"
71
-
#endif
72
70
73
71
#ifdef HAVE_ALBUMART
74
72
#include "playback.h"
···
127
125
struct wps_token *token,
128
126
struct wps_data *wps_data);
129
127
130
-
#ifdef HAVE_LCD_BITMAP
131
128
/* add a skin_token_list item to the list chain. ALWAYS appended because some of the
132
129
* chains require the order to be kept.
133
130
*/
···
147
144
}
148
145
}
149
146
150
-
#endif
151
-
152
-
153
147
void *skin_find_item(const char *label, enum skin_find_what what,
154
148
struct wps_data *data)
155
149
{
···
170
164
list.vplist = SKINOFFSETTOPTR(databuf, data->tree);
171
165
isvplist = true;
172
166
break;
173
-
#ifdef HAVE_LCD_BITMAP
174
167
case SKIN_FIND_IMAGE:
175
168
list.linkedlist = SKINOFFSETTOPTR(databuf, data->images);
176
169
break;
177
-
#endif
178
170
#ifdef HAVE_TOUCHSCREEN
179
171
case SKIN_FIND_TOUCHREGION:
180
172
list.linkedlist = SKINOFFSETTOPTR(databuf, data->touchregions);
···
190
182
while (list.linkedlist)
191
183
{
192
184
bool skip = false;
193
-
#ifdef HAVE_LCD_BITMAP
194
185
struct wps_token *token = NULL;
195
186
if (!isvplist)
196
187
token = SKINOFFSETTOPTR(databuf, list.linkedlist->token);
197
-
#endif
198
188
switch (what)
199
189
{
200
190
case SKIN_FIND_UIVP:
···
207
197
skip = !(((struct skin_viewport *)ret)->is_infovp ==
208
198
(what==SKIN_FIND_UIVP));
209
199
break;
210
-
#ifdef HAVE_LCD_BITMAP
211
200
case SKIN_FIND_IMAGE:
212
201
ret = SKINOFFSETTOPTR(databuf, token->value.data);
213
202
itemlabel = SKINOFFSETTOPTR(databuf, ((struct gui_img *)ret)->label);
214
203
break;
215
-
#endif
216
204
#ifdef HAVE_TOUCHSCREEN
217
205
case SKIN_FIND_TOUCHREGION:
218
206
ret = SKINOFFSETTOPTR(databuf, token->value.data);
···
239
227
}
240
228
return NULL;
241
229
}
242
-
243
-
#ifdef HAVE_LCD_BITMAP
244
230
245
231
/* create and init a new wpsll item.
246
232
* passing NULL to token will alloc a new one.
···
493
479
return 0;
494
480
}
495
481
496
-
497
-
#ifdef HAVE_LCD_BITMAP
498
-
499
482
static int parse_playlistview(struct skin_element *element,
500
483
struct wps_token *token,
501
484
struct wps_data *wps_data)
···
513
496
514
497
return 0;
515
498
}
516
-
#endif
499
+
517
500
#ifdef HAVE_LCD_COLOR
518
501
static int parse_viewport_gradient_setup(struct skin_element *element,
519
502
struct wps_token *token,
···
755
738
return 0;
756
739
}
757
740
#endif
758
-
759
-
#endif /* HAVE_LCD_BITMAP */
760
741
761
742
static int parse_progressbar_tag(struct skin_element* element,
762
743
struct wps_token *token,
···
898
879
struct wps_token *token,
899
880
struct wps_data *wps_data)
900
881
{
901
-
#ifdef HAVE_LCD_BITMAP
902
882
struct progressbar *pb;
903
883
struct viewport *vp = &curr_vp->vp;
904
884
struct skin_tag_parameter *param = get_param(element, 0);
···
1211
1191
add_to_ll_chain(&wps_data->touchregions, item);
1212
1192
}
1213
1193
#endif
1214
-
1215
1194
return 0;
1216
-
1217
-
#else
1218
-
(void)element;
1219
-
if (token->type == SKIN_TOKEN_PROGRESSBAR ||
1220
-
token->type == SKIN_TOKEN_PLAYER_PROGRESSBAR)
1221
-
{
1222
-
wps_data->full_line_progressbar =
1223
-
token->type == SKIN_TOKEN_PLAYER_PROGRESSBAR;
1224
-
}
1225
-
return 0;
1226
-
1227
-
#endif
1228
1195
}
1229
1196
1230
1197
#ifdef HAVE_ALBUMART
···
1741
1708
{
1742
1709
if (wps_data->wps_loaded)
1743
1710
skin_buffer = get_skin_buffer(wps_data);
1744
-
#ifdef HAVE_LCD_BITMAP
1745
1711
#ifndef __PCTOOL__
1746
1712
struct skin_token_list *list = SKINOFFSETTOPTR(skin_buffer, wps_data->images);
1747
1713
int *font_ids = SKINOFFSETTOPTR(skin_buffer, wps_data->font_ids);
···
1776
1742
core_free(wps_data->buflib_handle);
1777
1743
wps_data->buflib_handle = -1;
1778
1744
#endif
1779
-
#endif
1780
1745
}
1781
1746
1782
1747
/*
···
1787
1752
static void skin_data_reset(struct wps_data *wps_data)
1788
1753
{
1789
1754
skin_data_free_buflib_allocs(wps_data);
1790
-
#ifdef HAVE_LCD_BITMAP
1791
1755
wps_data->images = INVALID_OFFSET;
1792
-
#endif
1793
1756
wps_data->tree = INVALID_OFFSET;
1794
1757
#ifdef HAVE_BACKDROP_IMAGE
1795
1758
if (wps_data->backdrop_id >= 0)
···
1811
1774
}
1812
1775
#endif
1813
1776
1814
-
#ifdef HAVE_LCD_BITMAP
1815
1777
wps_data->peak_meter_enabled = false;
1816
1778
wps_data->wps_sb_tag = false;
1817
1779
wps_data->show_sb_on_wps = false;
1818
-
#endif
1819
1780
wps_data->wps_loaded = false;
1820
1781
}
1821
1782
1822
-
#ifdef HAVE_LCD_BITMAP
1823
1783
#ifndef __PCTOOL__
1824
1784
static int currently_loading_handle = -1;
1825
1785
static int buflib_move_callback(int handle, void* current, void* new)
···
2065
2025
return success;
2066
2026
}
2067
2027
2068
-
#endif /* HAVE_LCD_BITMAP */
2069
2028
static int convert_viewport(struct wps_data *data, struct skin_element* element)
2070
2029
{
2071
2030
struct skin_viewport *skin_vp = skin_buffer_alloc(sizeof(*skin_vp));
···
2176
2135
skin_vp->vp.height = display->lcdheight - skin_vp->vp.y;
2177
2136
}
2178
2137
param++;
2179
-
#ifdef HAVE_LCD_BITMAP
2180
2138
/* font */
2181
2139
if (!isdefault(param))
2182
2140
skin_vp->parsed_fontid = param->data.number;
2183
-
#endif
2184
2141
if ((unsigned) skin_vp->vp.x >= (unsigned) display->lcdwidth ||
2185
2142
skin_vp->vp.width + skin_vp->vp.x > display->lcdwidth ||
2186
2143
(unsigned) skin_vp->vp.y >= (unsigned) display->lcdheight ||
···
2259
2216
case SKIN_TOKEN_TRACK_ENDING:
2260
2217
function = parse_timeout_tag;
2261
2218
break;
2262
-
#ifdef HAVE_LCD_BITMAP
2263
2219
case SKIN_TOKEN_LIST_ITEM_TEXT:
2264
2220
case SKIN_TOKEN_LIST_ITEM_ICON:
2265
2221
function = parse_listitem;
···
2274
2230
sb_skin_has_title(curr_screen);
2275
2231
#endif
2276
2232
break;
2277
-
#endif
2278
2233
#if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
2279
2234
case SKIN_TOKEN_DRAWRECTANGLE:
2280
2235
function = parse_drawrectangle;
···
2309
2264
case SKIN_TOKEN_SETTING:
2310
2265
function = parse_setting_and_lang;
2311
2266
break;
2312
-
#ifdef HAVE_LCD_BITMAP
2313
2267
case SKIN_TOKEN_VIEWPORT_CUSTOMLIST:
2314
2268
function = parse_playlistview;
2315
2269
break;
···
2331
2285
case SKIN_TOKEN_LIST_ITEM_CFG:
2332
2286
function = parse_listitemviewport;
2333
2287
break;
2334
-
#endif
2335
2288
#ifdef HAVE_TOUCHSCREEN
2336
2289
case SKIN_TOKEN_TOUCHREGION:
2337
2290
function = parse_touchregion;
···
2423
2376
char *wps_buffer = NULL;
2424
2377
if (!wps_data || !buf)
2425
2378
return false;
2426
-
#ifdef HAVE_LCD_BITMAP
2427
2379
int i;
2428
2380
for (i=0;i<MAXUSERFONTS;i++)
2429
2381
{
2430
2382
skinfonts[i].id = -1;
2431
2383
skinfonts[i].name = NULL;
2432
2384
}
2433
-
#endif
2434
2385
#ifdef DEBUG_SKIN_ENGINE
2435
2386
if (isfile && debug_wps)
2436
2387
{
···
2504
2455
return false;
2505
2456
}
2506
2457
2507
-
#ifdef HAVE_LCD_BITMAP
2508
2458
char bmpdir[MAX_PATH];
2509
2459
if (isfile)
2510
2460
{
···
2523
2473
skin_data_reset(wps_data);
2524
2474
return false;
2525
2475
}
2526
-
#endif
2527
2476
#if defined(HAVE_ALBUMART) && !defined(__PCTOOL__)
2528
2477
/* last_albumart_{width,height} is either both 0 or valid AA dimensions */
2529
2478
struct skin_albumart *aa = SKINOFFSETTOPTR(skin_buffer, wps_data->albumart);
+5
-33
apps/gui/skin_engine/skin_render.c
+5
-33
apps/gui/skin_engine/skin_render.c
···
77
77
typedef bool (*skin_render_func)(struct skin_element* alternator, struct skin_draw_info *info);
78
78
bool skin_render_alternator(struct skin_element* alternator, struct skin_draw_info *info);
79
79
80
-
#ifdef HAVE_LCD_BITMAP
81
80
static void skin_render_playlistviewer(struct playlistviewer* viewer,
82
81
struct gui_wps *gwps,
83
82
struct skin_viewport* skin_viewport,
84
83
unsigned long refresh_type);
85
-
#endif
86
84
87
85
static char* skin_buffer;
88
86
···
99
97
{
100
98
struct wps_token *token = (struct wps_token *)SKINOFFSETTOPTR(skin_buffer, element->data);
101
99
102
-
#ifdef HAVE_LCD_BITMAP
103
100
struct viewport *vp = &skin_vp->vp;
104
101
struct wps_data *data = gwps->data;
105
102
bool do_refresh = (element->tag->flags & info->refresh_type) > 0;
106
-
#endif
103
+
107
104
switch (token->type)
108
105
{
109
106
#if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
···
181
178
}
182
179
}
183
180
break;
184
-
#ifdef HAVE_LCD_BITMAP
185
181
case SKIN_TOKEN_LIST_ITEM_CFG:
186
182
skinlist_set_cfg(gwps->display->screen_type,
187
183
SKINOFFSETTOPTR(skin_buffer, token->value.data));
···
225
221
case SKIN_TOKEN_PEAKMETER_RIGHTBAR:
226
222
data->peak_meter_enabled = true;
227
223
/* fall through to the progressbar code */
228
-
#endif
229
224
case SKIN_TOKEN_VOLUMEBAR:
230
225
case SKIN_TOKEN_BATTERY_PERCENTBAR:
231
226
case SKIN_TOKEN_SETTINGBAR:
232
-
#ifdef HAVE_LCD_BITMAP
233
227
case SKIN_TOKEN_PROGRESSBAR:
234
228
case SKIN_TOKEN_TUNER_RSSI_BAR:
235
229
case SKIN_TOKEN_LIST_SCROLLBAR:
···
238
232
if (do_refresh)
239
233
draw_progressbar(gwps, info->line_number, bar);
240
234
}
241
-
#endif
242
235
break;
243
-
#ifdef HAVE_LCD_BITMAP
244
236
case SKIN_TOKEN_IMAGE_DISPLAY:
245
237
{
246
238
struct gui_img *img = SKINOFFSETTOPTR(skin_buffer, token->value.data);
···
321
313
skin_render_playlistviewer(SKINOFFSETTOPTR(skin_buffer, token->value.data), gwps,
322
314
info->skin_vp, info->refresh_type);
323
315
break;
324
-
325
-
#endif /* HAVE_LCD_BITMAP */
316
+
326
317
#ifdef HAVE_SKIN_VARIABLES
327
318
case SKIN_TOKEN_VAR_SET:
328
319
{
···
352
343
}
353
344
return true;
354
345
}
355
-
356
-
357
346
358
347
static void do_tags_in_hidden_conditional(struct skin_element* branch,
359
348
struct skin_draw_info *info)
360
349
{
361
-
#ifdef HAVE_LCD_BITMAP
362
350
struct gui_wps *gwps = info->gwps;
363
351
struct wps_data *data = gwps->data;
364
-
#endif
365
352
/* Tags here are ones which need to be "turned off" or cleared
366
353
* if they are in a conditional branch which isnt being used */
367
354
if (branch->type == LINE_ALTERNATOR)
···
375
362
else if (branch->type == LINE && branch->children_count)
376
363
{
377
364
struct skin_element *child = get_child(branch->children, 0);
378
-
#if defined(HAVE_LCD_BITMAP) || defined(HAVE_ALBUMART)
379
365
struct wps_token *token;
380
-
#endif
381
366
while (child)
382
367
{
383
368
if (child->type == CONDITIONAL)
···
395
380
child = SKINOFFSETTOPTR(skin_buffer, child->next);
396
381
continue;
397
382
}
398
-
#if defined(HAVE_LCD_BITMAP) || defined(HAVE_ALBUMART)
399
383
token = (struct wps_token *)SKINOFFSETTOPTR(skin_buffer, child->data);
400
-
#endif
401
-
#ifdef HAVE_LCD_BITMAP
402
384
/* clear all pictures in the conditional and nested ones */
403
385
if (token->type == SKIN_TOKEN_IMAGE_PRELOAD_DISPLAY)
404
386
{
···
420
402
viewport = SKINOFFSETTOPTR(skin_buffer, viewport->next))
421
403
{
422
404
struct skin_viewport *skin_viewport = SKINOFFSETTOPTR(skin_buffer, viewport->data);
423
-
424
405
char *vplabel = SKINOFFSETTOPTR(skin_buffer, skin_viewport->label);
425
406
if (skin_viewport->label == VP_DEFAULT_LABEL)
426
407
vplabel = VP_DEFAULT_LABEL_STRING;
···
460
441
}
461
442
}
462
443
}
463
-
#endif
464
444
#ifdef HAVE_ALBUMART
465
445
else if (data->albumart && token->type == SKIN_TOKEN_ALBUMART_DISPLAY)
466
446
{
···
734
714
.offset = 0,
735
715
.line_desc = LINE_DESC_DEFINIT,
736
716
};
737
-
717
+
738
718
struct align_pos * align = &info.align;
739
719
bool needs_update, update_all = false;
740
720
skin_buffer = get_skin_buffer(gwps->data);
741
-
#ifdef HAVE_LCD_BITMAP
742
721
/* Set images to not to be displayed */
743
722
struct skin_token_list *imglist = SKINOFFSETTOPTR(skin_buffer, gwps->data->images);
744
723
while (imglist)
···
752
731
/* fix font ID's */
753
732
if (skin_viewport->parsed_fontid == 1)
754
733
skin_viewport->vp.font = display->getuifont();
755
-
#endif
756
-
757
734
758
-
759
735
while (line)
760
736
{
761
737
linebuf[0] = '\0';
···
811
787
info.line_number++;
812
788
line = SKINOFFSETTOPTR(skin_buffer, line->next);
813
789
}
814
-
#ifdef HAVE_LCD_BITMAP
815
790
wps_display_images(gwps, &skin_viewport->vp);
816
-
#endif
817
791
}
818
792
819
793
void skin_render(struct gui_wps *gwps, unsigned refresh_mode)
···
903
877
display->update();
904
878
}
905
879
906
-
#ifdef HAVE_LCD_BITMAP
907
-
static __attribute__((noinline))
880
+
static __attribute__((noinline))
908
881
void skin_render_playlistviewer(struct playlistviewer* viewer,
909
882
struct gui_wps *gwps,
910
883
struct skin_viewport* skin_viewport,
···
926
899
.offset = viewer->start_offset,
927
900
.line_desc = LINE_DESC_DEFINIT,
928
901
};
929
-
902
+
930
903
struct align_pos * align = &info.align;
931
904
bool needs_update;
932
905
int cur_pos, start_item, max;
···
989
962
start_item++;
990
963
}
991
964
}
992
-
#endif
-6
apps/gui/skin_engine/skin_tokens.c
-6
apps/gui/skin_engine/skin_tokens.c
···
41
41
#include "lang.h"
42
42
#include "misc.h"
43
43
#include "led.h"
44
-
#ifdef HAVE_LCD_BITMAP
45
44
#include "peakmeter.h"
46
45
/* Image stuff */
47
46
#include "albumart.h"
48
-
#endif
49
47
#include "playlist.h"
50
48
#include "playback.h"
51
49
#include "tdspeed.h"
···
813
811
if (intval)
814
812
*intval = playlist_amount();
815
813
return buf;
816
-
#ifdef HAVE_LCD_BITMAP
817
814
case SKIN_TOKEN_LIST_TITLE_TEXT:
818
815
return sb_get_title(gwps->display->screen_type);
819
816
case SKIN_TOKEN_LIST_TITLE_ICON:
···
854
851
}
855
852
case SKIN_TOKEN_LIST_NEEDS_SCROLLBAR:
856
853
return skinlist_needs_scrollbar(gwps->display->screen_type) ? "s" : "";
857
-
#endif
858
854
case SKIN_TOKEN_PLAYLIST_NAME:
859
855
return playlist_name(NULL, buf, buf_size);
860
856
···
1202
1198
return "-";
1203
1199
#endif
1204
1200
1205
-
#ifdef HAVE_LCD_BITMAP
1206
1201
/* peakmeter */
1207
1202
case SKIN_TOKEN_PEAKMETER_LEFT:
1208
1203
case SKIN_TOKEN_PEAKMETER_RIGHT:
···
1218
1213
data->peak_meter_enabled = true;
1219
1214
return buf;
1220
1215
}
1221
-
#endif
1222
1216
1223
1217
case SKIN_TOKEN_CROSSFADE:
1224
1218
#ifdef HAVE_CROSSFADE
-14
apps/gui/skin_engine/wps_internals.h
-14
apps/gui/skin_engine/wps_internals.h
···
80
80
OFFSETTYPE(struct skin_token_list *) next;
81
81
};
82
82
83
-
#ifdef HAVE_LCD_BITMAP
84
83
struct gui_img {
85
84
OFFSETTYPE(struct viewport*) vp; /* The viewport to display this image in */
86
85
short int x; /* x-pos */
···
137
136
unsigned start_colour;
138
137
unsigned end_colour;
139
138
};
140
-
#endif
141
-
142
-
143
139
144
140
struct align_pos {
145
141
char* left;
···
147
143
char* right;
148
144
};
149
145
150
-
#ifdef HAVE_LCD_BITMAP
151
146
#define WPS_MAX_TOKENS 1150
152
-
#else
153
-
#define WPS_MAX_TOKENS 64
154
-
#endif
155
147
156
148
enum wps_parse_error {
157
149
PARSE_OK,
···
344
336
int buflib_handle;
345
337
346
338
OFFSETTYPE(struct skin_element *) tree;
347
-
#ifdef HAVE_LCD_BITMAP
348
339
OFFSETTYPE(struct skin_token_list *) images;
349
340
OFFSETTYPE(int *) font_ids;
350
341
int font_count;
351
-
#endif
352
342
#ifdef HAVE_BACKDROP_IMAGE
353
343
int backdrop_id;
354
344
bool use_extra_framebuffer;
···
370
360
OFFSETTYPE(struct skin_token_list *) skinvars;
371
361
#endif
372
362
373
-
#ifdef HAVE_LCD_BITMAP
374
363
bool peak_meter_enabled;
375
364
bool wps_sb_tag;
376
365
bool show_sb_on_wps;
377
-
#endif
378
366
bool wps_loaded;
379
367
};
380
368
···
448
436
enum skin_find_what {
449
437
SKIN_FIND_VP = 0,
450
438
SKIN_FIND_UIVP,
451
-
#ifdef HAVE_LCD_BITMAP
452
439
SKIN_FIND_IMAGE,
453
-
#endif
454
440
#ifdef HAVE_TOUCHSCREEN
455
441
SKIN_FIND_TOUCHREGION,
456
442
#endif
+1
-21
apps/gui/splash.c
+1
-21
apps/gui/splash.c
···
31
31
#include "viewport.h"
32
32
#include "strtok_r.h"
33
33
34
-
#ifdef HAVE_LCD_BITMAP
35
-
36
34
#define MAXLINES (LCD_HEIGHT/6)
37
35
#define MAXBUFFER 512
38
36
#define RECT_SPACING 2
39
37
#define SPLASH_MEMORY_INTERVAL (HZ)
40
-
41
-
#endif
42
-
43
38
44
39
static void splash_internal(struct screen * screen, const char *fmt, va_list ap)
45
40
{
···
54
49
int y, i;
55
50
int space_w, w, h;
56
51
struct viewport vp;
57
-
#ifdef HAVE_LCD_BITMAP
58
52
int width, height;
59
53
int maxw = 0;
60
54
61
55
viewport_set_defaults(&vp, screen->screen_type);
62
56
screen->set_viewport(&vp);
63
-
57
+
64
58
screen->getstringsize(" ", &space_w, &h);
65
-
#endif
66
59
y = h;
67
60
68
61
vsnprintf(splash_buf, sizeof(splash_buf), fmt, ap);
···
77
70
lines[0] = next;
78
71
while (true)
79
72
{
80
-
#ifdef HAVE_LCD_BITMAP
81
73
screen->getstringsize(next, &w, NULL);
82
-
#else
83
-
w = utf8length(next);
84
-
#endif
85
74
if (lastbreak)
86
75
{
87
76
if (x + (next - lastbreak) * space_w + w
88
77
> vp.width - RECT_SPACING*2)
89
78
{ /* too wide, wrap */
90
-
#ifdef HAVE_LCD_BITMAP
91
79
if (x > maxw)
92
80
maxw = x;
93
-
#endif
94
81
if ((y + h > vp.height) || (line >= (MAXLINES-1)))
95
82
break; /* screen full or out of lines */
96
83
x = 0;
···
109
96
next = strtok_r(NULL, " ", &store);
110
97
if (!next)
111
98
{ /* no more words */
112
-
#ifdef HAVE_LCD_BITMAP
113
99
if (x > maxw)
114
100
maxw = x;
115
-
#endif
116
101
break;
117
102
}
118
103
}
···
123
108
124
109
screen->scroll_stop();
125
110
126
-
#ifdef HAVE_LCD_BITMAP
127
-
128
111
width = maxw + 2*RECT_SPACING;
129
112
height = y + 2*RECT_SPACING;
130
113
···
166
149
167
150
/* prepare putting the text */
168
151
y = RECT_SPACING;
169
-
#endif
170
152
171
153
/* print the message to screen */
172
154
for (i = 0; i <= line; i++, y+=h)
173
155
{
174
-
#ifdef HAVE_LCD_BITMAP
175
156
screen->putsxy(0, y, lines[i]);
176
-
#endif
177
157
}
178
158
screen->update_viewport();
179
159
end:
-11
apps/gui/statusbar-skinned.h
-11
apps/gui/statusbar-skinned.h
···
23
23
24
24
#define DEFAULT_UPDATE_DELAY (HZ/7)
25
25
26
-
#ifdef HAVE_LCD_BITMAP
27
-
28
26
#include <stdio.h>
29
27
#include <string.h>
30
28
#include <stdlib.h>
···
57
55
int sb_preproccess(enum screen_type screen, struct wps_data *data);
58
56
int sb_postproccess(enum screen_type screen, struct wps_data *data);
59
57
60
-
#else /* CHARCELL */
61
-
#define sb_skin_init()
62
-
#define sb_skin_data_load(a,b,c)
63
-
#define sb_skin_set_update_delay(a)
64
-
#define sb_skin_set_state(a,b)
65
-
#define sb_create_from_settings NULL
66
-
#define sb_preproccess NULL
67
-
#define sb_postproccess NULL
68
-
#endif
69
58
void do_sbs_update_callback(unsigned short id, void *param);
70
59
#endif /* __STATUSBAR_SKINNED_H__ */
-12
apps/gui/statusbar.c
-12
apps/gui/statusbar.c
···
132
132
struct gui_syncstatusbar statusbars;
133
133
134
134
/* Prototypes */
135
-
#ifdef HAVE_LCD_BITMAP
136
135
static void gui_statusbar_icon_battery(struct screen * display, int percent,
137
136
int batt_charge_step);
138
137
static bool gui_statusbar_icon_volume(struct gui_statusbar * bar, int volume);
···
151
150
#endif
152
151
#if CONFIG_RTC
153
152
static void gui_statusbar_time(struct screen * display, struct tm *time);
154
-
#endif
155
153
#endif
156
154
157
155
/* End prototypes */
···
242
240
}
243
241
244
242
bar->info.volume = global_settings.volume;
245
-
#ifdef HAVE_LCD_BITMAP
246
243
bar->info.shuffle = global_settings.playlist_shuffle;
247
244
#ifdef HAS_BUTTON_HOLD
248
245
bar->info.keylock = button_hold();
···
349
346
display->set_viewport(NULL);
350
347
bar->lastinfo = bar->info;
351
348
}
352
-
#endif /* HAVE_LCD_BITMAP */
353
-
354
349
}
355
350
356
-
#ifdef HAVE_LCD_BITMAP
357
351
/* from icon.c */
358
352
/*
359
353
* Print battery icon to status bar
···
717
711
}
718
712
#endif /* HAVE_RECORDING */
719
713
720
-
#endif /* HAVE_LCD_BITMAP */
721
-
722
714
void gui_syncstatusbar_init(struct gui_syncstatusbar * bars)
723
715
{
724
716
FOR_NB_SCREENS(i) {
···
730
722
void gui_syncstatusbar_draw(struct gui_syncstatusbar * bars,
731
723
bool force_redraw)
732
724
{
733
-
#ifdef HAVE_LCD_BITMAP
734
725
if(!global_settings.statusbar)
735
726
return;
736
727
struct viewport viewport;
···
738
729
GET_RECT(viewport,statusbar_position(i),&screens[i]);
739
730
gui_statusbar_draw( &(bars->statusbars[i]), force_redraw, &viewport );
740
731
}
741
-
#else
742
-
gui_statusbar_draw( &(bars->statusbars[0]), force_redraw, NULL );
743
-
#endif /* HAVE_LCD_BITMAP */
744
732
}
745
733
746
734
+1
-26
apps/gui/usb_screen.c
+1
-26
apps/gui/usb_screen.c
···
42
42
#include "playlist.h"
43
43
#include "misc.h"
44
44
45
-
#ifdef HAVE_LCD_BITMAP
46
45
#include "bitmaps/usblogo.h"
47
-
#endif
48
46
49
47
#ifdef HAVE_REMOTE_LCD
50
48
#include "bitmaps/remote_usblogo.h"
···
122
120
struct usb_screen_vps_t
123
121
{
124
122
struct viewport parent;
125
-
#ifdef HAVE_LCD_BITMAP
126
123
struct viewport logo;
127
124
#ifdef USB_ENABLE_HID
128
125
struct viewport title;
129
-
#endif
130
126
#endif
131
127
};
132
128
133
-
#ifdef HAVE_LCD_BITMAP
134
129
static void usb_screen_fix_viewports(struct screen *screen,
135
130
struct usb_screen_vps_t *usb_screen_vps)
136
131
{
···
181
176
}
182
177
#endif
183
178
}
184
-
#endif
185
179
186
180
static void usb_screens_draw(struct usb_screen_vps_t *usb_screen_vps_ar)
187
181
{
188
-
#ifdef HAVE_LCD_BITMAP
189
182
static const struct bitmap* logos[NB_SCREENS] = {
190
183
&bm_usblogo,
191
184
#ifdef HAVE_REMOTE_LCD
192
185
&bm_remote_usblogo,
193
186
#endif
194
187
};
195
-
#endif
196
188
197
189
FOR_NB_SCREENS(i)
198
190
{
···
200
192
201
193
struct usb_screen_vps_t *usb_screen_vps = &usb_screen_vps_ar[i];
202
194
struct viewport *parent = &usb_screen_vps->parent;
203
-
#ifdef HAVE_LCD_BITMAP
204
195
struct viewport *logo = &usb_screen_vps->logo;
205
-
#endif
206
196
207
197
screen->set_viewport(parent);
208
198
screen->clear_viewport();
209
199
screen->backlight_on();
210
200
211
-
#ifdef HAVE_LCD_BITMAP
212
201
screen->set_viewport(logo);
213
202
screen->bmp(logos[i], 0, 0);
214
203
if (i == SCREEN_MAIN)
···
228
217
}
229
218
screen->set_viewport(parent);
230
219
231
-
#else /* !HAVE_LCD_BITMAP */
232
-
screen->double_height(false);
233
-
screen->puts_scroll(0, 0, "[USB Mode]");
234
-
status_set_param(false);
235
-
status_set_audio(false);
236
-
status_set_usb(true);
237
-
#endif /* HAVE_LCD_BITMAP */
238
-
239
220
screen->set_viewport(NULL);
240
221
screen->update_viewport();
241
222
}
···
275
256
/* update the UI before disabling fonts, this maximizes the propability
276
257
* that font cache lookups succeed during USB */
277
258
send_event(GUI_EVENT_ACTIONUPDATE, NULL);
278
-
#ifdef HAVE_LCD_BITMAP
279
259
if(!early_usb)
280
260
{
281
261
/* The font system leaves the .fnt fd's open, so we need for force close them all */
282
262
font_disable_all();
283
263
}
284
-
#endif
285
264
286
265
usb_acknowledge(SYS_USB_CONNECTED_ACK);
287
266
···
302
281
{
303
282
const struct viewport* vp = NULL;
304
283
305
-
#if defined(HAVE_LCD_BITMAP) && defined(USB_ENABLE_HID)
284
+
#if defined(USB_ENABLE_HID)
306
285
vp = usb_hid ? &usb_screen_vps_ar[i].title : NULL;
307
-
#elif !defined(HAVE_LCD_BITMAP)
308
-
vp = &usb_screen_vps_ar[i].parent;
309
286
#endif
310
287
if (vp)
311
288
screens[i].scroll_stop_viewport(vp);
···
322
299
touchscreen_set_mode(old_mode);
323
300
#endif
324
301
325
-
#ifdef HAVE_LCD_BITMAP
326
302
if(!early_usb)
327
303
{
328
304
font_enable_all();
···
331
307
/* Reload playlist */
332
308
playlist_resume();
333
309
}
334
-
#endif
335
310
336
311
FOR_NB_SCREENS(i)
337
312
{
+2
-28
apps/gui/viewport.c
+2
-28
apps/gui/viewport.c
···
54
54
#include "statusbar.h"
55
55
#include "appevents.h"
56
56
#include "panic.h"
57
-
#ifdef HAVE_LCD_BITMAP
58
57
#include "language.h"
59
-
#endif
60
58
#include "statusbar-skinned.h"
61
59
#include "skin_engine/skin_engine.h"
62
60
#include "debug.h"
···
68
66
bool enabled;
69
67
};
70
68
71
-
#ifdef HAVE_LCD_BITMAP
72
69
static void viewportmanager_redraw(unsigned short id, void* data);
73
70
74
71
static int theme_stack_top[NB_SCREENS]; /* the last item added */
···
218
215
int top = theme_stack_top[screen];
219
216
return theme_stack[screen][top].enabled;
220
217
}
221
-
#endif /* HAVE_LCD_BITMAP */
222
218
223
219
int viewport_get_nb_lines(const struct viewport *vp)
224
220
{
225
-
#ifdef HAVE_LCD_BITMAP
226
221
return vp->height/font_get(vp->font)->height;
227
-
#else
228
-
(void)vp;
229
-
return 2;
230
-
#endif
231
222
}
232
223
233
224
static void viewportmanager_redraw(unsigned short id, void* data)
···
235
226
(void)id;
236
227
FOR_NB_SCREENS(i)
237
228
{
238
-
#ifdef HAVE_LCD_BITMAP
239
229
if (is_theme_enabled(i))
240
230
sb_skin_update(i, NULL != data);
241
-
#else
242
-
(void)data;
243
-
gui_statusbar_draw(&statusbars.statusbars[i], NULL, NULL);
244
-
#endif
245
231
}
246
232
}
247
233
248
234
void viewportmanager_init()
249
235
{
250
-
#ifdef HAVE_LCD_BITMAP
251
236
FOR_NB_SCREENS(i)
252
237
{
253
238
theme_stack_top[i] = -1; /* the next call fixes this to 0 */
254
239
/* We always want the theme enabled by default... */
255
240
viewportmanager_theme_enable(i, true, NULL);
256
241
}
257
-
#else
258
-
add_event(GUI_EVENT_ACTIONUPDATE, viewportmanager_redraw);
259
-
#endif
260
242
}
261
243
262
-
#ifdef HAVE_LCD_BITMAP
263
244
void viewportmanager_theme_changed(const int which)
264
245
{
265
246
if (which & THEME_LANGUAGE)
···
296
277
vp->flags |= VP_FLAG_ALIGN_RIGHT;
297
278
}
298
279
299
-
#endif /* HAVE_LCD_BITMAP */
300
280
#endif /* __PCTOOL__ */
301
281
302
282
void viewport_set_fullscreen(struct viewport *vp,
···
307
287
vp->width = screens[screen].lcdwidth;
308
288
vp->height = screens[screen].lcdheight;
309
289
310
-
#ifdef HAVE_LCD_BITMAP
311
290
#ifndef __PCTOOL__
312
291
set_default_align_flags(vp);
313
292
#endif
···
331
310
vp->bg_pattern = LCD_REMOTE_DEFAULT_BG;
332
311
}
333
312
#endif
334
-
#endif
335
313
}
336
314
337
315
void viewport_set_defaults(struct viewport *vp,
338
316
const enum screen_type screen)
339
317
{
340
-
#if defined(HAVE_LCD_BITMAP) && !defined(__PCTOOL__)
318
+
#if !defined(__PCTOOL__)
341
319
struct viewport *sbs_area = NULL;
342
320
if (!is_theme_enabled(screen))
343
321
{
···
349
327
if (sbs_area)
350
328
*vp = *sbs_area;
351
329
else
352
-
#endif /* HAVE_LCD_BITMAP */
330
+
#endif /* !__PCTOOL__ */
353
331
viewport_set_fullscreen(vp, screen);
354
332
}
355
333
356
-
357
-
#ifdef HAVE_LCD_BITMAP
358
334
359
335
int get_viewport_default_colour(enum screen_type screen, bool fgcolour)
360
336
{
···
392
368
return 0;
393
369
#endif /* LCD_DEPTH > 1 || LCD_REMOTE_DEPTH > 1 */
394
370
}
395
-
396
-
#endif
-3
apps/gui/viewport.h
-3
apps/gui/viewport.h
···
53
53
*/
54
54
void viewportmanager_init(void) INIT_ATTR;
55
55
56
-
#ifdef HAVE_LCD_BITMAP
57
56
void viewportmanager_theme_enable(enum screen_type screen, bool enable,
58
57
struct viewport *viewport);
59
58
/* Force will cause a redraw even if the theme was previously and
···
67
66
#ifdef HAVE_TOUCHSCREEN
68
67
bool viewport_point_within_vp(const struct viewport *vp,
69
68
const int x, const int y);
70
-
#endif
71
-
72
69
#endif
73
70
74
71
#endif /* __PCTOOL__ */
-7
apps/gui/wps.c
-7
apps/gui/wps.c
···
39
39
#include "storage.h"
40
40
#include "screens.h"
41
41
#include "playlist.h"
42
-
#ifdef HAVE_LCD_BITMAP
43
42
#include "icons.h"
44
-
#endif
45
43
#include "lang.h"
46
44
#include "bookmark.h"
47
45
#include "misc.h"
···
87
85
char* wps_default_skin(enum screen_type screen)
88
86
{
89
87
static char *skin_buf[NB_SCREENS] = {
90
-
#ifdef HAVE_LCD_BITMAP
91
88
#if LCD_DEPTH > 1
92
89
"%X(d)\n"
93
90
#endif
···
97
94
"%al%pc/%pt%ar[%pp:%pe]\n"
98
95
"%fbkBit %?fv<avg|> %?iv<%(id3v%iv%)|%(no id3%)>\n"
99
96
"%pb\n%pm\n",
100
-
#else
101
-
"%s%pp/%pe: %?it<%it|%fn> - %?ia<%ia|%d(2)> - %?id<%id|%d(1)>\n"
102
-
"%pc%?ps<*|/>%pt\n",
103
-
#endif
104
97
#ifdef HAVE_REMOTE_LCD
105
98
#if LCD_REMOTE_DEPTH > 1
106
99
"%X(d)\n"
-2
apps/gui/yesno.c
-2
apps/gui/yesno.c
···
112
112
if(line_shift+3 <= vp_lines)
113
113
line_shift++;
114
114
display->puts(0, line_shift, str(LANG_CONFIRM_WITH_BUTTON));
115
-
#ifdef HAVE_LCD_BITMAP
116
115
display->puts(0, line_shift+1, str(LANG_CANCEL_WITH_ANY));
117
-
#endif
118
116
}
119
117
#endif
120
118
display->update_viewport();
-2
apps/keyboard.h
-2
apps/keyboard.h
-2
apps/lang/SOURCES
-2
apps/lang/SOURCES
-2
apps/language.c
-2
apps/language.c
···
26
26
#include "lang.h"
27
27
#include "debug.h"
28
28
#include "string.h"
29
-
#ifdef HAVE_LCD_BITMAP
30
29
#include "viewport.h"
31
-
#endif
32
30
33
31
/* The following header is generated by the build system and only defines
34
32
MAX_LANGUAGE_SIZE to be the size of the largest currently available
+2
-4
apps/logfdisp.c
+2
-4
apps/logfdisp.c
···
36
36
#include "action.h"
37
37
#include "splash.h"
38
38
39
-
#ifdef HAVE_LCD_BITMAP
40
39
int compute_nb_lines(int w, struct font* font)
41
40
{
42
41
int i, nb_lines;
43
42
int cur_x, delta_x;
44
-
43
+
45
44
if(logfindex == 0 && !logfwrap)
46
45
return 0;
47
-
46
+
48
47
if(logfwrap)
49
48
i = logfindex;
50
49
else
···
209
208
210
209
return false;
211
210
}
212
-
#endif /* HAVE_LCD_BITMAP */
213
211
214
212
bool logfdump(void)
215
213
{
-17
apps/main.c
-17
apps/main.c
···
167
167
screens[i].clear_display();
168
168
screens[i].update();
169
169
}
170
-
#ifdef HAVE_LCD_BITMAP
171
170
list_init();
172
-
#endif
173
171
tree_gui_init();
174
172
/* Keep the order of this 3
175
173
* Must be done before any code uses the multi-screen API */
···
280
278
talk_number(tagcache_get_max_commit_step(), true);
281
279
}
282
280
#endif
283
-
#ifdef HAVE_LCD_BITMAP
284
281
if (lang_is_rtl())
285
282
{
286
283
splashf(0, "[%d/%d] %s", ret, tagcache_get_max_commit_step(),
···
291
288
splashf(0, "%s [%d/%d]", str(LANG_TAGCACHE_INIT), ret,
292
289
tagcache_get_max_commit_step());
293
290
}
294
-
#else
295
-
lcd_double_height(false);
296
-
lcd_putsf(0, 1, " DB [%d/%d]", ret,
297
-
tagcache_get_max_commit_step());
298
-
lcd_update();
299
-
#endif
300
291
clear = true;
301
292
}
302
293
sleep(HZ/4);
···
326
317
#ifdef HAVE_REMOTE_LCD
327
318
lcd_remote_init();
328
319
#endif
329
-
#ifdef HAVE_LCD_BITMAP
330
320
FOR_NB_SCREENS(i)
331
321
global_status.font_id[i] = FONT_SYSFIXED;
332
322
font_init();
333
-
#endif
334
323
show_logo();
335
324
#ifndef USB_NONE
336
325
usb_init();
···
428
417
#ifdef HAVE_REMOTE_LCD
429
418
lcd_remote_init();
430
419
#endif
431
-
#ifdef HAVE_LCD_BITMAP
432
420
FOR_NB_SCREENS(i)
433
421
global_status.font_id[i] = FONT_SYSFIXED;
434
422
font_init();
435
-
#endif
436
423
437
424
settings_reset();
438
425
···
507
494
CHART("<storage_init");
508
495
if(rc)
509
496
{
510
-
#ifdef HAVE_LCD_BITMAP
511
497
lcd_clear_display();
512
498
lcd_putsf(0, 1, "ATA error: %d", rc);
513
499
lcd_puts(0, 3, "Press ON to debug");
514
500
lcd_update();
515
501
while(!(button_get(true) & BUTTON_REL)); /* DO NOT CHANGE TO ACTION SYSTEM */
516
502
dbg_ports();
517
-
#endif
518
503
panicf("ata: %d", rc);
519
504
}
520
505
···
565
550
lcd_clear_display();
566
551
lcd_puts(0, 0, "No partition");
567
552
lcd_puts(0, 1, "found.");
568
-
#ifdef HAVE_LCD_BITMAP
569
553
lcd_puts(0, 2, "Insert USB cable");
570
554
lcd_puts(0, 3, "and fix it.");
571
-
#endif
572
555
lcd_update();
573
556
574
557
while(button_get(true) != SYS_USB_CONNECTED) {};
+2
-17
apps/misc.c
+2
-17
apps/misc.c
···
84
84
#if defined(HAVE_RECORDING) && !defined(__PCTOOL__)
85
85
#include "recording.h"
86
86
#endif
87
-
#if defined(HAVE_LCD_BITMAP) && !defined(__PCTOOL__)
87
+
#if !defined(__PCTOOL__)
88
88
#include "bmp.h"
89
89
#include "icons.h"
90
-
#endif /* End HAVE_LCD_BITMAP */
90
+
#endif /* !__PCTOOL__ */
91
91
#include "bookmark.h"
92
92
#include "wps.h"
93
93
#include "playback.h"
···
712
712
713
713
int show_logo( void )
714
714
{
715
-
#ifdef HAVE_LCD_BITMAP
716
715
char version[32];
717
716
int font_h, font_w;
718
717
···
735
734
#endif
736
735
lcd_setfont(FONT_UI);
737
736
738
-
#else
739
-
char *rockbox = " ROCKbox!";
740
-
741
-
lcd_clear_display();
742
-
lcd_double_height(true);
743
-
lcd_puts(0, 0, rockbox);
744
-
lcd_puts_scroll(0, 1, rbversion);
745
-
#endif
746
737
lcd_update();
747
738
748
739
#ifdef HAVE_REMOTE_LCD
···
1439
1430
}
1440
1431
#endif /* HAVE_LCD_COLOR */
1441
1432
1442
-
#ifdef HAVE_LCD_BITMAP
1443
1433
/* '0'-'3' are ASCII 0x30 to 0x33 */
1444
1434
#define is0123(x) (((x) & 0xfc) == 0x30)
1445
1435
#if !defined(__PCTOOL__) || defined(CHECKWPS)
···
1482
1472
return value;
1483
1473
}
1484
1474
#endif
1485
-
#endif
1486
1475
1487
1476
1488
1477
#ifndef __PCTOOL__
···
1494
1483
void push_current_activity(enum current_activity screen)
1495
1484
{
1496
1485
current_activity[current_activity_top++] = screen;
1497
-
#ifdef HAVE_LCD_BITMAP
1498
1486
FOR_NB_SCREENS(i)
1499
1487
{
1500
1488
skinlist_set_cfg(i, NULL);
1501
1489
skin_update(CUSTOM_STATUSBAR, i, SKIN_REFRESH_ALL);
1502
1490
}
1503
-
#endif
1504
1491
}
1505
1492
1506
1493
void pop_current_activity(void)
1507
1494
{
1508
1495
current_activity_top--;
1509
-
#ifdef HAVE_LCD_BITMAP
1510
1496
FOR_NB_SCREENS(i)
1511
1497
{
1512
1498
skinlist_set_cfg(i, NULL);
1513
1499
skin_update(CUSTOM_STATUSBAR, i, SKIN_REFRESH_ALL);
1514
1500
}
1515
-
#endif
1516
1501
}
1517
1502
enum current_activity get_current_activity(void)
1518
1503
{
-2
apps/misc.h
-2
apps/misc.h
···
147
147
*/
148
148
char *strip_extension(char* buffer, int buffer_size, const char *filename);
149
149
150
-
#ifdef HAVE_LCD_BITMAP
151
150
bool parse_color(enum screen_type screen, char *text, int *value);
152
151
153
152
/* only used in USB HID and set_time screen */
154
153
#if defined(USB_ENABLE_HID) || (CONFIG_RTC != 0)
155
154
int clamp_value_wrap(int value, int max, int min);
156
-
#endif
157
155
#endif
158
156
159
157
enum current_activity {
-6
apps/onplay.c
-6
apps/onplay.c
···
49
49
#include "splash.h"
50
50
#include "yesno.h"
51
51
#include "menus/exported_menus.h"
52
-
#ifdef HAVE_LCD_BITMAP
53
52
#include "icons.h"
54
-
#endif
55
53
#include "sound_menu.h"
56
54
#include "playlist_menu.h"
57
55
#include "playlist_catalog.h"
···
794
792
return action;
795
793
}
796
794
797
-
#ifdef HAVE_LCD_BITMAP
798
795
static void draw_slider(void)
799
796
{
800
797
FOR_NB_SCREENS(i)
···
809
806
screens[i].set_viewport(NULL);
810
807
}
811
808
}
812
-
#else
813
-
#define draw_slider()
814
-
#endif
815
809
816
810
static void clear_display(bool update)
817
811
{
-2
apps/playback.c
-2
apps/playback.c
-2
apps/playlist.c
-2
apps/playlist.c
+1
-10
apps/plugin.c
+1
-10
apps/plugin.c
···
50
50
#include "power.h"
51
51
#endif
52
52
53
-
#ifdef HAVE_LCD_BITMAP
54
53
#include "scrollbar.h"
55
54
#include "peakmeter.h"
56
55
#include "bmp.h"
57
56
#include "bidi.h"
58
-
#endif
59
57
60
58
#ifdef USB_ENABLE_HID
61
59
#include "usbstack/usb_hid.h"
···
301
299
#endif
302
300
303
301
viewport_set_defaults,
304
-
#ifdef HAVE_LCD_BITMAP
305
302
viewportmanager_theme_enable,
306
303
viewportmanager_theme_undo,
307
304
viewport_set_fullscreen,
308
-
#endif
309
305
310
306
#ifdef HAVE_BACKLIGHT
311
307
/* lcd backlight */
···
533
529
534
530
#if (CONFIG_PLATFORM & PLATFORM_HOSTED)
535
531
/* special simulator hooks */
536
-
#if defined(HAVE_LCD_BITMAP) && LCD_DEPTH < 8
532
+
#if LCD_DEPTH < 8
537
533
sim_lcd_ex_init,
538
534
sim_lcd_ex_update_rect,
539
535
#endif
···
780
776
remove_array_ptr,
781
777
round_value_to_list32,
782
778
783
-
#ifdef HAVE_LCD_BITMAP
784
779
read_bmp_file,
785
780
read_bmp_fd,
786
781
#ifdef HAVE_JPEG
···
788
783
read_jpeg_fd,
789
784
#endif
790
785
screen_dump_set_hook,
791
-
#endif
792
786
show_logo,
793
787
794
788
#ifdef HAVE_WHEEL_POSITION
···
927
921
touchscreen_set_mode(global_settings.touch_mode);
928
922
#endif
929
923
930
-
#ifdef HAVE_LCD_BITMAP
931
924
screen_helper_setfont(FONT_UI);
932
925
#if LCD_DEPTH > 1
933
926
#ifdef HAVE_LCD_COLOR
···
939
932
#else /* LCD_DEPTH == 1 */
940
933
lcd_set_drawmode(DRMODE_SOLID);
941
934
#endif /* LCD_DEPTH */
942
-
#endif /* HAVE_LCD_BITMAP */
943
-
944
935
945
936
#ifdef HAVE_REMOTE_LCD
946
937
#if LCD_REMOTE_DEPTH > 1
+3
-9
apps/plugin.h
+3
-9
apps/plugin.h
···
89
89
#include "settings.h"
90
90
#include "timer.h"
91
91
#include "playlist.h"
92
-
#ifdef HAVE_LCD_BITMAP
93
92
#include "screendump.h"
94
93
#include "scrollbar.h"
95
94
#include "jpeg_load.h"
96
95
#include "../recorder/bmp.h"
97
-
#endif
98
96
#include "statusbar.h"
99
97
#include "menu.h"
100
98
#include "rbunicode.h"
···
156
154
#define PLUGIN_MAGIC 0x526F634B /* RocK */
157
155
158
156
/* increase this every time the api struct changes */
159
-
#define PLUGIN_API_VERSION 238
157
+
#define PLUGIN_API_VERSION 239
160
158
161
159
/* update this to latest version if a change to the api struct breaks
162
160
backwards compatibility (and please take the opportunity to sort in any
163
161
new function which are "waiting" at the end of the function table) */
164
-
#define PLUGIN_MIN_API_VERSION 238
162
+
#define PLUGIN_MIN_API_VERSION 239
165
163
166
164
/* plugin return codes */
167
165
/* internal returns start at 0x100 to make exit(1..255) work */
···
331
329
332
330
void (*viewport_set_defaults)(struct viewport *vp,
333
331
const enum screen_type screen);
334
-
#ifdef HAVE_LCD_BITMAP
335
332
void (*viewportmanager_theme_enable)(enum screen_type screen, bool enable,
336
333
struct viewport *viewport);
337
334
void (*viewportmanager_theme_undo)(enum screen_type screen, bool force_redraw);
338
335
void (*viewport_set_fullscreen)(struct viewport *vp,
339
336
const enum screen_type screen);
340
-
#endif
341
337
342
338
#ifdef HAVE_BACKLIGHT
343
339
/* lcd backlight */
···
597
593
598
594
#if (CONFIG_PLATFORM & PLATFORM_HOSTED)
599
595
/* special simulator hooks */
600
-
#if defined(HAVE_LCD_BITMAP) && LCD_DEPTH < 8
596
+
#if LCD_DEPTH < 8
601
597
void (*sim_lcd_ex_init)(unsigned long (*getpixel)(int, int));
602
598
void (*sim_lcd_ex_update_rect)(int x, int y, int width, int height);
603
599
#endif
···
900
896
int count,
901
897
bool signd);
902
898
903
-
#ifdef HAVE_LCD_BITMAP
904
899
int (*read_bmp_file)(const char* filename, struct bitmap *bm, int maxsize,
905
900
int format, const struct custom_format *cformat);
906
901
int (*read_bmp_fd)(int fd, struct bitmap *bm, int maxsize,
···
912
907
int format, const struct custom_format *cformat);
913
908
#endif
914
909
void (*screen_dump_set_hook)(void (*hook)(int fh));
915
-
#endif
916
910
int (*show_logo)(void);
917
911
918
912
#ifdef HAVE_WHEEL_POSITION
-2
apps/plugins/2048.c
-2
apps/plugins/2048.c
+2
-10
apps/plugins/SOURCES
+2
-10
apps/plugins/SOURCES
···
79
79
#endif
80
80
#endif
81
81
82
-
#if PLUGIN_BUFFER_SIZE <= 0x20000 && defined(HAVE_LCD_BITMAP)
82
+
#if PLUGIN_BUFFER_SIZE <= 0x20000
83
83
84
84
#if CONFIG_KEYPAD != SANSA_M200_PAD \
85
85
&& CONFIG_KEYPAD != HM60X_PAD
···
92
92
goban.c
93
93
pictureflow.c
94
94
95
-
#endif /* PLUGIN_BUFFER_SIZE <= 0x20000 && HAVE_LCD_BITMAP */
95
+
#endif /* PLUGIN_BUFFER_SIZE <= 0x20000 */
96
96
97
97
#if defined(IRIVER_H100_SERIES)
98
98
iriver_flash.c
···
105
105
#endif /* PLATFORM_NATIVE */
106
106
107
107
metronome.c
108
-
109
-
#ifdef HAVE_LCD_BITMAP /* Not for the Archos Player */
110
108
111
109
2048.c
112
110
···
173
171
174
172
rocklife.c
175
173
176
-
#endif /* HAVE_LCD_BITMAP */
177
-
178
174
#if LCD_DEPTH > 1 /* non-mono bitmap targets */
179
175
180
176
matrix.c
···
198
194
test_core_jpeg.c
199
195
#endif
200
196
test_disk.c
201
-
#ifdef HAVE_LCD_BITMAP
202
197
test_fps.c
203
198
test_gfx.c
204
199
#if LCD_DEPTH < 4 && !defined(SIMULATOR)
···
208
203
test_grey.c
209
204
test_greylib_bitmap_scale.c
210
205
#endif
211
-
#endif
212
206
test_mem.c
213
-
#ifdef HAVE_LCD_BITMAP
214
207
test_mem_jpeg.c
215
-
#endif
216
208
#ifdef HAVE_LCD_COLOR
217
209
test_resize.c
218
210
#endif
-4
apps/plugins/SOURCES.app_build
-4
apps/plugins/SOURCES.app_build
···
28
28
test_core_jpeg.c
29
29
#endif
30
30
test_disk.c
31
-
#ifdef HAVE_LCD_BITMAP
32
31
#if LCD_DEPTH < 4 && !defined(SIMULATOR)
33
32
test_scanrate.c
34
33
#endif
···
36
35
test_grey.c
37
36
test_greylib_bitmap_scale.c
38
37
#endif
39
-
#endif
40
38
test_mem.c
41
-
#ifdef HAVE_LCD_BITMAP
42
39
test_mem_jpeg.c
43
-
#endif
44
40
#ifdef HAVE_LCD_COLOR
45
41
test_resize.c
46
42
#endif
-5
apps/plugins/SUBDIRS
-5
apps/plugins/SUBDIRS
···
8
8
clock
9
9
#endif
10
10
11
-
/* For all targets with a bitmap display */
12
-
#ifdef HAVE_LCD_BITMAP
13
-
14
11
/* color horizontal-stride LCDs */
15
12
#if defined(HAVE_LCD_COLOR) && \
16
13
(!defined(LCD_STRIDEFORMAT) || (LCD_STRIDEFORMAT != VERTICAL_STRIDE))
···
54
51
zxbox
55
52
#endif
56
53
#endif
57
-
58
-
#endif /* HAVE_LCD_BITMAP */
59
54
60
55
/* For all big enough colour screens, iriver H1x0 and iAudio M5 */
61
56
#if defined(HAVE_LCD_COLOR) && ( (LCD_HEIGHT >= 90 && LCD_WIDTH >=116) \
-3
apps/plugins/SUBDIRS.app_build
-3
apps/plugins/SUBDIRS.app_build
···
8
8
*/
9
9
lua
10
10
lua_scripts
11
-
#ifdef HAVE_LCD_BITMAP
12
11
13
12
#if PLUGIN_BUFFER_SIZE > 0x20000
14
13
fft
···
19
18
#ifdef HAVE_TAGCACHE
20
19
pictureflow
21
20
#endif
22
-
23
-
#endif /* HAVE_LCD_BITMAP */
24
21
25
22
/* For all the swcodec targets */
26
23
#if MEMORYSIZE > 2 /* we need a lot of RAM for instruments */
+1
-16
apps/plugins/battery_bench.c
+1
-16
apps/plugins/battery_bench.c
···
329
329
rb->lcd_clear_display();
330
330
rb->lcd_puts_scroll(0, 0, "Batt.Bench is currently running.");
331
331
rb->lcd_puts_scroll(0, 1, "Press " BATTERY_OFF_TXT " to cancel the test");
332
-
#ifdef HAVE_LCD_BITMAP
333
332
rb->lcd_puts_scroll(0, 2, "Anything else will resume");
334
-
#endif
335
333
if(rb->global_settings->talk_menu)
336
334
rb->talk_id(VOICE_BATTERY_BENCH_IS_ALREADY_RUNNING, true);
337
335
rb->lcd_update();
···
488
486
exit = true;
489
487
break;
490
488
case EV_EXIT:
491
-
#ifdef HAVE_LCD_BITMAP
492
489
rb->splash(HZ, "Exiting battery_bench...");
493
-
#else
494
-
rb->splash(HZ, "bench exit");
495
-
#endif
496
490
exit_reason = "plugin exit";
497
491
exit = true;
498
492
break;
···
516
510
}
517
511
518
512
519
-
#ifdef HAVE_LCD_BITMAP
520
513
typedef void (*plcdfunc)(int x, int y, const unsigned char *str);
521
514
522
515
static void put_centered_str(const char* str, plcdfunc putsxy, int lcd_width, int line)
···
525
518
rb->lcd_getstringsize(str, &strwdt, &strhgt);
526
519
putsxy((lcd_width - strwdt)/2, line*(strhgt), str);
527
520
}
528
-
#endif
529
521
530
522
enum plugin_status plugin_start(const void* parameter)
531
523
{
···
533
525
int button, fd;
534
526
bool on = false;
535
527
start_tick = *rb->current_tick;
536
-
#ifdef HAVE_LCD_BITMAP
537
528
int i;
538
529
const char *msgs[] = { "Battery Benchmark","Check file", BATTERY_LOG,
539
530
"for more info", BATTERY_ON_TXT, BATTERY_OFF_TXT " - quit" };
540
-
#endif
541
531
rb->lcd_clear_display();
542
532
543
-
#ifdef HAVE_LCD_BITMAP
544
533
rb->lcd_clear_display();
545
534
rb->lcd_setfont(FONT_SYSFIXED);
546
535
547
536
for (i = 0; i<(int)(sizeof(msgs)/sizeof(char *)); i++)
548
537
put_centered_str(msgs[i],rb->lcd_putsxy,LCD_WIDTH,i+1);
549
-
#else
550
-
rb->lcd_puts_scroll(0, 0, "Batt.Bench.");
551
-
rb->lcd_puts_scroll(0, 1, "PLAY/STOP");
552
-
#endif
553
538
if(rb->global_settings->talk_menu)
554
539
rb->talk_id(VOICE_BAT_BENCH_KEYS, true);
555
540
rb->lcd_update();
556
-
541
+
557
542
#ifdef HAVE_REMOTE_LCD
558
543
rb->lcd_remote_clear_display();
559
544
put_centered_str(msgs[0],rb->lcd_remote_putsxy,LCD_REMOTE_WIDTH,0);
-3
apps/plugins/bitmaps/mono/SOURCES
-3
apps/plugins/bitmaps/mono/SOURCES
···
1
-
#ifdef HAVE_LCD_BITMAP
2
-
3
1
/* Bubbles */
4
2
#if (LCD_WIDTH == 112) && (LCD_HEIGHT == 64)
5
3
bubbles_bubble.112x64x1.bmp
···
59
57
superdom_boarditems.160x128x1.bmp
60
58
#endif
61
59
62
-
#endif /* HAVE_LCD_BITMAP */
63
60
#if (CONFIG_PLATFORM & PLATFORM_HOSTED) && defined(__APPLE__)
64
61
osx.dummy.bmp
65
62
#endif
-4
apps/plugins/bitmaps/native/SOURCES
-4
apps/plugins/bitmaps/native/SOURCES
-8
apps/plugins/chessclock.c
-8
apps/plugins/chessclock.c
···
448
448
449
449
450
450
/* leave first line blank on bitmap display, for pause icon */
451
-
#ifdef HAVE_LCD_BITMAP
452
451
#define FIRST_LINE 1
453
-
#else
454
-
#define FIRST_LINE 0
455
-
#endif
456
452
457
453
#define MAX_PLAYERS 10
458
454
···
597
593
return PLUGIN_OK;
598
594
}
599
595
600
-
#ifdef HAVE_LCD_BITMAP
601
596
static void show_pause_mode(bool enabled)
602
597
{
603
598
static const char pause_icon[] = {0x00,0x7f,0x7f,0x00,0x7f,0x7f,0x00};
···
611
606
rb->lcd_set_drawmode(DRMODE_SOLID);
612
607
}
613
608
}
614
-
#else
615
-
#define show_pause_mode(enabled) rb->lcd_icon(ICON_PAUSE, enabled)
616
-
#endif
617
609
618
610
static int run_timer(int nr)
619
611
{
-34
apps/plugins/cube.c
-34
apps/plugins/cube.c
···
451
451
#endif
452
452
#endif
453
453
454
-
455
-
#ifdef HAVE_LCD_BITMAP
456
-
457
454
#define DIST (10 * MIN(LCD_HEIGHT, LCD_WIDTH) / 16)
458
455
static int x_off = LCD_WIDTH/2;
459
456
static int y_off = LCD_HEIGHT/2;
···
485
482
#else
486
483
#define ASPECT 256 /* = 1.00 */
487
484
#endif
488
-
489
-
#else /* !LCD_BITMAP */
490
-
491
-
#define MYLCD(fn) pgfx_ ## fn
492
-
#define DIST 9
493
-
static int x_off = 10;
494
-
static int y_off = 7;
495
-
#define ASPECT 300 /* = 1.175 */
496
-
497
-
#endif /* !LCD_BITMAP */
498
485
499
486
struct point_3D {
500
487
long x, y, z;
···
771
758
772
759
(void)(parameter);
773
760
774
-
#ifdef HAVE_LCD_BITMAP
775
761
#if defined(USEGSLIB)
776
762
gbuf = (unsigned char *)rb->plugin_get_buffer(&gbuf_size);
777
763
if (!grey_init(gbuf, gbuf_size, GREY_BUFFERED,
···
794
780
grey_setfont(FONT_SYSFIXED);
795
781
#endif
796
782
rb->lcd_setfont(FONT_SYSFIXED);
797
-
#endif
798
783
799
784
atexit(cleanup);
800
785
while(!quit)
···
808
793
redraw = false;
809
794
}
810
795
811
-
#ifdef HAVE_LCD_BITMAP
812
796
if (t_disp > 0)
813
797
{
814
798
char buffer[30];
···
821
805
if (t_disp == 0)
822
806
redraw = true;
823
807
}
824
-
#else
825
-
if (t_disp > 0)
826
-
{
827
-
if (t_disp == DISP_TIME)
828
-
{
829
-
rb->lcd_puts(5, 0, axes[curr].label);
830
-
rb->lcd_putsf(5, 1, "%d %c",
831
-
paused ? axes[curr].angle : axes[curr].speed,
832
-
highspeed ? 'H' : ' ');
833
-
}
834
-
t_disp--;
835
-
if (t_disp == 0)
836
-
{
837
-
rb->lcd_clear_display();
838
-
pgfx_display(0, 0);
839
-
}
840
-
}
841
-
#endif
842
808
#ifdef USEGSLIB
843
809
if (mode_switch)
844
810
{
-2
apps/plugins/disktidy.c
-2
apps/plugins/disktidy.c
···
343
343
rb->lcd_clear_display();
344
344
rb->lcd_puts(0, 0, "Working ...");
345
345
rb->lcd_puts(0, 1, name);
346
-
#ifdef HAVE_LCD_BITMAP
347
346
rb->lcd_putsf(0, 2, "Cleaned up %d items",
348
347
run_stats.files_removed + run_stats.dirs_removed);
349
-
#endif
350
348
rb->lcd_update();
351
349
}
352
350
+1
-6
apps/plugins/flipit.c
+1
-6
apps/plugins/flipit.c
···
534
534
static int toggle[20];
535
535
static int cursor_pos, moves;
536
536
537
-
#ifdef HAVE_LCD_BITMAP
538
-
539
537
#include "pluginbitmaps/flipit_cursor.h"
540
538
#include "pluginbitmaps/flipit_tokens.h"
541
539
···
594
592
rb->lcd_putsxy( (LCD_WIDTH - rb->lcd_getstringsize(s, NULL, NULL)) / 2,
595
593
GRID_TOP + 4*(TK_HEIGHT+TK_SPACE) + 2, s );
596
594
}
597
-
598
-
#endif /* LCD */
599
595
600
596
/* clear the cursor where it is */
601
597
static inline void clear_cursor(void)
···
829
825
830
826
rb->splash(HZ, "FlipIt!");
831
827
832
-
#ifdef HAVE_LCD_BITMAP
833
828
/* print instructions */
834
829
rb->lcd_clear_display();
835
830
rb->lcd_setfont(FONT_SYSFIXED);
···
909
904
#endif
910
905
911
906
rb->lcd_update();
912
-
#endif
907
+
913
908
rb->button_get_w_tmo(HZ*3);
914
909
915
910
rb->lcd_clear_display();
+2
-2
apps/plugins/greyscale.c
+2
-2
apps/plugins/greyscale.c
···
24
24
#include "plugin.h"
25
25
#include "lib/helper.h"
26
26
27
-
#if defined(HAVE_LCD_BITMAP) && (LCD_DEPTH < 4)
27
+
#if (LCD_DEPTH < 4)
28
28
#include "lib/grey.h"
29
29
30
30
···
372
372
return main();
373
373
}
374
374
375
-
#endif /* #ifdef HAVE_LCD_BITMAP */
375
+
#endif /* #if LCD_DEPTH < 4 */
376
376
-2
apps/plugins/jackpot.c
-2
apps/plugins/jackpot.c
···
30
30
#define NB_PICTURES 9
31
31
#define NB_SLOTS 3
32
32
33
-
#ifdef HAVE_LCD_BITMAP
34
33
#define PICTURE_HEIGHT (BMPHEIGHT_jackpot_slots/(NB_PICTURES+1))
35
34
#if NB_SCREENS==1
36
35
#define PICTURE_ROTATION_STEPS PICTURE_HEIGHT
···
55
54
};
56
55
57
56
#define SLEEP_TIME (HZ/200)
58
-
#endif /* HAVE_LCD_BITMAP */
59
57
60
58
struct jackpot
61
59
{
+2
-6
apps/plugins/lib/SOURCES
+2
-6
apps/plugins/lib/SOURCES
···
13
13
strncpy.c
14
14
stdio_compat.c
15
15
16
-
#if defined(HAVE_LCD_BITMAP) && (LCD_DEPTH < 4)
16
+
#if (LCD_DEPTH < 4)
17
17
grey_core.c
18
18
grey_draw.c
19
19
grey_parm.c
···
23
23
grey_coldfire.S
24
24
#endif
25
25
26
-
#endif /* HAVE_LCD_BITMAP && LCD_DEPTH < 4 */
26
+
#endif /* LCD_DEPTH < 4 */
27
27
28
28
#if (CONFIG_PLATFORM & PLATFORM_NATIVE)
29
29
overlay.c
···
32
32
#ifdef RB_PROFILE
33
33
profile_plugin.c
34
34
#endif
35
-
36
-
#ifdef HAVE_LCD_BITMAP
37
35
38
36
#ifdef CPU_ARM
39
37
pluginlib_jpeg_idct_arm.S
···
64
62
#endif
65
63
66
64
kbd_helper.c
67
-
68
-
#endif /* HAVE_LCD_BITMAP */
69
65
70
66
#ifdef HAVE_TOUCHSCREEN
71
67
pluginlib_touchscreen.c
-4
apps/plugins/lib/checkbox.h
-4
apps/plugins/lib/checkbox.h
-8
apps/plugins/lib/display_text.c
-8
apps/plugins/lib/display_text.c
···
39
39
bool display_text(unsigned short words, char** text, struct style_text* style,
40
40
struct viewport* vp_text, bool wait_key)
41
41
{
42
-
#ifdef HAVE_LCD_BITMAP
43
42
int prev_drawmode;
44
-
#endif
45
43
#ifdef HAVE_LCD_COLOR
46
44
int standard_fgcolor;
47
45
#endif
···
55
53
vp_height = vp_text->height;
56
54
}
57
55
rb->screens[SCREEN_MAIN]->set_viewport(vp_text);
58
-
#ifdef HAVE_LCD_BITMAP
59
56
prev_drawmode = rb->lcd_get_drawmode();
60
57
rb->lcd_set_drawmode(DRMODE_SOLID);
61
-
#endif
62
58
#ifdef HAVE_LCD_COLOR
63
59
standard_fgcolor = rb->lcd_get_foreground();
64
60
#endif
···
121
117
#endif
122
118
rb->lcd_putsxy(x, y, text[i]);
123
119
/* underline the word */
124
-
#ifdef HAVE_LCD_BITMAP
125
120
if (style[style_index].flags&TEXT_UNDERLINE) {
126
121
rb->lcd_hline(x, x+width, y+height-1);
127
122
}
128
-
#endif
129
123
#ifdef HAVE_LCD_COLOR
130
124
rb->lcd_set_foreground(standard_fgcolor);
131
125
#endif
···
134
128
x += width + space_w;
135
129
}
136
130
rb->screens[SCREEN_MAIN]->update_viewport();
137
-
#ifdef HAVE_LCD_BITMAP
138
131
rb->lcd_set_drawmode(prev_drawmode);
139
-
#endif
140
132
if (wait_key)
141
133
{
142
134
if (wait_key_press())
+2
-2
apps/plugins/lib/grey.h
+2
-2
apps/plugins/lib/grey.h
···
29
29
30
30
#include "plugin.h"
31
31
32
-
#if defined(HAVE_LCD_BITMAP) && (LCD_DEPTH < 4)
32
+
#if (LCD_DEPTH < 4)
33
33
34
34
/* The greyscale lib uses 8 bit brightness values natively on input. */
35
35
#define GREY_BRIGHTNESS(y) (y)
···
201
201
/* Global variable, defined in the plugin */
202
202
extern struct _grey_info _grey_info;
203
203
204
-
#endif /* HAVE_LCD_BITMAP && (LCD_DEPTH < 4) */
204
+
#endif /* (LCD_DEPTH < 4) */
205
205
#endif /* __GREY_H__ */
-35
apps/plugins/lib/highscore.c
-35
apps/plugins/lib/highscore.c
···
119
119
return (num_scores > 0) && (score > scores[num_scores-1].score);
120
120
}
121
121
122
-
#ifdef HAVE_LCD_BITMAP
123
122
#define MARGIN 5
124
123
void highscore_show(int position, struct highscore *scores, int num_scores,
125
124
bool show_level)
···
179
178
rb->lcd_set_foreground(fgcolor);
180
179
#endif
181
180
}
182
-
#else
183
-
struct scoreinfo {
184
-
struct highscore *scores;
185
-
int position;
186
-
bool show_level;
187
-
};
188
-
static const char* get_score(int selected, void * data,
189
-
char * buffer, size_t buffer_len)
190
-
{
191
-
struct scoreinfo *scoreinfo = (struct scoreinfo *) data;
192
-
int len;
193
-
len = rb->snprintf(buffer, buffer_len, "%c%d) %4d",
194
-
(scoreinfo->position == selected?'*':' '),
195
-
selected+1, scoreinfo->scores[selected].score);
196
-
197
-
if (scoreinfo->show_level)
198
-
rb->snprintf(buffer + len, buffer_len - len, " %d",
199
-
scoreinfo->scores[selected].level);
200
-
return buffer;
201
-
}
202
-
203
-
void highscore_show(int position, struct highscore *scores, int num_scores,
204
-
bool show_level)
205
-
{
206
-
struct simplelist_info info;
207
-
struct scoreinfo scoreinfo = {scores, position, show_level};
208
-
rb->simplelist_info_init(&info, "High Scores", num_scores, &scoreinfo);
209
-
if (position >= 0)
210
-
info.selection = position;
211
-
info.hide_selection = true;
212
-
info.get_name = get_score;
213
-
rb->simplelist_show_list(&info);
214
-
}
215
-
#endif /* HAVE_LCD_BITMAP */
+3
-25
apps/plugins/lib/mylcd.h
+3
-25
apps/plugins/lib/mylcd.h
···
35
35
* lib/grey.h should be included before including this
36
36
* header. For bitmap LCD's, defaults to rb->lcd_XXXX otherwise.
37
37
*/
38
-
#if defined (HAVE_LCD_BITMAP) && (LCD_DEPTH < 4) && defined(__GREY_H__)
38
+
#if (LCD_DEPTH < 4) && defined(__GREY_H__)
39
39
#define MYLCD_CFG_GREYLIB /* using greylib */
40
40
#define mylcd_(fn) grey_##fn
41
41
#define myxlcd_(fn) grey_##fn
···
51
51
#define MYLCD_DEFAULT_FG GREY_BLACK
52
52
#define MYLCD_DEFAULT_BG GREY_WHITE
53
53
54
-
#elif defined (HAVE_LCD_BITMAP)
54
+
#else
55
+
55
56
#define MYLCD_CFG_RB_XLCD /* using standard (X)LCD routines */
56
57
#define mylcd_(fn) rb->lcd_##fn
57
58
#define myxlcd_(fn) xlcd_##fn
···
67
68
#define MYLCD_DEFAULT_FG LCD_DEFAULT_FG
68
69
#define MYLCD_DEFAULT_BG LCD_DEFAULT_BG
69
70
70
-
#else
71
-
#error Configuration not supported! Did you forget to include the correct lib header?
72
71
#endif /* end LCD type selection */
73
72
74
73
/* Update functions */
75
74
#define mylcd_update mylcd_(update)
76
-
#ifdef HAVE_LCD_BITMAP
77
75
#define mylcd_update_rect mylcd_(update_rect)
78
-
#else
79
-
static inline void mylcd_update_rect(int x, int y, int w, int h)
80
-
{ (void)x; (void)y; (void)w; (void)h; pgfx_update(); }
81
-
#endif /* HAVE_LCD_BITMAP */
82
76
83
77
/* Update functions - unbuffered : special handling for these
84
78
* It is desirable to still evaluate arguments even if there will
···
104
98
#define mylcd_set_drawmode mylcd_(set_drawmode)
105
99
#define mylcd_get_drawmode mylcd_(get_drawmode)
106
100
107
-
#ifdef HAVE_LCD_BITMAP
108
101
#define mylcd_set_foreground mylcd_(set_foreground)
109
102
#define mylcd_get_foreground mylcd_(get_foreground)
110
103
#define mylcd_set_background mylcd_(set_background)
···
112
105
#define mylcd_set_drawinfo mylcd_(set_drawinfo)
113
106
#define mylcd_setfont mylcd_(setfont)
114
107
#define mylcd_getstringsize mylcd_(getstringsize)
115
-
#endif /* HAVE_LCD_BITMAP */
116
108
117
109
/* Whole display */
118
110
#define mylcd_clear_display mylcd_(clear_display)
···
131
123
132
124
/* Filled Primitives */
133
125
#define mylcd_fillrect mylcd_(fillrect)
134
-
#ifdef HAVE_LCD_BITMAP
135
126
#define mylcd_filltriangle myxlcd_(filltriangle)
136
-
#endif /* HAVE_LCD_BITMAP */
137
127
138
128
/* Bitmaps */
139
129
#define mylcd_mono_bitmap_part mylcd_(mono_bitmap_part)
140
130
#define mylcd_mono_bitmap mylcd_(mono_bitmap)
141
131
142
-
#ifdef HAVE_LCD_BITMAP
143
132
#define mylcd_gray_bitmap_part myxlcd_(gray_bitmap_part)
144
133
#define mylcd_gray_bitmap myxlcd_(gray_bitmap)
145
134
#if 0 /* possible, but not implemented in greylib */
146
135
#define mylcd_color_bitmap_part myxlcd_(color_bitmap_part)
147
136
#define mylcd_color_bitmap myxlcd_(color_bitmap)
148
137
#endif
149
-
#endif /* HAVE_LCD_BITMAP */
150
138
151
139
/* Bitmaps - unbuffered */
152
-
#ifdef HAVE_LCD_BITMAP
153
140
#define mylcd_ub_gray_bitmap_part myxlcd_ub_(gray_bitmap_part)
154
141
#define mylcd_ub_gray_bitmap myxlcd_ub_(gray_bitmap)
155
-
#endif /* HAVE_LCD_BITMAP */
156
142
157
143
/* Text */
158
144
/* lcd_putsxyofs is static'ed in the core for now on color */
159
-
#ifdef HAVE_LCD_BITMAP
160
145
#define mylcd_putsxyofs mylcd_(putsxyofs)
161
146
#define mylcd_putsxy mylcd_(putsxy)
162
-
#endif /* HAVE_LCD_BITMAP */
163
147
164
148
/* Scrolling */
165
-
#ifdef HAVE_LCD_BITMAP
166
149
#define mylcd_scroll_left myxlcd_(scroll_left)
167
150
#define mylcd_scroll_right myxlcd_(scroll_right)
168
151
#define mylcd_scroll_up myxlcd_(scroll_up)
169
152
#define mylcd_scroll_down myxlcd_(scroll_down)
170
-
#endif /* HAVE_LCD_BITMAP */
171
153
172
154
/* Scrolling - unbuffered */
173
-
#ifdef HAVE_LCD_BITMAP
174
155
#define mylcd_ub_scroll_left myxlcd_ub_(scroll_left)
175
156
#define mylcd_ub_scroll_right myxlcd_ub_(scroll_right)
176
157
#define mylcd_ub_scroll_up myxlcd_ub_(scroll_up)
177
158
#define mylcd_ub_scroll_down myxlcd_ub_(scroll_down)
178
-
#endif /* HAVE_LCD_BITMAP */
179
159
180
160
/* Viewports */
181
-
#ifdef HAVE_LCD_BITMAP
182
161
#define mylcd_clear_viewport mylcd_(clear_viewport)
183
162
#define mylcd_set_viewport mylcd_(set_viewport)
184
163
#define mylcd_viewport_set_fullscreen mylcd_viewport_(set_fullscreen)
185
-
#endif /* HAVE_LCD_BITMAP */
186
164
187
165
#endif /* MYLCD_H */
+1
-1
apps/plugins/lib/pluginlib_bmp.h
+1
-1
apps/plugins/lib/pluginlib_bmp.h
-20
apps/plugins/lib/simple_viewer.c
-20
apps/plugins/lib/simple_viewer.c
···
27
27
28
28
29
29
struct view_info {
30
-
#ifdef HAVE_LCD_BITMAP
31
30
struct font* pf;
32
31
struct viewport scrollbar_vp; /* viewport for scrollbar */
33
-
#endif
34
32
struct viewport vp;
35
33
const char *title;
36
34
const char *text; /* displayed text */
···
89
87
{
90
88
const char *ptr = info->text;
91
89
int i = 0;
92
-
#ifdef HAVE_LCD_BITMAP
93
90
bool scrollbar = false;
94
-
#endif
95
91
96
92
while (*ptr)
97
93
{
98
94
ptr = get_next_line(ptr, info);
99
95
i++;
100
-
#ifdef HAVE_LCD_BITMAP
101
96
if (!scrollbar && i > info->display_lines)
102
97
{
103
98
ptr = info->text;
···
111
106
info->scrollbar_vp.x = info->vp.width;
112
107
scrollbar = true;
113
108
}
114
-
#endif
115
109
}
116
110
info->line_count = i;
117
111
}
···
144
138
const char *title, const char *text)
145
139
{
146
140
rb->viewport_set_defaults(&info->vp, SCREEN_MAIN);
147
-
#ifdef HAVE_LCD_BITMAP
148
141
info->pf = rb->font_get(FONT_UI);
149
142
info->display_lines = info->vp.height / info->pf->height;
150
-
#else
151
-
info->display_lines = info->vp.height;
152
-
#endif
153
143
154
144
info->title = title;
155
145
info->text = text;
···
157
147
info->line = 0;
158
148
info->start = 0;
159
149
160
-
#ifdef HAVE_LCD_BITMAP
161
150
/* no title for small screens. */
162
151
if (info->display_lines < 4)
163
152
{
···
169
158
info->vp.y += info->pf->height;
170
159
info->vp.height -= info->pf->height;
171
160
}
172
-
#endif
173
161
174
162
calc_line_count(info);
175
163
return 0;
···
177
165
178
166
static void draw_text(struct view_info *info)
179
167
{
180
-
#ifdef HAVE_LCD_BITMAP
181
168
#define OUTPUT_SIZE LCD_WIDTH+1
182
-
#else
183
-
#define OUTPUT_SIZE LCD_WIDTH*3+1
184
-
#endif
185
169
static char output[OUTPUT_SIZE];
186
170
const char *text, *ptr;
187
171
int max_show, line;
···
190
174
/* clear screen */
191
175
display->clear_display();
192
176
193
-
#ifdef HAVE_LCD_BITMAP
194
177
/* display title. */
195
178
if(info->title)
196
179
{
197
180
display->set_viewport(NULL);
198
181
display->puts(0, 0, info->title);
199
182
}
200
-
#endif
201
183
202
184
max_show = MIN(info->line_count - info->line, info->display_lines);
203
185
text = info->text + info->start;
···
215
197
display->puts(0, line, output);
216
198
text = ptr;
217
199
}
218
-
#ifdef HAVE_LCD_BITMAP
219
200
if (info->line_count > info->display_lines)
220
201
{
221
202
display->set_viewport(&info->scrollbar_vp);
···
224
205
info->line_count, info->line, info->line + max_show,
225
206
VERTICAL);
226
207
}
227
-
#endif
228
208
229
209
display->set_viewport(NULL);
230
210
display->update();
-3
apps/plugins/lib/xlcd.h
-3
apps/plugins/lib/xlcd.h
···
26
26
27
27
#include "plugin.h"
28
28
29
-
#ifdef HAVE_LCD_BITMAP
30
-
31
29
void xlcd_filltriangle(int x1, int y1, int x2, int y2, int x3, int y3);
32
30
void xlcd_filltriangle_screen(struct screen* display,
33
31
int x1, int y1, int x2, int y2, int x3, int y3);
···
54
52
void xlcd_scroll_up(int count);
55
53
void xlcd_scroll_down(int count);
56
54
57
-
#endif /* HAVE_LCD_BITMAP */
58
55
#endif /* __XLCD_H__ */
59
56
-3
apps/plugins/lib/xlcd_core.c
-3
apps/plugins/lib/xlcd_core.c
-3
apps/plugins/lib/xlcd_draw.c
-3
apps/plugins/lib/xlcd_draw.c
-30
apps/plugins/logo.c
-30
apps/plugins/logo.c
···
29
29
#endif
30
30
};
31
31
32
-
#ifdef HAVE_LCD_BITMAP
33
32
#define DISPLAY_WIDTH LCD_WIDTH
34
33
#define DISPLAY_HEIGHT LCD_HEIGHT
35
34
#define RAND_SCALE 5
···
48
47
#define LOGO_WIDTH BMPWIDTH_rockboxlogo
49
48
#define LOGO_HEIGHT BMPHEIGHT_rockboxlogo
50
49
51
-
#else /* !LCD_BITMAP */
52
-
#define DISPLAY_WIDTH 55
53
-
#define DISPLAY_HEIGHT 14
54
-
#define RAND_SCALE 2
55
-
#define LOGO_WIDTH 16
56
-
#define LOGO_HEIGHT 7
57
-
#define LOGO rockbox16x7
58
-
const unsigned char rockbox16x7[] = {
59
-
0x47, 0x18, 0xa6, 0xd8, 0x66, 0xde, 0xb7, 0x9b,
60
-
0x76, 0xdb, 0x26, 0xdb, 0x66, 0xde,
61
-
};
62
-
#endif /* !LCD_BITMAP */
63
-
64
50
/* We use PLA */
65
51
#define LP_QUIT PLA_EXIT
66
52
#define LP_QUIT2 PLA_CANCEL
···
88
74
dy = rb->rand()%(2*RAND_SCALE+1) - RAND_SCALE;
89
75
90
76
while (1) {
91
-
#ifdef HAVE_LCD_BITMAP
92
77
rb->lcd_clear_display();
93
78
rb->lcd_bitmap((const fb_data*)LOGO, x, y, LOGO_WIDTH, LOGO_HEIGHT);
94
79
#ifdef REMOTE_LOGO
···
98
83
(y * (REMOTE_HEIGHT - REMOTE_LOGO_HEIGHT)) / (DISPLAY_HEIGHT - LOGO_HEIGHT),
99
84
REMOTE_LOGO_WIDTH, REMOTE_LOGO_HEIGHT);
100
85
#endif
101
-
#else
102
-
pgfx_clear_display();
103
-
pgfx_mono_bitmap(LOGO, x % 5, y, LOGO_WIDTH, LOGO_HEIGHT);
104
-
cpos = x / 5;
105
-
#endif
106
-
107
86
x += dx;
108
87
if (x < 0) {
109
88
dx = -dx;
···
124
103
y = DISPLAY_HEIGHT - LOGO_HEIGHT;
125
104
}
126
105
127
-
#ifdef HAVE_LCD_BITMAP
128
106
rb->lcd_update();
129
107
#ifdef REMOTE_LOGO
130
108
rb->lcd_remote_update();
131
-
#endif
132
-
#else
133
-
if (cpos != old_cpos) {
134
-
rb->lcd_clear_display();
135
-
pgfx_display(cpos, 0);
136
-
old_cpos = cpos;
137
-
}
138
-
pgfx_update();
139
109
#endif
140
110
rb->sleep(HZ/timer);
141
111
+4
-69
apps/plugins/lrcplayer.c
+4
-69
apps/plugins/lrcplayer.c
···
71
71
unsigned active_color;
72
72
unsigned inactive_color;
73
73
#endif
74
-
#ifdef HAVE_LCD_BITMAP
75
74
bool wrap;
76
75
bool wipe;
77
76
bool active_one_line;
78
77
int align; /* 0: left, 1: center, 2: right */
79
78
bool statusbar_on;
80
79
bool display_title;
81
-
#endif
82
80
bool display_time;
83
81
bool backlight_on;
84
82
···
118
116
bool loaded_lrc;
119
117
bool changed_lrc;
120
118
bool too_many_lines; /* true if nlrcline >= max_lrclines after calc pos */
121
-
#ifdef HAVE_LCD_BITMAP
122
119
bool wipe; /* false if lyrics is unsynched */
123
-
#endif
124
120
} current;
125
121
static char temp_buf[MAX(MAX_LINE_LEN,MAX_PATH)];
126
-
#ifdef HAVE_LCD_BITMAP
127
122
static int uifont = -1;
128
123
static int font_ui_height = 1;
129
124
static struct viewport vp_info[NB_SCREENS];
130
-
#endif
131
125
static struct viewport vp_lyrics[NB_SCREENS];
132
126
133
127
#define AUDIO_PAUSE (current.audio_status & AUDIO_STATUS_PAUSE)
···
221
215
{
222
216
/* draw cursor */
223
217
buffer[p_end-1] = 0;
224
-
#ifdef HAVE_LCD_BITMAP
225
218
rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
226
219
rb->lcd_putsxy(x, y*(1+LST_OFF_Y), &buffer[p_start]);
227
220
rb->lcd_set_drawmode(DRMODE_SOLID);
228
-
#endif
229
221
}
230
222
rb->lcd_update();
231
223
int button = pluginlib_getaction(TIMEOUT_BLOCK, lst_contexts, ARRAYLEN(lst_contexts));
···
394
386
/* find start of next line */
395
387
static const char *lrc_skip_space(const char *str)
396
388
{
397
-
#ifdef HAVE_LCD_BITMAP
398
389
if (prefs.wrap)
399
390
{
400
391
while (*str && *str != '\n' && isspace(*str))
401
392
str++;
402
393
}
403
-
#endif
404
394
if (*str == '\n')
405
395
str++;
406
396
return str;
407
397
}
408
398
409
-
#ifdef HAVE_LCD_BITMAP
410
399
static bool isbrchr(const unsigned char *str, int len)
411
400
{
412
401
const unsigned char *p = "!,-.:;? 、。！，．：；？―";
···
422
411
}
423
412
return false;
424
413
}
425
-
#endif
426
414
427
415
/* calculate how many lines is needed to display and store it.
428
416
* create cache if there is enough space in lrc_buffer. */
···
431
419
struct lrc_brpos *lrc_brpos;
432
420
struct lrc_word *lrc_word;
433
421
int nlrcbrpos = 0, max_lrcbrpos;
434
-
#ifdef HAVE_LCD_BITMAP
435
422
uifont = rb->screens[0]->getuifont();
436
423
struct font* pf = rb->font_get(uifont);
437
424
unsigned short ch;
438
-
#endif
439
425
struct snap {
440
426
int count, width;
441
427
int nword;
···
1559
1545
str = "No lyrics";
1560
1546
}
1561
1547
1562
-
#ifdef HAVE_LCD_BITMAP
1563
1548
const char *info = NULL;
1564
1549
1565
1550
if (AUDIO_PLAY && prefs.display_title)
···
1605
1590
display->update_viewport();
1606
1591
display->set_viewport(NULL);
1607
1592
}
1608
-
#else
1609
-
/* there is no place to display title or artist. */
1610
-
rb->lcd_clear_display();
1611
-
if (str)
1612
-
rb->lcd_puts_scroll(0, 0, str);
1613
-
rb->lcd_update();
1614
-
#endif /* HAVE_LCD_BITMAP */
1615
1593
}
1616
1594
1617
1595
static void display_time(void)
···
1619
1597
rb->snprintf(temp_buf, MAX_LINE_LEN, "%ld:%02ld/%ld:%02ld",
1620
1598
current.elapsed/60000, (current.elapsed/1000)%60,
1621
1599
current.length/60000, (current.length)/1000%60);
1622
-
#ifdef HAVE_LCD_BITMAP
1623
1600
int y = (prefs.display_title? font_ui_height:0);
1624
1601
FOR_NB_SCREENS(i)
1625
1602
{
···
1634
1611
display->setfont(uifont);
1635
1612
display->set_viewport(NULL);
1636
1613
}
1637
-
#else
1638
-
rb->lcd_puts(0, 0, temp_buf);
1639
-
rb->lcd_update();
1640
-
#endif /* HAVE_LCD_BITMAP */
1641
1614
}
1642
1615
1643
1616
/*******************************
1644
1617
* Display lyrics
1645
1618
*******************************/
1646
-
#ifdef HAVE_LCD_BITMAP
1647
1619
static inline void set_to_default(struct screen *display)
1648
1620
{
1649
1621
#if (LCD_DEPTH > 1)
···
1817
1789
set_to_default(display);
1818
1790
return ypos;
1819
1791
}
1820
-
#endif /* HAVE_LCD_BITMAP */
1821
1792
1822
1793
static void display_lrcs(void)
1823
1794
{
···
1848
1819
/* display current line at the center of the viewport */
1849
1820
display->set_viewport(&vp_lyrics[i]);
1850
1821
display->clear_viewport();
1851
-
#ifdef HAVE_LCD_BITMAP
1822
+
1852
1823
struct lrc_line *lrc_line;
1853
1824
int y, ypos = 0, nblines = vp_lyrics[i].height/font_ui_height;
1854
1825
y = (nblines-1)/2;
···
1895
1866
}
1896
1867
if (!lrc_line && ypos < vp_lyrics[i].height)
1897
1868
display->putsxy(0, ypos, "[end]");
1898
-
#endif /* HAVE_LCD_BITMAP */
1869
+
1899
1870
display->update_viewport();
1900
1871
display->set_viewport(NULL);
1901
1872
}
···
2191
2162
{ TYPE_INT, 0, 0xffffff, { .int_p = &prefs.inactive_color },
2192
2163
"inactive color", NULL },
2193
2164
#endif
2194
-
#ifdef HAVE_LCD_BITMAP
2195
2165
{ TYPE_BOOL, 0, 1, { .bool_p = &prefs.wrap }, "wrap", NULL },
2196
2166
{ TYPE_BOOL, 0, 1, { .bool_p = &prefs.wipe }, "wipe", NULL },
2197
2167
{ TYPE_BOOL, 0, 1, { .bool_p = &prefs.active_one_line },
···
2201
2171
"statusbar on", NULL },
2202
2172
{ TYPE_BOOL, 0, 1, { .bool_p = &prefs.display_title },
2203
2173
"display title", NULL },
2204
-
#endif
2205
2174
{ TYPE_BOOL, 0, 1, { .bool_p = &prefs.display_time },
2206
2175
"display time", NULL },
2207
2176
{ TYPE_BOOL, 0, 1, { .bool_p = &prefs.backlight_on },
···
2223
2192
prefs.active_color = rb->lcd_get_foreground();
2224
2193
prefs.inactive_color = LCD_LIGHTGRAY;
2225
2194
#endif
2226
-
#ifdef HAVE_LCD_BITMAP
2227
2195
prefs.wrap = true;
2228
2196
prefs.wipe = true;
2229
2197
prefs.active_one_line = false;
2230
2198
prefs.align = 1; /* center */
2231
2199
prefs.statusbar_on = false;
2232
2200
prefs.display_title = true;
2233
-
#endif
2234
2201
prefs.display_time = true;
2235
2202
prefs.backlight_on = false;
2236
2203
#ifdef LRC_SUPPORT_ID3
···
2252
2219
static bool lrc_theme_menu(void)
2253
2220
{
2254
2221
enum {
2255
-
#ifdef HAVE_LCD_BITMAP
2256
2222
LRC_MENU_STATUSBAR,
2257
2223
LRC_MENU_DISP_TITLE,
2258
-
#endif
2259
2224
LRC_MENU_DISP_TIME,
2260
2225
#ifdef HAVE_LCD_COLOR
2261
2226
LRC_MENU_INACTIVE_COLOR,
···
2267
2232
bool exit = false, usb = false;
2268
2233
2269
2234
MENUITEM_STRINGLIST(menu, "Theme Settings", NULL,
2270
-
#ifdef HAVE_LCD_BITMAP
2271
2235
"Show Statusbar", "Display Title",
2272
-
#endif
2273
2236
"Display Time",
2274
2237
#ifdef HAVE_LCD_COLOR
2275
2238
"Inactive Colour",
···
2280
2243
{
2281
2244
switch (rb->do_menu(&menu, &selected, NULL, false))
2282
2245
{
2283
-
#ifdef HAVE_LCD_BITMAP
2284
2246
case LRC_MENU_STATUSBAR:
2285
2247
usb = rb->set_bool("Show Statusbar", &prefs.statusbar_on);
2286
2248
break;
2287
2249
case LRC_MENU_DISP_TITLE:
2288
2250
usb = rb->set_bool("Display Title", &prefs.display_title);
2289
2251
break;
2290
-
#endif
2291
2252
case LRC_MENU_DISP_TIME:
2292
2253
usb = rb->set_bool("Display Time", &prefs.display_time);
2293
2254
break;
···
2312
2273
return usb;
2313
2274
}
2314
2275
2315
-
#ifdef HAVE_LCD_BITMAP
2316
2276
static bool lrc_display_menu(void)
2317
2277
{
2318
2278
enum {
···
2362
2322
2363
2323
return usb;
2364
2324
}
2365
-
#endif /* HAVE_LCD_BITMAP */
2366
2325
2367
2326
static bool lrc_lyrics_menu(void)
2368
2327
{
···
2489
2448
{
2490
2449
enum {
2491
2450
LRC_MENU_THEME,
2492
-
#ifdef HAVE_LCD_BITMAP
2493
2451
LRC_MENU_DISPLAY,
2494
-
#endif
2495
2452
LRC_MENU_LYRICS,
2496
2453
LRC_MENU_PLAYBACK,
2497
2454
#ifdef LRC_DEBUG
···
2504
2461
2505
2462
MENUITEM_STRINGLIST(menu, "Lrcplayer Menu", NULL,
2506
2463
"Theme Settings",
2507
-
#ifdef HAVE_LCD_BITMAP
2508
2464
"Display Settings",
2509
-
#endif
2510
2465
"Lyrics Settings",
2511
2466
"Playback Control",
2512
2467
#ifdef LRC_DEBUG
···
2524
2479
case LRC_MENU_THEME:
2525
2480
usb = lrc_theme_menu();
2526
2481
break;
2527
-
#ifdef HAVE_LCD_BITMAP
2528
2482
case LRC_MENU_DISPLAY:
2529
2483
usb = lrc_display_menu();
2530
2484
break;
2531
-
#endif
2532
2485
case LRC_MENU_LYRICS:
2533
2486
usb = lrc_lyrics_menu();
2534
2487
break;
···
2720
2673
long id3_timeout = 0;
2721
2674
bool update_display_state = true;
2722
2675
2723
-
#ifdef HAVE_LCD_BITMAP
2724
2676
/* y offset of vp_lyrics */
2725
2677
int h = (prefs.display_title?font_ui_height:0)+
2726
2678
(prefs.display_time?SYSFONT_HEIGHT*2:0);
2727
2679
2728
-
#endif
2729
2680
2730
2681
FOR_NB_SCREENS(i)
2731
2682
{
2732
-
#ifdef HAVE_LCD_BITMAP
2733
2683
rb->viewportmanager_theme_enable(i, prefs.statusbar_on, &vp_info[i]);
2734
2684
vp_lyrics[i] = vp_info[i];
2735
2685
vp_lyrics[i].flags &= ~VP_FLAG_ALIGNMENT_MASK;
2736
2686
vp_lyrics[i].y += h;
2737
2687
vp_lyrics[i].height -= h;
2738
-
#else
2739
-
rb->viewport_set_defaults(&vp_lyrics[i], i);
2740
-
if (prefs.display_time)
2741
-
{
2742
-
vp_lyrics[i].y += 1; /* time */
2743
-
vp_lyrics[i].height -= 1;
2744
-
}
2745
-
#endif
2746
2688
}
2747
2689
2748
2690
if (prefs.backlight_on)
2749
2691
backlight_ignore_timeout();
2750
2692
2751
-
#ifdef HAVE_LCD_BITMAP
2752
-
/* in case settings that may affect break position
2693
+
/* in case settings that may affect break position
2753
2694
* are changed (statusbar_on and wrap). */
2754
2695
if (!current.too_many_lines)
2755
2696
calc_brpos(NULL, 0);
2756
-
#endif
2757
2697
2758
2698
while (ret == LRC_GOTO_MAIN)
2759
2699
{
···
2819
2759
}
2820
2760
if (update_display_state)
2821
2761
{
2822
-
#ifdef HAVE_LCD_BITMAP
2823
2762
if (current.type == TXT || current.type == ID3_USLT)
2824
2763
current.wipe = false;
2825
2764
else
2826
2765
current.wipe = prefs.wipe;
2827
-
#endif
2828
2766
display_state();
2829
2767
update_display_state = false;
2830
2768
}
···
2839
2777
ret = handle_button();
2840
2778
}
2841
2779
2842
-
#ifdef HAVE_LCD_BITMAP
2843
2780
FOR_NB_SCREENS(i)
2844
2781
rb->viewportmanager_theme_undo(i, false);
2845
-
#endif
2782
+
2846
2783
if (prefs.backlight_on)
2847
2784
backlight_use_settings();
2848
2785
···
2857
2794
/* initialize settings. */
2858
2795
load_or_save_settings(false);
2859
2796
2860
-
#ifdef HAVE_LCD_BITMAP
2861
2797
uifont = rb->screens[0]->getuifont();
2862
2798
font_ui_height = rb->font_get(uifont)->height;
2863
-
#endif
2864
2799
2865
2800
lrc_buffer = rb->plugin_get_buffer(&lrc_buffer_size);
2866
2801
lrc_buffer = ALIGN_UP(lrc_buffer, 4); /* 4 bytes aligned */
-7
apps/plugins/lua/rocklib_img.c
-7
apps/plugins/lua/rocklib_img.c
···
1331
1331
vp->y = check_tablevalue(L, "y", narg);
1332
1332
vp->width = check_tablevalue(L, "width", narg);
1333
1333
vp->height = check_tablevalue(L, "height", narg);
1334
-
#ifdef HAVE_LCD_BITMAP
1335
1334
vp->font = check_tablevalue(L, "font", narg);
1336
1335
vp->drawmode = check_tablevalue(L, "drawmode", narg);
1337
-
#endif
1338
1336
#if LCD_DEPTH > 1
1339
1337
vp->fg_pattern = (unsigned int) check_tablevalue(L, "fg_pattern", narg);
1340
1338
vp->bg_pattern = (unsigned int) check_tablevalue(L, "bg_pattern", narg);
···
1379
1377
return 3;
1380
1378
}
1381
1379
1382
-
#ifdef HAVE_LCD_BITMAP
1383
1380
RB_WRAP(lcd_framebuffer)
1384
1381
{
1385
1382
rli_wrap(L, rb->lcd_framebuffer, LCD_WIDTH, LCD_HEIGHT);
···
1620
1617
return 0;
1621
1618
}
1622
1619
1623
-
#endif /* defined(LCD_BITMAP) */
1624
-
1625
1620
#ifdef HAVE_LCD_COLOR
1626
1621
RB_WRAP(lcd_rgbpack)
1627
1622
{
···
1690
1685
R(set_viewport),
1691
1686
R(clear_viewport),
1692
1687
R(font_getstringsize),
1693
-
#ifdef HAVE_LCD_BITMAP
1694
1688
R(lcd_framebuffer),
1695
1689
R(lcd_setfont),
1696
1690
R(gui_scrollbar_draw),
···
1721
1715
R(lcd_vline),
1722
1716
R(lcd_drawpixel),
1723
1717
1724
-
#endif /*HAVE_LCD_BITMAP*/
1725
1718
#ifdef HAVE_LCD_COLOR
1726
1719
R(lcd_rgbpack),
1727
1720
R(lcd_rgbunpack),
-2
apps/plugins/lua/rocklib_img.h
-2
apps/plugins/lua/rocklib_img.h
-51
apps/plugins/metronome.c
-51
apps/plugins/metronome.c
···
840
840
int textlen = display->lcdwidth / display->getcharwidth();
841
841
ps = part;
842
842
display->clear_display();
843
-
#ifdef HAVE_LCD_BITMAP
844
843
display->setfont(FONT_SYSFIXED);
845
-
#endif
846
844
switch(state)
847
845
{
848
-
#ifdef HAVE_LCD_BITMAP
849
846
case 0:
850
847
if(sound_paused)
851
848
{
···
876
873
case 3:
877
874
display->puts((textlen-3)/2,0, "o.O");
878
875
break;
879
-
#else /* Much simpler on 2-line text display, but same thing. */
880
-
case 1:
881
-
if((beat+1) % 2 == 0)
882
-
beat1 = '/';
883
-
else
884
-
beat1 = '\\';
885
-
break;
886
-
case 2:
887
-
if((beat+1) % 2 == 0)
888
-
beat2 = '/';
889
-
else
890
-
beat2 = '\\';
891
-
break;
892
-
case 3:
893
-
beat1 = '.';
894
-
break;
895
-
#endif
896
876
}
897
877
898
878
if(track_mode)
899
879
{
900
880
901
-
#ifdef HAVE_LCD_BITMAP
902
881
/* One line in several. */
903
882
rb->snprintf( buffer, sizeof(buffer), "%u/%u@%u V%d"
904
883
, ps->beats_per_bar, ps->base_beat
905
884
, bpm, rb->global_settings->volume );
906
885
display->puts(0,4, buffer);
907
-
#else
908
-
/* Just two short lines with integrated beat indicator. */
909
-
rb->snprintf( buffer, sizeof(buffer), "%c %u/%u@%u"
910
-
, beat1
911
-
, ps->beats_per_bar, ps->base_beat
912
-
, bpm );
913
-
display->puts(0,0, buffer);
914
-
/* Simulator prints format %+02d ... real Rockbox doesn't. */
915
-
rb->snprintf( buffer, sizeof(buffer), "%c V%d"
916
-
, beat2
917
-
, rb->global_settings->volume );
918
-
display->puts(0,1, buffer);
919
-
#endif /* HAVE_LCD_BITMAP */
920
886
921
-
#ifdef HAVE_LCD_BITMAP
922
887
/* Would it hurt to draw a 3rd line to 2-line display?
923
888
I guess there are 3-line displays out there. */
924
889
if(ps->label && rb->strlen(ps->label))
···
935
900
rb->snprintf( buffer, sizeof(buffer), "P%u/%u: B%u/_+%u"
936
901
, part->id+1, parts, bar+1, beat+1 );
937
902
display->puts(0, 5, buffer);
938
-
#endif /* HAVE_LCD_BITMAP */
939
903
940
904
}
941
905
else /* track mode */
942
906
{
943
907
944
-
#ifdef HAVE_LCD_BITMAP
945
908
if(display->screen_type==SCREEN_MAIN)
946
909
{
947
910
#ifdef MET_SYNC
···
960
923
#endif
961
924
}
962
925
#endif
963
-
#endif /* HAVE_LCD_BITMAP */
964
926
965
-
#ifdef HAVE_LCD_BITMAP
966
927
rb->snprintf( buffer, sizeof(buffer), "BPM: %d Vol: %d"
967
928
, bpm, rb->global_settings->volume );
968
929
display->puts(0,3, buffer);
969
-
#else
970
-
rb->snprintf( buffer, sizeof(buffer), "%c BPM: %d "
971
-
, beat1, bpm );
972
-
display->puts(0,0, buffer);
973
-
rb->snprintf( buffer, sizeof(buffer), "%c Vol: %d"
974
-
, beat2, rb->global_settings->volume );
975
-
display->puts(0,1, buffer);
976
-
#endif /* HAVE_LCD_BITMAP */
977
930
978
-
#ifdef HAVE_LCD_BITMAP
979
931
display->hline(0, 111, 12);
980
932
if(sound_paused) display->puts(0,2,"start: hold select");
981
933
else display->puts(0,2,"stop : cancel");
982
-
#endif /* HAVE_LCD_BITMAP */
983
934
984
935
} /* !track_mode */
985
936
986
-
#ifdef HAVE_LCD_BITMAP
987
937
display->setfont(FONT_UI);
988
-
#endif /* HAVE_LCD_BITMAP */
989
938
display->update();
990
939
}
991
940
-7
apps/plugins/mosaique.c
-7
apps/plugins/mosaique.c
···
23
23
#include "lib/pluginlib_actions.h"
24
24
25
25
26
-
#ifdef HAVE_LCD_BITMAP
27
26
#define GFX_X (LCD_WIDTH/2-1)
28
27
#define GFX_Y (LCD_HEIGHT/2-1)
29
28
#if LCD_WIDTH != LCD_HEIGHT
···
32
31
#else
33
32
#define GFX_WIDTH GFX_X
34
33
#define GFX_HEIGHT (4*GFX_Y/5)
35
-
#endif
36
-
#else
37
-
#define GFX_X 9
38
-
#define GFX_Y 6
39
-
#define GFX_WIDTH 9
40
-
#define GFX_HEIGHT 6
41
34
#endif
42
35
43
36
/* this set the context to use with PLA */
-2
apps/plugins/otp.c
-2
apps/plugins/otp.c
-2
apps/plugins/pegbox.c
-2
apps/plugins/pegbox.c
···
1462
1462
enum plugin_status plugin_start(const void* parameter)
1463
1463
{
1464
1464
(void)parameter;
1465
-
#ifdef HAVE_LCD_BITMAP
1466
1465
rb->lcd_setfont(FONT_SYSFIXED);
1467
1466
#if LCD_DEPTH > 1
1468
1467
rb->lcd_set_backdrop(NULL);
···
1484
1483
pegbox_main(&pb);
1485
1484
configfile_save(CONFIG_FILE_NAME,config,2,0);
1486
1485
rb->lcd_setfont(FONT_UI);
1487
-
#endif /* HAVE_LCD_BITMAP */
1488
1486
1489
1487
return PLUGIN_OK;
1490
1488
}
-4
apps/plugins/properties.c
-4
apps/plugins/properties.c
···
411
411
return PLUGIN_OK;
412
412
}
413
413
414
-
#ifdef HAVE_LCD_BITMAP
415
414
FOR_NB_SCREENS(i)
416
415
rb->viewportmanager_theme_enable(i, true, NULL);
417
-
#endif
418
416
419
417
rb->gui_synclist_init(&properties_lists, &get_props, &dps, false, 2, NULL);
420
418
rb->gui_synclist_set_title(&properties_lists, rb->str(its_a_dir ? LANG_PROPERTIES_DIRECTORY_PROPERTIES : LANG_PROPERTIES_FILE_PROPERTIES), NOICON);
···
448
446
}
449
447
}
450
448
451
-
#ifdef HAVE_LCD_BITMAP
452
449
FOR_NB_SCREENS(i)
453
450
rb->viewportmanager_theme_undo(i, false);
454
-
#endif
455
451
456
452
return usb? PLUGIN_USB_CONNECTED: PLUGIN_OK;
457
453
}
+3
-30
apps/plugins/rockblox.c
+3
-30
apps/plugins/rockblox.c
···
532
532
533
533
#define BOARD_WIDTH 10
534
534
535
-
#ifdef HAVE_LCD_BITMAP
536
-
537
535
#define BOARD_HEIGHT 20
538
536
539
537
#if (LCD_WIDTH == 640) && (LCD_HEIGHT == 480)
···
757
755
#define LEVEL_X 58
758
756
#define LINES_Y 62
759
757
#define LINES_X 58
758
+
759
+
#else
760
+
#error "lcd screen size not defined!"
760
761
#endif
761
762
762
763
#ifndef LEVEL_X
···
768
769
#endif
769
770
770
771
extern const fb_data rockblox_background[];
771
-
772
-
#else
773
-
#error "lcd screen size not defined!"
774
-
#endif
775
772
776
773
#ifndef HIGHSCORE_SPACE
777
774
#define HIGHSCORE_SPACE " "
···
974
971
/* show the score, level and lines */
975
972
static void show_details (void)
976
973
{
977
-
#ifdef HAVE_LCD_BITMAP
978
974
#if LCD_DEPTH >= 2
979
975
rb->lcd_set_foreground (LCD_BLACK);
980
976
rb->lcd_set_background (LCD_WHITE);
···
982
978
rb->lcd_putsxyf (LABEL_X, SCORE_Y, "%d", rockblox_status.score);
983
979
rb->lcd_putsxyf (LEVEL_X, LEVEL_Y, "%d", rockblox_status.level);
984
980
rb->lcd_putsxyf (LINES_X, LINES_Y, "%d", rockblox_status.lines);
985
-
#endif
986
981
}
987
982
988
983
#ifdef HIGH_SCORE_Y
···
1050
1045
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
1051
1046
tm->tm_hour, tm->tm_min, tm->tm_sec);
1052
1047
1053
-
#ifdef HAVE_LCD_BITMAP
1054
1048
rb->lcd_bitmap (rockblox_background, 0, 0, LCD_WIDTH, LCD_HEIGHT);
1055
-
#endif
1056
1049
if (!resume)
1057
1050
{
1058
1051
rockblox_status.level = 1;
···
1149
1142
for (j = 0; j < BOARD_HEIGHT; j++) {
1150
1143
block = rockblox_status.board[j][i];
1151
1144
if (block != EMPTY_BLOCK) {
1152
-
#ifdef HAVE_LCD_BITMAP
1153
1145
#if LCD_DEPTH >= 2
1154
1146
/* middle drawing */
1155
1147
rb->lcd_set_foreground (figures[block].color[1]);
···
1177
1169
rb->lcd_hline (BOARD_X + i * BLOCK_WIDTH + 1,
1178
1170
BOARD_X + (i + 1) * BLOCK_WIDTH - 1,
1179
1171
BOARD_Y + (j + 1) * BLOCK_HEIGHT - 1);
1180
-
#endif
1181
1172
}
1182
1173
}
1183
1174
···
1194
1185
+ rockblox_status.cx;
1195
1186
y = getRelativeY (rockblox_status.cf, i, rockblox_status.co)
1196
1187
+ ghost_y;
1197
-
#ifdef HAVE_LCD_BITMAP
1198
1188
#if LCD_DEPTH >= 2
1199
1189
/* middle drawing */
1200
1190
rb->lcd_set_foreground (ghost_colors[rockblox_status.cf][0]);
···
1221
1211
rb->lcd_hline (BOARD_X + x * BLOCK_WIDTH + 1,
1222
1212
BOARD_X + (x + 1) * BLOCK_WIDTH - 1,
1223
1213
BOARD_Y + (y + 1) * BLOCK_HEIGHT - 1);
1224
-
#endif
1225
1214
}
1226
1215
1227
1216
/* draw current piece */
···
1231
1220
+ rockblox_status.cx;
1232
1221
y = getRelativeY (rockblox_status.cf, i, rockblox_status.co)
1233
1222
+ rockblox_status.cy;
1234
-
#ifdef HAVE_LCD_BITMAP
1235
1223
#if LCD_DEPTH >= 2
1236
1224
/* middle drawing */
1237
1225
rb->lcd_set_foreground (figures[rockblox_status.cf].color[1]);
···
1258
1246
rb->lcd_hline (BOARD_X + x * BLOCK_WIDTH + 1,
1259
1247
BOARD_X + (x + 1) * BLOCK_WIDTH - 1,
1260
1248
BOARD_Y + (y + 1) * BLOCK_HEIGHT - 1);
1261
-
#endif
1262
1249
}
1263
1250
1264
1251
mylcd_update ();
···
1301
1288
for (i = 0; i < 4; i++) {
1302
1289
rx = getRelativeX (rockblox_status.nf, i, 0) + 2;
1303
1290
ry = getRelativeY (rockblox_status.nf, i, 0) + 2;
1304
-
#ifdef HAVE_LCD_BITMAP
1305
1291
#if LCD_DEPTH >= 2
1306
1292
rb->lcd_set_foreground (figures[rockblox_status.nf].color[1]); /* middle drawing */
1307
1293
#endif
···
1326
1312
rb->lcd_hline (PREVIEW_X + rx * BLOCK_WIDTH + 1,
1327
1313
PREVIEW_X + (rx + 1) * BLOCK_WIDTH - 1,
1328
1314
PREVIEW_Y + (ry + 1) * BLOCK_HEIGHT - 1);
1329
-
#endif
1330
1315
}
1331
1316
1332
1317
}
···
1428
1413
LAST_STYLE_ITEM
1429
1414
};
1430
1415
1431
-
#ifdef HAVE_LCD_BITMAP
1432
1416
rb->lcd_setfont(FONT_UI);
1433
-
#endif
1434
1417
#ifdef HAVE_LCD_COLOR
1435
1418
rb->lcd_set_background(LCD_BLACK);
1436
1419
rb->lcd_set_foreground(LCD_WHITE);
1437
1420
#endif
1438
1421
if (display_text(ARRAYLEN(help_text), help_text, formation, NULL, true))
1439
1422
return true;
1440
-
#ifdef HAVE_LCD_BITMAP
1441
1423
rb->lcd_setfont(FONT_SYSFIXED);
1442
-
#endif
1443
1424
1444
1425
return false;
1445
1426
}
···
1699
1680
rb->lcd_set_backdrop(NULL);
1700
1681
#endif
1701
1682
1702
-
#ifdef HAVE_LCD_BITMAP
1703
1683
rb->lcd_setfont (FONT_SYSFIXED);
1704
-
#else
1705
-
if (!pgfx_init(4, 2))
1706
-
{
1707
-
rb->splash(HZ*2, "Old LCD :(");
1708
-
return PLUGIN_OK;
1709
-
}
1710
-
#endif
1711
1684
1712
1685
/* Turn off backlight timeout */
1713
1686
backlight_ignore_timeout();
-4
apps/plugins/search.c
-4
apps/plugins/search.c
···
125
125
fdw = rb->open(resultfile, O_WRONLY|O_CREAT|O_TRUNC, 0666);
126
126
127
127
if (fdw < 0) {
128
-
#ifdef HAVE_LCD_BITMAP
129
128
rb->splash(HZ, "Failed to create result file!");
130
-
#else
131
-
rb->splash(HZ, "File creation failed");
132
-
#endif
133
129
rb->close(fd);
134
130
return false;
135
131
}
-8
apps/plugins/searchengine/searchengine.h
-8
apps/plugins/searchengine/searchengine.h
···
25
25
#include <autoconf.h>
26
26
27
27
extern int w, h, y;
28
-
#ifdef HAVE_LCD_BITMAP
29
28
#define PUTS(str) do { \
30
29
rb->lcd_putsxy(1, y, str); \
31
30
rb->lcd_getstringsize(str, &w, &h); \
32
31
y += h + 1; \
33
32
} while (0); \
34
33
rb->lcd_update()
35
-
#else
36
-
#define PUTS(str) do { \
37
-
rb->lcd_puts(0, y, str); \
38
-
y = (y + 1) % 2; \
39
-
} while (0); \
40
-
rb->lcd_update()
41
-
#endif
42
34
43
35
void *my_malloc(size_t size);
44
36
void setmallocpos(void *pointer);
-4
apps/plugins/shortcuts/shortcuts_view.c
-4
apps/plugins/shortcuts/shortcuts_view.c
···
223
223
return PLUGIN_OK;
224
224
}
225
225
226
-
#ifdef HAVE_LCD_BITMAP
227
226
FOR_NB_SCREENS(i)
228
227
rb->viewportmanager_theme_enable(i, true, NULL);
229
-
#endif
230
228
231
229
do {
232
230
/* Display a menu to choose between the entries */
233
231
leave_loop = list_sc();
234
232
} while (!leave_loop);
235
233
236
-
#ifdef HAVE_LCD_BITMAP
237
234
FOR_NB_SCREENS(i)
238
235
rb->viewportmanager_theme_undo(i, false);
239
-
#endif
240
236
241
237
return usb_connected ? PLUGIN_USB_CONNECTED : PLUGIN_OK;
242
238
}
-16
apps/plugins/snow.c
-16
apps/plugins/snow.c
···
22
22
#include "lib/mylcd.h"
23
23
#include "lib/pluginlib_actions.h"
24
24
25
-
#ifdef HAVE_LCD_BITMAP
26
25
#define NUM_PARTICLES (LCD_WIDTH * LCD_HEIGHT / 72)
27
26
#define SNOW_HEIGHT LCD_HEIGHT
28
27
#define SNOW_WIDTH LCD_WIDTH
29
-
#else
30
-
#define NUM_PARTICLES 10
31
-
#define SNOW_HEIGHT 14
32
-
#define SNOW_WIDTH 20
33
-
#endif
34
28
35
29
static const struct button_mapping *plugin_contexts[] = { pla_main_ctx };
36
30
···
40
34
41
35
static short particles[NUM_PARTICLES][2];
42
36
43
-
#ifdef HAVE_LCD_BITMAP
44
37
#if LCD_WIDTH >= 160
45
38
#define FLAKE_WIDTH 5
46
39
static const unsigned char flake[] = {0x0a,0x04,0x1f,0x04,0x0a};
47
40
#else
48
41
#define FLAKE_WIDTH 3
49
42
static const unsigned char flake[] = {0x02,0x07,0x02};
50
-
#endif
51
43
#endif
52
44
53
45
static bool particle_exists(int particle)
···
83
75
for (i=0; i<NUM_PARTICLES; i++) {
84
76
if (particle_exists(i)) {
85
77
mylcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
86
-
#ifdef HAVE_LCD_BITMAP
87
78
rb->lcd_fillrect(particles[i][0],particles[i][1],
88
79
FLAKE_WIDTH,FLAKE_WIDTH);
89
-
#else
90
-
pgfx_drawpixel(particles[i][0],particles[i][1]);
91
-
#endif
92
80
mylcd_set_drawmode(DRMODE_SOLID);
93
81
#ifdef HAVE_REMOTE_LCD
94
82
if (particles[i][0] <= LCD_REMOTE_WIDTH
···
116
104
break;
117
105
}
118
106
if (particle_exists(i))
119
-
#ifdef HAVE_LCD_BITMAP
120
107
rb->lcd_mono_bitmap(flake,particles[i][0],particles[i][1],
121
108
FLAKE_WIDTH,FLAKE_WIDTH);
122
-
#else
123
-
pgfx_drawpixel(particles[i][0],particles[i][1]);
124
-
#endif
125
109
#ifdef HAVE_REMOTE_LCD
126
110
if (particles[i][0] <= LCD_REMOTE_WIDTH
127
111
&& particles[i][1] <= LCD_REMOTE_HEIGHT) {
-7
apps/plugins/stats.c
-7
apps/plugins/stats.c
···
56
56
rb->lcd_remote_clear_display();
57
57
#endif
58
58
59
-
#ifdef HAVE_LCD_BITMAP
60
59
rb->snprintf(buf, sizeof(buf), "Total Files: %d", files);
61
60
prn(buf,0);
62
61
rb->snprintf(buf, sizeof(buf), "Audio: %d", audiofiles);
···
71
70
prn(buf,5);
72
71
rb->snprintf(buf, sizeof(buf), "Max files in Dir: %d", largestdir);
73
72
prn(buf,6);
74
-
#else
75
-
rb->snprintf(buf, sizeof(buf), "Files:%5d", files);
76
-
prn(buf,0);
77
-
rb->snprintf(buf, sizeof(buf), "Dirs: %5d", dirs);
78
-
prn(buf,1);
79
-
#endif
80
73
81
74
rb->lcd_update();
82
75
#ifdef HAVE_REMOTE_LCD
-8
apps/plugins/stopwatch.c
-8
apps/plugins/stopwatch.c
···
23
23
24
24
25
25
26
-
#ifdef HAVE_LCD_BITMAP
27
26
#define TIMER_Y 1
28
-
#else
29
-
#define TIMER_Y 0
30
-
#endif
31
27
32
28
#define LAP_Y TIMER_Y+1
33
29
#define MAX_LAPS 64
···
481
477
482
478
(void)parameter;
483
479
484
-
#ifdef HAVE_LCD_BITMAP
485
480
int h;
486
481
rb->lcd_setfont(FONT_UI);
487
482
rb->lcd_getstringsize("M", NULL, &h);
488
483
lines = (LCD_HEIGHT / h) - (LAP_Y);
489
-
#else
490
-
lines = 1;
491
-
#endif
492
484
493
485
load_stopwatch();
494
486
+1
-3
apps/plugins/test_mem.c
+1
-3
apps/plugins/test_mem.c
-62
apps/plugins/test_viewports.c
-62
apps/plugins/test_viewports.c
···
21
21
22
22
#include "plugin.h"
23
23
24
-
25
-
26
-
#ifdef HAVE_LCD_BITMAP
27
-
28
24
#ifdef HAVE_LCD_COLOR
29
25
#define BGCOLOR_1 LCD_RGBPACK(255,255,0)
30
26
#define BGCOLOR_2 LCD_RGBPACK(0,255,0)
···
207
203
208
204
return PLUGIN_OK;
209
205
}
210
-
211
-
212
-
#else
213
-
214
-
/* Charcell version of plugin */
215
-
216
-
static struct viewport vp0 =
217
-
{
218
-
.x = 0,
219
-
.y = 0,
220
-
.width = 5,
221
-
.height = 1,
222
-
};
223
-
224
-
static struct viewport vp1 =
225
-
{
226
-
.x = 6,
227
-
.y = 0,
228
-
.width = 5,
229
-
.height = 1,
230
-
};
231
-
232
-
static struct viewport vp2 =
233
-
{
234
-
.x = 0,
235
-
.y = 1,
236
-
.width = LCD_WIDTH,
237
-
.height = 1,
238
-
};
239
-
240
-
241
-
enum plugin_status plugin_start(const void* parameter)
242
-
{
243
-
(void)parameter;
244
-
245
-
rb->screens[SCREEN_MAIN]->set_viewport(&vp0);
246
-
rb->screens[SCREEN_MAIN]->clear_viewport();
247
-
rb->screens[SCREEN_MAIN]->puts_scroll(0,0,"Rockbox");
248
-
249
-
rb->screens[SCREEN_MAIN]->set_viewport(&vp1);
250
-
rb->screens[SCREEN_MAIN]->clear_viewport();
251
-
rb->screens[SCREEN_MAIN]->puts_scroll(0,0,"Viewports");
252
-
253
-
rb->screens[SCREEN_MAIN]->set_viewport(&vp2);
254
-
rb->screens[SCREEN_MAIN]->clear_viewport();
255
-
rb->screens[SCREEN_MAIN]->puts_scroll(0,0,"Demonstration");
256
-
257
-
rb->screens[SCREEN_MAIN]->update();
258
-
259
-
rb->button_get(true);
260
-
261
-
/* Restore the default viewport */
262
-
rb->screens[SCREEN_MAIN]->set_viewport(NULL);
263
-
264
-
return PLUGIN_OK;
265
-
}
266
-
267
-
#endif /* !HAVE_LCD_BITMAP */
-2
apps/plugins/text_viewer/text_viewer.c
-2
apps/plugins/text_viewer/text_viewer.c
-4
apps/plugins/text_viewer/tv_action.c
-4
apps/plugins/text_viewer/tv_action.c
···
100
100
(mode == TV_VERTICAL_SCROLL_PREFS && preferences->vertical_scroll_mode == VS_PAGE))
101
101
{
102
102
offset_page--;
103
-
#ifdef HAVE_LCD_BITMAP
104
103
offset_line = (preferences->overlap_page_mode)? 1:0;
105
-
#endif
106
104
}
107
105
tv_move_screen(offset_page, offset_line, SEEK_CUR);
108
106
scrolled = true;
···
117
115
(mode == TV_VERTICAL_SCROLL_PREFS && preferences->vertical_scroll_mode == VS_PAGE))
118
116
{
119
117
offset_page++;
120
-
#ifdef HAVE_LCD_BITMAP
121
118
offset_line = (preferences->overlap_page_mode)? -1:0;
122
-
#endif
123
119
}
124
120
tv_move_screen(offset_page, offset_line, SEEK_CUR);
125
121
scrolled = true;
-4
apps/plugins/text_viewer/tv_bookmark.c
-4
apps/plugins/text_viewer/tv_bookmark.c
···
182
182
(void)data;
183
183
struct tv_bookmark_info *bookmark = &bookmarks[selected];
184
184
rb->snprintf(buffer, buffer_len,
185
-
#ifdef HAVE_LCD_BITMAP
186
185
"%cPage: %d Line: %d",
187
-
#else
188
-
"%cP:%d L:%d",
189
-
#endif
190
186
(bookmark->flag & TV_BOOKMARK_SYSTEM)? '*' : ' ',
191
187
bookmark->pos.page + 1, bookmark->pos.line + 1);
192
188
return buffer;
-73
apps/plugins/text_viewer/tv_display.c
-73
apps/plugins/text_viewer/tv_display.c
···
25
25
/*
26
26
* display layout
27
27
*
28
-
* when is defined HAVE_LCD_BITMAP
29
28
* +-------------------------+
30
29
* |statusbar (1) |
31
30
* +-------------------------+
···
56
55
* (5) displays when preferences->footer_mode is FT_PAGE.
57
56
* (6) displays when rb->global_settings->statusbar == STATUSBAR_BOTTOM.
58
57
*
59
-
*
60
-
* when isn't defined HAVE_LCD_BITMAP
61
-
* +---+---------------------+
62
-
* | | |
63
-
* |(7)| draw area |
64
-
* | | |
65
-
* +---+---------------------+
66
-
* (7) bookmark
67
58
*/
68
59
69
60
#define TV_SCROLLBAR_WIDTH rb->global_settings->scrollbar_width
···
83
74
static struct screen* display;
84
75
85
76
/* layout */
86
-
#ifdef HAVE_LCD_BITMAP
87
77
static struct tv_rect header;
88
78
static struct tv_rect footer;
89
79
static struct tv_rect horizontal_scrollbar;
90
80
static struct tv_rect vertical_scrollbar;
91
-
#else
92
-
static struct tv_rect bookmark;
93
-
#endif
94
81
95
82
static bool show_horizontal_scrollbar;
96
83
static bool show_vertical_scrollbar;
···
102
89
static int row_height = 1;
103
90
104
91
static int totalsize;
105
-
106
-
#ifdef HAVE_LCD_BITMAP
107
92
108
93
static void tv_show_header(void)
109
94
{
···
156
141
}
157
142
}
158
143
159
-
#endif
160
-
161
144
void tv_init_scrollbar(off_t total, bool show_scrollbar)
162
145
{
163
146
totalsize = total;
···
167
150
168
151
void tv_show_bookmarks(const int *rows, int count)
169
152
{
170
-
#ifdef HAVE_LCD_BITMAP
171
153
display->set_viewport(&vp_text);
172
154
display->set_drawmode(DRMODE_COMPLEMENT);
173
-
#endif
174
155
175
156
while (count--)
176
157
{
177
-
#ifdef HAVE_LCD_BITMAP
178
158
display->fillrect(0, rows[count] * row_height,
179
159
vp_text.width, row_height);
180
-
#else
181
-
display->putchar(bookmark.x, bookmark.y + rows[count], TV_BOOKMARK_ICON);
182
-
#endif
183
160
}
184
-
#ifdef HAVE_LCD_BITMAP
185
161
display->set_drawmode(DRMODE_SOLID);
186
162
display->set_viewport(&vp_info);
187
-
#endif
188
163
}
189
164
190
165
void tv_update_extra(int window, int col, const struct tv_screen_pos *pos, int size)
191
166
{
192
-
#ifdef HAVE_LCD_BITMAP
193
167
tv_show_scrollbar(window, col, pos->file_pos, size);
194
168
tv_show_header();
195
169
tv_show_footer(pos);
196
-
#else
197
-
(void)window;
198
-
(void)col;
199
-
(void)pos;
200
-
(void)size;
201
-
#endif
202
170
}
203
171
204
172
void tv_draw_text(int row, const unsigned char *text, int offset)
···
217
185
218
186
display->set_viewport(&vp_text);
219
187
tv_night_mode();
220
-
#ifdef HAVE_LCD_BITMAP
221
188
display->putsxy(xpos, row * row_height, text);
222
-
#else
223
-
display->puts(xpos, row, text);
224
-
#endif
225
189
display->set_viewport(&vp_info);
226
190
}
227
191
···
229
193
{
230
194
display->set_viewport(&vp_info);
231
195
tv_night_mode();
232
-
#ifdef HAVE_LCD_BITMAP
233
196
display->set_drawmode(DRMODE_SOLID);
234
-
#endif
235
197
236
198
#if LCD_DEPTH > 1
237
199
rb->lcd_set_backdrop(NULL);
···
248
210
249
211
void tv_set_layout(bool show_scrollbar)
250
212
{
251
-
#ifdef HAVE_LCD_BITMAP
252
213
int scrollbar_width = (show_scrollbar && preferences->vertical_scrollbar)?
253
214
TV_SCROLLBAR_WIDTH + 1 : 0;
254
215
int scrollbar_height = (show_scrollbar && preferences->horizontal_scrollbar)?
···
282
243
vp_text.y += vertical_scrollbar.y;
283
244
vp_text.width = horizontal_scrollbar.w;
284
245
vp_text.height = vertical_scrollbar.h;
285
-
#else
286
-
(void) show_scrollbar;
287
-
288
-
row_height = 1;
289
-
290
-
bookmark.x = 0;
291
-
bookmark.y = 0;
292
-
bookmark.w = 1;
293
-
bookmark.h = vp_info.height;
294
-
295
-
vp_text = vp_info;
296
-
vp_text.x += 1;
297
-
vp_text.width -= 1;
298
-
#endif
299
246
300
247
display_columns = vp_text.width / col_width;
301
248
display_rows = vp_text.height / row_height;
···
310
257
311
258
static void tv_change_viewport(void)
312
259
{
313
-
#ifdef HAVE_LCD_BITMAP
314
260
bool show_statusbar = preferences->statusbar;
315
261
316
262
if (is_initialized_vp)
···
321
267
rb->viewportmanager_theme_enable(SCREEN_MAIN, show_statusbar, &vp_info);
322
268
vp_info.flags &= ~VP_FLAG_ALIGNMENT_MASK;
323
269
display->set_viewport(&vp_info);
324
-
#else
325
-
if (!is_initialized_vp)
326
-
{
327
-
rb->viewport_set_defaults(&vp_info, SCREEN_MAIN);
328
-
is_initialized_vp = true;
329
-
}
330
-
#endif
331
270
}
332
271
333
-
#ifdef HAVE_LCD_BITMAP
334
272
static bool tv_set_font(const unsigned char *font)
335
273
{
336
274
unsigned char path[MAX_PATH];
···
350
288
vp_text.font = preferences->font_id;
351
289
return true;
352
290
}
353
-
#endif
354
291
355
292
static int tv_change_preferences(const struct tv_preferences *oldp)
356
293
{
357
-
#ifdef HAVE_LCD_BITMAP
358
294
static bool font_changing = false;
359
295
const unsigned char *font_str;
360
296
struct tv_preferences new_prefs;
···
382
318
col_width = 2 * rb->font_get_width(rb->font_get(preferences->font_id), ' ');
383
319
font_changing = false;
384
320
}
385
-
#else
386
-
(void)oldp;
387
-
#endif
388
321
tv_change_viewport();
389
322
return TV_CALLBACK_OK;
390
323
}
···
419
352
420
353
void tv_finalize_display(void)
421
354
{
422
-
#ifdef HAVE_LCD_BITMAP
423
355
/* restore font */
424
356
if (preferences->font_id >= 0 &&
425
357
(preferences->font_id != rb->global_status->font_id[SCREEN_MAIN]))
···
430
362
/* undo viewport */
431
363
if (is_initialized_vp)
432
364
rb->viewportmanager_theme_undo(SCREEN_MAIN, false);
433
-
#endif
434
365
}
435
366
436
367
bool tv_exist_scrollbar(void)
437
368
{
438
-
#ifdef HAVE_LCD_BITMAP
439
369
return true;
440
-
#else
441
-
return false;
442
-
#endif
443
370
}
-10
apps/plugins/text_viewer/tv_preferences.c
-10
apps/plugins/text_viewer/tv_preferences.c
···
59
59
(oldp->vertical_scrollbar != preferences->vertical_scrollbar) ||
60
60
(oldp->encoding != preferences->encoding) ||
61
61
(oldp->indent_spaces != preferences->indent_spaces) ||
62
-
#ifdef HAVE_LCD_BITMAP
63
62
(oldp->header_mode != preferences->header_mode) ||
64
63
(oldp->footer_mode != preferences->footer_mode) ||
65
64
(oldp->statusbar != preferences->statusbar) ||
66
65
(rb->strcmp(oldp->font_name, preferences->font_name)) ||
67
-
#endif
68
66
(rb->strcmp(oldp->file_name, preferences->file_name)))
69
67
{
70
68
/* callback functions are called as FILO */
···
110
108
p->overlap_page_mode = false;
111
109
p->horizontal_scrollbar = false;
112
110
p->vertical_scrollbar = false;
113
-
#ifdef HAVE_LCD_BITMAP
114
111
p->header_mode = true;
115
112
p->footer_mode = true;
116
113
p->statusbar = true;
117
114
rb->strlcpy(p->font_name, rb->global_settings->font_file, MAX_PATH);
118
115
p->font_id = rb->global_status->font_id[SCREEN_MAIN];
119
-
#else
120
-
p->header_mode = false;
121
-
p->footer_mode = false;
122
-
p->statusbar = false;
123
-
#endif
124
116
p->autoscroll_speed = 10;
125
117
p->night_mode = false;
126
118
p->narrow_mode = NM_PAGE;
···
139
131
void tv_change_fontid(int id)
140
132
{
141
133
(void)id;
142
-
#ifdef HAVE_LCD_BITMAP
143
134
prefs.font_id = id;
144
-
#endif
145
135
}
+1
-2
apps/plugins/text_viewer/tv_preferences.h
+1
-2
apps/plugins/text_viewer/tv_preferences.h
-4
apps/plugins/text_viewer/tv_settings.c
-4
apps/plugins/text_viewer/tv_settings.c
···
219
219
if (version > 6)
220
220
prefs->night_mode = (*p++ != 0);
221
221
222
-
#ifdef HAVE_LCD_BITMAP
223
222
rb->strlcpy(prefs->font_name, buf + read_size - MAX_PATH, MAX_PATH);
224
223
225
224
prefs->font_id = rb->global_status->font_id[SCREEN_MAIN];
226
-
#endif
227
225
228
226
return true;
229
227
}
···
253
251
*p++ = prefs->statusbar;
254
252
*p++ = prefs->night_mode;
255
253
256
-
#ifdef HAVE_LCD_BITMAP
257
254
rb->strlcpy(buf + 28, prefs->font_name, MAX_PATH);
258
-
#endif
259
255
}
260
256
261
257
static bool tv_write_preferences(int pfd, const struct tv_preferences *prefs)
+1
-10
apps/plugins/text_viewer/tv_text_processor.c
+1
-10
apps/plugins/text_viewer/tv_text_processor.c
···
33
33
};
34
34
35
35
/* the max characters of each blocks */
36
-
#ifdef HAVE_LCD_BITMAP
37
36
#define TV_MAX_CHARS_PER_BLOCK (LCD_WIDTH / 2 + 1)
38
-
#else
39
-
#define TV_MAX_CHARS_PER_BLOCK (LCD_WIDTH + 1)
40
-
#endif
41
37
42
38
#define TV_MAX_BLOCKS 5
43
39
···
90
86
if (ch == 0)
91
87
ch = ' ';
92
88
93
-
#ifdef HAVE_LCD_BITMAP
94
89
/* the width of the diacritics charcter is 0 */
95
90
if (rb->is_diacritic(ch, NULL))
96
91
return 0;
97
92
98
93
return rb->font_get_width(rb->font_get(preferences->font_id), ch);
99
-
#else
100
-
return 1;
101
-
#endif
102
94
}
103
95
104
96
static unsigned char *tv_get_ucs(const unsigned char *str, unsigned short *ch)
···
138
130
if (preferences->encoding == UTF_8)
139
131
return (unsigned char*)rb->utf8decode(str, ch);
140
132
141
-
#ifdef HAVE_LCD_BITMAP
142
133
if ((*str >= 0x80) &&
143
134
((preferences->encoding > SJIS) ||
144
135
(preferences->encoding == SJIS && (*str <= 0xa0 || *str >= 0xe0))))
···
151
142
}
152
143
count = 2;
153
144
}
154
-
#endif
145
+
155
146
rb->iso_decode(str, utf8_tmp, preferences->encoding, count);
156
147
rb->utf8decode(utf8_tmp, ch);
157
148
return (unsigned char *)str + count;
+1
-42
apps/plugins/theme_remove.c
+1
-42
apps/plugins/theme_remove.c
···
48
48
};
49
49
50
50
static int remove_wps(struct remove_setting *);
51
-
#ifdef HAVE_LCD_BITMAP
52
51
static int remove_icons(struct remove_setting *setting);
53
-
#endif
54
52
55
53
enum remove_settings {
56
-
#ifdef HAVE_LCD_BITMAP
57
54
REMOVE_FONT,
58
-
#endif
59
55
REMOVE_WPS,
60
-
#ifdef HAVE_LCD_BITMAP
61
56
REMOVE_SBS,
62
-
#endif
63
57
#ifdef HAVE_REMOTE_LCD
64
58
REMOVE_RWPS,
65
59
REMOVE_RSBS,
···
67
61
#if LCD_DEPTH > 1
68
62
REMOVE_BACKDROP,
69
63
#endif
70
-
#ifdef HAVE_LCD_BITMAP
71
64
REMOVE_ICON,
72
65
REMOVE_VICON,
73
-
#endif
74
66
#ifdef HAVE_REMOTE_LCD
75
67
REMOVE_RICON,
76
68
REMOVE_RVICON,
···
83
75
84
76
static bool create_log = true;
85
77
static struct remove_setting remove_list[NUM_REMOVE_ITEMS] = {
86
-
#ifdef HAVE_LCD_BITMAP
87
78
[REMOVE_FONT] = { "font", FONT_DIR "/", ".fnt", "",
88
79
ASK_FOR_REMOVAL, NULL, false },
89
-
#endif
90
80
[REMOVE_WPS] = { "wps", WPS_DIR "/", ".wps", "",
91
81
REMOVE_IF_NOT_USED, remove_wps, false },
92
-
#ifdef HAVE_LCD_BITMAP
93
82
[REMOVE_SBS] = { "sbs", SBS_DIR "/", ".sbs", "",
94
83
REMOVE_IF_NOT_USED, remove_wps, false },
95
-
#endif
96
84
#ifdef HAVE_REMOTE_LCD
97
85
[REMOVE_RWPS] = { "rwps", WPS_DIR "/", ".rwps", "",
98
86
REMOVE_IF_NOT_USED, remove_wps, false },
···
103
91
[REMOVE_BACKDROP] = { "backdrop", BACKDROP_DIR "/", ".bmp", "",
104
92
REMOVE_IF_NOT_USED, NULL, false },
105
93
#endif
106
-
#ifdef HAVE_LCD_BITMAP
107
94
[REMOVE_ICON] = { "iconset", ICON_DIR "/", ".bmp", "",
108
95
ASK_FOR_REMOVAL, NULL, false },
109
96
[REMOVE_VICON] = { "viewers iconset", ICON_DIR "/", ".bmp", "",
110
97
ASK_FOR_REMOVAL, remove_icons, false },
111
-
#endif
112
98
#ifdef HAVE_REMOTE_LCD
113
99
[REMOVE_RICON] = { "remote iconset", ICON_DIR "/", ".bmp", "",
114
100
ASK_FOR_REMOVAL, NULL, false },
···
124
110
"always", "never", "not used", "ask",
125
111
};
126
112
static struct configdata config[] = {
127
-
#ifdef HAVE_LCD_BITMAP
128
113
{ TYPE_INT, 0, NUM_REMOVE_OPTION,
129
114
{ .int_p = &remove_list[REMOVE_FONT].option },
130
115
"remove font", option_names },
131
-
#endif
132
116
{ TYPE_INT, 0, NUM_REMOVE_OPTION,
133
117
{ .int_p = &remove_list[REMOVE_WPS].option },
134
118
"remove wps", option_names },
135
-
#ifdef HAVE_LCD_BITMAP
136
119
{ TYPE_INT, 0, NUM_REMOVE_OPTION,
137
120
{ .int_p = &remove_list[REMOVE_SBS].option },
138
121
"remove sbs", option_names },
139
-
#endif
140
122
#ifdef HAVE_REMOTE_LCD
141
123
{ TYPE_INT, 0, NUM_REMOVE_OPTION,
142
124
{ .int_p = &remove_list[REMOVE_RWPS].option },
···
150
132
{ .int_p = &remove_list[REMOVE_BACKDROP].option },
151
133
"remove backdrop", option_names },
152
134
#endif
153
-
#ifdef HAVE_LCD_BITMAP
154
135
{ TYPE_INT, 0, NUM_REMOVE_OPTION,
155
136
{ .int_p = &remove_list[REMOVE_ICON].option },
156
137
"remove iconset", option_names },
157
138
{ TYPE_INT, 0, NUM_REMOVE_OPTION,
158
139
{ .int_p = &remove_list[REMOVE_VICON].option },
159
140
"remove viconset", option_names },
160
-
#endif
161
141
#ifdef HAVE_REMOTE_LCD
162
142
{ TYPE_INT, 0, NUM_REMOVE_OPTION,
163
143
{ .int_p = &remove_list[REMOVE_RICON].option },
···
285
265
return remove_dir(bmpdir, MAX_PATH);
286
266
}
287
267
288
-
#ifdef HAVE_LCD_BITMAP
289
268
static int remove_icons(struct remove_setting *setting)
290
269
{
291
270
char path[MAX_PATH];
···
306
285
show_mess("Removed", path);
307
286
return 0;
308
287
}
309
-
#endif
310
288
311
-
#ifdef HAVE_LCD_BITMAP
312
289
static char font_file[MAX_PATH];
313
-
#endif
290
+
314
291
static bool is_deny_file(const char *file)
315
292
{
316
293
const char *deny_files[] = {
317
294
WPS_DEFAULTCFG,
318
295
RWPS_DEFAULTCFG,
319
-
#ifdef HAVE_LCD_BITMAP
320
296
font_file,
321
-
#endif
322
297
NULL
323
298
};
324
299
const char **p = deny_files;
···
334
309
static void check_whether_used_in_setting(void)
335
310
{
336
311
const char *setting_files[] = {
337
-
#ifdef HAVE_LCD_BITMAP
338
312
rb->global_settings->font_file,
339
-
#endif
340
313
rb->global_settings->wps_file,
341
-
#ifdef HAVE_LCD_BITMAP
342
314
rb->global_settings->sbs_file,
343
-
#endif
344
315
#ifdef HAVE_REMOTE_LCD
345
316
rb->global_settings->rwps_file,
346
317
rb->global_settings->rsbs_file,
···
348
319
#if LCD_DEPTH > 1
349
320
rb->global_settings->backdrop_file,
350
321
#endif
351
-
#ifdef HAVE_LCD_BITMAP
352
322
rb->global_settings->icon_file,
353
323
rb->global_settings->viewers_icon_file,
354
-
#endif
355
324
#ifdef HAVE_REMOTE_LCD
356
325
rb->global_settings->remote_icon_file,
357
326
rb->global_settings->remote_viewers_icon_file,
···
419
388
DIR *dir;
420
389
421
390
check_whether_used_in_setting();
422
-
#ifdef HAVE_LCD_BITMAP
423
391
/* mark font files come from rockbox-font.zip as used and don't remove
424
392
* them automatically as themes may depend on those fonts. */
425
393
if (remove_list[REMOVE_FONT].option == REMOVE_IF_NOT_USED)
426
394
check_whether_used_in_file(RB_FONTS_CONFIG);
427
-
#endif
428
395
429
396
dir = rb->opendir(THEME_DIR);
430
397
if (!dir)
···
591
558
{
592
559
MENUITEM_STRINGLIST(option_menu, "Remove Options", NULL,
593
560
/* same order as remove_list */
594
-
#ifdef HAVE_LCD_BITMAP
595
561
"Font",
596
-
#endif
597
562
"WPS",
598
-
#ifdef HAVE_LCD_BITMAP
599
563
"Statusbar Skin",
600
-
#endif
601
564
#ifdef HAVE_REMOTE_LCD
602
565
"Remote WPS",
603
566
"Remote Statusbar Skin",
···
605
568
#if LCD_DEPTH > 1
606
569
"Backdrop",
607
570
#endif
608
-
#ifdef HAVE_LCD_BITMAP
609
571
"Iconset", "Viewers Iconset",
610
-
#endif
611
572
#ifdef HAVE_REMOTE_LCD
612
573
"Remote Iconset", "Remote Viewers Iconset",
613
574
#endif
···
669
630
if((p = rb->strrchr(title, '.')))
670
631
*p = 0;
671
632
672
-
#ifdef HAVE_LCD_BITMAP
673
633
rb->snprintf(font_file, MAX_PATH, FONT_DIR "/%s.fnt",
674
634
rb->global_settings->font_file);
675
-
#endif
676
635
rb->strlcpy(themefile, parameter, MAX_PATH);
677
636
if (!rb->file_exists(themefile))
678
637
{
-4
apps/plugins/wav2wv.c
-4
apps/plugins/wav2wv.c
···
77
77
rb->lcd_putsf(0, 6, "realtime: %d%% ", realtime);
78
78
rb->lcd_putsf(0, 8, "compression: %d%% ", compression);
79
79
80
-
#ifdef HAVE_LCD_BITMAP
81
80
rb->lcd_update();
82
-
#endif
83
81
}
84
82
85
83
#define TEMP_SAMPLES 4096
···
102
100
103
101
rb->lcd_clear_display();
104
102
rb->lcd_puts_scroll(0, 0, (unsigned char *)infile);
105
-
#ifdef HAVE_LCD_BITMAP
106
103
rb->lcd_update();
107
-
#endif
108
104
109
105
last_buttons = rb->button_status ();
110
106
start_tick = *rb->current_tick;
-2
apps/radio/presets.c
-2
apps/radio/presets.c
-3
apps/recorder/icons.h
-3
apps/recorder/icons.h
···
26
26
#include <lcd.h>
27
27
#include "metadata.h"
28
28
29
-
#ifdef HAVE_LCD_BITMAP
30
-
31
29
/* External bitmaps */
32
30
33
31
#include "bitmaps/rockboxlogo.h"
···
125
123
#define ICON_DISK_X_POS STATUSBAR_WIDTH-ICON_DISK_WIDTH
126
124
#define TIME_X_END STATUSBAR_WIDTH-1
127
125
128
-
#endif /* End HAVE_LCD_BITMAP */
129
126
#endif /* PLUGIN */
130
127
#endif /* _ICONS_H_ */
-44
apps/screen_access.c
-44
apps/screen_access.c
···
39
39
/* some helper functions to calculate metrics on the fly */
40
40
static int screen_helper_getcharwidth(void)
41
41
{
42
-
#ifdef HAVE_LCD_BITMAP
43
42
return font_get(lcd_getfont())->maxwidth;
44
-
#else
45
-
return 1;
46
-
#endif
47
43
}
48
44
49
45
static int screen_helper_getcharheight(void)
50
46
{
51
-
#ifdef HAVE_LCD_BITMAP
52
47
return font_get(lcd_getfont())->height;
53
-
#else
54
-
return 1;
55
-
#endif
56
48
}
57
49
58
50
static int screen_helper_getnblines(void)
59
51
{
60
52
int height=screens[0].lcdheight;
61
-
#ifdef HAVE_LCD_BITMAP
62
53
if(global_settings.statusbar != STATUSBAR_OFF)
63
54
height -= STATUSBAR_HEIGHT;
64
-
#endif
65
55
return height / screens[0].getcharheight();
66
56
}
67
57
68
58
void screen_helper_setfont(int font)
69
59
{
70
60
(void)font;
71
-
#ifdef HAVE_LCD_BITMAP
72
61
if (font == FONT_UI)
73
62
font = global_status.font_id[SCREEN_MAIN];
74
63
lcd_setfont(font);
75
-
#endif
76
64
}
77
65
78
-
#ifdef HAVE_LCD_BITMAP
79
66
static int screen_helper_getuifont(void)
80
67
{
81
68
return global_status.font_id[SCREEN_MAIN];
···
85
72
{
86
73
global_status.font_id[SCREEN_MAIN] = font;
87
74
}
88
-
#endif
89
75
90
76
static void screen_helper_set_drawmode(int mode)
91
77
{
92
-
#ifdef HAVE_LCD_BITMAP
93
78
lcd_set_drawmode(mode);
94
-
#else
95
-
(void) mode;
96
-
#endif
97
79
}
98
80
99
81
static void screen_helper_put_line(int x, int y, struct line_desc *line,
···
108
90
#if NB_SCREENS == 2
109
91
static int screen_helper_remote_getcharwidth(void)
110
92
{
111
-
#ifdef HAVE_LCD_BITMAP
112
93
return font_get(lcd_remote_getfont())->maxwidth;
113
-
#else
114
-
return 1;
115
-
#endif
116
94
}
117
95
118
96
static int screen_helper_remote_getcharheight(void)
119
97
{
120
-
#ifdef HAVE_LCD_BITMAP
121
98
return font_get(lcd_remote_getfont())->height;
122
-
#else
123
-
return 1;
124
-
#endif
125
99
}
126
100
127
101
static int screen_helper_remote_getnblines(void)
128
102
{
129
103
int height=screens[1].lcdheight;
130
-
#ifdef HAVE_LCD_BITMAP
131
104
if(global_settings.statusbar != STATUSBAR_OFF)
132
105
height -= STATUSBAR_HEIGHT;
133
-
#endif
134
106
return height / screens[1].getcharheight();
135
107
}
136
108
···
143
115
144
116
static int screen_helper_remote_getuifont(void)
145
117
{
146
-
#ifdef HAVE_LCD_BITMAP
147
118
return global_status.font_id[SCREEN_REMOTE];
148
-
#else
149
-
return FONT_SYSFIXED;
150
-
#endif
151
119
}
152
120
153
121
static void screen_helper_remote_setuifont(int font)
154
122
{
155
-
#ifdef HAVE_LCD_BITMAP
156
123
global_status.font_id[SCREEN_REMOTE] = font;
157
-
#endif
158
124
}
159
125
160
126
static void screen_helper_remote_put_line(int x, int y, struct line_desc *line,
···
181
147
#else
182
148
.is_color=false,
183
149
#endif
184
-
#ifdef HAVE_LCD_BITMAP
185
150
.pixel_format=LCD_PIXELFORMAT,
186
-
#endif
187
151
.getcharwidth=screen_helper_getcharwidth,
188
152
.getcharheight=screen_helper_getcharheight,
189
153
#if (CONFIG_LED == LED_VIRTUAL)
···
196
160
.getwidth=&lcd_getwidth,
197
161
.getheight=&lcd_getheight,
198
162
.getstringsize=&lcd_getstringsize,
199
-
#ifdef HAVE_LCD_BITMAP
200
163
.setfont=screen_helper_setfont,
201
164
.getuifont=screen_helper_getuifont,
202
165
.setuifont=screen_helper_setuifont,
···
235
198
.vline=&lcd_vline,
236
199
.hline=&lcd_hline,
237
200
.scroll_step=&lcd_scroll_step,
238
-
#endif /* HAVE_LCD_BITMAP */
239
201
240
202
.putsxy=&lcd_putsxy,
241
203
.puts=&lcd_puts,
···
259
221
.backdrop_load=&backdrop_load,
260
222
.backdrop_show=&backdrop_show,
261
223
#endif
262
-
#if defined(HAVE_LCD_BITMAP)
263
224
.set_framebuffer = (void*)lcd_set_framebuffer,
264
225
#if defined(HAVE_LCD_COLOR)
265
226
.gradient_fillrect = lcd_gradient_fillrect,
266
227
.gradient_fillrect_part = lcd_gradient_fillrect_part,
267
228
#endif
268
-
#endif
269
229
.put_line = screen_helper_put_line,
270
230
},
271
231
#if NB_SCREENS == 2
···
347
307
.backdrop_load=&remote_backdrop_load,
348
308
.backdrop_show=&remote_backdrop_show,
349
309
#endif
350
-
#if defined(HAVE_LCD_BITMAP)
351
310
.set_framebuffer = (void*)lcd_remote_set_framebuffer,
352
-
#endif
353
311
.put_line = screen_helper_remote_put_line,
354
312
}
355
313
#endif /* NB_SCREENS == 2 */
356
314
};
357
315
358
-
#ifdef HAVE_LCD_BITMAP
359
316
void screen_clear_area(struct screen * display, int xstart, int ystart,
360
317
int width, int height)
361
318
{
···
363
320
display->fillrect(xstart, ystart, width, height);
364
321
display->set_drawmode(DRMODE_SOLID);
365
322
}
366
-
#endif
-10
apps/screen_access.h
-10
apps/screen_access.h
···
50
50
int lcdwidth, lcdheight;
51
51
int depth;
52
52
int (*getnblines)(void);
53
-
#ifdef HAVE_LCD_BITMAP
54
53
int pixel_format;
55
-
#endif
56
54
int (*getcharwidth)(void);
57
55
int (*getcharheight)(void);
58
56
bool is_color;
···
64
62
int (*getwidth)(void);
65
63
int (*getheight)(void);
66
64
int (*getstringsize)(const unsigned char *str, int *w, int *h);
67
-
#if defined(HAVE_LCD_BITMAP) || defined(HAVE_REMOTE_LCD) /* always bitmap */
68
65
void (*setfont)(int newfont);
69
66
int (*getuifont)(void);
70
67
void (*setuifont)(int newfont);
···
104
101
void (*drawline)(int x1, int y1, int x2, int y2);
105
102
void (*vline)(int x, int y1, int y2);
106
103
void (*hline)(int x1, int x2, int y);
107
-
#endif /* HAVE_LCD_BITMAP || HAVE_REMOTE_LCD */
108
104
109
105
void (*putsxy)(int x, int y, const unsigned char *str);
110
106
void (*puts)(int x, int y, const unsigned char *str);
···
130
126
bool (*backdrop_load)(const char *filename, char* backdrop_buffer);
131
127
void (*backdrop_show)(char* backdrop_buffer);
132
128
#endif
133
-
#if defined(HAVE_LCD_BITMAP)
134
129
void (*set_framebuffer)(void *framebuffer);
135
130
#if defined(HAVE_LCD_COLOR)
136
131
void (*gradient_fillrect)(int x, int y, int width, int height,
···
138
133
void (*gradient_fillrect_part)(int x, int y, int width, int height,
139
134
unsigned start, unsigned end, int src_height, int row_skip);
140
135
#endif
141
-
#endif
142
-
#if defined(HAVE_LCD_BITMAP)
143
136
void (*nine_segment_bmp)(const struct bitmap* bm, int x, int y,
144
137
int width, int height);
145
-
#endif
146
138
void (*put_line)(int x, int y, struct line_desc *line, const char *fmt, ...);
147
139
};
148
140
149
-
#if defined(HAVE_LCD_BITMAP) || defined(HAVE_REMOTE_LCD)
150
141
/*
151
142
* Clear only a given area of the screen
152
143
* - screen : the screen structure
···
155
146
*/
156
147
void screen_clear_area(struct screen * display, int xstart, int ystart,
157
148
int width, int height);
158
-
#endif
159
149
160
150
/*
161
151
* exported screens array that should be used
+2
-2
apps/screens.c
+2
-2
apps/screens.c
···
66
66
#endif
67
67
68
68
69
-
#if defined(HAVE_LCD_BITMAP) && (CONFIG_RTC != 0)
69
+
#if (CONFIG_RTC != 0)
70
70
71
71
/* little helper function for voice output */
72
72
static void say_time(int cursorpos, const struct tm *tm)
···
360
360
#endif
361
361
return usb;
362
362
}
363
-
#endif /* defined(HAVE_LCD_BITMAP) && (CONFIG_RTC != 0) */
363
+
#endif /* (CONFIG_RTC != 0) */
364
364
365
365
static const int id3_headers[]=
366
366
{
-21
apps/settings.c
-21
apps/settings.c
···
47
47
#include "system.h"
48
48
#include "general.h"
49
49
#include "misc.h"
50
-
#ifdef HAVE_LCD_BITMAP
51
50
#include "icons.h"
52
51
#include "font.h"
53
52
#include "peakmeter.h"
54
-
#endif
55
53
#include "lang.h"
56
54
#include "language.h"
57
55
#include "powermgmt.h"
···
91
89
#define NVRAM_BLOCK_SIZE (sizeof(struct system_status) + NVRAM_DATA_START)
92
90
#endif
93
91
94
-
#ifdef HAVE_LCD_BITMAP
95
92
#define MAX_LINES 10
96
-
#else
97
-
#define MAX_LINES 2
98
-
#endif
99
93
100
94
#ifdef HAVE_REMOTE_LCD
101
95
#include "lcd-remote.h"
···
706
700
707
701
/** Apply and Reset settings **/
708
702
709
-
710
-
#ifdef HAVE_LCD_BITMAP
711
703
/*
712
704
* Applies the range infos stored in global_settings to
713
705
* the peak meter.
···
734
726
/* apply the range */
735
727
peak_meter_init_range(global_settings.peak_meter_dbfs, pm_min, pm_max);
736
728
}
737
-
#endif /* HAVE_LCD_BITMAP */
738
729
739
730
void sound_settings_apply(void)
740
731
{
···
786
777
787
778
void settings_apply(bool read_disk)
788
779
{
789
-
#ifdef HAVE_LCD_BITMAP
790
780
int rc;
791
-
#endif
792
781
CHART(">set_codepage");
793
782
set_codepage(global_settings.default_codepage);
794
783
CHART("<set_codepage");
···
864
853
set_battery_type(global_settings.battery_type);
865
854
#endif
866
855
867
-
#ifdef HAVE_LCD_BITMAP
868
856
#ifdef HAVE_LCD_INVERT
869
857
lcd_set_invert_display(global_settings.invert);
870
858
#endif
···
877
865
peak_meter_init_times(
878
866
global_settings.peak_meter_release, global_settings.peak_meter_hold,
879
867
global_settings.peak_meter_clip_hold);
880
-
#endif
881
868
882
869
#ifdef HAVE_SPEAKER
883
870
audio_enable_speaker(global_settings.speaker_mode);
···
886
873
if (read_disk)
887
874
{
888
875
char buf[MAX_PATH];
889
-
#ifdef HAVE_LCD_BITMAP
890
876
/* fonts need to be loaded before the WPS */
891
877
if (global_settings.font_file[0]
892
878
&& global_settings.font_file[0] != '-') {
···
935
921
}
936
922
else
937
923
load_kbd(NULL);
938
-
#endif /* HAVE_LCD_BITMAP */
939
924
if ( global_settings.lang_file[0]) {
940
925
snprintf(buf, sizeof buf, LANG_DIR "/%s.lng",
941
926
global_settings.lang_file);
···
967
952
screens[SCREEN_MAIN].set_background(global_settings.bg_color);
968
953
#endif
969
954
970
-
#ifdef HAVE_LCD_BITMAP
971
955
lcd_scroll_step(global_settings.scroll_step);
972
956
gui_list_screen_scroll_step(global_settings.screen_scroll_step);
973
957
gui_list_screen_scroll_out_of_view(global_settings.offset_out_of_view);
974
-
#endif
975
958
lcd_bidir_scroll(global_settings.bidir_limit);
976
959
lcd_scroll_delay(global_settings.scroll_delay);
977
960
···
1063
1046
#if defined(HAVE_RECORDING)
1064
1047
enc_global_settings_apply();
1065
1048
#endif
1066
-
#ifdef HAVE_LCD_BITMAP
1067
1049
/* already called with THEME_STATUSBAR in settings_apply_skins() */
1068
1050
CHART(">viewportmanager_theme_changed");
1069
1051
viewportmanager_theme_changed(THEME_UI_VIEWPORT|THEME_LANGUAGE|THEME_BUTTONBAR);
1070
1052
CHART("<viewportmanager_theme_changed");
1071
-
#endif
1072
1053
}
1073
1054
1074
1055
···
1109
1090
#if defined (HAVE_RECORDING)
1110
1091
enc_global_settings_reset();
1111
1092
#endif
1112
-
#ifdef HAVE_LCD_BITMAP
1113
1093
FOR_NB_SCREENS(i)
1114
1094
{
1115
1095
if (screens[i].getuifont() > FONT_SYSFIXED)
···
1119
1099
screens[i].setfont(FONT_SYSFIXED);
1120
1100
}
1121
1101
}
1122
-
#endif
1123
1102
}
1124
1103
1125
1104
/** Changing setting values **/
-10
apps/settings.h
-10
apps/settings.h
···
286
286
signed char last_screen;
287
287
int viewer_icon_count;
288
288
int last_volume_change; /* tick the last volume change happened. skins use this */
289
-
#ifdef HAVE_LCD_BITMAP
290
289
int font_id[NB_SCREENS]; /* font id of the settings font for each screen */
291
-
#endif
292
290
293
291
};
294
292
···
494
492
int peak_meter_max; /* range maximum */
495
493
496
494
unsigned char wps_file[MAX_FILENAME+1]; /* last wps */
497
-
#ifdef HAVE_LCD_BITMAP
498
495
unsigned char sbs_file[MAX_FILENAME+1]; /* last statusbar skin */
499
-
#endif
500
496
#ifdef HAVE_REMOTE_LCD
501
497
unsigned char rwps_file[MAX_FILENAME+1]; /* last remote-wps */
502
498
unsigned char rsbs_file[MAX_FILENAME+1]; /* last remote statusbar skin */
···
514
510
int remote_statusbar;
515
511
#endif
516
512
517
-
#ifdef HAVE_LCD_BITMAP
518
513
int scrollbar; /* SCROLLBAR_* enum values */
519
514
int scrollbar_width;
520
515
···
525
520
int list_separator_height; /* -1=auto (== 1 currently), 0=disabled, X=height in pixels */
526
521
int list_separator_color;
527
522
#endif
528
-
#endif
529
523
/* goto current song when exiting WPS */
530
524
bool browse_current; /* 1=goto current song,
531
525
0=goto previous location */
···
621
615
int contrast; /* lcd contrast */
622
616
#endif
623
617
624
-
#ifdef HAVE_LCD_BITMAP
625
618
#ifdef HAVE_LCD_INVERT
626
619
bool invert; /* invert display */
627
620
#endif
···
640
633
unsigned char remote_font_file[MAX_FILENAME+1]; /* last font */
641
634
#endif
642
635
unsigned char kbd_file[MAX_FILENAME+1]; /* last keyboard */
643
-
#endif /* HAVE_LCD_BITMAP */
644
636
int backlight_timeout; /* backlight off timeout: -1=never,
645
637
0=always, or time in seconds */
646
638
bool caption_backlight; /* turn on backlight at end and start of track */
···
748
740
bool usb_skip_first_drive;
749
741
#endif
750
742
751
-
#ifdef HAVE_LCD_BITMAP
752
743
unsigned char ui_vp_config[64]; /* viewport string for the lists */
753
744
#ifdef HAVE_REMOTE_LCD
754
745
unsigned char remote_ui_vp_config[64]; /* viewport string for the remote lists */
755
-
#endif
756
746
#endif
757
747
758
748
struct compressor_settings compressor_settings;
-42
apps/settings_list.c
-42
apps/settings_list.c
···
43
43
#endif
44
44
#include "list.h"
45
45
#include "rbunicode.h"
46
-
#ifdef HAVE_LCD_BITMAP
47
46
#include "peakmeter.h"
48
-
#endif
49
47
#include "menus/eq_menu.h"
50
48
#if CONFIG_TUNER
51
49
#include "radio.h"
···
219
217
static const int backlight_fade[] = {0,100,200,300,500,1000,2000,3000,5000,10000};
220
218
#endif
221
219
222
-
#ifdef HAVE_LCD_BITMAP
223
220
static const char graphic_numeric[] = "graphic,numeric";
224
-
#endif
225
221
226
222
/* Default theme settings */
227
223
#define DEFAULT_WPSNAME "cabbiev2"
228
224
#define DEFAULT_SBSNAME "-"
229
225
#define DEFAULT_FMS_NAME "cabbiev2"
230
-
231
-
#ifdef HAVE_LCD_BITMAP
232
226
233
227
#if LCD_HEIGHT <= 64
234
228
#define DEFAULT_FONT_HEIGHT 8
···
255
249
#define MIN_GLYPHS 50
256
250
#define MAX_GLYPHS 65540
257
251
258
-
#else
259
-
#define DEFAULT_FONT_HEIGHT 12
260
-
#endif
261
-
262
252
#ifndef DEFAULT_FONTNAME
263
253
/* ugly expansion needed */
264
254
#define _EXPAND2(x) #x
···
438
428
return talk_time_intervals(value, unit, false);
439
429
}
440
430
441
-
#ifdef HAVE_LCD_BITMAP
442
431
static const char* formatter_time_unit_0_is_eternal(char *buffer,
443
432
size_t buffer_size, int val, const char *unit)
444
433
{
···
455
444
else
456
445
return talk_time_intervals(value, unit, false);
457
446
}
458
-
#endif /* HAVE_LCD_BITMAP */
459
447
460
448
#ifndef HAVE_WHEEL_ACCELERATION
461
449
static const char* scanaccel_formatter(char *buffer, size_t buffer_size,
···
907
895
23, timeout_sec_common),
908
896
#endif
909
897
#endif /* HAVE_BACKLIGHT */
910
-
#ifdef HAVE_LCD_BITMAP
911
898
#ifdef HAVE_LCD_INVERT
912
899
BOOL_SETTING(0, invert, LANG_INVERT, false ,"invert", off_on,
913
900
LANG_INVERT_LCD_INVERSE, LANG_NORMAL, lcd_set_invert_display),
···
972
959
CHOICE_SETTING(0, timeformat, LANG_TIMEFORMAT, 0,
973
960
"time format", "24hour,12hour", NULL, 2,
974
961
ID2P(LANG_24_HOUR_CLOCK), ID2P(LANG_12_HOUR_CLOCK)),
975
-
#endif /* HAVE_LCD_BITMAP */
976
962
OFFON_SETTING(0,show_icons, LANG_SHOW_ICONS ,true,"show icons", NULL),
977
963
/* system */
978
964
INT_SETTING(F_TIME_SETTING, poweroff, LANG_POWEROFF_IDLE, 10,
···
1170
1156
"remote bidir limit", UNIT_PERCENT, 0, 200, 25, NULL, NULL,
1171
1157
lcd_remote_bidir_scroll),
1172
1158
#endif
1173
-
#ifdef HAVE_LCD_BITMAP
1174
1159
OFFON_SETTING(0, offset_out_of_view, LANG_SCREEN_SCROLL_VIEW,
1175
1160
false, "Screen Scrolls Out Of View",
1176
1161
gui_list_screen_scroll_out_of_view),
···
1179
1164
INT_SETTING(F_PADTITLE, screen_scroll_step, LANG_SCREEN_SCROLL_STEP, 16,
1180
1165
"screen scroll step", UNIT_PIXEL, 1, LCD_WIDTH, 1, NULL, NULL,
1181
1166
gui_list_screen_scroll_step),
1182
-
#endif /* HAVE_LCD_BITMAP */
1183
1167
OFFON_SETTING(0,scroll_paginated,LANG_SCROLL_PAGINATED,
1184
1168
false,"scroll paginated",NULL),
1185
1169
#ifdef HAVE_LCD_COLOR
···
1274
1258
ID2P(LANG_SET_BOOL_YES),
1275
1259
ID2P(LANG_BOOKMARK_SETTINGS_ONE_PER_PLAYLIST),
1276
1260
ID2P(LANG_BOOKMARK_SETTINGS_ONE_PER_TRACK)),
1277
-
#ifdef HAVE_LCD_BITMAP
1278
1261
/* peak meter */
1279
1262
TABLE_SETTING_LIST(F_TIME_SETTING | F_ALLOW_ARBITRARY_VALS, peak_meter_clip_hold,
1280
1263
LANG_PM_CLIP_HOLD, 60, "peak meter clip hold", "eternal",
···
1297
1280
OFFON_SETTING(0, peak_meter_clipcounter, LANG_PM_CLIPCOUNTER, false,
1298
1281
"peak meter clipcounter", NULL),
1299
1282
#endif /* HAVE_RECORDING */
1300
-
#endif /* HAVE_LCD_BITMAP */
1301
1283
/* voice */
1302
1284
OFFON_SETTING(F_TEMPVAR, talk_menu, LANG_VOICE_MENU, true, "talk menu", NULL),
1303
1285
CHOICE_SETTING(0, talk_dir, LANG_VOICE_DIR, 0,
···
1755
1737
#endif
1756
1738
CHOICE_SETTING(F_TEMPVAR, default_codepage, LANG_DEFAULT_CODEPAGE, 0,
1757
1739
"default codepage",
1758
-
#ifdef HAVE_LCD_BITMAP
1759
1740
/* The order must match with that in unicode.c */
1760
1741
"iso8859-1,iso8859-7,iso8859-8,cp1251,iso8859-11,cp1256,"
1761
1742
"iso8859-9,iso8859-2,cp1250,cp1252,sjis,gb2312,ksx1001,big5,utf-8",
···
1771
1752
ID2P(LANG_CODEPAGE_JAPANESE),
1772
1753
ID2P(LANG_CODEPAGE_SIMPLIFIED), ID2P(LANG_CODEPAGE_KOREAN),
1773
1754
ID2P(LANG_CODEPAGE_TRADITIONAL), ID2P(LANG_CODEPAGE_UTF8)),
1774
-
#else /* !HAVE_LCD_BITMAP */
1775
-
/* The order must match with that in unicode.c */
1776
-
"iso8859-1,iso8859-7,cp1251,iso8859-9,iso8859-2,cp1250,cp1252,utf-8",
1777
-
NULL, 8,
1778
-
ID2P(LANG_CODEPAGE_LATIN1), ID2P(LANG_CODEPAGE_GREEK),
1779
-
ID2P(LANG_CODEPAGE_CYRILLIC), ID2P(LANG_CODEPAGE_TURKISH),
1780
-
ID2P(LANG_CODEPAGE_LATIN_EXTENDED),
1781
-
ID2P(LANG_CODEPAGE_CENTRAL_EUROPEAN),
1782
-
ID2P(LANG_CODEPAGE_WESTERN_EUROPEAN),
1783
-
ID2P(LANG_CODEPAGE_UTF8)),
1784
-
#endif
1785
1755
OFFON_SETTING(0, warnon_erase_dynplaylist, LANG_WARN_ERASEDYNPLAYLIST_MENU,
1786
1756
true, "warn when erasing dynamic playlist",NULL),
1787
1757
···
1805
1775
1806
1776
OFFON_SETTING(0, hold_lr_for_scroll_in_list, -1, true,
1807
1777
"hold_lr_for_scroll_in_list",NULL),
1808
-
#ifdef HAVE_LCD_BITMAP
1809
1778
CHOICE_SETTING(0, show_path_in_browser, LANG_SHOW_PATH, SHOW_PATH_CURRENT,
1810
1779
"show path in browser", "off,current directory,full path",
1811
1780
NULL, 3, ID2P(LANG_OFF), ID2P(LANG_SHOW_PATH_CURRENT),
1812
1781
ID2P(LANG_DISPLAY_FULL_PATH)),
1813
-
#endif
1814
1782
1815
1783
#ifdef HAVE_AGC
1816
1784
{F_T_INT,&global_settings.rec_agc_preset_mic,LANG_RECORDING_AGC_PRESET,
···
1866
1834
DEFAULT_FMS_NAME, SBS_DIR "/", ".rfms"),
1867
1835
#endif
1868
1836
#endif /* CONFIG_TUNER */
1869
-
#ifdef HAVE_LCD_BITMAP
1870
1837
TEXT_SETTING(F_THEMESETTING, font_file, "font",
1871
1838
DEFAULT_FONTNAME, FONT_DIR "/", ".fnt"),
1872
1839
INT_SETTING(0, glyphs_to_cache, LANG_GLYPHS, DEFAULT_GLYPHS,
1873
1840
"glyphs", UNIT_INT, MIN_GLYPHS, MAX_GLYPHS, 10,
1874
1841
NULL, NULL, NULL),
1875
-
#endif
1876
1842
#ifdef HAVE_REMOTE_LCD
1877
1843
TEXT_SETTING(F_THEMESETTING, remote_font_file, "remote font",
1878
1844
DEFAULT_REMOTE_FONTNAME, FONT_DIR "/", ".fnt"),
1879
1845
#endif
1880
1846
TEXT_SETTING(F_THEMESETTING,wps_file, "wps",
1881
1847
DEFAULT_WPSNAME, WPS_DIR "/", ".wps"),
1882
-
#ifdef HAVE_LCD_BITMAP
1883
1848
TEXT_SETTING(F_THEMESETTING,sbs_file, "sbs",
1884
1849
DEFAULT_SBSNAME, SBS_DIR "/", ".sbs"),
1885
-
#endif
1886
1850
#ifdef HAVE_REMOTE_LCD
1887
1851
TEXT_SETTING(F_THEMESETTING,rwps_file,"rwps",
1888
1852
DEFAULT_WPSNAME, WPS_DIR "/", ".rwps"),
···
1894
1858
TEXT_SETTING(F_THEMESETTING,backdrop_file,"backdrop",
1895
1859
DEFAULT_BACKDROP, NULL, NULL),
1896
1860
#endif
1897
-
#ifdef HAVE_LCD_BITMAP
1898
1861
TEXT_SETTING(0,kbd_file,"kbd","-",ROCKBOX_DIR "/",".kbd"),
1899
-
#endif
1900
1862
#ifdef HAVE_USB_CHARGING_ENABLE
1901
1863
CHOICE_SETTING(0, usb_charging, LANG_USB_CHARGING, 1, "usb charging",
1902
1864
"off,on,force", NULL, 3, ID2P(LANG_SET_BOOL_NO),
···
1965
1927
#endif /* HAVE_RTC_ALARM */
1966
1928
1967
1929
/* Customizable icons */
1968
-
#ifdef HAVE_LCD_BITMAP
1969
1930
TEXT_SETTING(F_THEMESETTING, icon_file, "iconset", DEFAULT_ICONSET,
1970
1931
ICON_DIR "/", ".bmp"),
1971
1932
TEXT_SETTING(F_THEMESETTING, viewers_icon_file, "viewers iconset",
1972
1933
DEFAULT_VIEWERS_ICONSET,
1973
1934
ICON_DIR "/", ".bmp"),
1974
-
#endif
1975
1935
#ifdef HAVE_REMOTE_LCD
1976
1936
TEXT_SETTING(F_THEMESETTING, remote_icon_file, "remote iconset", "-",
1977
1937
ICON_DIR "/", ".bmp"),
···
2128
2088
#endif
2129
2089
2130
2090
/* Customizable list */
2131
-
#ifdef HAVE_LCD_BITMAP
2132
2091
VIEWPORT_SETTING(ui_vp_config, "ui viewport"),
2133
2092
#ifdef HAVE_REMOTE_LCD
2134
2093
VIEWPORT_SETTING(remote_ui_vp_config, "remote ui viewport"),
2135
-
#endif
2136
2094
#endif
2137
2095
2138
2096
#ifdef HAVE_MORSE_INPUT
+4
-12
apps/tree.c
+4
-12
apps/tree.c
···
399
399
}
400
400
}
401
401
#ifdef HAVE_TAGCACHE
402
-
if (id3db)
402
+
if (id3db)
403
403
{
404
-
#ifdef HAVE_LCD_BITMAP
405
404
if (global_settings.show_path_in_browser == SHOW_PATH_FULL
406
405
|| global_settings.show_path_in_browser == SHOW_PATH_CURRENT)
407
406
{
···
412
411
{
413
412
/* Must clear the title as the list is reused */
414
413
gui_synclist_set_title(&tree_lists, NULL, NOICON);
415
-
}
416
-
#endif
414
+
}
417
415
}
418
416
else
419
417
#endif
420
418
{
421
-
#ifdef HAVE_LCD_BITMAP
422
419
if (tc.browse && tc.browse->title)
423
420
{
424
421
int icon = tc.browse->icon;
···
448
445
{
449
446
/* Must clear the title as the list is reused */
450
447
gui_synclist_set_title(&tree_lists, NULL, NOICON);
451
-
}
452
-
#endif
448
+
}
453
449
}
454
450
455
451
gui_synclist_set_nb_items(&tree_lists, tc.filesindir);
···
606
602
char buf[MAX_PATH];
607
603
int len;
608
604
int button;
609
-
#ifdef HAVE_LCD_BITMAP
610
605
int oldbutton;
611
-
#endif
612
606
bool reload_root = false;
613
607
int lastfilter = *tc.dirfilter;
614
608
bool lastsortcase = global_settings.sort_case;
···
643
637
splash(HZ*2, ID2P(LANG_NO_FILES));
644
638
return GO_TO_PREVIOUS; /* No files found for rockbox_browse() */
645
639
}
646
-
640
+
647
641
gui_synclist_draw(&tree_lists);
648
642
while(1) {
649
643
bool restore = false;
···
653
647
keyclick_set_callback(gui_synclist_keyclick_callback, &tree_lists);
654
648
button = get_action(CONTEXT_TREE,
655
649
list_do_action_timeout(&tree_lists, HZ/2));
656
-
#ifdef HAVE_LCD_BITMAP
657
650
oldbutton = button;
658
-
#endif
659
651
gui_synclist_do_button(&tree_lists, &button,LIST_WRAP_UNLESS_HELD);
660
652
tc.selected_item = gui_synclist_get_sel_pos(&tree_lists);
661
653
switch ( button ) {
+18
-41
docs/PLUGIN_API
+18
-41
docs/PLUGIN_API
···
185
185
\description
186
186
187
187
unsigned short *bidi_l2v( const unsigned char *str, int orientation )
188
-
\conditions defined(HAVE_LCD_BITMAP)
189
188
\param str
190
189
\param orientation
191
190
\return
···
332
331
\description
333
332
334
333
struct event_queue *button_queue
335
-
\conditions defined(HAVE_LCD_BITMAP) )) && (defined(HAVE_LCD_ENABLE
334
+
\conditions (defined(HAVE_LCD_ENABLE))
336
335
\return
337
336
\description
338
337
···
351
350
\description Unboosts the CPU for the current thread
352
351
353
352
const unsigned char *font_get_bits( struct font *pf, unsigned short char_code )
354
-
\conditions defined(HAVE_LCD_BITMAP)
355
353
\param pf
356
354
\param char_code
357
355
\return
···
601
599
\description
602
600
603
601
struct font* font_get(int font)
604
-
\conditions defined(HAVE_LCD_BITMAP)
605
602
\param font
606
603
\return the font structure for =font=
607
604
\description If the requested font isn't loaded/compiled-in, decrement the font number and try again.
608
605
\see [S[firmware/export/font.h]]
609
606
610
607
int font_getstringsize(const unsigned char *str, int *w, int *h, int fontnumber)
611
-
\conditions defined(HAVE_LCD_BITMAP)
612
608
\param str
613
609
\param w
614
610
\param h
···
617
613
\description
618
614
619
615
int font_get_width(struct font* pf, unsigned short char_code)
620
-
\conditions defined(HAVE_LCD_BITMAP)
621
616
\param pf
622
617
\param char_code
623
618
\return
624
619
\description
625
620
626
621
struct font* font_load(const char *path)
627
-
\conditions defined(HAVE_LCD_BITMAP)
628
622
\param path
629
623
\return
630
624
\description Load font =path= and returns a struct font pointer for it
···
678
672
\see [S[apps/settings.h]]
679
673
680
674
void gui_scrollbar_draw(struct screen * screen, int x, int y, int width, int height, int items, int min_shown, int max_shown, unsigned flags)
681
-
\conditions defined(HAVE_LCD_BITMAP)
682
675
\param screen
683
676
\param x
684
677
\param y
···
808
801
809
802
void lcd_bitmap(const fb_data *src, int x, int y, int width, int height)
810
803
\group lcd
811
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
804
+
\conditions (LCD_DEPTH > 1)
812
805
\param src
813
806
\param x
814
807
\param y
···
818
811
819
812
void lcd_bitmap_part(const fb_data *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
820
813
\group lcd
821
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
814
+
\conditions (LCD_DEPTH > 1)
822
815
\param src
823
816
\param src_x
824
817
\param src_y
···
831
824
832
825
void lcd_bitmap_transparent(const fb_data *src, int x, int y, int width, int height)
833
826
\group lcd
834
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH == 16)
827
+
\conditions (LCD_DEPTH >= 16)
835
828
\param src
836
829
\param x
837
830
\param y
···
841
834
842
835
void lcd_bitmap_transparent_part(const fb_data *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
843
836
\group lcd
844
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH == 16)
837
+
\conditions (LCD_DEPTH >= 16)
845
838
\param src
846
839
\param src_x
847
840
\param src_y
···
854
847
855
848
void lcd_blit_grey_phase(unsigned char *values, unsigned char *phases, int bx, int by, int bwidth, int bheight, int stride)
856
849
\group lcd
857
-
\conditions defined(HAVE_LCD_BITMAP) )) && ((LCD_DEPTH < 4) && !defined(SIMULATOR
850
+
\conditions ((LCD_DEPTH < 4) && !defined(SIMULATOR))
858
851
\param values
859
852
\param phases
860
853
\param bx
···
866
859
867
860
void lcd_blit_mono(const unsigned char *data, int x, int by, int width, int bheight, int stride)
868
861
\group lcd
869
-
\conditions defined(HAVE_LCD_BITMAP) )) && ((LCD_DEPTH < 4) && !defined(SIMULATOR
862
+
\conditions ((LCD_DEPTH < 4) && !defined(SIMULATOR))
870
863
\param data
871
864
\param x
872
865
\param by
···
877
870
878
871
void lcd_blit_yuv(unsigned char * const src[3], int src_x, int src_y, int stride, int x, int y, int width, int height)
879
872
\group lcd
880
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH == 16)
873
+
\conditions (LCD_DEPTH >= 16)
881
874
\param src[3]
882
875
\param src_x
883
876
\param src_y
···
894
887
895
888
void lcd_drawline(int x1, int y1, int x2, int y2)
896
889
\group lcd
897
-
\conditions defined(HAVE_LCD_BITMAP)
898
890
\param x1 X top coordinate
899
891
\param y1 Y top coordinate
900
892
\param x2 X bottom coordinate
···
903
895
904
896
void lcd_drawpixel(int x, int y)
905
897
\group lcd
906
-
\conditions defined(HAVE_LCD_BITMAP)
907
898
\param x
908
899
\param y
909
900
\description Draws a pixel at (=x=, =y=) within current drawing mode
910
901
911
902
void lcd_drawrect(int x, int y, int width, int height)
912
903
\group lcd
913
-
\conditions defined(HAVE_LCD_BITMAP)
914
904
\param x
915
905
\param y
916
906
\param width
···
919
909
920
910
void lcd_fillrect(int x, int y, int width, int height)
921
911
\group lcd
922
-
\conditions defined(HAVE_LCD_BITMAP)
923
912
\param x
924
913
\param y
925
914
\param width
···
928
917
929
918
fb_data* lcd_framebuffer
930
919
\group lcd
931
-
\conditions defined(HAVE_LCD_BITMAP)
932
920
\return
933
921
\description Pointer to the framebuffer
934
922
\see [S[firmware/export/lcd.h]]
···
943
931
944
932
fb_data* lcd_get_backdrop(void)
945
933
\group lcd
946
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
934
+
\conditions (LCD_DEPTH > 1)
947
935
\return Pointer to framebuffer data
948
936
\description Gets the current backdrop
949
937
\see lcd_framebuffer
950
938
951
939
unsigned lcd_get_background(void)
952
940
\group lcd
953
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
941
+
\conditions (LCD_DEPTH > 1)
954
942
\return
955
943
\description
956
944
957
945
int lcd_get_drawmode(void)
958
946
\group lcd
959
-
\conditions defined(HAVE_LCD_BITMAP)
960
947
\return current LCD drawing mode
961
948
\description
962
949
963
950
unsigned lcd_get_foreground(void)
964
951
\group lcd
965
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
952
+
\conditions (LCD_DEPTH > 1)
966
953
\return
967
954
\description
968
955
969
956
void lcd_hline(int x1, int x2, int y)
970
957
\group lcd
971
-
\conditions defined(HAVE_LCD_BITMAP)
972
958
\param x1 X start coordinate
973
959
\param x2 X end coordinate
974
960
\param y Y coordinate
···
976
962
977
963
void lcd_mono_bitmap(const unsigned char *src, int x, int y, int width, int height)
978
964
\group lcd
979
-
\conditions defined(HAVE_LCD_BITMAP)
980
965
\param src
981
966
\param x
982
967
\param y
···
986
971
987
972
void lcd_mono_bitmap_part(const unsigned char *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
988
973
\group lcd
989
-
\conditions defined(HAVE_LCD_BITMAP)
990
974
\param src
991
975
\param src_x
992
976
\param src_y
···
1230
1214
1231
1215
void lcd_setfont(int font)
1232
1216
\group lcd
1233
-
\conditions defined(HAVE_LCD_BITMAP)
1234
1217
\param font
1235
1218
\description Set default font
1236
1219
1237
1220
void lcd_set_backdrop(fb_data* backdrop)
1238
1221
\group lcd
1239
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
1222
+
\conditions (LCD_DEPTH > 1)
1240
1223
\param backdrop Pointer to backdrop image
1241
1224
\description Set the backdrop to =backdrop=
1242
1225
\see lcd_framebuffer
1243
1226
1244
1227
void lcd_set_background(unsigned foreground)
1245
1228
\group lcd
1246
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
1229
+
\conditions (LCD_DEPTH > 1)
1247
1230
\param foreground
1248
1231
\description
1249
1232
···
1254
1237
1255
1238
void lcd_set_drawmode(int mode)
1256
1239
\group lcd
1257
-
\conditions defined(HAVE_LCD_BITMAP)
1258
1240
\param mode
1259
1241
\description
1260
1242
1261
1243
void lcd_set_foreground(unsigned foreground)
1262
1244
\group lcd
1263
-
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
1245
+
\conditions (LCD_DEPTH > 1)
1264
1246
\param foreground
1265
1247
\description
1266
1248
1267
1249
void lcd_set_invert_display(bool yesno)
1268
1250
\group lcd
1269
-
\conditions defined(HAVE_LCD_BITMAP) )) && (defined(HAVE_LCD_INVERT
1251
+
\conditions (defined(HAVE_LCD_INVERT))
1270
1252
\param yesno
1271
1253
\description
1272
1254
···
1280
1262
1281
1263
void lcd_update_rect(int x, int y, int width, int height)
1282
1264
\group lcd
1283
-
\conditions defined(HAVE_LCD_BITMAP)
1284
1265
\param x measured in pixels
1285
1266
\param y measured in pixels
1286
1267
\param width measured in pixels
···
1289
1270
1290
1271
void lcd_vline(int x, int y1, int y2)
1291
1272
\group lcd
1292
-
\conditions defined(HAVE_LCD_BITMAP)
1293
1273
\param x X coordinate
1294
1274
\param y1 Y start coordinate
1295
1275
\param y2 Y end coordinate
···
1297
1277
1298
1278
void lcd_yuv_set_options(unsigned options)
1299
1279
\group lcd
1300
-
\conditions defined(HAVE_LCD_BITMAP) )) && (LCD_DEPTH == 16) && (defined(TOSHIBA_GIGABEAT_F) || defined(SANSA_E200) || defined(SANSA_C200) || defined(IRIVER_H10) || defined(COWON_D2
1280
+
\conditions (LCD_DEPTH >= 16) && (defined(TOSHIBA_GIGABEAT_F) || defined(SANSA_E200) || defined(SANSA_C200) || defined(IRIVER_H10) || defined(COWON_D2))
1301
1281
\param options
1302
1282
\description
1303
1283
···
1762
1742
\description
1763
1743
1764
1744
int read_bmp_file(const char* filename, struct bitmap *bm, int maxsize, int format)
1765
-
\conditions (defined(HAVE_LCD_BITMAP))
1766
1745
\param filename
1767
1746
\param bm
1768
1747
\param maxsize
···
1820
1799
\description
1821
1800
1822
1801
void screen_clear_area(struct screen * display, int xstart, int ystart, int width, int height)
1823
-
\conditions defined(HAVE_LCD_BITMAP)
1824
1802
\param display
1825
1803
\param xstart
1826
1804
\param ystart
···
1829
1807
\description
1830
1808
1831
1809
void screen_dump_set_hook(void (*hook)(int fh))
1832
-
\conditions (defined(HAVE_LCD_BITMAP))
1833
1810
\param hook
1834
1811
\description
1835
1812
···
1962
1939
1963
1940
void sim_lcd_ex_init(int shades, unsigned long (*getpixel)(int, int))
1964
1941
\group special simulator hooks
1965
-
\conditions (defined(SIMULATOR)) && (defined(HAVE_LCD_BITMAP) && LCD_DEPTH < 8)
1942
+
\conditions (defined(SIMULATOR) && LCD_DEPTH < 8))
1966
1943
\param shades
1967
1944
\param getpixel
1968
1945
\description
1969
1946
1970
1947
void sim_lcd_ex_update_rect(int x, int y, int width, int height)
1971
1948
\group special simulator hooks
1972
-
\conditions (defined(SIMULATOR)) && (defined(HAVE_LCD_BITMAP) && LCD_DEPTH < 8)
1949
+
\conditions (defined(SIMULATOR) LCD_DEPTH < 8))
1973
1950
\param x
1974
1951
\param y
1975
1952
\param width
-4
firmware/SOURCES
-4
firmware/SOURCES
···
50
50
#ifdef HAVE_SDL
51
51
target/hosted/sdl/button-sdl.c
52
52
target/hosted/sdl/kernel-sdl.c
53
-
#ifdef HAVE_LCD_BITMAP
54
53
target/hosted/sdl/lcd-bitmap.c
55
-
#endif
56
54
#ifdef HAVE_REMOTE_LCD
57
55
target/hosted/sdl/lcd-remote-bitmap.c
58
56
#endif
···
253
251
/* Display */
254
252
scroll_engine.c
255
253
256
-
#ifdef HAVE_LCD_BITMAP
257
254
arabjoin.c
258
255
bidi.c
259
256
font_cache.c
···
283
280
drivers/lcd-24bit.c
284
281
#endif /* LCD_DEPTH */
285
282
common/diacritic.c
286
-
#endif /* HAVE_LCD_BITMAP */
287
283
288
284
#ifdef HAVE_REMOTE_LCD
289
285
#if LCD_REMOTE_DEPTH == 1
-25
firmware/common/unicode.c
-25
firmware/common/unicode.c
···
88
88
const char *name;
89
89
};
90
90
91
-
#ifdef HAVE_LCD_BITMAP
92
-
93
91
#define MAX_CP_TABLE_SIZE 32768
94
92
95
93
#define CPF_ISO "iso.cp"
···
117
115
[BIG_5] = { CP_TID_950 , CPF_950, "BIG5" },
118
116
[UTF_8] = { CP_TID_NONE, NULL , "UTF-8" },
119
117
};
120
-
121
-
#else /* !HAVE_LCD_BITMAP, reduced support */
122
-
123
-
#define MAX_CP_TABLE_SIZE 768
124
-
125
-
#define CPF_ISOMINI "isomini.cp"
126
-
127
-
static const struct cp_info cp_info[NUM_CODEPAGES+1] =
128
-
{
129
-
[0 ... NUM_CODEPAGES] = { CP_TID_NONE, NULL , "unknown" },
130
-
[ISO_8859_1] = { CP_TID_NONE, NULL , "ISO-8859-1" },
131
-
[ISO_8859_7] = { CP_TID_ISO , CPF_ISOMINI, "ISO-8859-7" },
132
-
[WIN_1251] = { CP_TID_ISO , CPF_ISOMINI, "CP1251" },
133
-
[ISO_8859_9] = { CP_TID_ISO , CPF_ISOMINI, "ISO-8859-9" },
134
-
[ISO_8859_2] = { CP_TID_ISO , CPF_ISOMINI, "ISO-8859-2" },
135
-
[WIN_1250] = { CP_TID_ISO , CPF_ISOMINI, "CP1250" },
136
-
[WIN_1252] = { CP_TID_ISO , CPF_ISOMINI, "CP1252" },
137
-
[UTF_8] = { CP_TID_ISO , NULL , "UTF-8" },
138
-
};
139
-
140
-
#endif /* HAVE_LCD_BITMAP */
141
118
142
119
static int default_cp = INIT_CODEPAGE;
143
120
static int default_cp_tid = CP_TID_NONE;
···
368
345
ucs = table[tmp];
369
346
break;
370
347
371
-
#ifdef HAVE_LCD_BITMAP
372
348
case CP_TID_932: /* Japanese */
373
349
if (*iso > 0xA0 && *iso < 0xE0) {
374
350
tmp = *iso++ | (0xA100 - 0x8000);
···
392
368
ucs = table[tmp];
393
369
count--;
394
370
break;
395
-
#endif /* HAVE_LCD_BITMAP */
396
371
397
372
default:
398
373
ucs = *iso++;
-13
firmware/drivers/lcd-scroll.c
-13
firmware/drivers/lcd-scroll.c
···
39
39
.ticks = 12,
40
40
.delay = HZ/2,
41
41
.bidir_limit = 50,
42
-
#ifdef HAVE_LCD_BITMAP
43
42
.step = 6,
44
-
#endif
45
43
};
46
44
47
45
···
100
98
LCDFN(scroll_info).ticks = scroll_tick_table[speed];
101
99
}
102
100
103
-
#if defined(HAVE_LCD_BITMAP)
104
101
void LCDFN(scroll_step)(int step)
105
102
{
106
103
LCDFN(scroll_info).step = step;
107
104
}
108
-
#endif
109
105
110
106
void LCDFN(scroll_delay)(int ms)
111
107
{
···
162
158
163
159
/* Stash and restore these three, so that the scroll_func
164
160
* can do whatever it likes without destroying the state */
165
-
#ifdef HAVE_LCD_BITMAP
166
161
unsigned drawmode;
167
162
#if LCD_DEPTH > 1
168
163
unsigned fg_pattern, bg_pattern;
···
170
165
bg_pattern = s->vp->bg_pattern;
171
166
#endif
172
167
drawmode = s->vp->drawmode;
173
-
#endif
174
168
s->scroll_func(s);
175
169
176
170
LCDFN(update_viewport_rect)(s->x, s->y, s->width, s->height);
177
171
178
-
#ifdef HAVE_LCD_BITMAP
179
172
#if LCD_DEPTH > 1
180
173
s->vp->fg_pattern = fg_pattern;
181
174
s->vp->bg_pattern = bg_pattern;
182
175
#endif
183
176
s->vp->drawmode = drawmode;
184
-
#endif
185
177
186
178
return ended;
187
179
}
···
216
208
LCDFN(set_viewport)(s->vp);
217
209
218
210
makedelay = false;
219
-
#ifdef HAVE_LCD_BITMAP
220
211
step = si->step;
221
-
#else
222
-
step = 1;
223
-
#endif
224
-
225
212
226
213
if (s->backward)
227
214
s->offset -= step;
+1
-1
firmware/export/config.h
+1
-1
firmware/export/config.h
+2
-2
firmware/export/config/agptekrocker.h
+2
-2
firmware/export/config/agptekrocker.h
+2
-2
firmware/export/config/android.h
+2
-2
firmware/export/config/android.h
+2
-2
firmware/export/config/cowond2.h
+2
-2
firmware/export/config/cowond2.h
+2
-2
firmware/export/config/creativezen.h
+2
-2
firmware/export/config/creativezen.h
+2
-2
firmware/export/config/creativezenmozaic.h
+2
-2
firmware/export/config/creativezenmozaic.h
+2
-2
firmware/export/config/creativezenv.h
+2
-2
firmware/export/config/creativezenv.h
+2
-2
firmware/export/config/creativezenxfi.h
+2
-2
firmware/export/config/creativezenxfi.h
+2
-2
firmware/export/config/creativezenxfi2.h
+2
-2
firmware/export/config/creativezenxfi2.h
+2
-2
firmware/export/config/creativezenxfi3.h
+2
-2
firmware/export/config/creativezenxfi3.h
+2
-2
firmware/export/config/creativezenxfistyle.h
+2
-2
firmware/export/config/creativezenxfistyle.h
+2
-2
firmware/export/config/creativezv.h
+2
-2
firmware/export/config/creativezv.h
+2
-2
firmware/export/config/gigabeatfx.h
+2
-2
firmware/export/config/gigabeatfx.h
+2
-2
firmware/export/config/gigabeats.h
+2
-2
firmware/export/config/gigabeats.h
+2
-2
firmware/export/config/gogearhdd1630.h
+2
-2
firmware/export/config/gogearhdd1630.h
···
27
27
#define REC_SAMPR_CAPS (SAMPR_CAP_96 | SAMPR_CAP_88 | SAMPR_CAP_48 | \
28
28
SAMPR_CAP_44 | SAMPR_CAP_32 | SAMPR_CAP_8)
29
29
30
-
/* define this if you have a bitmap LCD display */
31
-
#define HAVE_LCD_BITMAP
30
+
31
+
32
32
33
33
/* define this if you have a colour LCD */
34
34
#define HAVE_LCD_COLOR
+2
-2
firmware/export/config/gogearhdd6330.h
+2
-2
firmware/export/config/gogearhdd6330.h
···
27
27
#define REC_SAMPR_CAPS (SAMPR_CAP_96 | SAMPR_CAP_88 | SAMPR_CAP_48 | \
28
28
SAMPR_CAP_44 | SAMPR_CAP_32 | SAMPR_CAP_8)
29
29
30
-
/* define this if you have a bitmap LCD display */
31
-
#define HAVE_LCD_BITMAP
30
+
31
+
32
32
33
33
/* define this if you have a colour LCD */
34
34
#define HAVE_LCD_COLOR
+2
-2
firmware/export/config/gogearsa9200.h
+2
-2
firmware/export/config/gogearsa9200.h
+2
-2
firmware/export/config/hifietma8.h
+2
-2
firmware/export/config/hifietma8.h
+2
-2
firmware/export/config/hifietma8c.h
+2
-2
firmware/export/config/hifietma8c.h
+2
-2
firmware/export/config/hifietma9.h
+2
-2
firmware/export/config/hifietma9.h
+2
-2
firmware/export/config/hifietma9c.h
+2
-2
firmware/export/config/hifietma9c.h
+2
-2
firmware/export/config/hifimanhm60x.h
+2
-2
firmware/export/config/hifimanhm60x.h
+2
-2
firmware/export/config/hifimanhm801.h
+2
-2
firmware/export/config/hifimanhm801.h
+2
-2
firmware/export/config/iaudio7.h
+2
-2
firmware/export/config/iaudio7.h
···
26
26
/* define the bitmask of recording sample rates */
27
27
#define REC_SAMPR_CAPS (SAMPR_CAP_44/* | SAMPR_CAP_22 | SAMPR_CAP_11*/)
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you have a colour LCD */
33
33
#define HAVE_LCD_COLOR
+2
-2
firmware/export/config/iaudiom3.h
+2
-2
firmware/export/config/iaudiom3.h
···
26
26
/* define the bitmask of recording sample rates */
27
27
#define REC_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | SAMPR_CAP_11)
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you want album art for this target */
33
33
#define HAVE_ALBUMART
+2
-2
firmware/export/config/iaudiom5.h
+2
-2
firmware/export/config/iaudiom5.h
···
30
30
/* define the bitmask of recording sample rates */
31
31
#define REC_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | SAMPR_CAP_11)
32
32
33
-
/* define this if you have a bitmap LCD display */
34
-
#define HAVE_LCD_BITMAP
33
+
34
+
35
35
36
36
/* define this if you want album art for this target */
37
37
#define HAVE_ALBUMART
+2
-2
firmware/export/config/iaudiox5.h
+2
-2
firmware/export/config/iaudiox5.h
···
26
26
/* define the bitmask of recording sample rates */
27
27
#define REC_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | SAMPR_CAP_11)
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you can flip your LCD */
33
33
#define HAVE_LCD_FLIP
+2
-2
firmware/export/config/ibassodx50.h
+2
-2
firmware/export/config/ibassodx50.h
+2
-2
firmware/export/config/ibassodx90.h
+2
-2
firmware/export/config/ibassodx90.h
+2
-2
firmware/export/config/ihifi760.h
+2
-2
firmware/export/config/ihifi760.h
+2
-2
firmware/export/config/ihifi770.h
+2
-2
firmware/export/config/ihifi770.h
+2
-2
firmware/export/config/ihifi770c.h
+2
-2
firmware/export/config/ihifi770c.h
+2
-2
firmware/export/config/ihifi800.h
+2
-2
firmware/export/config/ihifi800.h
+2
-2
firmware/export/config/ihifi960.h
+2
-2
firmware/export/config/ihifi960.h
+2
-2
firmware/export/config/ipod1g2g.h
+2
-2
firmware/export/config/ipod1g2g.h
···
26
26
#define REC_SAMPR_CAPS (SAMPR_CAP_96 | SAMPR_CAP_88 | SAMPR_CAP_48 | \
27
27
SAMPR_CAP_44 | SAMPR_CAP_32 | SAMPR_CAP_8) */
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you want album art for this target */
33
33
#define HAVE_ALBUMART
+2
-2
firmware/export/config/ipod3g.h
+2
-2
firmware/export/config/ipod3g.h
···
26
26
#define REC_SAMPR_CAPS (SAMPR_CAP_96 | SAMPR_CAP_88 | SAMPR_CAP_48 | \
27
27
SAMPR_CAP_44 | SAMPR_CAP_32 | SAMPR_CAP_8) */
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you want album art for this target */
33
33
#define HAVE_ALBUMART
+2
-2
firmware/export/config/ipod4g.h
+2
-2
firmware/export/config/ipod4g.h
···
28
28
/* define the bitmask of recording sample rates */
29
29
#define REC_SAMPR_CAPS (SAMPR_CAP_44)
30
30
31
-
/* define this if you have a bitmap LCD display */
32
-
#define HAVE_LCD_BITMAP
31
+
32
+
33
33
34
34
/* define this if you want album art for this target */
35
35
#define HAVE_ALBUMART
+2
-2
firmware/export/config/ipod6g.h
+2
-2
firmware/export/config/ipod6g.h
+2
-2
firmware/export/config/ipodcolor.h
+2
-2
firmware/export/config/ipodcolor.h
+2
-2
firmware/export/config/ipodmini1g.h
+2
-2
firmware/export/config/ipodmini1g.h
···
28
28
#define REC_SAMPR_CAPS (SAMPR_CAP_96 | SAMPR_CAP_88 | SAMPR_CAP_48 | \
29
29
SAMPR_CAP_44 | SAMPR_CAP_32 | SAMPR_CAP_8) */
30
30
31
-
/* define this if you have a bitmap LCD display */
32
-
#define HAVE_LCD_BITMAP
31
+
32
+
33
33
34
34
/* define this if you want album art for this target */
35
35
#define HAVE_ALBUMART
+2
-2
firmware/export/config/ipodmini2g.h
+2
-2
firmware/export/config/ipodmini2g.h
···
28
28
#define REC_SAMPR_CAPS (SAMPR_CAP_96 | SAMPR_CAP_88 | SAMPR_CAP_48 | \
29
29
SAMPR_CAP_44 | SAMPR_CAP_32 | SAMPR_CAP_8) */
30
30
31
-
/* define this if you have a bitmap LCD display */
32
-
#define HAVE_LCD_BITMAP
31
+
32
+
33
33
34
34
/* define this if you want album art for this target */
35
35
#define HAVE_ALBUMART
+2
-2
firmware/export/config/ipodnano1g.h
+2
-2
firmware/export/config/ipodnano1g.h
+2
-2
firmware/export/config/ipodnano2g.h
+2
-2
firmware/export/config/ipodnano2g.h
···
26
26
| SAMPR_CAP_96 | SAMPR_CAP_48 | SAMPR_CAP_24 | SAMPR_CAP_12 \
27
27
| SAMPR_CAP_64 | SAMPR_CAP_32 | SAMPR_CAP_16 | SAMPR_CAP_8)
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you can flip your LCD */
33
33
//#define HAVE_LCD_FLIP
+2
-2
firmware/export/config/ipodvideo.h
+2
-2
firmware/export/config/ipodvideo.h
+2
-2
firmware/export/config/iriverh10.h
+2
-2
firmware/export/config/iriverh10.h
···
26
26
#define REC_SAMPR_CAPS (SAMPR_CAP_96 | SAMPR_CAP_88 | SAMPR_CAP_48 | \
27
27
SAMPR_CAP_44 | SAMPR_CAP_32 | SAMPR_CAP_8)
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you have a colour LCD */
33
33
#define HAVE_LCD_COLOR
+2
-2
firmware/export/config/iriverh100.h
+2
-2
firmware/export/config/iriverh100.h
···
14
14
/*define this if the ATA controller and method of USB access support LBA48 */
15
15
#define HAVE_LBA48
16
16
17
-
/* define this if you have a bitmap LCD display */
18
-
#define HAVE_LCD_BITMAP
17
+
18
+
19
19
20
20
/* define this if you want album art for this target */
21
21
#define HAVE_ALBUMART
+2
-2
firmware/export/config/iriverh10_5gb.h
+2
-2
firmware/export/config/iriverh10_5gb.h
···
26
26
#define REC_SAMPR_CAPS (SAMPR_CAP_96 | SAMPR_CAP_88 | SAMPR_CAP_48 | \
27
27
SAMPR_CAP_44 | SAMPR_CAP_32 | SAMPR_CAP_8)
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you have a colour LCD */
33
33
#define HAVE_LCD_COLOR
+2
-2
firmware/export/config/iriverh120.h
+2
-2
firmware/export/config/iriverh120.h
···
14
14
/*define this if the ATA controller and method of USB access support LBA48 */
15
15
#define HAVE_LBA48
16
16
17
-
/* define this if you have a bitmap LCD display */
18
-
#define HAVE_LCD_BITMAP
17
+
18
+
19
19
20
20
/* define this if you want album art for this target */
21
21
#define HAVE_ALBUMART
+2
-2
firmware/export/config/iriverh300.h
+2
-2
firmware/export/config/iriverh300.h
+2
-2
firmware/export/config/iriverifp7xx.h
+2
-2
firmware/export/config/iriverifp7xx.h
···
12
12
/* define this if you have recording possibility */
13
13
/*#define HAVE_RECORDING*/
14
14
15
-
/* define this if you have a bitmap LCD display */
16
-
#define HAVE_LCD_BITMAP
15
+
16
+
17
17
18
18
/* define this if you would like tagcache to build on this target */
19
19
/* #define HAVE_TAGCACHE */
+2
-2
firmware/export/config/logikdax.h
+2
-2
firmware/export/config/logikdax.h
+2
-2
firmware/export/config/lyreproto1.h
+2
-2
firmware/export/config/lyreproto1.h
+2
-2
firmware/export/config/meizum3.h
+2
-2
firmware/export/config/meizum3.h
···
20
20
/* define the bitmask of recording sample rates */
21
21
#define REC_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | SAMPR_CAP_11)
22
22
23
-
/* define this if you have a bitmap LCD display */
24
-
#define HAVE_LCD_BITMAP
23
+
24
+
25
25
26
26
/* define this if you can flip your LCD */
27
27
//#define HAVE_LCD_FLIP
+2
-2
firmware/export/config/meizum6sl.h
+2
-2
firmware/export/config/meizum6sl.h
···
20
20
/* define the bitmask of recording sample rates */
21
21
#define REC_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | SAMPR_CAP_11)
22
22
23
-
/* define this if you have a bitmap LCD display */
24
-
#define HAVE_LCD_BITMAP
23
+
24
+
25
25
26
26
/* define this if you can flip your LCD */
27
27
//#define HAVE_LCD_FLIP
+2
-2
firmware/export/config/meizum6sp.h
+2
-2
firmware/export/config/meizum6sp.h
···
26
26
/* define the bitmask of recording sample rates */
27
27
#define REC_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | SAMPR_CAP_11)
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you can flip your LCD */
33
33
//#define HAVE_LCD_FLIP
+2
-2
firmware/export/config/mini2440.h
+2
-2
firmware/export/config/mini2440.h
···
50
50
/* #define HAVE_DISK_STORAGE */
51
51
52
52
/* Display */
53
-
/* define this if you have a bitmap LCD display */
54
-
#define HAVE_LCD_BITMAP
53
+
54
+
55
55
/* define this if you have a colour LCD */
56
56
#define HAVE_LCD_COLOR
57
57
/* The LCD is assumed to be 3.5" TFT touch screen, others are possible */
+2
-2
firmware/export/config/mpiohd200.h
+2
-2
firmware/export/config/mpiohd200.h
···
26
26
/* define the bitmask of recording sample rates */
27
27
#define REC_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | SAMPR_CAP_11)
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you want album art for this target */
33
33
#define HAVE_ALBUMART
+2
-2
firmware/export/config/mpiohd300.h
+2
-2
firmware/export/config/mpiohd300.h
···
26
26
/* define the bitmask of recording sample rates */
27
27
#define REC_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | SAMPR_CAP_11)
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you want album art for this target */
33
33
#define HAVE_ALBUMART
+2
-2
firmware/export/config/mrobe100.h
+2
-2
firmware/export/config/mrobe100.h
···
12
12
/*define this if the ATA controller and method of USB access support LBA48 */
13
13
#define HAVE_LBA48
14
14
15
-
/* define this if you have a bitmap LCD display */
16
-
#define HAVE_LCD_BITMAP
15
+
16
+
17
17
18
18
/* define this if you have access to the quickscreen */
19
19
#define HAVE_QUICKSCREEN
+2
-2
firmware/export/config/mrobe500.h
+2
-2
firmware/export/config/mrobe500.h
+2
-2
firmware/export/config/nokian8xx.h
+2
-2
firmware/export/config/nokian8xx.h
+2
-2
firmware/export/config/nokian900.h
+2
-2
firmware/export/config/nokian900.h
+2
-2
firmware/export/config/ondavx747.h
+2
-2
firmware/export/config/ondavx747.h
+2
-2
firmware/export/config/ondavx767.h
+2
-2
firmware/export/config/ondavx767.h
+2
-2
firmware/export/config/ondavx777.h
+2
-2
firmware/export/config/ondavx777.h
+2
-2
firmware/export/config/pandora.h
+2
-2
firmware/export/config/pandora.h
+2
-2
firmware/export/config/rk27generic.h
+2
-2
firmware/export/config/rk27generic.h
+2
-2
firmware/export/config/samsungyh820.h
+2
-2
firmware/export/config/samsungyh820.h
+2
-2
firmware/export/config/samsungyh920.h
+2
-2
firmware/export/config/samsungyh920.h
+2
-2
firmware/export/config/samsungyh925.h
+2
-2
firmware/export/config/samsungyh925.h
+2
-2
firmware/export/config/samsungypr0.h
+2
-2
firmware/export/config/samsungypr0.h
+2
-2
firmware/export/config/samsungypr1.h
+2
-2
firmware/export/config/samsungypr1.h
+2
-2
firmware/export/config/samsungyps3.h
+2
-2
firmware/export/config/samsungyps3.h
···
20
20
/* define the bitmask of recording sample rates */
21
21
#define REC_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | SAMPR_CAP_11)
22
22
23
-
/* define this if you have a bitmap LCD display */
24
-
#define HAVE_LCD_BITMAP
23
+
24
+
25
25
26
26
/* define this if you can flip your LCD */
27
27
//#define HAVE_LCD_FLIP
+2
-2
firmware/export/config/samsungypz5.h
+2
-2
firmware/export/config/samsungypz5.h
+2
-2
firmware/export/config/sansac100.h
+2
-2
firmware/export/config/sansac100.h
···
10
10
/* define hardware samples rate caps mask */
11
11
#define HW_SAMPR_CAPS (/*SAMPR_CAP_88 | */SAMPR_CAP_44/* | SAMPR_CAP_22 | SAMPR_CAP_11*/)
12
12
13
-
/* define this if you have a bitmap LCD display */
14
-
#define HAVE_LCD_BITMAP
13
+
14
+
15
15
16
16
/* define this if you have a colour LCD */
17
17
#define HAVE_LCD_COLOR
+2
-2
firmware/export/config/sansac200.h
+2
-2
firmware/export/config/sansac200.h
+2
-2
firmware/export/config/sansac200v2.h
+2
-2
firmware/export/config/sansac200v2.h
+2
-2
firmware/export/config/sansaclip.h
+2
-2
firmware/export/config/sansaclip.h
···
26
26
explicitly if different */
27
27
#define INPUT_SRC_CAPS (SRC_CAP_MIC | SRC_CAP_FMRADIO)
28
28
29
-
/* define this if you have a bitmap LCD display */
30
-
#define HAVE_LCD_BITMAP
29
+
30
+
31
31
32
32
/* define this if you have a light associated with the buttons */
33
33
#define HAVE_BUTTON_LIGHT
+2
-2
firmware/export/config/sansaclipplus.h
+2
-2
firmware/export/config/sansaclipplus.h
+2
-2
firmware/export/config/sansaclipv2.h
+2
-2
firmware/export/config/sansaclipv2.h
···
28
28
explicitly if different */
29
29
#define INPUT_SRC_CAPS (SRC_CAP_MIC | SRC_CAP_FMRADIO)
30
30
31
-
/* define this if you have a bitmap LCD display */
32
-
#define HAVE_LCD_BITMAP
31
+
32
+
33
33
34
34
/* define this if you have a light associated with the buttons */
35
35
#define HAVE_BUTTON_LIGHT
+2
-2
firmware/export/config/sansaclipzip.h
+2
-2
firmware/export/config/sansaclipzip.h
+2
-2
firmware/export/config/sansaconnect.h
+2
-2
firmware/export/config/sansaconnect.h
+2
-2
firmware/export/config/sansae200.h
+2
-2
firmware/export/config/sansae200.h
+2
-2
firmware/export/config/sansae200v2.h
+2
-2
firmware/export/config/sansae200v2.h
+2
-2
firmware/export/config/sansafuze.h
+2
-2
firmware/export/config/sansafuze.h
+2
-2
firmware/export/config/sansafuzeplus.h
+2
-2
firmware/export/config/sansafuzeplus.h
···
29
29
explicitly if different */
30
30
#define INPUT_SRC_CAPS (SRC_CAP_MIC | SRC_CAP_FMRADIO)
31
31
32
-
/* define this if you have a bitmap LCD display */
33
-
#define HAVE_LCD_BITMAP
32
+
33
+
34
34
/* define this if you have a colour LCD */
35
35
#define HAVE_LCD_COLOR
36
36
#define HAVE_LCD_FLIP
+2
-2
firmware/export/config/sansafuzev2.h
+2
-2
firmware/export/config/sansafuzev2.h
+2
-2
firmware/export/config/sansam200.h
+2
-2
firmware/export/config/sansam200.h
+2
-2
firmware/export/config/sansam200v4.h
+2
-2
firmware/export/config/sansam200v4.h
+2
-2
firmware/export/config/sansaview.h
+2
-2
firmware/export/config/sansaview.h
+2
-2
firmware/export/config/sdlapp.h
+2
-2
firmware/export/config/sdlapp.h
+2
-2
firmware/export/config/sonynwze360.h
+2
-2
firmware/export/config/sonynwze360.h
+2
-2
firmware/export/config/sonynwze370.h
+2
-2
firmware/export/config/sonynwze370.h
+2
-2
firmware/export/config/sonynwzlinux.h
+2
-2
firmware/export/config/sonynwzlinux.h
+2
-2
firmware/export/config/tatungtpj1022.h
+2
-2
firmware/export/config/tatungtpj1022.h
···
24
24
#define REC_SAMPR_CAPS (SAMPR_CAP_96 | SAMPR_CAP_88 | SAMPR_CAP_48 | \
25
25
SAMPR_CAP_44 | SAMPR_CAP_32 | SAMPR_CAP_8) */
26
26
27
-
/* define this if you have a bitmap LCD display */
28
-
#define HAVE_LCD_BITMAP
27
+
28
+
29
29
30
30
/* define this if you have a colour LCD */
31
31
#define HAVE_LCD_COLOR
+2
-2
firmware/export/config/vibe500.h
+2
-2
firmware/export/config/vibe500.h
···
25
25
/* define the bitmask of recording sample rates */
26
26
#define REC_SAMPR_CAPS (SAMPR_CAP_88 | SAMPR_CAP_44 | SAMPR_CAP_22 | SAMPR_CAP_11)
27
27
28
-
/* define this if you have a bitmap LCD display */
29
-
#define HAVE_LCD_BITMAP
28
+
29
+
30
30
31
31
/* define this if you can flip your LCD */
32
32
#define HAVE_LCD_FLIP
+2
-2
firmware/export/config/xduoox20.h
+2
-2
firmware/export/config/xduoox20.h
+2
-2
firmware/export/config/xduoox3.h
+2
-2
firmware/export/config/xduoox3.h
+2
-2
firmware/export/config/xduoox3ii.h
+2
-2
firmware/export/config/xduoox3ii.h
+2
-2
firmware/export/config/zenvisionm30gb.h
+2
-2
firmware/export/config/zenvisionm30gb.h
+2
-2
firmware/export/config/zenvisionm60gb.h
+2
-2
firmware/export/config/zenvisionm60gb.h
-9
firmware/export/font.h
-9
firmware/export/font.h
···
30
30
*/
31
31
#include "config.h"
32
32
33
-
#if defined(HAVE_LCD_BITMAP) || (CONFIG_PLATFORM & PLATFORM_HOSTED)
34
33
#ifndef __PCTOOL__
35
34
#include "font_cache.h"
36
35
#include "sysfont.h"
37
36
#endif
38
-
39
37
40
38
/*
41
39
* Fonts are specified by number, and used for display
···
138
136
int font_getstringsize(const unsigned char *str, int *w, int *h, int fontnumber);
139
137
int font_get_width(struct font* ft, unsigned short ch);
140
138
const unsigned char * font_get_bits(struct font* ft, unsigned short ch);
141
-
142
-
#else /* HAVE_LCD_BITMAP */
143
-
144
-
#define font_init()
145
-
#define font_load(x)
146
-
147
-
#endif
148
139
149
140
#endif
-11
firmware/export/lcd.h
-11
firmware/export/lcd.h
···
40
40
int y;
41
41
int width;
42
42
int height;
43
-
#ifdef HAVE_LCD_BITMAP
44
43
int flags;
45
44
int font;
46
45
int drawmode;
47
46
/* needed for even for mono displays to support greylib */
48
47
unsigned fg_pattern;
49
48
unsigned bg_pattern;
50
-
#endif
51
49
};
52
50
53
51
/* Frame buffer stride
···
114
112
#define STRIDE(screen, w, h) (screen==SCREEN_MAIN?STRIDE_MAIN((w), \
115
113
(h)):STRIDE_REMOTE((w),(h)))
116
114
117
-
#ifdef HAVE_LCD_BITMAP
118
115
#if LCD_DEPTH <=8
119
116
#if (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED) \
120
117
|| (LCD_PIXELFORMAT == HORIZONTAL_INTERLEAVED)
···
144
141
#endif
145
142
#define FB_DATA_SZ 4
146
143
#endif /* LCD_DEPTH */
147
-
#endif
148
144
149
145
#if defined(HAVE_LCD_MODES)
150
146
void lcd_set_mode(int mode);
···
193
189
void (*scroll_func)(struct scrollinfo *),
194
190
void *data, int x_offset);
195
191
196
-
#ifdef HAVE_LCD_BITMAP
197
-
198
192
/* performance function */
199
193
#if defined(HAVE_LCD_COLOR)
200
194
#if MEMORYSIZE > 2
···
221
215
/* update a fraction of the screen */
222
216
extern void lcd_remote_update_rect(int x, int y, int width, int height);
223
217
#endif /* HAVE_REMOTE_LCD */
224
-
#endif /* HAVE_LCD_BITMAP */
225
218
226
219
/* Bitmap formats */
227
220
enum
···
248
241
#if LCD_DEPTH >= 8
249
242
typedef void lcd_fastpixelfunc_type(fb_data *address);
250
243
#endif
251
-
252
-
#ifdef HAVE_LCD_BITMAP
253
244
254
245
#if defined(HAVE_LCD_COLOR) && defined(LCD_REMOTE_DEPTH) && \
255
246
LCD_REMOTE_DEPTH > 1
···
592
583
#else
593
584
extern int lcd_get_dpi(void);
594
585
#endif /* LCD_DPI */
595
-
596
-
#endif /* HAVE_LCD_BITMAP */
597
586
598
587
#endif /* __LCD_H__ */
+1
-4
firmware/export/screendump.h
+1
-4
firmware/export/screendump.h
···
24
24
25
25
#include "config.h"
26
26
27
-
/* Make BMP colour map entries from R, G, B triples, without and with blending.
28
-
* Not within HAVE_LCD_BITMAP because it is also used for the Player sim */
27
+
/* Make BMP colour map entries from R, G, B triples, without and with blending. */
29
28
#define RED_CMP(c) (((c) >> 16) & 0xff)
30
29
#define GREEN_CMP(c) (((c) >> 8) & 0xff)
31
30
#define BLUE_CMP(c) ((c) & 0xff)
···
63
62
/* Save a .BMP file containing the current screen contents. */
64
63
void screen_dump(void);
65
64
66
-
#ifdef HAVE_LCD_BITMAP
67
65
void screen_dump_set_hook(void (*hook)(int fd));
68
-
#endif
69
66
70
67
#ifdef HAVE_REMOTE_LCD
71
68
/* Save a .BMP file containing the current remote screen contents. */
-10
firmware/export/scroll_engine.h
-10
firmware/export/scroll_engine.h
···
58
58
* larger than the normal linebuffer since it holds the line a second
59
59
* time (+3 spaces) for non-bidir scrolling */
60
60
#define SCROLL_SPACING 3
61
-
#ifdef HAVE_LCD_BITMAP
62
61
#define SCROLL_LINE_SIZE (MAX_PATH + SCROLL_SPACING + 3*LCD_WIDTH/2 + 2)
63
-
#else
64
-
#define SCROLL_LINE_SIZE (MAX_PATH + SCROLL_SPACING + 3*LCD_WIDTH + 2)
65
-
#endif
66
62
67
63
struct scrollinfo
68
64
{
···
95
91
long ticks; /* # of ticks between updates*/
96
92
long delay; /* ticks delay before start */
97
93
int bidir_limit; /* percent */
98
-
#if defined(HAVE_LCD_BITMAP) || defined(HAVE_REMOTE_LCD)
99
94
int step; /* pixels per scroll step */
100
-
#endif
101
95
#if defined(HAVE_REMOTE_LCD)
102
96
long last_scroll;
103
97
#endif
104
98
};
105
99
106
100
/** main lcd **/
107
-
#ifdef HAVE_LCD_BITMAP
108
101
#define LCD_SCROLLABLE_LINES ((LCD_HEIGHT+4)/5 < 32 ? (LCD_HEIGHT+4)/5 : 32)
109
-
#else
110
-
#define LCD_SCROLLABLE_LINES LCD_HEIGHT * 2
111
-
#endif
112
102
113
103
extern struct scroll_screen_info lcd_scroll_info;
114
104
-2
firmware/export/usb.h
-2
firmware/export/usb.h
···
107
107
/* Messages from usb_tick and thread states */
108
108
enum
109
109
{
110
-
#ifdef HAVE_LCD_BITMAP
111
110
USB_SCREENDUMP = -1, /* State */
112
-
#endif
113
111
USB_EXTRACTED = 0, /* Event+State */
114
112
USB_INSERTED, /* Event+State */
115
113
USB_POWERED, /* State - transitional indicator if no host */
-19
firmware/include/rbunicode.h
-19
firmware/include/rbunicode.h
···
33
33
#define MASK 0xC0 /* 11000000 */
34
34
#define COMP 0x80 /* 10x */
35
35
36
-
#ifdef HAVE_LCD_BITMAP
37
-
38
36
enum codepages {
39
37
ISO_8859_1 = 0, /* Latin1 */
40
38
ISO_8859_7, /* Greek */
···
54
52
NUM_CODEPAGES,
55
53
INIT_CODEPAGE = ISO_8859_1,
56
54
};
57
-
58
-
#else /* !HAVE_LCD_BITMAP, reduced support */
59
-
60
-
enum codepages {
61
-
ISO_8859_1 = 0, /* Latin1 */
62
-
ISO_8859_7, /* Greek */
63
-
WIN_1251, /* Cyrillic */
64
-
ISO_8859_9, /* Turkish */
65
-
ISO_8859_2, /* Latin Extended */
66
-
WIN_1250, /* Central European */
67
-
WIN_1252, /* Western European */
68
-
UTF_8, /* Unicode */
69
-
NUM_CODEPAGES,
70
-
INIT_CODEPAGE = ISO_8859_1,
71
-
};
72
-
73
-
#endif
74
55
75
56
/* Encode a UCS value as UTF-8 and return a pointer after this UTF-8 char. */
76
57
unsigned char* utf8encode(unsigned long ucs, unsigned char *utf8);
-4
firmware/panic.c
-4
firmware/panic.c
-4
firmware/powermgmt.c
-4
firmware/powermgmt.c
···
40
40
#include "fmradio.h"
41
41
#endif
42
42
#include "sound.h"
43
-
#ifdef HAVE_LCD_BITMAP
44
43
#include "font.h"
45
-
#endif
46
44
#include "logf.h"
47
45
#ifdef HAVE_REMOTE_LCD
48
46
#include "lcd-remote.h"
···
754
752
audio_stop();
755
753
756
754
if (battery_level_safe()) { /* do not save on critical battery */
757
-
#ifdef HAVE_LCD_BITMAP
758
755
font_unload_all();
759
-
#endif
760
756
761
757
/* Commit pending writes if needed. Even though we don't do write caching,
762
758
things like flash translation layers may need this to commit scattered
-2
firmware/target/hosted/sdl/system-sdl.c
-2
firmware/target/hosted/sdl/system-sdl.c
+1
-2
firmware/target/mips/ingenic_jz47xx/system-jz4740.c
+1
-2
firmware/target/mips/ingenic_jz47xx/system-jz4740.c
···
261
261
"$1", "LO", "HI", "STATUS", "EPC" };
262
262
int i;
263
263
264
-
#ifdef HAVE_LCD_BITMAP
265
264
#if LCD_DEPTH > 1
266
265
lcd_set_backdrop(NULL);
267
266
lcd_set_drawmode(DRMODE_SOLID);
···
270
269
#endif
271
270
lcd_setfont(FONT_SYSFIXED);
272
271
lcd_set_viewport(NULL);
273
-
#endif
272
+
274
273
lcd_clear_display();
275
274
backlight_hw_on();
276
275
-6
firmware/usb.c
-6
firmware/usb.c
···
56
56
#define USB_FULL_INIT
57
57
#endif
58
58
59
-
#ifdef HAVE_LCD_BITMAP
60
59
bool do_screendump_instead_of_usb = false;
61
-
#endif
62
60
63
61
#if !defined(SIMULATOR) && !defined(USB_NONE)
64
62
···
116
114
#endif /* USB_FIRWIRE_HANDLING */
117
115
118
116
/* Screen dump */
119
-
#ifdef HAVE_LCD_BITMAP
120
117
static inline bool usb_do_screendump(void)
121
118
{
122
119
if(do_screendump_instead_of_usb)
···
129
126
}
130
127
return false;
131
128
}
132
-
#endif /* HAVE_LCD_BITMAP */
133
129
134
130
/* Power (charging-only) button */
135
131
static inline void usb_detect_charging_only(bool detect)
···
458
454
if(usb_state != USB_EXTRACTED)
459
455
break;
460
456
461
-
#ifdef HAVE_LCD_BITMAP
462
457
if(usb_do_screendump())
463
458
{
464
459
usb_state = USB_SCREENDUMP;
465
460
break;
466
461
}
467
-
#endif
468
462
469
463
usb_state = USB_POWERED;
470
464
usb_stack_enable(true);
-6
lib/rbcodec/metadata/smaf.c
-6
lib/rbcodec/metadata/smaf.c
···
34
34
static const int frequency[5] = { 4000, 8000, 11025, 22050, 44100 };
35
35
36
36
static const int support_codepages[5] = {
37
-
#ifdef HAVE_LCD_BITMAP
38
37
SJIS, ISO_8859_1, -1, GB_2312, BIG_5,
39
-
#else
40
-
-1, ISO_8859_1, -1, -1, -1,
41
-
#endif
42
38
};
43
39
44
40
/* extra codepage */
···
170
166
while ((*p & MASK) != COMP)
171
167
*q++ = *p++;
172
168
}
173
-
#ifdef HAVE_LCD_BITMAP
174
169
else if (codepage == SJIS)
175
170
{
176
171
if (*p <= 0xa0 || *p >= 0xe0)
177
172
*q++ = *p++;
178
173
}
179
-
#endif
180
174
}
181
175
182
176
*q++ = *p++;
-2
tools/buildzip.pl
-2
tools/buildzip.pl
···
258
258
# Get the LCD screen depth and graphical status
259
259
print GCC <<STOP
260
260
\#include "config.h"
261
-
#ifdef HAVE_LCD_BITMAP
262
261
Bitmap: yes
263
262
Depth: LCD_DEPTH
264
263
LCD Width: LCD_WIDTH
265
264
LCD Height: LCD_HEIGHT
266
265
Icon Width: CONFIG_DEFAULT_ICON_WIDTH
267
266
Icon Height: CONFIG_DEFAULT_ICON_HEIGHT
268
-
#endif
269
267
#ifdef HAVE_REMOTE_LCD
270
268
Remote Depth: LCD_REMOTE_DEPTH
271
269
Remote Icon Width: CONFIG_REMOTE_DEFAULT_ICON_WIDTH
-2
tools/checkwps/SOURCES
-2
tools/checkwps/SOURCES
+1
-7
tools/checkwps/checkwps.c
+1
-7
tools/checkwps/checkwps.c
···
181
181
#endif
182
182
.getwidth = getwidth,
183
183
.getheight = getheight,
184
-
#ifdef HAVE_LCD_BITMAP
185
184
.getuifont = getuifont,
186
-
#endif
187
185
#if LCD_DEPTH > 1
188
186
.get_foreground=dummy_func2,
189
187
.get_background=dummy_func2,
···
209
207
#endif
210
208
};
211
209
212
-
#ifdef HAVE_LCD_BITMAP
213
210
void screen_clear_area(struct screen * display, int xstart, int ystart,
214
211
int width, int height)
215
212
{
···
217
214
display->fillrect(xstart, ystart, width, height);
218
215
display->set_drawmode(DRMODE_SOLID);
219
216
}
220
-
#endif
221
217
222
218
#if CONFIG_TUNER
223
219
bool radio_hardware_present(void)
···
226
222
}
227
223
#endif
228
224
229
-
#ifdef HAVE_LCD_BITMAP
230
225
static int loaded_fonts = 0;
231
226
static struct font _font;
232
227
int font_load(const char *path)
···
235
230
loaded_fonts++;
236
231
return id;
237
232
}
238
-
233
+
239
234
void font_unload(int font_id)
240
235
{
241
236
(void)font_id;
···
245
240
{
246
241
return &_font;
247
242
}
248
-
#endif
249
243
250
244
/* This is no longer defined in ROCKBOX builds so just use a huge value */
251
245
#define SKIN_BUFFER_SIZE (200*1024)
+1
-5
tools/convbdf.c
+1
-5
tools/convbdf.c
···
1214
1214
"#include <stdbool.h>\n"
1215
1215
"#include \"config.h\"\n"
1216
1216
"#include \"font.h\"\n"
1217
-
"#ifdef HAVE_LCD_BITMAP\n"
1218
1217
"\n"
1219
1218
"/* Font information:\n"
1220
1219
" name: %s\n"
···
1426
1425
" 0, /* */\n"
1427
1426
" 0, /* */\n"
1428
1427
"};\n"
1429
-
"#endif /* HAVE_LCD_BITMAP */\n"
1430
1428
);
1431
1429
1432
1430
return 0;
···
1440
1438
char buf[256];
1441
1439
char *hdr1 =
1442
1440
"/* Generated by convbdf on %s. */\n"
1443
-
"#ifdef HAVE_LCD_BITMAP\n"
1444
1441
"\n"
1445
1442
"/* Font information */\n"
1446
1443
"#define SYSFONT_NAME %s\n"
···
1458
1455
"#define SYSFONT_PROPORTIONAL %d\n"
1459
1456
"#define SYSFONT_COPYRIGHT %s\n"
1460
1457
"#define SYSFONT_BITS_SIZE %d\n"
1461
-
"\n"
1462
-
"#endif\n";
1458
+
"\n";
1463
1459
1464
1460
ofp = fopen(path, "w");
1465
1461
if (!ofp) {