forked from len0rd/rockbox
5629d551d7
This makes plugins show the menu backdrop in their backdrop so that they don't look like crap if you have an sbs and look more integrated. I've test about all plugins and all work fine. git-svn-id: svn://svn.rockbox.org/rockbox/trunk@24335 a1c6a512-1295-4272-9138-f99709370657
532 lines
16 KiB
C
532 lines
16 KiB
C
/***************************************************************************
|
|
* __________ __ ___.
|
|
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
|
|
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
|
|
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
|
|
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
|
|
* \/ \/ \/ \/ \/
|
|
* $Id$
|
|
*
|
|
* Copyright (C) 2008 by Jonathan Gordon
|
|
*
|
|
* 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 <stdlib.h>
|
|
#include "config.h"
|
|
#include "lcd.h"
|
|
#include "lcd-remote.h"
|
|
#include "font.h"
|
|
#include "viewport.h"
|
|
#include "screen_access.h"
|
|
#include "settings.h"
|
|
#include "misc.h"
|
|
|
|
/*some short cuts for fg/bg/line selector handling */
|
|
#ifdef HAVE_LCD_COLOR
|
|
#define FG_FALLBACK global_settings.fg_color
|
|
#define BG_FALLBACK global_settings.bg_color
|
|
#else
|
|
#define FG_FALLBACK LCD_DEFAULT_FG
|
|
#define BG_FALLBACK LCD_DEFAULT_BG
|
|
#endif
|
|
|
|
/* all below isn't needed for pc tools (i.e. checkwps/wps editor)
|
|
* only viewport_parse_viewport() is */
|
|
#ifndef __PCTOOL__
|
|
#include "sprintf.h"
|
|
#include "string.h"
|
|
#include "kernel.h"
|
|
#include "system.h"
|
|
#include "statusbar.h"
|
|
#include "appevents.h"
|
|
#include "panic.h"
|
|
#ifdef HAVE_LCD_BITMAP
|
|
#include "language.h"
|
|
#endif
|
|
#include "statusbar-skinned.h"
|
|
#include "debug.h"
|
|
#include "viewport.h"
|
|
|
|
#define VPSTACK_DEPTH 16
|
|
struct viewport_stack_item
|
|
{
|
|
struct viewport* vp;
|
|
bool enabled;
|
|
};
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
static void viewportmanager_redraw(void* data);
|
|
|
|
static int theme_stack_top[NB_SCREENS]; /* the last item added */
|
|
static struct viewport_stack_item theme_stack[NB_SCREENS][VPSTACK_DEPTH];
|
|
static bool is_theme_enabled(enum screen_type screen);
|
|
|
|
static void toggle_theme(enum screen_type screen, bool force)
|
|
{
|
|
bool enable_event = false;
|
|
static bool was_enabled[NB_SCREENS] = {false};
|
|
int i;
|
|
FOR_NB_SCREENS(i)
|
|
{
|
|
enable_event = enable_event || is_theme_enabled(i);
|
|
}
|
|
if (enable_event)
|
|
{
|
|
add_event(GUI_EVENT_ACTIONUPDATE, false, viewportmanager_redraw);
|
|
#if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
|
|
add_event(LCD_EVENT_ACTIVATION, false, do_sbs_update_callback);
|
|
#endif
|
|
add_event(PLAYBACK_EVENT_TRACK_CHANGE, false,
|
|
do_sbs_update_callback);
|
|
add_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, false,
|
|
do_sbs_update_callback);
|
|
|
|
screens[screen].backdrop_show(BACKDROP_MAIN);
|
|
|
|
/* remove the left overs from the previous screen.
|
|
* could cause a tiny flicker. Redo your screen code if that happens */
|
|
if (!was_enabled[screen] || force)
|
|
{
|
|
struct viewport deadspace, user;
|
|
viewport_set_defaults(&user, screen);
|
|
deadspace = user; /* get colours and everything */
|
|
/* above */
|
|
deadspace.x = 0;
|
|
deadspace.y = 0;
|
|
deadspace.width = screens[screen].lcdwidth;
|
|
deadspace.height = user.y;
|
|
if (deadspace.width && deadspace.height)
|
|
{
|
|
screens[screen].set_viewport(&deadspace);
|
|
screens[screen].clear_viewport();
|
|
screens[screen].update_viewport();
|
|
}
|
|
/* below */
|
|
deadspace.y = user.y + user.height;
|
|
deadspace.height = screens[screen].lcdheight - deadspace.y;
|
|
if (deadspace.width && deadspace.height)
|
|
{
|
|
screens[screen].set_viewport(&deadspace);
|
|
screens[screen].clear_viewport();
|
|
screens[screen].update_viewport();
|
|
}
|
|
/* left */
|
|
deadspace.x = 0;
|
|
deadspace.y = 0;
|
|
deadspace.width = user.x;
|
|
deadspace.height = screens[screen].lcdheight;
|
|
if (deadspace.width && deadspace.height)
|
|
{
|
|
screens[screen].set_viewport(&deadspace);
|
|
screens[screen].clear_viewport();
|
|
screens[screen].update_viewport();
|
|
}
|
|
/* below */
|
|
deadspace.x = user.x + user.width;
|
|
deadspace.width = screens[screen].lcdwidth - deadspace.x;
|
|
if (deadspace.width && deadspace.height)
|
|
{
|
|
screens[screen].set_viewport(&deadspace);
|
|
screens[screen].clear_viewport();
|
|
screens[screen].update_viewport();
|
|
}
|
|
}
|
|
send_event(GUI_EVENT_ACTIONUPDATE, (void*)1); /* force a redraw */
|
|
}
|
|
else
|
|
{
|
|
FOR_NB_SCREENS(i)
|
|
{
|
|
screens[i].backdrop_hide();
|
|
screens[i].stop_scroll();
|
|
}
|
|
|
|
#if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
|
|
remove_event(LCD_EVENT_ACTIVATION, do_sbs_update_callback);
|
|
#endif
|
|
remove_event(PLAYBACK_EVENT_TRACK_CHANGE, do_sbs_update_callback);
|
|
remove_event(PLAYBACK_EVENT_NEXTTRACKID3_AVAILABLE, do_sbs_update_callback);
|
|
remove_event(GUI_EVENT_ACTIONUPDATE, viewportmanager_redraw);
|
|
}
|
|
/* let list initialize viewport in case viewport dimensions is changed. */
|
|
send_event(GUI_EVENT_THEME_CHANGED, NULL);
|
|
FOR_NB_SCREENS(i)
|
|
was_enabled[i] = is_theme_enabled(i);
|
|
}
|
|
|
|
void viewportmanager_theme_enable(enum screen_type screen, bool enable,
|
|
struct viewport *viewport)
|
|
{
|
|
int top = ++theme_stack_top[screen];
|
|
if (top >= VPSTACK_DEPTH-1)
|
|
panicf("Stack overflow... viewportmanager");
|
|
theme_stack[screen][top].enabled = enable;
|
|
theme_stack[screen][top].vp = viewport;
|
|
toggle_theme(screen, false);
|
|
/* then be nice and set the viewport up */
|
|
if (viewport)
|
|
viewport_set_defaults(viewport, screen);
|
|
}
|
|
|
|
void viewportmanager_theme_undo(enum screen_type screen, bool force_redraw)
|
|
{
|
|
int top = --theme_stack_top[screen];
|
|
if (top < 0)
|
|
panicf("Stack underflow... viewportmanager");
|
|
|
|
toggle_theme(screen, force_redraw);
|
|
}
|
|
|
|
|
|
static bool is_theme_enabled(enum screen_type screen)
|
|
{
|
|
int top = theme_stack_top[screen];
|
|
return theme_stack[screen][top].enabled;
|
|
}
|
|
|
|
static bool custom_vp_loaded_ok[NB_SCREENS];
|
|
static struct viewport custom_vp[NB_SCREENS];
|
|
|
|
static unsigned viewport_init_ui_vp(void);
|
|
#endif /* HAVE_LCD_BITMAP */
|
|
|
|
int viewport_get_nb_lines(const struct viewport *vp)
|
|
{
|
|
#ifdef HAVE_LCD_BITMAP
|
|
return vp->height/font_get(vp->font)->height;
|
|
#else
|
|
(void)vp;
|
|
return 2;
|
|
#endif
|
|
}
|
|
|
|
static void viewportmanager_redraw(void* data)
|
|
{
|
|
int i;
|
|
FOR_NB_SCREENS(i)
|
|
{
|
|
#ifdef HAVE_LCD_BITMAP
|
|
if (statusbar_position(i) == STATUSBAR_CUSTOM)
|
|
sb_skin_update(i, NULL != data);
|
|
else if (statusbar_position(i) != STATUSBAR_OFF)
|
|
#endif
|
|
gui_statusbar_draw(&statusbars.statusbars[i], NULL != data);
|
|
}
|
|
}
|
|
|
|
void viewportmanager_init()
|
|
{
|
|
#ifdef HAVE_LCD_BITMAP
|
|
int i;
|
|
FOR_NB_SCREENS(i)
|
|
{
|
|
theme_stack_top[i] = -1; /* the next call fixes this to 0 */
|
|
/* We always want the theme enabled by default... */
|
|
viewportmanager_theme_enable(i, true, NULL);
|
|
}
|
|
#else
|
|
add_event(GUI_EVENT_ACTIONUPDATE, false, viewportmanager_redraw);
|
|
#endif
|
|
}
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
void viewportmanager_theme_changed(const int which)
|
|
{
|
|
int i;
|
|
#ifdef HAVE_BUTTONBAR
|
|
if (which & THEME_BUTTONBAR)
|
|
{ /* don't handle further, the custom ui viewport ignores the buttonbar,
|
|
* as does viewport_set_defaults(), since only lists use it*/
|
|
screens[SCREEN_MAIN].has_buttonbar = global_settings.buttonbar;
|
|
}
|
|
#endif
|
|
if (which & THEME_UI_VIEWPORT)
|
|
{
|
|
viewport_init_ui_vp();
|
|
}
|
|
if (which & THEME_LANGUAGE)
|
|
{
|
|
}
|
|
if (which & THEME_STATUSBAR)
|
|
{
|
|
FOR_NB_SCREENS(i)
|
|
{
|
|
/* This can probably be done better...
|
|
* disable the theme so it's forced to do a full redraw */
|
|
viewportmanager_theme_enable(i, false, NULL);
|
|
viewportmanager_theme_undo(i, true);
|
|
}
|
|
}
|
|
send_event(GUI_EVENT_THEME_CHANGED, NULL);
|
|
}
|
|
|
|
/*
|
|
* (re)parse the UI vp from the settings
|
|
* - Returns
|
|
* 0 if no UI vp is used at all
|
|
* else the bit for the screen (1<<screen) is set
|
|
*/
|
|
static unsigned viewport_init_ui_vp(void)
|
|
{
|
|
int screen;
|
|
const char *ret = NULL;
|
|
char *setting;
|
|
FOR_NB_SCREENS(screen)
|
|
{
|
|
#ifdef HAVE_REMOTE_LCD
|
|
if ((screen == SCREEN_REMOTE))
|
|
setting = global_settings.remote_ui_vp_config;
|
|
else
|
|
#endif
|
|
setting = global_settings.ui_vp_config;
|
|
|
|
ret = viewport_parse_viewport(&custom_vp[screen], screen,
|
|
setting, ',');
|
|
|
|
custom_vp_loaded_ok[screen] = (ret != NULL);
|
|
}
|
|
return true; /* meh fixme */
|
|
}
|
|
|
|
#ifdef HAVE_TOUCHSCREEN
|
|
/* check if a point (x and y coordinates) are within a viewport */
|
|
bool viewport_point_within_vp(const struct viewport *vp,
|
|
const int x, const int y)
|
|
{
|
|
bool is_x = (x >= vp->x && x < (vp->x + vp->width));
|
|
bool is_y = (y >= vp->y && y < (vp->y + vp->height));
|
|
return (is_x && is_y);
|
|
}
|
|
#endif /* HAVE_TOUCHSCREEN */
|
|
|
|
static void set_default_align_flags(struct viewport *vp)
|
|
{
|
|
vp->flags &= ~VP_FLAG_ALIGNMENT_MASK;
|
|
if (UNLIKELY(lang_is_rtl()))
|
|
vp->flags |= VP_FLAG_ALIGN_RIGHT;
|
|
}
|
|
|
|
#endif /* HAVE_LCD_BITMAP */
|
|
#endif /* __PCTOOL__ */
|
|
|
|
#ifdef HAVE_LCD_COLOR
|
|
#define ARG_STRING(_depth) ((_depth) == 2 ? "dddddgg":"dddddcc")
|
|
#else
|
|
#define ARG_STRING(_depth) "dddddgg"
|
|
#endif
|
|
|
|
|
|
void viewport_set_fullscreen(struct viewport *vp,
|
|
const enum screen_type screen)
|
|
{
|
|
vp->x = 0;
|
|
vp->y = 0;
|
|
vp->width = screens[screen].lcdwidth;
|
|
vp->height = screens[screen].lcdheight;
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
#ifndef __PCTOOL__
|
|
set_default_align_flags(vp);
|
|
#endif
|
|
vp->font = FONT_UI; /* default to UI to discourage SYSFONT use */
|
|
vp->drawmode = DRMODE_SOLID;
|
|
#if LCD_DEPTH > 1
|
|
#ifdef HAVE_REMOTE_LCD
|
|
/* We only need this test if there is a remote LCD */
|
|
if (screen == SCREEN_MAIN)
|
|
#endif
|
|
{
|
|
vp->fg_pattern = FG_FALLBACK;
|
|
vp->bg_pattern = BG_FALLBACK;
|
|
#ifdef HAVE_LCD_COLOR
|
|
vp->lss_pattern = global_settings.lss_color;
|
|
vp->lse_pattern = global_settings.lse_color;
|
|
vp->lst_pattern = global_settings.lst_color;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#if defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
|
|
if (screen == SCREEN_REMOTE)
|
|
{
|
|
vp->fg_pattern = LCD_REMOTE_DEFAULT_FG;
|
|
vp->bg_pattern = LCD_REMOTE_DEFAULT_BG;
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void viewport_set_defaults(struct viewport *vp,
|
|
const enum screen_type screen)
|
|
{
|
|
/* Reposition:
|
|
1) If the "ui viewport" setting is set, and a sbs is loaded which specifies a %Vi
|
|
return the intersection of those two viewports
|
|
2) If only one of the "ui viewport" setting, or sbs %Vi is set
|
|
return it
|
|
3) No user viewports set
|
|
return the full display
|
|
*/
|
|
#if defined(HAVE_LCD_BITMAP) && !defined(__PCTOOL__)
|
|
|
|
struct viewport *sbs_area = NULL, *user_setting = NULL;
|
|
if (!is_theme_enabled(screen))
|
|
{
|
|
viewport_set_fullscreen(vp, screen);
|
|
return;
|
|
}
|
|
/* get the two viewports */
|
|
if (custom_vp_loaded_ok[screen])
|
|
user_setting = &custom_vp[screen];
|
|
if (sb_skin_get_state(screen))
|
|
sbs_area = sb_skin_get_info_vp(screen);
|
|
|
|
/* have both? get their intersection */
|
|
if (sbs_area && user_setting)
|
|
{
|
|
struct viewport *a = sbs_area, *b = user_setting;
|
|
/* if ui vp and info vp overlap, intersect */
|
|
if (a->x < b->x + b->width &&
|
|
a->x + a->width > b->x &&
|
|
a->y < b->y + b->height &&
|
|
a->y + a->height > b->y)
|
|
{
|
|
/* copy from ui vp first (for other field),fix coordinates after */
|
|
*vp = *user_setting;
|
|
set_default_align_flags(vp);
|
|
vp->x = MAX(a->x, b->x);
|
|
vp->y = MAX(a->y, b->y);
|
|
vp->width = MIN(a->x + a->width, b->x + b->width) - vp->x;
|
|
vp->height = MIN(a->y + a->height, b->y + b->height) - vp->y;
|
|
return;
|
|
}
|
|
/* else (no overlap at all) fall back to info vp from sbs, that
|
|
* has no redraw problems */
|
|
}
|
|
|
|
/* if only one is active use it
|
|
* or if the above check for overlapping failed, use info vp then, because
|
|
* that doesn't give redraw problems */
|
|
if (sbs_area)
|
|
*vp = *sbs_area;
|
|
else if (user_setting)
|
|
*vp = *user_setting;
|
|
/* have neither so its fullscreen which was fixed at the beginning */
|
|
else
|
|
#endif /* HAVE_LCD_BITMAP */
|
|
viewport_set_fullscreen(vp, screen);
|
|
}
|
|
|
|
|
|
#ifdef HAVE_LCD_BITMAP
|
|
const char* viewport_parse_viewport(struct viewport *vp,
|
|
enum screen_type screen,
|
|
const char *bufptr,
|
|
const char separator)
|
|
{
|
|
/* parse the list to the viewport struct */
|
|
const char *ptr = bufptr;
|
|
int depth;
|
|
uint32_t set = 0;
|
|
|
|
enum {
|
|
PL_X = 0,
|
|
PL_Y,
|
|
PL_WIDTH,
|
|
PL_HEIGHT,
|
|
PL_FONT,
|
|
PL_FG,
|
|
PL_BG,
|
|
};
|
|
|
|
/* Work out the depth of this display */
|
|
depth = screens[screen].depth;
|
|
#if (LCD_DEPTH == 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH == 1)
|
|
if (depth == 1)
|
|
{
|
|
if (!(ptr = parse_list("ddddd", &set, separator, ptr,
|
|
&vp->x, &vp->y, &vp->width, &vp->height, &vp->font)))
|
|
return NULL;
|
|
}
|
|
else
|
|
#endif
|
|
#if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
if (depth >= 2)
|
|
{
|
|
if (!(ptr = parse_list(ARG_STRING(depth), &set, separator, ptr,
|
|
&vp->x, &vp->y, &vp->width, &vp->height, &vp->font,
|
|
&vp->fg_pattern,&vp->bg_pattern)))
|
|
return NULL;
|
|
}
|
|
else
|
|
#endif
|
|
{}
|
|
#undef ARG_STRING
|
|
|
|
/* X and Y *must* be set */
|
|
if (!LIST_VALUE_PARSED(set, PL_X) || !LIST_VALUE_PARSED(set, PL_Y))
|
|
return NULL;
|
|
/* check for negative values */
|
|
if (vp->x < 0)
|
|
vp->x += screens[screen].lcdwidth;
|
|
if (vp->y < 0)
|
|
vp->y += screens[screen].lcdheight;
|
|
|
|
/* fix defaults,
|
|
* and negative width/height which means "extend to edge minus value */
|
|
if (!LIST_VALUE_PARSED(set, PL_WIDTH))
|
|
vp->width = screens[screen].lcdwidth - vp->x;
|
|
else if (vp->width < 0)
|
|
vp->width = (vp->width + screens[screen].lcdwidth) - vp->x;
|
|
if (!LIST_VALUE_PARSED(set, PL_HEIGHT))
|
|
vp->height = screens[screen].lcdheight - vp->y;
|
|
else if (vp->height < 0)
|
|
vp->height = (vp->height + screens[screen].lcdheight) - vp->y;
|
|
|
|
#if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1)
|
|
if (!LIST_VALUE_PARSED(set, PL_FG))
|
|
vp->fg_pattern = FG_FALLBACK;
|
|
if (!LIST_VALUE_PARSED(set, PL_BG))
|
|
vp->bg_pattern = BG_FALLBACK;
|
|
#endif /* LCD_DEPTH > 1 || LCD_REMOTE_DEPTH > 1 */
|
|
|
|
#ifdef HAVE_LCD_COLOR
|
|
vp->lss_pattern = global_settings.lss_color;
|
|
vp->lse_pattern = global_settings.lse_color;
|
|
vp->lst_pattern = global_settings.lst_color;
|
|
#endif
|
|
|
|
/* Validate the viewport dimensions - we know that the numbers are
|
|
non-negative integers, ignore bars and assume the viewport takes them
|
|
* into account */
|
|
if ((vp->x >= screens[screen].lcdwidth) ||
|
|
((vp->x + vp->width) > screens[screen].lcdwidth) ||
|
|
(vp->y >= screens[screen].lcdheight) ||
|
|
((vp->y + vp->height) > screens[screen].lcdheight))
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* Default to using the user font if the font was an invalid number or '-'*/
|
|
if (((vp->font != FONT_SYSFIXED) && (vp->font != FONT_UI))
|
|
|| !LIST_VALUE_PARSED(set, PL_FONT)
|
|
)
|
|
vp->font = FONT_UI;
|
|
|
|
/* Set the defaults for fields not user-specified */
|
|
vp->drawmode = DRMODE_SOLID;
|
|
#ifndef __PCTOOL__
|
|
set_default_align_flags(vp);
|
|
#endif
|
|
|
|
return ptr;
|
|
}
|
|
#endif
|