len0rd/rockbox
1
0
Fork 1
mirror of https://github.com/Rockbox/rockbox.git synced 2026-07-10 13:29:52 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
rockbox/apps/gui/skin_engine/skin_display.c
Adam N. Burke a824085057 skin: add %pX tag for time-based playlist progress 
%pP reports playlist progress by position index, which treats every
track as equally long. For playlists with tracks of unequal length --
audiobooks with chapters anywhere from two minutes to an hour are the
motivating case -- position is a poor proxy for listening progress.

%pX reports the played percentage of the whole playlist by time: the
summed length of all preceding tracks plus the elapsed time in the
current one, relative to the playlist's total duration. It can be
used as a value, in a conditional, with %if(), or as a bar tag like
%pb.

If a playlist contains more than 500 tracks or the scan is taking too
long and the user aborts the tag will fallback to the behavior of %pP
except the progress through the current track will be included in the
returned percentage

--------------------------------------
Computing this needs every track's length, and reading metadata for
every track is too slow and disk-heavy for a tag that refreshes on the
WPS. Instead each track's length is estimated from its file size: the
skin engine scans the playlist in the background, a batch of files each
skin refresh, opening each file only to read its size (directory
metadata, no header parse). Size is turned into time by calibrating one
file of each type -- the first file of each extension is parsed once
with get_metadata to learn its bytes-per-second, and every later file
of that type reuses it. A single-format playlist, the usual audiobook
case, parses exactly one file and stat's the rest.

The result is an estimate -- bitrate varies within a type, especially
for VBR -- but it is cheap and accurate enough for a progress
indicator, and the playing track always contributes its exact elapsed
time. Per-track lengths are stored as two bytes of minutes each in a
movable buffer sized to the track count and allocated only while the
tag is in use; the cache is keyed on the track count and a crc of the
first, middle and last filenames, so a playlist swap or reshuffle is
caught. If the buffer cannot be allocated (a very large playlist on a
low-memory target) the tag falls back to position-based progress.

The buffer is allocated when playback starts (and when the now-playing
screen is opened with playback already active) rather than lazily on the
first WPS refresh, so the one-time allocation happens at a playback
boundary instead of during steady-state playback; it falls back to
allocating on first use if that point is missed.

Until the scan finishes the tag does not blank: it returns an instant
equal-weight estimate -- (completed tracks + fraction through the
current one) / track count -- which sharpens into the size-based value
as the scan fills in. So a theme can just use %pX and it is correct
from the first frame, and %?pX is true whenever a playlist is loaded.

Tested on a Sansa Clip Zip and in the simulator. On a 216-track,
~745 MB single-format audiobook playlist the length scan dropped from
~4150 ms (get_metadata on every track) to ~174 ms (one parse plus 215
file-size stats), roughly 24x lighter.

Change-Id: I6e572e78a10444bd513ddc77e30da04aa5153ef2
2026-06-27 12:29:31 -04:00

