/**
* Initialize the application
* @return pointer to the application descriptor of this application
*/
const lv_app_dsc_t * lv_app_files_init(void)
{
lv_app_style_t * app_style = lv_app_style_get();
memcpy(&style_sc_label, &app_style->sc_rec_rel, sizeof(lv_style_t));
style_sc_label.font = font_get(LV_APP_FONT_LARGE);
lv_style_get(LV_STYLE_BTN_REL, &style_btn_symbol);
style_btn_symbol.font = font_get(LV_IMG_DEF_SYMBOL_FONT);
return &my_app_dsc;
}
static void pitchscreen_fix_viewports(struct viewport *parent,
struct viewport pitch_viewports[PITCH_ITEM_COUNT])
{
int i, font_height;
font_height = font_get(parent->font)->height;
for (i = 0; i < PITCH_ITEM_COUNT; i++)
{
pitch_viewports[i] = *parent;
pitch_viewports[i].height = font_height;
if (i == PITCH_TOP || i == PITCH_BOTTOM)
pitch_viewports[i].flags |= VP_FLAG_ALIGN_CENTER;
}
pitch_viewports[PITCH_TOP].y += ICON_BORDER;
pitch_viewports[PITCH_MID].x += ICON_BORDER;
pitch_viewports[PITCH_MID].width = parent->width - ICON_BORDER*2;
pitch_viewports[PITCH_MID].height = parent->height - ICON_BORDER*2
- font_height * 2;
if(pitch_viewports[PITCH_MID].height < font_height * 2)
pitch_viewports[PITCH_MID].height = font_height * 2;
pitch_viewports[PITCH_MID].y += parent->height / 2 -
pitch_viewports[PITCH_MID].height / 2;
pitch_viewports[PITCH_BOTTOM].y += parent->height - font_height
- ICON_BORDER;
}
/*
* Fixes the viewports so they represent the 3 rows, and adds a little margin
* on all sides for the icons (which are drawn outside of the grid
*
* The modified viewports need to be passed to the touchscreen handling function
**/
static void pitchscreen_fix_viewports(struct viewport *parent,
struct viewport pitch_viewports[PITCH_ITEM_COUNT])
{
int i, font_height;
font_height = font_get(parent->font)->height;
for (i = 0; i < PITCH_ITEM_COUNT; i++)
{
pitch_viewports[i] = *parent;
pitch_viewports[i].height = parent->height / PITCH_ITEM_COUNT;
pitch_viewports[i].x += ICON_BORDER;
pitch_viewports[i].width -= 2*ICON_BORDER;
}
pitch_viewports[PITCH_TOP].y += ICON_BORDER;
pitch_viewports[PITCH_TOP].height -= ICON_BORDER;
if(pitch_viewports[PITCH_MID].height < font_height * 2)
pitch_viewports[PITCH_MID].height = font_height * 2;
pitch_viewports[PITCH_MID].y = pitch_viewports[PITCH_TOP].y
+ pitch_viewports[PITCH_TOP].height;
pitch_viewports[PITCH_BOTTOM].y = pitch_viewports[PITCH_MID].y
+ pitch_viewports[PITCH_MID].height;
pitch_viewports[PITCH_BOTTOM].height -= ICON_BORDER;
}
static int scrollbar_scroll(struct gui_synclist * gui_list,
int y)
{
const int screen = screens[SCREEN_MAIN].screen_type;
const int nb_lines = viewport_get_nb_lines(&list_text[screen]);
if (nb_lines < gui_list->nb_items)
{
/* scrollbar scrolling is still line based */
y_offset = 0;
int scrollbar_size = nb_lines*
font_get(gui_list->parent[screen]->font)->height;
int actual_y = y - list_text[screen].y;
int new_selection = (actual_y * gui_list->nb_items)
/ scrollbar_size;
int start_item = new_selection - nb_lines/2;
if(start_item < 0)
start_item = 0;
else if(start_item > gui_list->nb_items - nb_lines)
start_item = gui_list->nb_items - nb_lines;
gui_list->start_item[screen] = start_item;
return ACTION_REDRAW;
}
return ACTION_NONE;
}
static int screen_helper_getcharheight(void)
{
#ifdef HAVE_LCD_BITMAP
return font_get(lcd_getfont())->height;
#else
return 1;
#endif
}
static int screen_helper_remote_getcharwidth(void)
{
#ifdef HAVE_LCD_BITMAP
return font_get(lcd_remote_getfont())->maxwidth;
#else
return 1;
#endif
}
int time_screen(void* ignored)
{
(void)ignored;
int nb_lines, font_h, ret;
menu_was_pressed = false;
push_current_activity(ACTIVITY_TIMEDATESCREEN);
FOR_NB_SCREENS(i)
{
viewport_set_defaults(&clock_vps[i], i);
#ifdef HAVE_BUTTONBAR
if (global_settings.buttonbar)
{
clock_vps[i].height -= BUTTONBAR_HEIGHT;
}
#endif
nb_lines = viewport_get_nb_lines(&clock_vps[i]);
gui_synclist_set_viewport_defaults(&menu[i], i);
/* force time to be drawn centered */
clock_vps[i].flags |= VP_FLAG_ALIGN_CENTER;
font_h = font_get(clock_vps[i].font)->height;
nb_lines -= 2; /* at least 2 lines for menu */
if (nb_lines > 4)
nb_lines = 4;
if (nb_lines >= 2)
clock_vps[i].height = nb_lines*font_h;
else /* disable the clock_vps drawing */
clock_vps[i].height = 0;
menu[i].y += clock_vps[i].height;
menu[i].height -= clock_vps[i].height;
draw_timedate(&clock_vps[i], &screens[i]);
}
#ifdef SAMSUNG_YH820
/* some hardware revisions of the yh820 have a rtc problem: if you try to set
the time/date it will leave the player in an absolute unresponsive state
which can only be reverted by removing the battery. Setting time/date
should be prohibited on this targets. Fortunately we can autodetect these,
because they always report "02:02:02" as time.
*/
struct tm *tm = get_time();
if (tm->tm_year==102 && tm->tm_hour==2 && tm->tm_min==2 && tm->tm_sec==2) {
splash(4*HZ, "Can't set time/date due to hardware issues!");
return 0;
}
#endif
ret = do_menu(&time_menu, NULL, menu, false);
pop_current_activity();
/* see comments above in the button callback */
if (!menu_was_pressed && ret == GO_TO_PREVIOUS)
return 0;
return ret;
}
bool dbg_hw_info_pinctrl(void)
{
lcd_setfont(FONT_SYSFIXED);
#ifdef IMX233_PINCTRL_DEBUG
unsigned top_user = 0;
#endif
while(1)
{
int button = get_action(CONTEXT_STD, HZ / 10);
switch(button)
{
case ACTION_STD_NEXT:
#ifdef IMX233_PINCTRL_DEBUG
top_user++;
break;
#endif
case ACTION_STD_PREV:
#ifdef IMX233_PINCTRL_DEBUG
if(top_user > 0)
top_user--;
break;
#endif
case ACTION_STD_OK:
case ACTION_STD_MENU:
lcd_setfont(FONT_UI);
return true;
case ACTION_STD_CANCEL:
lcd_setfont(FONT_UI);
return false;
}
lcd_clear_display();
for(int i = 0; i < 4; i++)
lcd_putsf(0, i, "DIN%d = 0x%08x", i, imx233_get_gpio_input_mask(i, 0xffffffff));
#ifdef IMX233_PINCTRL_DEBUG
unsigned cur_line = 6;
unsigned last_line = lcd_getheight() / font_get(lcd_getfont())->height;
unsigned cur_idx = 0;
for(int bank = 0; bank < 4; bank++)
for(int pin = 0; pin < 32; pin++)
{
const char *owner = imx233_pinctrl_get_pin_use(bank, pin);
if(owner == NULL)
continue;
if(cur_idx++ >= top_user && cur_line < last_line)
lcd_putsf(0, cur_line++, "B%dP%02d %s", bank, pin, owner);
}
if(cur_idx < top_user)
top_user = cur_idx - 1;
#endif
lcd_update();
yield();
}
}
void LCDFN(scroll_fn)(void)
{
struct font* pf;
struct scrollinfo* s;
int index;
int xpos, ypos;
struct viewport* old_vp = current_vp;
for ( index = 0; index < LCDFN(scroll_info).lines; index++ ) {
s = &LCDFN(scroll_info).scroll[index];
/* check pause */
if (TIME_BEFORE(current_tick, s->start_tick))
continue;
LCDFN(set_viewport)(s->vp);
if (s->backward)
s->offset -= LCDFN(scroll_info).step;
else
s->offset += LCDFN(scroll_info).step;
pf = font_get(current_vp->font);
xpos = s->startx;
ypos = s->y * pf->height + s->y_offset;
if (s->bidir) { /* scroll bidirectional */
if (s->offset <= 0) {
/* at beginning of line */
s->offset = 0;
s->backward = false;
s->start_tick = current_tick + LCDFN(scroll_info).delay * 2;
}
if (s->offset >= s->width - (current_vp->width - xpos)) {
/* at end of line */
s->offset = s->width - (current_vp->width - xpos);
s->backward = true;
s->start_tick = current_tick + LCDFN(scroll_info).delay * 2;
}
}
else {
/* scroll forward the whole time */
if (s->offset >= s->width)
s->offset %= s->width;
}
LCDFN(putsxyofs_style)(xpos, ypos, s->line, s->style, s->width,
pf->height, s->offset);
LCDFN(update_viewport_rect)(xpos, ypos, current_vp->width - xpos,
pf->height);
}
LCDFN(set_viewport)(old_vp);
}
static void usb_screen_fix_viewports(struct screen *screen,
struct usb_screen_vps_t *usb_screen_vps)
{
int logo_width, logo_height;
struct viewport *parent = &usb_screen_vps->parent;
struct viewport *logo = &usb_screen_vps->logo;
#ifdef HAVE_REMOTE_LCD
if (screen->screen_type == SCREEN_REMOTE)
{
logo_width = BMPWIDTH_remote_usblogo;
logo_height = BMPHEIGHT_remote_usblogo;
}
else
#endif
{
logo_width = BMPWIDTH_usblogo;
logo_height = BMPHEIGHT_usblogo;
}
viewportmanager_theme_enable(screen->screen_type, true, parent);
if (logo_width > parent->width)
logo_width = parent->width;
if (logo_height > parent->height)
logo_height = parent->height;
*logo = *parent;
logo->x = parent->x + parent->width - logo_width;
logo->y = parent->y + (parent->height - logo_height) / 2;
logo->width = logo_width;
logo->height = logo_height;
#ifdef USB_ENABLE_HID
if (usb_hid)
{
struct viewport *title = &usb_screen_vps->title;
int char_height = font_get(parent->font)->height;
*title = *parent;
title->y = logo->y + logo->height + char_height;
title->height = char_height;
/* try to fit logo and title to parent */
if (parent->y + parent->height < title->y + title->height)
{
logo->y = parent->y;
title->y = parent->y + logo->height;
}
}
#endif
}
bool dbg_hw_info_ocotp(void)
{
lcd_setfont(FONT_SYSFIXED);
unsigned top_user = 0;
while(1)
{
int button = get_action(CONTEXT_STD, HZ / 10);
switch(button)
{
case ACTION_STD_NEXT:
top_user++;
break;
case ACTION_STD_PREV:
if(top_user > 0)
top_user--;
break;
case ACTION_STD_OK:
case ACTION_STD_MENU:
lcd_setfont(FONT_UI);
return true;
case ACTION_STD_CANCEL:
lcd_setfont(FONT_UI);
return false;
}
lcd_clear_display();
unsigned cur_line = 0;
unsigned last_line = lcd_getheight() / font_get(lcd_getfont())->height;
unsigned i = 0;
for(i = 0; i < ARRAYLEN(dbg_ocotp); i++)
{
if(i >= top_user && cur_line < last_line)
{
lcd_putsf(0, cur_line, "%s", dbg_ocotp[i].name);
lcd_putsf(8, cur_line++, "%x", imx233_ocotp_read(dbg_ocotp[i].addr));
}
}
if(i < top_user)
top_user = i - 1;
lcd_update();
yield();
}
}
bool dbg_hw_info_icoll(void)
{
lcd_setfont(FONT_SYSFIXED);
int first_irq = 0;
int dbg_irqs_count = sizeof(dbg_irqs) / sizeof(dbg_irqs[0]);
int line_count = lcd_getheight() / font_get(lcd_getfont())->height;
while(1)
{
int button = get_action(CONTEXT_STD, HZ / 10);
switch(button)
{
case ACTION_STD_NEXT:
first_irq++;
if(first_irq >= dbg_irqs_count)
first_irq = dbg_irqs_count - 1;
break;
case ACTION_STD_PREV:
first_irq--;
if(first_irq < 0)
first_irq = 0;
break;
case ACTION_STD_OK:
case ACTION_STD_MENU:
lcd_setfont(FONT_UI);
return true;
case ACTION_STD_CANCEL:
lcd_setfont(FONT_UI);
return false;
}
lcd_clear_display();
for(int i = first_irq, j = 0; i < dbg_irqs_count && j < line_count; i++, j++)
{
struct imx233_icoll_irq_info_t info = imx233_icoll_get_irq_info(dbg_irqs[i].src);
lcd_putsf(0, j, "%s", dbg_irqs[i].name);
if(info.enabled)
lcd_putsf(10, j, "%d", info.freq);
}
lcd_update();
yield();
}
}
int time_screen(void* ignored)
{
(void)ignored;
int nb_lines, font_h, ret;
menu_was_pressed = false;
push_current_activity(ACTIVITY_TIMEDATESCREEN);
FOR_NB_SCREENS(i)
{
viewport_set_defaults(&clock_vps[i], i);
#ifdef HAVE_BUTTONBAR
if (global_settings.buttonbar)
{
clock_vps[i].height -= BUTTONBAR_HEIGHT;
}
#endif
nb_lines = viewport_get_nb_lines(&clock_vps[i]);
gui_synclist_set_viewport_defaults(&menu[i], i);
/* force time to be drawn centered */
clock_vps[i].flags |= VP_FLAG_ALIGN_CENTER;
font_h = font_get(clock_vps[i].font)->height;
nb_lines -= 2; /* at least 2 lines for menu */
if (nb_lines > 4)
nb_lines = 4;
if (nb_lines >= 2)
clock_vps[i].height = nb_lines*font_h;
else /* disable the clock_vps drawing */
clock_vps[i].height = 0;
menu[i].y += clock_vps[i].height;
menu[i].height -= clock_vps[i].height;
draw_timedate(&clock_vps[i], &screens[i]);
}
ret = do_menu(&time_menu, NULL, menu, false);
pop_current_activity();
/* see comments above in the button callback */
if (!menu_was_pressed && ret == GO_TO_PREVIOUS)
return 0;
return ret;
}
/* Draw the list...
internal screen layout:
-----------------
|TI| title | TI is title icon
-----------------
| | | |
|S|I| | S - scrollbar
| | | items | I - icons
| | | |
------------------
Note: This image is flipped horizontally when the language is a
right-to-left one (Hebrew, Arabic)
*/
static bool draw_title(struct screen *display, struct gui_synclist *list)
{
const int screen = display->screen_type;
int style = STYLE_DEFAULT;
struct viewport *title_text_vp = &title_text[screen];
if (sb_set_title_text(list->title, list->title_icon, screen))
return false; /* the sbs is handling the title */
display->scroll_stop(title_text_vp);
if (!list_display_title(list, screen))
return false;
*title_text_vp = *(list->parent[screen]);
title_text_vp->height = font_get(title_text_vp->font)->height;
if (list->title_icon != Icon_NOICON && global_settings.show_icons)
{
struct viewport title_icon = *title_text_vp;
title_icon.width = get_icon_width(screen) + ICON_PADDING * 2;
if (VP_IS_RTL(&title_icon))
{
title_icon.x += title_text_vp->width - title_icon.width;
}
else
{
title_text_vp->x += title_icon.width;
}
title_text_vp->width -= title_icon.width;
display->set_viewport(&title_icon);
screen_put_icon(display, 0, 0, list->title_icon);
}
#ifdef HAVE_LCD_COLOR
if (list->title_color >= 0)
{
style |= (STYLE_COLORED|list->title_color);
}
#endif
display->set_viewport(title_text_vp);
display->puts_scroll_style(0, 0, list->title, style);
return true;
}
/**********************************
Show tiles types
**********************************/
static void compose_type(context_t * ctx,int layer_index)
{
int x = 0;
int y = 0;
item_t * item;
char * type;
static TTF_Font * font = NULL;
int w;
int h;
char layer_name[SMALL_BUF];
if( option->show_tile_type == false) {
return;
}
sprintf(layer_name,"%s%d",MAP_KEY_LAYER,layer_index);
if( entry_exist(MAP_TABLE, ctx->map, layer_name,MAP_KEY_TYPE,NULL) == false ) {
return;
}
font = font_get(ctx,ITEM_FONT, ITEM_FONT_SIZE);
for( x=0; x<default_layer->map_w; x++) {
for( y=0; y<default_layer->map_h; y++) {
if(entry_read_list_index(MAP_TABLE,ctx->map,&type,x + y * default_layer->map_w,layer_name,MAP_KEY_TYPE,NULL) == RET_NOK ) {
continue;
}
if( type[0] == 0 ) {
continue;
}
item = item_list_add(&item_list);
item_set_string(item,type);
item_set_font(item,font);
sdl_get_string_size(item->font,item->string,&w,&h);
item_set_anim_shape(item,map_t2p_x(x,y,default_layer),map_t2p_y(x,y,default_layer),w,h);
}
}
}
static int kinetic_callback(struct timeout *tmo)
{
/* cancel if screen was pressed */
if (scroll_mode != SCROLL_KINETIC)
return 0;
struct cb_data *data = (struct cb_data*)tmo->data;
int line_height = font_get(data->list->parent[0]->font)->height;
/* ds = v*dt */
int pixel_diff = data->velocity * RELOAD_INTERVAL / HZ;
/* remember signedness to detect stopping */
int old_sign = SIGN(data->velocity);
/* advance the list */
if (!swipe_scroll(data->list, line_height, pixel_diff))
{
/* nothing to scroll? */
data->velocity = 0;
}
else
{
/* decelerate by a fixed amount
* decrementing v0 over time by the deceleration is
* equivalent to computing v = a*t + v0 */
data->velocity -= SIGN(data->velocity)*DECELERATION;
if (SIGN(data->velocity) != old_sign)
data->velocity = 0;
}
queue_post(&button_queue, BUTTON_TOUCHSCREEN, 0);
/* stop if the velocity hit or crossed zero */
if (!data->velocity)
{
kinetic_stats_reset();
return 0;
}
/* let get_action() timeout, which loads to a
* gui_synclist_draw() call from the main thread */
return RELOAD_INTERVAL; /* cancel or reload */
}
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));
}
}
}
/******************************************************
create a list of item for the currently selected screen
******************************************************/
static void compose_scr(context_t * context)
{
static TTF_Font * font = NULL;
option_t * option = option_get();
SDL_SetRenderDrawColor(context->render, 0, 0, 0, 255);
switch(current_screen) {
case SCREEN_SELECT:
item_list = scr_select_compose(context);
break;
case SCREEN_PLAY:
item_list = scr_play_compose(context);
break;
}
if( option->show_fps ) {
font = font_get(context,ITEM_FONT, ITEM_FONT_SIZE);
frame_rate = item_list_add(&item_list);
item_set_font(frame_rate,font);
item_set_anim_shape(frame_rate,50,50,20,20);
item_set_overlay(frame_rate,1);
}
}
static int parse_progressbar_tag(struct skin_element* element,
struct wps_token *token,
struct wps_data *wps_data)
{
#ifdef HAVE_LCD_BITMAP
struct progressbar *pb;
struct viewport *vp = &curr_vp->vp;
struct skin_tag_parameter *param = element->params;
int curr_param = 0;
char *image_filename = NULL;
if (element->params_count == 0 &&
element->tag->type != SKIN_TOKEN_PROGRESSBAR)
return 0; /* nothing to do */
pb = (struct progressbar*)skin_buffer_alloc(sizeof(struct progressbar));
token->value.data = pb;
if (!pb)
return WPS_ERROR_INVALID_PARAM;
pb->vp = vp;
pb->follow_lang_direction = follow_lang_direction > 0;
pb->nofill = false;
pb->nobar = false;
pb->image = NULL;
pb->slider = NULL;
pb->invert_fill_direction = false;
pb->horizontal = true;
if (element->params_count == 0)
{
pb->x = 0;
pb->width = vp->width;
pb->height = SYSFONT_HEIGHT-2;
pb->y = -1; /* Will be computed during the rendering */
pb->type = element->tag->type;
return 0;
}
/* (x, y, width, height, ...) */
if (!isdefault(param))
pb->x = param->data.number;
else
pb->x = 0;
param++;
if (!isdefault(param))
pb->y = param->data.number;
else
pb->y = -1; /* computed at rendering */
param++;
if (!isdefault(param))
pb->width = param->data.number;
else
pb->width = vp->width - pb->x;
param++;
if (!isdefault(param))
{
/* A zero height makes no sense - reject it */
if (param->data.number == 0)
return WPS_ERROR_INVALID_PARAM;
pb->height = param->data.number;
}
else
{
if (vp->font > FONT_UI)
pb->height = -1; /* calculate at display time */
else
{
#ifndef __PCTOOL__
pb->height = font_get(vp->font)->height;
#else
pb->height = 8;
#endif
}
}
/* optional params, first is the image filename if it isnt recognised as a keyword */
curr_param = 4;
if (isdefault(&element->params[curr_param]))
{
param++;
curr_param++;
}
pb->horizontal = pb->width > pb->height;
while (curr_param < element->params_count)
{
param++;
if (!strcmp(param->data.text, "invert"))
pb->invert_fill_direction = true;
else if (!strcmp(param->data.text, "nofill"))
pb->nofill = true;
else if (!strcmp(param->data.text, "nobar"))
pb->nobar = true;
else if (!strcmp(param->data.text, "slider"))
{
if (curr_param+1 < element->params_count)
{
curr_param++;
param++;
pb->slider = find_image(param->data.text, wps_data);
}
else /* option needs the next param */
return -1;
}
else if (!strcmp(param->data.text, "image"))
{
if (curr_param+1 < element->params_count)
{
curr_param++;
param++;
image_filename = param->data.text;
}
else /* option needs the next param */
return -1;
}
else if (!strcmp(param->data.text, "vertical"))
{
pb->horizontal = false;
if (isdefault(&element->params[3]))
pb->height = vp->height - pb->y;
}
else if (!strcmp(param->data.text, "horizontal"))
pb->horizontal = true;
else if (curr_param == 4)
image_filename = param->data.text;
curr_param++;
}
if (image_filename)
{
pb->image = find_image(image_filename, wps_data);
if (!pb->image) /* load later */
{
struct gui_img* img = (struct gui_img*)skin_buffer_alloc(sizeof(struct gui_img));
if (!img)
return WPS_ERROR_INVALID_PARAM;
/* save a pointer to the filename */
img->bm.data = (char*)image_filename;
img->label = image_filename;
img->x = 0;
img->y = 0;
img->num_subimages = 1;
img->always_display = false;
img->display = -1;
img->using_preloaded_icons = false;
img->vp = &curr_vp->vp;
struct skin_token_list *item =
(struct skin_token_list *)new_skin_token_list_item(NULL, img);
if (!item)
return WPS_ERROR_INVALID_PARAM;
add_to_ll_chain(&wps_data->images, item);
pb->image = img;
}
}
if (token->type == SKIN_TOKEN_VOLUME)
token->type = SKIN_TOKEN_VOLUMEBAR;
else if (token->type == SKIN_TOKEN_BATTERY_PERCENT)
token->type = SKIN_TOKEN_BATTERY_PERCENTBAR;
else if (token->type == SKIN_TOKEN_TUNER_RSSI)
token->type = SKIN_TOKEN_TUNER_RSSI_BAR;
pb->type = token->type;
return 0;
#else
(void)element;
if (token->type == SKIN_TOKEN_PROGRESSBAR ||
token->type == SKIN_TOKEN_PLAYER_PROGRESSBAR)
{
wps_data->full_line_progressbar =
token->type == SKIN_TOKEN_PLAYER_PROGRESSBAR;
}
return 0;
#endif
}
unsigned gui_synclist_do_touchscreen(struct gui_synclist * gui_list)
{
short x, y;
const enum screen_type screen = SCREEN_MAIN;
struct viewport *info_vp = sb_skin_get_info_vp(screen);
const int button = action_get_touchscreen_press_in_vp(&x, &y, info_vp);
const int list_start_item = gui_list->start_item[screen];
const int line_height = font_get(gui_list->parent[screen]->font)->height;
const struct viewport *list_text_vp = &list_text[screen];
const bool old_released = released;
const bool show_title = list_display_title(gui_list, screen);
const bool show_cursor = !global_settings.cursor_style &&
gui_list->show_selection_marker;
const bool on_title_clicked = show_title && y < line_height && (button&BUTTON_REL);
const bool cancelled_kinetic = (scroll_mode == SCROLL_KINETIC
&& button != ACTION_NONE && button != ACTION_UNKNOWN
&& !is_kinetic_over());
int icon_width = 0;
int line, list_width = list_text_vp->width;
released = (button&BUTTON_REL) != 0;
if (button == ACTION_NONE || button == ACTION_UNKNOWN)
{
/* this happens when we hit edges of the list while kinetic scrolling,
* but not when manually cancelling */
if (scroll_mode == SCROLL_KINETIC)
return ACTION_REDRAW;
return ACTION_NONE;
}
/* x and y are relative to info_vp */
if (gui_list->callback_get_item_icon != NULL)
icon_width += get_icon_width(screen);
if (show_cursor)
icon_width += get_icon_width(screen);
if (on_title_clicked)
{
if (scroll_mode == SCROLL_NONE || is_kinetic_over())
{
if (x < icon_width)
{
/* Top left corner is GO_TO_ROOT */
if (button == BUTTON_REL)
return ACTION_STD_MENU;
else if (button == (BUTTON_REPEAT|BUTTON_REL))
return ACTION_STD_CONTEXT;
return ACTION_NONE;
}
else /* click on title text is cancel */
if (button == BUTTON_REL)
return ACTION_STD_CANCEL;
}
/* do this after the above so the scrolling stops without
* going back in the list with the same touch */
if (scroll_mode == SCROLL_KINETIC)
{
kinetic_force_stop();
scroll_mode = SCROLL_NONE;
}
}
else /* list area clicked (or not released) */
{
const int actual_y = y - (show_title ? line_height : 0);
bool on_scrollbar_clicked;
switch (global_settings.scrollbar)
{
case SCROLLBAR_LEFT:
on_scrollbar_clicked = x <= SCROLLBAR_WIDTH; break;
case SCROLLBAR_RIGHT:
on_scrollbar_clicked = x > (icon_width + list_width); break;
default:
on_scrollbar_clicked = false; break;
}
/* conditions for scrollbar scrolling:
* * pen is on the scrollbar
* AND scrollbar is on the right (left case is handled above)
* OR * pen is in the somewhere else but we did scrollbar scrolling before
*
* scrollbar scrolling must end if the pen is released
* scrollbar scrolling must not happen if we're currently scrolling
* via swiping the screen
**/
if (!released && scroll_mode != SCROLL_SWIPE &&
(on_scrollbar_clicked || scroll_mode == SCROLL_BAR))
{
if (scroll_mode == SCROLL_KINETIC)
kinetic_force_stop();
scroll_mode = SCROLL_BAR;
return scrollbar_scroll(gui_list, y);
}
/* |--------------------------------------------------------|
* | Description of the touchscreen list interface: |
* |--------------------------------------------------------|
* | Pressing an item will select it and "enter" it. |
* | |
* | Pressing and holding your pen down will scroll through |
* | the list of items. |
* | |
* | Pressing and holding your pen down on a single item |
* | will bring up the context menu of it. |
* |--------------------------------------------------------|
*/
if (actual_y > 0 || button & BUTTON_REPEAT)
{
/* selection needs to be corrected if an items are only
* partially visible */
line = (actual_y - y_offset) / line_height;
if (cancelled_kinetic)
{
kinetic_force_stop();
scroll_mode = SCROLL_SWIPE;
}
/* Pressed below the list*/
if (list_start_item + line >= gui_list->nb_items)
{
/* don't collect last_position outside of the list area
* it'd break selecting after such a situation */
last_position = 0;
return ACTION_NONE;
}
if (button & BUTTON_REPEAT && scroll_mode == SCROLL_NONE)
{
/* held a single line for a while, bring up the context menu */
gui_synclist_select_item(gui_list, list_start_item + line);
/* don't sent context repeatedly */
action_wait_for_release();
last_position = 0;
return ACTION_STD_CONTEXT;
}
if (released && !cancelled_kinetic)
{
/* Pen was released anywhere on the screen */
last_position = 0;
if (scroll_mode == SCROLL_NONE)
{
/* select current line */
gui_synclist_select_item(gui_list, list_start_item + line);
return ACTION_STD_OK;
}
else
{
/* we were scrolling
* -> reset scrolling but do nothing else */
if (scroll_mode == SCROLL_SWIPE)
{
if (kinetic_setup_scroll(gui_list))
scroll_mode = SCROLL_KINETIC;
}
if (scroll_mode != SCROLL_KINETIC)
scroll_mode = SCROLL_NONE;
return ACTION_NONE;
}
}
else
{ /* pen is on the screen */
bool redraw = false, result = false;
/* beginning of list interaction denoted by release in
* the previous call */
if (old_released || is_kinetic_over())
{
scroll_mode = SCROLL_NONE;
redraw = true;
}
/* select current item; gui_synclist_select_item()
* is not called because it has side effects that
* disturb kinetic scrolling */
gui_list->selected_item = list_start_item+line;
gui_synclist_speak_item(gui_list);
if (last_position == 0)
{
redraw = true;
last_position = actual_y;
}
else
{
/* record speed data in case we do kinetic scrolling */
int diff = actual_y - last_position;
kinetic_stats_collect(diff);
result = swipe_scroll(gui_list, line_height, diff);
}
/* Start scrolling once the pen is moved without
* releasing it inbetween */
if (result)
{
redraw = true;
scroll_mode = SCROLL_SWIPE;
}
last_position = actual_y;
return redraw ? ACTION_REDRAW:ACTION_NONE;
}
}
}
return ACTION_REDRAW;
}
static void displayremote(void)
{
/* TODO: we should have a debug option that enables/disables this! */
int w, h, i;
int fontnr;
int cur_x, cur_y, delta_y, delta_x;
struct font* font;
int nb_lines;
char buf[2];
/* Memorize the pointer to the beginning of the last ... lines
I assume delta_y >= 6 to avoid wasting memory and allocating memory dynamically
I hope there is no font with height < 6 ! */
const int NB_ENTRIES=LCD_REMOTE_HEIGHT / 6;
int line_start_ptr[NB_ENTRIES];
fontnr = lcd_getfont();
font = font_get(fontnr);
/* get the horizontal size of each line */
font_getstringsize("A", NULL, &delta_y, fontnr);
/* font too small ? */
if(delta_y < 6)
return;
/* nothing to print ? */
if(logfindex == 0 && !logfwrap)
return;
w = LCD_REMOTE_WIDTH;
h = LCD_REMOTE_HEIGHT;
nb_lines = 0;
if(logfwrap)
i = logfindex;
else
i = 0;
cur_x = 0;
line_start_ptr[0] = i;
do
{
if(logfbuffer[i] == '\0')
{
line_start_ptr[++nb_lines % NB_ENTRIES] = i+1;
cur_x = 0;
}
else
{
/* does character fit on this line ? */
delta_x = font_get_width(font, logfbuffer[i]);
if(cur_x + delta_x > w)
{
cur_x = 0;
line_start_ptr[++nb_lines % NB_ENTRIES] = i;
}
/* update pointer */
cur_x += delta_x;
}
i++;
if(i >= MAX_LOGF_SIZE)
i = 0;
} while(i != logfindex);
lcd_remote_clear_display();
i = line_start_ptr[ MAX(nb_lines - h / delta_y, 0) % NB_ENTRIES];
cur_x = 0;
cur_y = 0;
buf[1] = '\0';
do {
if(logfbuffer[i] == '\0')
{
cur_y += delta_y;
cur_x = 0;
}
else
{
/* does character fit on this line ? */
delta_x = font_get_width(font, logfbuffer[i]);
if(cur_x + delta_x > w)
{
cur_y += delta_y;
cur_x = 0;
}
buf[0] = logfbuffer[i];
lcd_remote_putsxy(cur_x, cur_y, buf);
cur_x += delta_x;
}
i++;
if(i >= MAX_LOGF_SIZE)
i = 0;
} while(i != logfindex);
lcd_remote_update();
}
void list_draw(struct screen *display, struct gui_synclist *list)
{
struct viewport list_icons;
int start, end, line_height, style, i;
const int screen = display->screen_type;
const int list_start_item = list->start_item[screen];
const int icon_width = get_icon_width(screen) + ICON_PADDING;
const bool scrollbar_in_left = (global_settings.scrollbar == SCROLLBAR_LEFT);
const bool show_cursor = !global_settings.cursor_style &&
list->show_selection_marker;
struct viewport *parent = (list->parent[screen]);
#ifdef HAVE_LCD_COLOR
unsigned char cur_line = 0;
#endif
int item_offset;
bool show_title;
struct viewport *list_text_vp = &list_text[screen];
line_height = font_get(parent->font)->height;
display->set_viewport(parent);
display->clear_viewport();
display->scroll_stop(list_text_vp);
*list_text_vp = *parent;
if ((show_title = draw_title(display, list)))
{
list_text_vp->y += line_height;
list_text_vp->height -= line_height;
}
const int nb_lines = viewport_get_nb_lines(list_text_vp);
start = list_start_item;
end = start + nb_lines;
#ifdef HAVE_TOUCHSCREEN
if (list->selected_item == 0 || (list->nb_items < nb_lines))
y_offset = 0; /* reset in case it's a new list */
int draw_offset = y_offset;
/* draw some extra items to not have empty lines at the top and bottom */
if (y_offset > 0)
{
/* make it negative for more consistent apparence when switching
* directions */
draw_offset -= line_height;
if (start > 0)
start--;
}
else if (y_offset < 0)
end++;
#else
#define draw_offset 0
#endif
/* draw the scrollbar if its needed */
if (global_settings.scrollbar && nb_lines < list->nb_items)
{
struct viewport vp = *list_text_vp;
vp.width = SCROLLBAR_WIDTH;
vp.height = line_height * nb_lines;
vp.x = parent->x;
list_text_vp->width -= SCROLLBAR_WIDTH;
if (scrollbar_in_left)
list_text_vp->x += SCROLLBAR_WIDTH;
else
vp.x += list_text_vp->width;
display->set_viewport(&vp);
gui_scrollbar_draw(display,
(scrollbar_in_left? 0: 1), 0, SCROLLBAR_WIDTH-1, vp.height,
list->nb_items, list_start_item, list_start_item + nb_lines,
VERTICAL);
}
else if (show_title)
{
/* shift everything a bit in relation to the title... */
if (!VP_IS_RTL(list_text_vp) && scrollbar_in_left)
{
list_text_vp->width -= SCROLLBAR_WIDTH;
list_text_vp->x += SCROLLBAR_WIDTH;
}
else if (VP_IS_RTL(list_text_vp) && !scrollbar_in_left)
{
list_text_vp->width -= SCROLLBAR_WIDTH;
}
}
/* setup icon placement */
list_icons = *list_text_vp;
int icon_count = (list->callback_get_item_icon != NULL) ? 1 : 0;
if (show_cursor)
icon_count++;
if (icon_count)
{
list_icons.width = icon_width * icon_count;
list_text_vp->width -= list_icons.width + ICON_PADDING;
if (VP_IS_RTL(&list_icons))
list_icons.x += list_text_vp->width + ICON_PADDING;
else
list_text_vp->x += list_icons.width + ICON_PADDING;
}
for (i=start; i<end && i<list->nb_items; i++)
{
/* do the text */
unsigned const char *s;
char entry_buffer[MAX_PATH];
unsigned char *entry_name;
int text_pos = 0;
int line = i - start;
s = list->callback_get_item_name(i, list->data, entry_buffer,
sizeof(entry_buffer));
entry_name = P2STR(s);
display->set_viewport(list_text_vp);
style = STYLE_DEFAULT;
/* position the string at the correct offset place */
int item_width,h;
display->getstringsize(entry_name, &item_width, &h);
item_offset = gui_list_get_item_offset(list, item_width, text_pos,
display, list_text_vp);
#ifdef HAVE_LCD_COLOR
/* if the list has a color callback */
if (list->callback_get_item_color)
{
int color = list->callback_get_item_color(i, list->data);
/* if color selected */
if (color >= 0)
{
style |= STYLE_COLORED|color;
}
}
#endif
/* draw the selected line */
if(
#ifdef HAVE_TOUCHSCREEN
/* don't draw it during scrolling */
scroll_mode == SCROLL_NONE &&
#endif
i >= list->selected_item
&& i < list->selected_item + list->selected_size
&& list->show_selection_marker)
{/* The selected item must be displayed scrolling */
if (global_settings.cursor_style == 1
#ifdef HAVE_REMOTE_LCD
/* the global_settings.cursor_style check is here to make
* sure if they want the cursor instead of bar it will work
*/
|| (display->depth < 16 && global_settings.cursor_style)
#endif
)
{
/* Display inverted-line-style */
style = STYLE_INVERT;
}
#ifdef HAVE_LCD_COLOR
else if (global_settings.cursor_style == 2)
{
/* Display colour line selector */
style = STYLE_COLORBAR;
}
else if (global_settings.cursor_style == 3)
{
/* Display gradient line selector */
style = STYLE_GRADIENT;
/* Make the lcd driver know how many lines the gradient should
cover and current line number */
/* number of selected lines */
style |= NUMLN_PACK(list->selected_size);
/* current line number, zero based */
style |= CURLN_PACK(cur_line);
cur_line++;
}
#endif
/* if the text is smaller than the viewport size */
if (item_offset> item_width - (list_text_vp->width - text_pos))
{
/* don't scroll */
display->puts_style_xyoffset(0, line, entry_name,
style, item_offset, draw_offset);
}
else
{
display->puts_scroll_style_xyoffset(0, line, entry_name,
style, item_offset, draw_offset);
}
}
else
{
if (list->scroll_all)
display->puts_scroll_style_xyoffset(0, line, entry_name,
style, item_offset, draw_offset);
else
display->puts_style_xyoffset(0, line, entry_name,
style, item_offset, draw_offset);
}
/* do the icon */
display->set_viewport(&list_icons);
if (list->callback_get_item_icon != NULL)
{
screen_put_icon_with_offset(display, show_cursor?1:0,
(line),show_cursor?ICON_PADDING:0,draw_offset,
list->callback_get_item_icon(i, list->data));
}
if (show_cursor && i >= list->selected_item &&
i < list->selected_item + list->selected_size)
{
screen_put_icon_with_offset(display, 0, line, 0, draw_offset, Icon_Cursor);
}
}
display->set_viewport(parent);
display->update_viewport();
display->set_viewport(NULL);
}
/**********************************
Compose item on map
**********************************/
static void compose_item(context_t * ctx,int layer_index)
{
char * sprite_name = NULL;
int sprite_align = ALIGN_CENTER;
int sprite_offset_y = 0;
anim_t * anim;
item_t * item;
int x;
int y;
int temp_x;
int temp_y;
char ** item_id;
int i;
static TTF_Font * font = NULL;
char * mytemplate;
int quantity;
char buf[SMALL_BUF];
char layer_name[SMALL_BUF];
sprintf(layer_name,"%s%d",MAP_KEY_LAYER,layer_index);
if(entry_get_group_list(MAP_TABLE,ctx->map,&item_id,layer_name,MAP_ENTRY_ITEM_LIST,NULL) == RET_NOK ) {
return;
}
font = font_get(ctx,ITEM_FONT, ITEM_FONT_SIZE);
i=0;
while( item_id[i] != NULL ) {
sprite_align = ALIGN_CENTER;
if(entry_read_int(MAP_TABLE,ctx->map,&x,layer_name,MAP_ENTRY_ITEM_LIST,item_id[i],MAP_ITEM_POS_X,NULL) == RET_NOK ) {
i++;
continue;
}
if(entry_read_int(MAP_TABLE,ctx->map,&y,layer_name,MAP_ENTRY_ITEM_LIST,item_id[i],MAP_ITEM_POS_Y,NULL) == RET_NOK ) {
i++;
continue;
}
mytemplate = item_is_resource(item_id[i]);
if ( mytemplate == NULL ) {
if(entry_read_string(ITEM_TABLE,item_id[i],&sprite_name,ITEM_SPRITE,NULL) == RET_NOK ) {
i++;
continue;
}
entry_read_int(ITEM_TABLE,item_id[i],&sprite_align,ITEM_ALIGN,NULL);
entry_read_int(ITEM_TABLE,item_id[i],&sprite_offset_y,ITEM_OFFSET_Y,NULL);
} else {
if(entry_read_string(ITEM_TEMPLATE_TABLE,mytemplate,&sprite_name,ITEM_SPRITE,NULL) == RET_NOK ) {
free(mytemplate);
i++;
continue;
}
entry_read_int(ITEM_TEMPLATE_TABLE,mytemplate,&sprite_align,ITEM_ALIGN,NULL);
entry_read_int(ITEM_TEMPLATE_TABLE,mytemplate,&sprite_offset_y,ITEM_OFFSET_Y,NULL);
free(mytemplate);
}
item = item_list_add(&item_list);
anim = imageDB_get_anim(ctx,sprite_name);
free(sprite_name);
temp_x = map_t2p_x(x,y,default_layer);
temp_y = map_t2p_y(x,y,default_layer);
x = temp_x;
y = temp_y;
/* Align on tile */
if( sprite_align == ALIGN_CENTER ) {
x -= ((anim->w*default_layer->map_zoom)-default_layer->tile_width)/2;
y -= ((anim->h*default_layer->map_zoom)-default_layer->tile_height)/2;
}
if( sprite_align == ALIGN_LOWER ) {
x -= ((anim->w*default_layer->map_zoom)-default_layer->tile_width)/2;
y -= (anim->h*default_layer->map_zoom)-default_layer->tile_height;
}
y += sprite_offset_y;
item_set_pos(item,x,y);
item_set_anim(item,anim,0);
item_set_zoom_x(item, default_layer->map_zoom );
item_set_zoom_y(item, default_layer->map_zoom );
if(font) {
quantity = resource_get_quantity(item_id[i]);
sprintf(buf,"%d",quantity);
item_set_string(item,buf);
item_set_font(item,font);
}
i++;
}
deep_free(item_id);
}
/* put a string at a given pixel position, skipping first ofs pixel columns */
static void LCDFN(putsxyofs)(int x, int y, int ofs, const unsigned char *str)
{
unsigned short *ucs;
struct font* pf = font_get(current_vp->font);
int vp_flags = current_vp->flags;
int rtl_next_non_diac_width, last_non_diacritic_width;
if ((vp_flags & VP_FLAG_ALIGNMENT_MASK) != 0)
{
int w;
LCDFN(getstringsize)(str, &w, NULL);
/* center takes precedence */
if (vp_flags & VP_FLAG_ALIGN_CENTER)
{
x = ((current_vp->width - w)/ 2) + x;
if (x < 0)
x = 0;
}
else
{
x = current_vp->width - w - x;
x += ofs;
ofs = 0;
}
}
rtl_next_non_diac_width = 0;
last_non_diacritic_width = 0;
/* Mark diacritic and rtl flags for each character */
for (ucs = bidi_l2v(str, 1); *ucs; ucs++)
{
bool is_rtl, is_diac;
const unsigned char *bits;
int width, base_width, drawmode = 0, base_ofs = 0;
const unsigned short next_ch = ucs[1];
if (x >= current_vp->width)
break;
is_diac = is_diacritic(*ucs, &is_rtl);
/* Get proportional width and glyph bits */
width = font_get_width(pf, *ucs);
/* Calculate base width */
if (is_rtl)
{
/* Forward-seek the next non-diacritic character for base width */
if (is_diac)
{
if (!rtl_next_non_diac_width)
{
const unsigned short *u;
/* Jump to next non-diacritic char, and calc its width */
for (u = &ucs[1]; *u && is_diacritic(*u, NULL); u++);
rtl_next_non_diac_width = *u ? font_get_width(pf, *u) : 0;
}
base_width = rtl_next_non_diac_width;
}
else
{
rtl_next_non_diac_width = 0; /* Mark */
base_width = width;
}
}
else
{
if (!is_diac)
last_non_diacritic_width = width;
base_width = last_non_diacritic_width;
}
if (ofs > width)
{
ofs -= width;
continue;
}
if (is_diac)
{
/* XXX: Suggested by amiconn:
* This will produce completely wrong results if the original
* drawmode is DRMODE_COMPLEMENT. We need to pre-render the current
* character with all its diacritics at least (in mono) and then
* finally draw that. And we'll need an extra buffer that can hold
* one char's bitmap. Basically we can't just change the draw mode
* to something else irrespective of the original mode and expect
* the result to look as intended and with DRMODE_COMPLEMENT (which
* means XORing pixels), overdrawing this way will cause odd results
* if the diacritics and the base char both have common pixels set.
* So we need to combine the char and its diacritics in a temp
* buffer using OR, and then draw the final bitmap instead of the
* chars, without touching the drawmode
**/
drawmode = current_vp->drawmode;
current_vp->drawmode = DRMODE_FG;
base_ofs = (base_width - width) / 2;
}
bits = font_get_bits(pf, *ucs);
LCDFN(mono_bitmap_part)(bits, ofs, 0, width, x + base_ofs, y,
width - ofs, pf->height);
if (is_diac)
{
current_vp->drawmode = drawmode;
}
if (next_ch)
{
bool next_is_rtl;
bool next_is_diacritic = is_diacritic(next_ch, &next_is_rtl);
/* Increment if:
* LTR: Next char is not diacritic,
* RTL: Current char is non-diacritic and next char is diacritic */
if ((is_rtl && !is_diac) ||
(!is_rtl && (!next_is_diacritic || next_is_rtl)))
{
x += base_width - ofs;
ofs = 0;
}
}
}
}
static void dsource_Redraw(t_HDataSource h, t_HGDI gdi, t_GuiViewType viewtype, int index, int width, int height, gboolean hilight)
{
t_DSAppStore* pme = (t_DSAppStore *)h;
t_AppStoreEntry* child;
BrdHandle brd;
resid_t resid;
t_HImage image = NULL;
char title[GUID_NAME_MAX+1];
gu32 old;
child = _GetEntry(pme->entry, index);
if(!child)
return;
if(pme->icon_w >= width || pme->icon_h >= height){
pme->icon_w = 0;
pme->icon_h = 0;
}
old = gdi_set_color(gdi, RGB_WHITE);
strcpy(title, "<N/A>");
if(child->type == APPSTORE_ENTRY_APP){
t_AppStoreApp *app = (t_AppStoreApp *)child;
brd = brd_get(app->guid);
resid = RESID_APP_ICON;
if(brd == BRD_HANDLE_ERROR) //2 资源获取失败则表示动态加载应用
image = pack_GetIcon(app->guid);
pack_GetModuleTitle(app->guid, app->module, title, sizeof(title));
}else{
t_AppStoreDir *dir = (t_AppStoreDir *)child;
brd = brd_get("sys");
resid = dir->icon;
//image = brd_get_image0(brd, dir->icon);
brd_get_string2(brd, dir->text, title, sizeof(title));
}
if(VIEWTYPE_IS_NORMAL(viewtype)){
if(image == NULL)
image = brd_get_image(brd, resid);
gdi_draw_icon_text(gdi, image, title, width, height, guiRight, IDF_HALIGN_LEFT|IDF_VALIGN_MIDDLE);
}else if(VIEWTYPE_IS_ICON(viewtype)){
int text_height = font_get(lang_get_current())->height;
int icon_height = height;
if(viewtype == GUI_VIEWTYPE_ICON_TEXT_BOTTOM || viewtype == GUI_VIEWTYPE_ICON_TEXT_TOP)
icon_height -= text_height+ICON_TEXT_SPLIT;
{
gui_rect_t tmp;
if(pme->icon_w && pme->icon_h){
tmp.x = (width-pme->icon_w)>>1;
tmp.y = (icon_height-pme->icon_h)>>1;
tmp.dx = pme->icon_w;
tmp.dy = pme->icon_h;
}else{
tmp.x = 0;
tmp.y = 0;
tmp.dx = width;
tmp.dy = icon_height;
}
if(g_object_valid(image)){
//2 动态加载的应用的图标，直接显示
gdi_draw_image_in(gdi, tmp.x, tmp.y, tmp.dx, tmp.dy, image, IDF_HALIGN_BESTFIT | IDF_VALIGN_BESTFIT);
}else if(!hilight){
//2 非焦点项，也直接显示
gdi_draw_image_in_by_resid(gdi, tmp.x, tmp.y, tmp.dx, tmp.dy, brd, resid, IDF_HALIGN_BESTFIT | IDF_VALIGN_BESTFIT);
}else{
//2 焦点项，如果是多帧gif，则播放动画
mmc_stop(pme->mmc_anim);
mmc_set_image_output(pme->mmc_anim, gdi, &tmp);
mmc_play_resid(pme->mmc_anim, -1, brd, resid);
}
}
void draw_progressbar(struct gui_wps *gwps, int line, struct progressbar *pb)
{
struct screen *display = gwps->display;
struct viewport *vp = SKINOFFSETTOPTR(get_skin_buffer(gwps->data), pb->vp);
struct wps_state *state = skin_get_global_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);
length = maxvol-minvol;
end = global_settings.volume-minvol;
}
else if (pb->type == SKIN_TOKEN_BATTERY_PERCENTBAR)
{
length = 100;
end = battery_level();
}
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_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_id, &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_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 (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
}
}
bool logfdisplay(void)
{
int action;
int w, h, i, index;
int fontnr;
int cur_x, cur_y, delta_y, delta_x;
struct font* font;
int user_index;/* user_index will be number of the first line to display (warning: line!=logf entry) */
char buf[2];
fontnr = lcd_getfont();
font = font_get(fontnr);
/* get the horizontal size of each line */
font_getstringsize("A", NULL, &delta_y, fontnr);
buf[1] = '\0';
w = LCD_WIDTH;
h = LCD_HEIGHT;
/* start at the end of the log */
user_index = compute_nb_lines(w, font) - h/delta_y -1; /* if negative, will be set 0 to zero later */
do {
lcd_clear_display();
if(user_index < 0)
user_index = 0;
if(logfwrap)
i = logfindex;
else
i = 0;
index = 0;
cur_x = 0;
cur_y = 0;
/* nothing to print ? */
if(logfindex == 0 && !logfwrap)
goto end_print;
do {
if(logfbuffer[i] == '\0')
{
/* should be display a newline ? */
if(index >= user_index)
cur_y += delta_y;
cur_x = 0;
index++;
}
else
{
/* does character fit on this line ? */
delta_x = font_get_width(font, logfbuffer[i]);
if(cur_x + delta_x > w)
{
/* should be display a newline ? */
if(index >= user_index)
cur_y += delta_y;
cur_x = 0;
index++;
}
/* should we print character ? */
if(index >= user_index)
{
buf[0] = logfbuffer[i];
lcd_putsxy(cur_x, cur_y, buf);
}
/* update pointer */
cur_x += delta_x;
}
/* did we fill the screen ? */
if(cur_y > h)
break;
i++;
if(i >= MAX_LOGF_SIZE)
i = 0;
} while(i != logfindex);
end_print:
lcd_update();
action = get_action(CONTEXT_STD, HZ);
switch( action )
{
case ACTION_STD_NEXT:
case ACTION_STD_NEXTREPEAT:
user_index++;
break;
case ACTION_STD_PREV:
case ACTION_STD_PREVREPEAT:
user_index--;
break;
case ACTION_STD_OK:
user_index = 0;
break;
#ifdef HAVE_TOUCHSCREEN
case ACTION_TOUCHSCREEN:
{
short x, y;
static int prev_y;
action = action_get_touchscreen_press(&x, &y);
if(action & BUTTON_REL)
prev_y = 0;
else
{
if(prev_y != 0)
user_index += (prev_y - y) / delta_y;
prev_y = y;
}
}
#endif
default:
break;
}
} while(action != ACTION_STD_CANCEL);
return false;
}
void draw_progressbar(struct gui_wps *gwps, int line, struct progressbar *pb)
{
struct screen *display = gwps->display;
struct viewport *vp = pb->vp;
struct wps_state *state = skin_get_global_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);
length = maxvol-minvol;
end = global_settings.volume-minvol;
}
else if (pb->type == SKIN_TOKEN_BATTERY_PERCENTBAR)
{
length = 100;
end = battery_level();
}
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);
}
#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_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->slider)
{
struct gui_img *img = pb->slider;
/* clear the slider */
screen_clear_area(display, x, y, width, height);
/* shrink the bar so the slider is inside bounds */
if (flags&HORIZONTAL)
{
width -= img->bm.width;
x += img->bm.width / 2;
}
else
{
height -= img->bm.height;
y += img->bm.height / 2;
}
}
if (pb->backdrop)
{
struct gui_img *img = pb->backdrop;
#if LCD_DEPTH > 1
if(img->bm.format == FORMAT_MONO) {
#endif
display->mono_bitmap_part(img->bm.data,
0, 0, img->bm.width,
x, y, width, height);
#if LCD_DEPTH > 1
} else {
display->transparent_bitmap_part((fb_data *)img->bm.data,
0, 0,
STRIDE(display->screen_type,
img->bm.width, img->bm.height),
x, y, width, height);
}
#endif
flags |= DONT_CLEAR_EXCESS;
}
if (!pb->nobar)
{
if (pb->image)
gui_bitmap_scrollbar_draw(display, &pb->image->bm,
x, y, width, height,
length, 0, end, flags);
else
gui_scrollbar_draw(display, x, y, width, height,
length, 0, end, flags);
}
if (pb->slider)
{
int xoff = 0, yoff = 0;
int w = width, h = height;
struct gui_img *img = pb->slider;
if (flags&HORIZONTAL)
{
w = img->bm.width;
xoff = width * end / length;
if (flags&INVERTFILL)
xoff = width - xoff;
xoff -= w / 2;
}
else
{
h = img->bm.height;
yoff = height * end / length;
if (flags&INVERTFILL)
yoff = height - yoff;
yoff -= h / 2;
}
#if LCD_DEPTH > 1
if(img->bm.format == FORMAT_MONO) {
#endif
display->mono_bitmap_part(img->bm.data,
0, 0, img->bm.width,
x + xoff, y + yoff, w, h);
#if LCD_DEPTH > 1
} else {
display->transparent_bitmap_part((fb_data *)img->bm.data,
0, 0,
STRIDE(display->screen_type,
img->bm.width, img->bm.height),
x + xoff, y + yoff, w, h);
}
#endif
}
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
}
}
bool dbg_hw_info_clkctrl(void)
{
lcd_setfont(FONT_SYSFIXED);
while(1)
{
int button = get_action(CONTEXT_STD, HZ / 10);
switch(button)
{
case ACTION_STD_NEXT:
case ACTION_STD_PREV:
case ACTION_STD_OK:
case ACTION_STD_MENU:
lcd_setfont(FONT_UI);
return true;
case ACTION_STD_CANCEL:
lcd_setfont(FONT_UI);
return false;
}
lcd_clear_display();
/* 012345678901234567890123456789 */
lcd_putsf(0, 0, "name en by idiv fdiv frequency");
for(unsigned i = 0; i < ARRAYLEN(dbg_clk); i++)
{
#define c dbg_clk[i]
lcd_putsf(0, i + 1, "%4s", c.name);
if(c.has_enable)
lcd_putsf(5, i + 1, "%2d", imx233_clkctrl_is_clock_enabled(c.clk));
if(c.has_bypass)
lcd_putsf(8, i + 1, "%2d", imx233_clkctrl_get_bypass_pll(c.clk));
if(c.has_idiv && imx233_clkctrl_get_clock_divisor(c.clk) != 0)
lcd_putsf(10, i + 1, "%4d", imx233_clkctrl_get_clock_divisor(c.clk));
if(c.has_fdiv && imx233_clkctrl_get_fractional_divisor(c.clk) != 0)
lcd_putsf(16, i + 1, "%4d", imx233_clkctrl_get_fractional_divisor(c.clk));
if(c.has_freq)
lcd_putsf(21, i + 1, "%9d", imx233_clkctrl_get_clock_freq(c.clk));
#undef c
}
int line = ARRAYLEN(dbg_clk) + 1;
lcd_putsf(0, line, "as: %d/%d emi sync: %d", imx233_clkctrl_is_auto_slow_enabled(),
1 << imx233_clkctrl_get_auto_slow_divisor(), imx233_clkctrl_is_emi_sync_enabled());
line++;
lcd_putsf(0, line, "as monitor: ");
int x_off = 12;
bool first = true;
unsigned line_w = lcd_getwidth() / font_get_width(font_get(lcd_getfont()), ' ');
for(unsigned i = 0; i < ARRAYLEN(dbg_as_monitor); i++)
{
if(!imx233_clkctrl_is_auto_slow_monitor_enabled(dbg_as_monitor[i].monitor))
continue;
if(!first)
{
lcd_putsf(x_off, line, ", ");
x_off += 2;
}
first = false;
if((x_off + strlen(dbg_as_monitor[i].name)) > line_w)
{
x_off = 1;
line++;
}
lcd_putsf(x_off, line, "%s", dbg_as_monitor[i].name);
x_off += strlen(dbg_as_monitor[i].name);
}
line++;
lcd_update();
yield();
}
}