811 lines
26 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
*
* Copyright (C) 2002-2007 Björn Stenberg
* Copyright (C) 2007-2008 Nicolas Pennequin
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include <stdio.h>
#include "string-extra.h"
#include "core_alloc.h"
#include "misc.h"
#include "font.h"
#include "system.h"
#include "rbunicode.h"
#include "sound.h"
#include "powermgmt.h"
#ifdef DEBUG
#include "debug.h"
#endif
#include "action.h"
#include "abrepeat.h"
#include "lang.h"
#include "language.h"
#include "statusbar.h"
#include "settings.h"
#include "scrollbar.h"
#include "screen_access.h"
#include "line.h"
#include "playlist.h"
#include "audio.h"
#include "tagcache.h"
#include "list.h"
#include "option_select.h"
#include "buffering.h"
#include "peakmeter.h"
/* Image stuff */
#include "bmp.h"
#ifdef HAVE_ALBUMART
#include "albumart.h"
#endif
#include "cuesheet.h"
#include "playback.h"
#include "backdrop.h"
#include "viewport.h"
#if CONFIG_TUNER
#include "radio.h"
#include "tuner.h"
#endif
#include "root_menu.h"
#include "wps.h"
#include "wps_internals.h"
#include "skin_engine.h"
#include "statusbar-skinned.h"
#include "skin_display.h"
static bool dirty[NB_SCREENS];
void skin_render(struct gui_wps *gwps, unsigned refresh_mode);
bool skin_is_dirty(enum screen_type screen)
{
return dirty[screen] && !(dirty[screen] = false);
}
void skin_mark_dirty(enum screen_type screen)
{
dirty[screen] = true;
}
/* update a skinned screen, update_type is WPS_REFRESH_* values.
* Usually it should only be WPS_REFRESH_NON_STATIC
* A full update will be done if required (skin_do_full_update() == true)
*/
void skin_update(enum skinnable_screens skin, enum screen_type screen,
unsigned int update_type)
{
struct gui_wps *gwps = skin_get_gwps(skin, screen);
/* This maybe shouldnt be here,
* This is also safe for skined screen which dont use the id3 */
struct mp3entry *id3 = get_wps_state()->id3;
bool cuesheet_update = (id3 != NULL ? cuesheet_subtrack_changed(id3) : false);
if (cuesheet_update)
skin_request_full_update(skin);
skin_render(gwps, skin_do_full_update(skin, screen) ?
SKIN_REFRESH_ALL : update_type);
skin_mark_dirty(screen);
}
#ifdef AB_REPEAT_ENABLE
#define DIRECTION_RIGHT 1
#define DIRECTION_LEFT -1
static int ab_calc_mark_x_pos(int mark, int capacity,
int offset, int size)
{
return offset + ( (size * mark) / capacity );
}
static void ab_draw_vertical_line_mark(struct screen * screen,
int x, int y, int h)
{
screen->set_drawmode(DRMODE_COMPLEMENT);
screen->vline(x, y, y+h-1);
}
static void ab_draw_arrow_mark(struct screen * screen,
int x, int y, int h, int direction)
{
/* draw lines in decreasing size until a height of zero is reached */
screen->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
while( h > 0 )
{
screen->vline(x, y, y+h-1);
h -= 2;
y++;
x += direction;
screen->set_drawmode(DRMODE_COMPLEMENT);
}
}
void ab_draw_markers(struct screen * screen, int capacity,
int x, int y, int w, int h)
{
bool a_set, b_set;
unsigned int a, b;
int xa, xb;
a_set = ab_get_A_marker(&a);
b_set = ab_get_B_marker(&b);
xa = ab_calc_mark_x_pos(a, capacity, x, w);
xb = ab_calc_mark_x_pos(b, capacity, x, w);
/* if both markers are set, determine if they're far enough apart
to draw arrows */
if ( a_set && b_set )
{
int arrow_width = (h+1) / 2;
if ( (xb-xa) < (arrow_width*2) )
{
ab_draw_vertical_line_mark(screen, xa, y, h);
ab_draw_vertical_line_mark(screen, xb, y, h);
return;
}
}
if (a_set)
ab_draw_arrow_mark(screen, xa, y, h, DIRECTION_RIGHT);
if (b_set)
ab_draw_arrow_mark(screen, xb, y, h, DIRECTION_LEFT);
}
#endif
void draw_progressbar(struct gui_wps *gwps, struct skin_viewport* skin_viewport,
int line, struct progressbar *pb)
{
struct screen *display = gwps->display;
struct viewport *vp = &skin_viewport->vp;
struct wps_state *state = get_wps_state();
struct mp3entry *id3 = state->id3;
int x = pb->x, y = pb->y, width = pb->width, height = pb->height;
unsigned long length, end;
int flags = HORIZONTAL;
if (height < 0)
height = font_get(vp->font)->height;
if (y < 0)
{
int line_height = font_get(vp->font)->height;
/* center the pb in the line, but only if the line is higher than the pb */
int center = (line_height-height)/2;
/* if Y was not set calculate by font height,Y is -line_number-1 */
y = line*line_height + (0 > center ? 0 : center);
}
if (pb->type == SKIN_TOKEN_VOLUMEBAR)
{
int minvol = sound_min(SOUND_VOLUME);
int maxvol = sound_max(SOUND_VOLUME);
#if defined(HAVE_PERCEPTUAL_VOLUME) || defined(HAVE_TOUCHSCREEN)
length = 1000;
end = to_normalized_volume(global_status.volume, minvol, maxvol, length);
#else
length = maxvol - minvol;
end = global_status.volume - minvol;
#endif
}
else if (pb->type == SKIN_TOKEN_BATTERY_PERCENTBAR)
{
length = 100;
end = battery_level();
}
else if (pb->type == SKIN_TOKEN_PLAYLIST_PROGRESSBAR)
{
unsigned long pl_elapsed, pl_total;
if (id3 && wps_get_playlist_percent(id3,
id3->elapsed + state->ff_rewind_count,
&pl_elapsed, &pl_total)
&& pl_total > 0)
{
length = pl_total;
end = pl_elapsed;
}
else
{
length = 1;
end = 0;
}
}
else if (pb->type == SKIN_TOKEN_PEAKMETER_LEFTBAR ||
pb->type == SKIN_TOKEN_PEAKMETER_RIGHTBAR)
{
int left, right, val;
peak_meter_current_vals(&left, &right);
val = pb->type == SKIN_TOKEN_PEAKMETER_LEFTBAR ? left : right;
length = MAX_PEAK;
end = peak_meter_scale_value(val, length);
}
else if (pb->type == SKIN_TOKEN_PLAYLIST_PERCENTBAR)
{
length = playlist_amount();
end = playlist_get_display_index();
}
else if (pb->type == SKIN_TOKEN_LIST_SCROLLBAR)
{
int val, min, max;
skinlist_get_scrollbar(&val, &min, &max);
end = val - min;
length = max - min;
}
else if (pb->type == SKIN_TOKEN_SETTINGBAR)
{
int val, count;
get_setting_info_for_bar(pb->setting, pb->setting_offset, &count, &val);
length = count - 1;
end = val;
}
#if CONFIG_TUNER
else if (in_radio_screen() || (get_radio_status() != FMRADIO_OFF))
{
#ifdef HAVE_RADIO_RSSI
if (pb->type == SKIN_TOKEN_TUNER_RSSI_BAR)
{
int val = tuner_get(RADIO_RSSI);
int min = tuner_get(RADIO_RSSI_MIN);
int max = tuner_get(RADIO_RSSI_MAX);
end = val - min;
length = max - min;
}
else
#endif
{
int min = fm_region_data[global_settings.fm_region].freq_min;
end = radio_get_current_frequency() - min;
length = fm_region_data[global_settings.fm_region].freq_max - min;
}
}
#endif
else if (id3 && id3->length)
{
length = id3->length;
end = id3->elapsed + state->ff_rewind_count;
}
else
{
length = 1;
end = 0;
}
if (!pb->horizontal)
{
/* we want to fill upwards which is technically inverted. */
flags = INVERTFILL;
}
if (pb->invert_fill_direction)
{
flags ^= INVERTFILL;
}
if (pb->nofill)
{
flags |= INNER_NOFILL;
}
if (pb->noborder)
{
flags |= BORDER_NOFILL;
}
if (SKINOFFSETTOPTR(get_skin_buffer(gwps->data), pb->slider))
{
struct gui_img *img = SKINOFFSETTOPTR(get_skin_buffer(gwps->data), pb->slider);
/* clear the slider */
screen_clear_area(display, x, y, width, height);
/* account for the sliders width in the progressbar */
if (flags&HORIZONTAL)
{
width -= img->bm.width;
}
else
{
height -= img->bm.height;
}
}
if (SKINOFFSETTOPTR(get_skin_buffer(gwps->data), pb->backdrop))
{
struct gui_img *img = SKINOFFSETTOPTR(get_skin_buffer(gwps->data), pb->backdrop);
img->bm.data = core_get_data(img->buflib_handle);
display->bmp_part(&img->bm, 0, 0, x, y, pb->width, height);
flags |= DONT_CLEAR_EXCESS;
}
if (!pb->nobar)
{
struct gui_img *img = SKINOFFSETTOPTR(get_skin_buffer(gwps->data), pb->image);
if (img)
{
char *img_data = core_get_data(img->buflib_handle);
img->bm.data = img_data;
gui_bitmap_scrollbar_draw(display, &img->bm,
x, y, width, height,
length, 0, end, flags);
}
else
gui_scrollbar_draw(display, x, y, width, height,
length, 0, end, flags);
}
if (SKINOFFSETTOPTR(get_skin_buffer(gwps->data), pb->slider))
{
int xoff = 0, yoff = 0;
int w = width, h = height;
struct gui_img *img = SKINOFFSETTOPTR(get_skin_buffer(gwps->data), pb->slider);
img->bm.data = core_get_data(img->buflib_handle);
if (flags&HORIZONTAL)
{
w = img->bm.width;
xoff = width * end / length;
if (flags&INVERTFILL)
xoff = width - xoff;
}
else
{
h = img->bm.height;
yoff = height * end / length;
if (flags&INVERTFILL)
yoff = height - yoff;
}
display->bmp_part(&img->bm, 0, 0, x + xoff, y + yoff, w, h);
}
if (pb->type == SKIN_TOKEN_PROGRESSBAR)
{
if (id3 && id3->length)
{
#ifdef AB_REPEAT_ENABLE
if (ab_repeat_mode_enabled())
ab_draw_markers(display, id3->length, x, y, width, height);
#endif
if (id3->cuesheet)
cue_draw_markers(display, id3->cuesheet, id3->length,
x, y+1, width, height-2);
}
#if 0 /* disable for now CONFIG_TUNER */
else if (in_radio_screen() || (get_radio_status() != FMRADIO_OFF))
{
presets_draw_markers(display, x, y, width, height);
}
#endif
}
}
/* clears the area where the image was shown */
void clear_image_pos(struct gui_wps *gwps, struct gui_img *img)
{
if(!gwps)
return;
gwps->display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
gwps->display->fillrect(img->x, img->y, img->bm.width, img->subimage_height);
gwps->display->set_drawmode(DRMODE_SOLID);
}
void wps_draw_image(struct gui_wps *gwps, struct gui_img *img,
int subimage, struct viewport* vp)
{
struct screen *display = gwps->display;
img->bm.data = core_get_data(img->buflib_handle);
display->set_drawmode(DRMODE_SOLID);
if (img->is_9_segment)
display->nine_segment_bmp(&img->bm, 0, 0, vp->width, vp->height);
else
display->bmp_part(&img->bm, 0, img->subimage_height * subimage,
img->x, img->y, img->bm.width, img->subimage_height);
}
void wps_display_images(struct gui_wps *gwps, struct viewport* vp)
{
if(!gwps || !gwps->data || !gwps->display)
return;
(void)vp;
struct wps_data *data = gwps->data;
struct screen *display = gwps->display;
/* Start with album art, as it may be drawn over by mask images */
#ifdef HAVE_ALBUMART
struct skin_albumart *aa = SKINOFFSETTOPTR(get_skin_buffer(data), data->albumart);
if (aa && aa->draw_handle >= 0)
{
draw_album_art(gwps, aa->draw_handle, false);
aa->draw_handle = -1;
}
#endif
struct skin_token_list *list = SKINOFFSETTOPTR(get_skin_buffer(data), data->images);
while (list)
{
struct wps_token *token = SKINOFFSETTOPTR(get_skin_buffer(data), list->token);
struct gui_img *img = NULL;
if (token)
img = (struct gui_img*)SKINOFFSETTOPTR(get_skin_buffer(data), token->value.data);
if (img) {
if (img->using_preloaded_icons && img->display >= 0)
{
screen_put_icon(display, img->x, img->y, img->display);
}
else if (img->loaded)
{
if (img->display >= 0)
{
wps_draw_image(gwps, img, img->display, vp);
}
}
}
list = SKINOFFSETTOPTR(get_skin_buffer(data), list->next);
}
display->set_drawmode(DRMODE_SOLID);
}
/* Evaluate the conditional that is at *token_index and return whether a skip
has ocurred. *token_index is updated with the new position.
*/
int evaluate_conditional(struct gui_wps *gwps, int offset,
struct conditional *conditional, int num_options)
{
if (!gwps)
return false;
char result[128];
const char *value;
int intval = num_options < 2 ? 2 : num_options;
/* get_token_value needs to know the number of options in the enum */
value = get_token_value(gwps, SKINOFFSETTOPTR(get_skin_buffer(gwps->data), conditional->token),
offset, result, sizeof(result), &intval);
/* intval is now the number of the enum option we want to read,
starting from 1. If intval is -1, we check if value is empty. */
if (intval == -1)
{
if (num_options == 1) /* so %?AA<true> */
intval = (value && *value) ? 1 : 0; /* returned as 0 for true, -1 for false */
else
intval = (value && *value) ? 1 : num_options;
}
else if (intval > num_options || intval < 1)
intval = num_options;
return intval -1;
}
/* Display a line appropriately according to its alignment format.
format_align contains the text, separated between left, center and right.
line is the index of the line on the screen.
scroll indicates whether the line is a scrolling one or not.
*/
void write_line(struct screen *display, struct align_pos *format_align,
int line, bool scroll, struct line_desc *linedes)
{
int left_width = 0;
int center_width = 0, center_xpos;
int right_width = 0, right_xpos;
int space_width;
int string_height;
int scroll_width;
int viewport_width = display->getwidth();
/* calculate different string sizes and positions */
display->getstringsize((unsigned char *)" ", &space_width, &string_height);
if (format_align->left != 0) {
display->getstringsize((unsigned char *)format_align->left,
&left_width, &string_height);
}
if (format_align->right != 0) {
display->getstringsize((unsigned char *)format_align->right,
&right_width, &string_height);
}
if (format_align->center != 0) {
display->getstringsize((unsigned char *)format_align->center,
&center_width, &string_height);
}
right_xpos = (viewport_width - right_width);
center_xpos = (viewport_width - center_width) / 2;
scroll_width = viewport_width;
/* Checks for overlapping strings.
If needed the overlapping strings will be merged, separated by a
space */
/* CASE 1: left and centered string overlap */
/* there is a left string, need to merge left and center */
if (center_width != 0)
{
if (left_width != 0 && left_width + space_width > center_xpos) {
/* replace the former separator '\0' of left and
center string with a space */
*(--format_align->center) = ' ';
/* calculate the new width and position of the merged string */
left_width = left_width + space_width + center_width;
/* there is no centered string anymore */
center_width = 0;
}
/* there is no left string, move center to left */
else if (left_width == 0 && center_xpos < 0) {
/* move the center string to the left string */
format_align->left = format_align->center;
/* calculate the new width and position of the string */
left_width = center_width;
/* there is no centered string anymore */
center_width = 0;
}
} /*(center_width != 0)*/
/* CASE 2: centered and right string overlap */
/* there is a right string, need to merge center and right */
if (center_width != 0)
{
int center_left_x = center_xpos + center_width;
if (right_width != 0 && center_left_x + space_width > right_xpos) {
/* replace the former separator '\0' of center and
right string with a space */
*(--format_align->right) = ' ';
/* move the center string to the right after merge */
format_align->right = format_align->center;
/* calculate the new width and position of the merged string */
right_width = center_width + space_width + right_width;
right_xpos = (viewport_width - right_width);
/* there is no centered string anymore */
center_width = 0;
}
/* there is no right string, move center to right */
else if (right_width == 0 && center_left_x > right_xpos) {
/* move the center string to the right string */
format_align->right = format_align->center;
/* calculate the new width and position of the string */
right_width = center_width;
right_xpos = (viewport_width - right_width);
/* there is no centered string anymore */
center_width = 0;
}
} /*(center_width != 0)*/
/* CASE 3: left and right overlap
There is no center string anymore, either there never
was one or it has been merged in case 1 or 2 */
/* there is a left string, need to merge left and right */
if (center_width == 0 && right_width != 0)
{
if (left_width != 0 && left_width + space_width > right_xpos) {
/* replace the former separator '\0' of left and
right string with a space */
*(--format_align->right) = ' ';
/* calculate the new width and position of the string */
left_width = left_width + space_width + right_width;
/* there is no right string anymore */
right_width = 0;
}
/* there is no left string, move right to left */
else if (left_width == 0 && right_xpos < 0) {
/* move the right string to the left string */
format_align->left = format_align->right;
/* calculate the new width and position of the string */
left_width = right_width;
/* there is no right string anymore */
right_width = 0;
}
} /* (center_width == 0 && right_width != 0)*/
if (scroll && ((left_width > scroll_width) ||
(center_width > scroll_width) ||
(right_width > scroll_width)))
{
/* strings can be as large as MAX_LINE which exceeds put_lines()
* limit for inline strings. Use $t to avoid truncation */
linedes->scroll = true;
display->put_line(0, line * string_height, linedes, "$t", format_align->left);
}
else
{
linedes->scroll = false;
/* clear the line first */
display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
display->fillrect(0, line*string_height, viewport_width, string_height);
display->set_drawmode(DRMODE_SOLID);
/* Nasty hack: we output an empty scrolling string,
which will reset the scroller for that line */
display->puts_scroll(0, line, (unsigned char *)"");
line *= string_height;
center_xpos = (viewport_width-center_width)/2;
right_xpos = viewport_width-right_width;
/* print aligned strings. print whole line at once so that %Vs works
* across the full viewport width */
char *left = format_align->left ?: "";
char *center = format_align->center ?: "";
char *right = format_align->right ?: "";
display->put_line(0, line, linedes, "$t$*s$t$*s$t", left_width == 0 ? "" : left ,
center_xpos - left_width, center_width == 0 ? "" : center,
right_xpos - center_xpos - center_width, right_width == 0 ? "" : right);
}
}
void draw_peakmeters(struct gui_wps *gwps, int line_number,
struct viewport *viewport)
{
struct wps_data *data = gwps->data;
if (!data->peak_meter_enabled)
{
peak_meter_enable(false);
}
else
{
int h = font_get(viewport->font)->height;
int peak_meter_y = line_number * h;
/* The user might decide to have the peak meter in the last
line so that it is only displayed if no status bar is
visible. If so we neither want do draw nor enable the
peak meter. */
if (peak_meter_y + h <= viewport->y+viewport->height) {
peak_meter_enable(true);
peak_meter_screen(gwps->display, 0, peak_meter_y,
MIN(h, viewport->y+viewport->height - peak_meter_y));
}
}
}
#ifdef HAVE_ALBUMART
/* Draw the album art bitmap from the given handle ID onto the given WPS.
Call with clear = true to clear the bitmap instead of drawing it. */
void draw_album_art(struct gui_wps *gwps, int handle_id, bool clear)
{
if (!gwps || !gwps->data || !gwps->display || handle_id < 0)
return;
struct wps_data *data = gwps->data;
struct skin_albumart *aa = SKINOFFSETTOPTR(get_skin_buffer(data), data->albumart);
if (!aa)
return;
struct bitmap *bmp;
if (bufgetdata(handle_id, 0, (void *)&bmp) <= 0)
return;
short x = aa->x;
short y = aa->y;
short width = bmp->width;
short height = bmp->height;
if (aa->width > 0)
{
/* Crop if the bitmap is too wide */
width = MIN(bmp->width, aa->width);
/* Align */
if (aa->xalign & WPS_ALBUMART_ALIGN_RIGHT)
x += aa->width - width;
else if (aa->xalign & WPS_ALBUMART_ALIGN_CENTER)
x += (aa->width - width) / 2;
}
if (aa->height > 0)
{
/* Crop if the bitmap is too high */
height = MIN(bmp->height, aa->height);
/* Align */
if (aa->yalign & WPS_ALBUMART_ALIGN_BOTTOM)
y += aa->height - height;
else if (aa->yalign & WPS_ALBUMART_ALIGN_CENTER)
y += (aa->height - height) / 2;
}
if (!clear)
{
/* Draw the bitmap */
gwps->display->bitmap_part((fb_data*)bmp->data, 0, 0,
STRIDE(gwps->display->screen_type,
bmp->width, bmp->height),
x, y, width, height);
#ifdef HAVE_LCD_INVERT
if (global_settings.invert) {
gwps->display->set_drawmode(DRMODE_COMPLEMENT);
gwps->display->fillrect(x, y, width, height);
gwps->display->set_drawmode(DRMODE_SOLID);
}
#endif
}
else
{
/* Clear the bitmap */
gwps->display->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
gwps->display->fillrect(x, y, width, height);
gwps->display->set_drawmode(DRMODE_SOLID);
}
}
#endif
bool skin_has_sbs(struct gui_wps *gwps)
{
struct wps_data *data = gwps->data;
bool draw = false;
if (data->wps_sb_tag)
draw = data->show_sb_on_wps;
else if (statusbar_position(gwps->display->screen_type) != STATUSBAR_OFF)
draw = true;
return draw;
}
/* do the button loop as often as required for the peak meters to update
* with a good refresh rate.
*/
int skin_wait_for_action(enum skinnable_screens skin, int context, int timeout)
{
int button = ACTION_NONE;
/* when the peak meter is enabled we want to have a
few extra updates to make it look smooth. On the
other hand we don't want to waste energy if it
isn't displayed */
bool pm=false;
FOR_NB_SCREENS(i)
{
if(skin_get_gwps(skin, i)->data->peak_meter_enabled)
pm = true;
}
if (pm) {
long next_refresh = current_tick;
long next_big_refresh = current_tick + timeout;
button = BUTTON_NONE;
while (TIME_BEFORE(current_tick, next_big_refresh)) {
button = get_action(context,TIMEOUT_NOBLOCK);
if (button != ACTION_NONE) {
break;
}
peak_meter_peek();
sleep(0); /* Sleep until end of current tick. */
if (TIME_AFTER(current_tick, next_refresh)) {
FOR_NB_SCREENS(i)
{
if(skin_get_gwps(skin, i)->data->peak_meter_enabled)
skin_update(skin, i, SKIN_REFRESH_PEAK_METER);
next_refresh += HZ / PEAK_METER_FPS;
}
}
}
}
/* The peak meter is disabled
-> no additional screen updates needed */
else
{
button = get_action(context, timeout);
}
return button;
}
Reference in a new issue View git blame Copy permalink